Changeset 2281 in MondoRescue for branches/2.2.10/mondo/src/mondorestore
- Timestamp:
- Jul 20, 2009, 12:27:56 AM (16 years ago)
- Location:
- branches/2.2.10/mondo/src/mondorestore
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/2.2.10/mondo/src/mondorestore/mondo-prep.c
r2230 r2281 60 60 void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist) 61 61 { 62 char *command ;62 char *command = NULL; 63 63 char *tmp; 64 64 int lino; 65 65 int i; 66 int res = 0; 66 67 FILE *fout; 67 68 char *buf; 68 69 const int blocksize = 512; 69 70 struct list_of_disks *drivelist = NULL; 71 70 72 // If LVMs are present and a zero-and-reboot wasn't recently undertaken 71 73 // then zero & insist on reboot. 72 malloc_string(command);73 74 malloc_string(tmp); 74 75 buf = malloc(blocksize); … … 78 79 make_list_of_drives_in_mountlist(mountlist, drivelist); 79 80 for (lino = 0; lino < drivelist->entries; lino++) { 80 sprintf(command,81 mr_asprintf(&command, 81 82 "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"", 82 83 drivelist->el[lino].device, MONDO_WAS_HERE); 83 if (!run_program_and_log_output(command, 1)) { 84 res = run_program_and_log_output(command, 1); 85 mr_free(command); 86 if (!res) { 84 87 log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)", 85 88 lino, drivelist->el[lino].device); … … 126 129 } 127 130 // Still here? Cool! 128 paranoid_free(command);129 131 paranoid_free(tmp); 130 132 log_msg(1, "Cool. I didn't have to wipe anything."); … … 236 238 malloc_string(vgchange_sz); 237 239 malloc_string(vgremove_sz); 238 // malloc_string(do_this_last); // postpone lvcreate call if necessary239 240 command = malloc(512); 240 241 241 // do_this_last[0] = '\0';242 242 log_it("STARTING"); 243 243 log_msg(1, "OK, opened i-want-my-lvm. Shutting down LVM volumes..."); … … 260 260 strcpy(vgremove_sz, "vgremove"); 261 261 } 262 sprintf(command,262 mr_asprintf(&tmp1, 263 263 "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); 264 run_program_and_log_output(command, 5); 264 run_program_and_log_output(tmp1, 5); 265 mr_free(tmp1); 266 265 267 sleep(1); 266 268 sprintf(command, … … 271 273 log_msg(1, "Closed i-want-my-lvm. Finished erasing LVMs."); 272 274 retval = 0; 273 goto end_of_i_want_my_lvm; 274 } 275 } else { 275 276 276 277 log_msg(1, "OK, rewound i-want-my-lvm. Doing funky stuff..."); … … 288 289 } 289 290 if ((p = strstr(incoming, "vgcreate"))) { 290 // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)291 // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm) 291 292 for (fgets(tmp, MAX_STR_LEN - 1, fin); !feof(fin); fgets(tmp, MAX_STR_LEN - 1, fin)) { 292 293 if (tmp[0] == '#') { … … 307 308 *q = '\0'; 308 309 log_msg(1, "Deleting old entries at /dev/%s", tmp); 309 // sprintf(command, "%s -f %s", vgremove_sz, tmp);310 // run_program_and_log_output(command, 1);311 sprintf(command, "rm -Rf /dev/%s", tmp);312 run_program_and_log_output(command, 1); 310 mr_asprintf(&tmp1, "rm -Rf /dev/%s", tmp); 311 run_program_and_log_output(tmp1, 1); 312 mr_free(tmp1); 313 313 314 run_program_and_log_output(vgscan_sz, 1); 314 315 run_program_and_log_output(pvscan_sz, 1); … … 339 340 mr_asprintf(&tmp1, "tail -n5 %s | grep Insufficient | tail -n1", MONDO_LOGFILE); 340 341 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1)); 341 free(tmp1);342 mr_free(tmp1); 342 343 } else { 343 344 mr_asprintf(&tmp1, "tail -n5 %s | grep lvcreate | tail -n1", MONDO_LOGFILE); 344 345 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1)); 345 free(tmp1);346 mr_free(tmp1); 346 347 } 347 348 for (p = tmp; *p != '\0' && !isdigit(*p); p++); … … 395 396 retval++; 396 397 } 397 sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command); 398 system(tmp); 398 mr_asprintf(&tmp1, "echo \"%s\" >> /tmp/out.sh", command); 399 system(tmp1); 400 mr_free(tmp1); 399 401 sleep(1); 400 402 } 401 403 paranoid_fclose(fin); 402 404 log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff."); 403 end_of_i_want_my_lvm: 405 } 404 406 paranoid_free(tmp); 405 407 paranoid_free(incoming); … … 412 414 paranoid_free(vgchange_sz); 413 415 paranoid_free(vgremove_sz); 414 // paranoid_free(do_this_last);415 416 system("sync"); 416 417 system("sync"); … … 450 451 /** buffers **********************************************************/ 451 452 char *incoming; 452 char *tmp ;453 char *tmp = NULL; 453 454 454 455 /** pointers *********************************************************/ … … 461 462 462 463 malloc_string(incoming); 463 malloc_string(tmp);464 464 assert(new_mountlist != NULL); 465 465 assert(old_mountlist != NULL); … … 487 487 fgets(incoming, MAX_STR_LEN - 1, fin)); 488 488 if (!feof(fin)) { 489 sprintf(tmp, "Investigating %s", 490 old_mountlist->el[lino].device); 489 mr_asprintf(&tmp, "Investigating %s", old_mountlist->el[lino].device); 491 490 log_it(tmp); 491 mr_free(tmp); 492 492 493 for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) 493 494 && !strstr(incoming, "raiddev"); … … 499 500 *p = '\0'; 500 501 for (p--; p > incoming && *(p - 1) > 32; p--); 501 sprintf(tmp, "Extrapolating %s", p);502 mr_asprintf(&tmp, "Extrapolating %s", p); 502 503 log_it(tmp); 504 mr_free(tmp); 505 503 506 for (j = 0; 504 507 j < new_mountlist->entries … … 518 521 new_mountlist->entries++; 519 522 } else { 520 sprintf(tmp,523 mr_asprintf(&tmp, 521 524 "Not adding %s to mountlist: it's already there", 522 525 p); 523 526 log_it(tmp); 527 mr_free(tmp); 524 528 } 525 529 } … … 540 544 } 541 545 paranoid_free(incoming); 542 paranoid_free(tmp);543 546 544 547 return (0); … … 683 686 684 687 /** buffers ***********************************************************/ 685 char *program ;688 char *program = NULL; 686 689 char *tmp = NULL; 687 690 int res = 0; … … 690 693 /** end ****************************************************************/ 691 694 692 malloc_string(program);693 695 assert_string_is_neither_NULL_nor_zerolength(device); 694 696 assert(format != NULL); … … 698 700 log_it(tmp); 699 701 paranoid_free(tmp); 700 paranoid_free(program);701 702 return (0); 702 703 } … … 704 705 if (strcmp(format, "swap") == 0) { 705 706 log_it("Not formatting %s - it's swap", device); 706 paranoid_free(program);707 paranoid_free(tmp);708 707 return (0); 709 708 } … … 715 714 log_it(tmp); 716 715 paranoid_free(tmp); 717 paranoid_free(program);718 716 return (0); 719 717 } … … 722 720 log_to_screen(tmp); 723 721 paranoid_free(tmp); 724 paranoid_free(program);725 722 return (1); 726 723 } … … 755 752 756 753 /* format raid partition */ 757 // sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003 758 sprintf(program, 759 "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes", 760 basename(device)); 754 mr_asprintf(&program, 755 "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes", basename(device)); 761 756 system(program); 762 757 if (g_fprep) { 763 758 fprintf(g_fprep, "%s\n", program); 764 759 } 760 mr_free(program); 761 765 762 fin = fopen("/tmp/plexes", "r"); 766 763 while (fgets(line, MAX_STR_LEN - 1, fin)) { … … 809 806 system("sync"); 810 807 sleep(1); 811 if (g_fprep) {812 fprintf(g_fprep, "%s\n", program);813 }814 808 815 809 log_msg(1, "Making %s", device); … … 819 813 log_msg(1, "Creating RAID device %s via mdadm returned %d", device, res); 820 814 } else { 821 sprintf(program, "mkraid --really-force %s", device);815 mr_asprintf(&program, "mkraid --really-force %s", device); 822 816 res = run_program_and_log_output(program, 1); 823 817 log_msg(1, "%s returned %d", program, res); … … 828 822 fprintf(g_fprep, "%s\n", program); 829 823 } 824 mr_free(program); 830 825 } 831 826 system("sync"); 832 827 sleep(2); 833 // log_to_screen("Starting %s", device);834 // sprintf(program, "raidstart %s", device);835 // res = run_program_and_log_output(program, 1);836 // log_msg(1, "%s returned %d", program, res);837 // system("sync"); sleep(1);838 828 #endif 839 829 system("sync"); … … 841 831 newtResume(); 842 832 } 843 //#ifndef __FreeBSD__844 //#endif845 833 846 834 if (!strcmp(format, "lvm")) { 847 835 log_msg(1, "Don't format %s - it's part of an lvm volume", device); 848 paranoid_free(program);849 836 paranoid_free(tmp); 850 837 return (0); 851 838 } 852 res = which_format_command_do_i_need(format, program);839 program = which_format_command_do_i_need(format); 853 840 mr_asprintf(&tmp, "%s %s", program, device); 854 841 if (strstr(program, "kludge")) { 855 842 mr_strcat(tmp, " /"); 856 843 } 857 sprintf(program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp); 844 mr_free(program); 845 846 mr_asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp); 858 847 paranoid_free(tmp); 859 848 … … 867 856 mr_strcat(tmp, "Kludge failed; using regular mkfs.%s to format %s", 868 857 format, device); 858 mr_free(program); 869 859 #ifdef __FreeBSD__ 870 sprintf(program, "newfs_msdos -F 32 %s", device);860 mr_asprintf(&program, "newfs_msdos -F 32 %s", device); 871 861 #else 872 862 #ifdef __IA64__ 873 863 /* For EFI partitions take fat16 874 864 * as we want to make small ones */ 875 sprintf(program, "mkfs -t %s -F 16 %s", format, device);865 mr_asprintf(&program, "mkfs -t %s -F 16 %s", format, device); 876 866 #else 877 sprintf(program, "mkfs -t %s -F 32 %s", format, device);867 mr_asprintf(&program, "mkfs -t %s -F 32 %s", format, device); 878 868 #endif 879 869 #endif … … 883 873 } 884 874 } 875 mr_free(program); 885 876 retval += res; 886 877 if (retval) { … … 891 882 892 883 log_to_screen(tmp); 893 paranoid_free(tmp); 894 895 paranoid_free(program); 884 mr_free(tmp); 885 896 886 system("sync"); 897 887 sleep(1); … … 916 906 int lino; 917 907 int res; 918 // int i;919 // struct list_of_disks *drivelist;920 908 921 909 /** long *************************************************************/ … … 926 914 927 915 /** buffers **********************************************************/ 928 char *tmp ;916 char *tmp = NULL; 929 917 930 918 /** pointers *********************************************************/ … … 933 921 934 922 assert(mountlist != NULL); 935 malloc_string(tmp); 936 sprintf(tmp, "format_everything (mountlist, interactively = %s", 923 Mr_asprintf(&tmp, "format_everything (mountlist, interactively = %s", 937 924 (interactively) ? "true" : "false"); 938 925 log_it(tmp); 926 mr_free(tmp); 927 939 928 mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions "); 940 929 open_progress_form("Formatting partitions", … … 946 935 (mountlist->entries > 947 936 0) ? g_maximum_progress / mountlist->entries : 1; 948 // start soft-raids now (because LVM might depend on them)949 // ...and for simplicity's sake, let's format them at the same time :)937 // start soft-raids now (because LVM might depend on them) 938 // ...and for simplicity's sake, let's format them at the same time :) 950 939 log_msg(1, "Stopping all RAID devices"); 951 940 stop_all_raid_devices(mountlist); … … 961 950 if (interactively) { 962 951 // ask user if we should format the current device 963 sprintf(tmp, "Shall I format %s (%s) ?", me->device,952 mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device, 964 953 me->mountpoint); 965 954 do_it = ask_me_yes_or_no(tmp); 955 mr_free(tmp); 966 956 } else { 967 957 do_it = TRUE; … … 991 981 newtSuspend(); 992 982 } 993 /*994 for(i=0; i<3; i++)995 {996 res = do_my_funky_lvm_stuff(FALSE, FALSE);997 if (!res) { break; }998 sleep(3);999 res = do_my_funky_lvm_stuff(TRUE, FALSE);1000 sleep(3);1001 }1002 if (res) {1003 log_msg(1, "Vacuum-packing...");1004 */1005 983 res = do_my_funky_lvm_stuff(FALSE, TRUE); 1006 /*1007 }1008 */1009 984 if (!g_text_mode) { 1010 985 newtResume(); … … 1015 990 log_to_screen("Failed to initialize LVM"); 1016 991 } 1017 // retval += res;1018 992 if (res) { 1019 993 retval++; … … 1021 995 sleep(3); 1022 996 } 1023 // do regulars at last997 // do regulars at last 1024 998 sleep(2); // woo! 1025 999 log_msg(1, "Formatting regulars"); … … 1027 1001 me = &mountlist->el[lino]; // the current mountlist entry 1028 1002 if (!strcmp(me->mountpoint, "image")) { 1029 sprintf(tmp, "Not formatting %s - it's an image", me->device);1003 mr_asprintf(&tmp, "Not formatting %s - it's an image", me->device); 1030 1004 log_it(tmp); 1005 mr_free(tmp); 1031 1006 } else if (!strcmp(me->format, "raid")) { 1032 sprintf(tmp, "Not formatting %s - it's a raid-let", 1033 me->device); 1007 mr_asprintf(&tmp, "Not formatting %s - it's a raid-let", me->device); 1034 1008 log_it(tmp); 1009 mr_free(tmp); 1035 1010 continue; 1036 1011 } else if (!strcmp(me->format, "lvm")) { 1037 sprintf(tmp, "Not formatting %s - it's an LVM", me->device);1012 mr_asprintf(&tmp, "Not formatting %s - it's an LVM", me->device); 1038 1013 log_it(tmp); 1014 mr_free(tmp); 1039 1015 continue; 1040 1016 } else if (!strncmp(me->device, "/dev/md", 7)) { 1041 sprintf(tmp, "Already formatted %s - it's a soft-RAID dev", 1042 me->device); 1017 mr_asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev", me->device); 1043 1018 log_it(tmp); 1019 mr_free(tmp); 1044 1020 continue; 1045 1021 } else if (!does_file_exist(me->device) 1046 1022 && strncmp(me->device, "/dev/hd", 7) 1047 1023 && strncmp(me->device, "/dev/sd", 7)) { 1048 sprintf(tmp, 1049 "Not formatting %s yet - doesn't exist - probably an LVM", 1050 me->device); 1024 mr_asprintf(&tmp, "Not formatting %s yet - doesn't exist - probably an LVM", me->device); 1051 1025 log_it(tmp); 1026 mr_free(tmp); 1052 1027 continue; 1053 1028 } else { 1054 1029 if (interactively) { 1055 1030 // ask user if we should format the current device 1056 sprintf(tmp, "Shall I format %s (%s) ?", me->device, 1057 me->mountpoint); 1031 mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device, me->mountpoint); 1058 1032 do_it = ask_me_yes_or_no(tmp); 1033 mr_free(tmp); 1059 1034 } else { 1060 1035 do_it = TRUE; … … 1085 1060 } 1086 1061 1087 sprintf(tmp, "format_everything () - %s", 1088 (retval) ? "failed!" : "finished successfully"); 1062 mr_asprintf(&tmp, "format_everything () - %s", (retval) ? "failed!" : "finished successfully"); 1089 1063 log_it(tmp); 1064 mr_free(tmp); 1090 1065 1091 1066 if (g_partition_table_locked_up > 0) { … … 1119 1094 system("clear"); 1120 1095 newtResume(); 1121 paranoid_free(tmp);1122 1096 return (retval); 1123 1097 } … … 1142 1116 1143 1117 /** buffers **********************************************************/ 1144 char *tmp ;1118 char *tmp = NULL; 1145 1119 1146 1120 /** end **************************************************************/ 1147 1121 1148 malloc_string(tmp);1149 1122 assert_string_is_neither_NULL_nor_zerolength(drivename); 1150 1123 1151 1124 if (devno_we_must_allow_for >= 5) { 1152 sprintf(tmp, "Making dummy primary 1 on %s", drivename);1125 mr_asprintf(&tmp, "Making dummy primary 1 on %s", drivename); 1153 1126 log_it(tmp); 1127 mr_free(tmp); 1128 1154 1129 g_maximum_progress++; 1155 1130 res = … … 1164 1139 } 1165 1140 for (; current_devno < devno_we_must_allow_for; current_devno++) { 1166 sprintf(tmp, "Creating dummy partition %d on %s", current_devno, drivename);1141 mr_asprintf(&tmp, "Creating dummy partition %d on %s", current_devno, drivename); 1167 1142 log_it(tmp); 1143 mr_free(tmp); 1168 1144 g_maximum_progress++; 1169 1145 res = … … 1173 1149 previous_devno = current_devno; 1174 1150 } 1175 paranoid_free(tmp);1176 1151 return (previous_devno); 1177 1152 } … … 1386 1361 char *drivename, struct disklabel *ret) 1387 1362 { 1388 char subdev_str[MAX_STR_LEN];1389 char command[MAX_STR_LEN];1363 char *subdev_str = NULL 1364 char *command = NULL; 1390 1365 struct disklabel *lp; 1391 1366 int i, lo = 0; … … 1397 1372 for (c = 'a'; c <= 'z'; ++c) { 1398 1373 int idx; 1399 sprintf(subdev_str, "%s%c", drivename, c);1374 mr_asprintf(&subdev_str, "%s%c", drivename, c); 1400 1375 if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) { 1401 1376 lp->d_partitions[c - 'a'].p_size = 0; … … 1422 1397 lp->d_partitions[c - 'a'].p_fstype = FS_OTHER; 1423 1398 } 1399 mr_free(subdev_str); 1424 1400 } 1425 1401 … … 1452 1428 display_disklabel(ftmp, lp); 1453 1429 fclose(ftmp); 1454 sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));1430 mr_asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename)); 1455 1431 retval += run_program_and_log_output(command, TRUE); 1456 sprintf(command, "disklabel -R %s /tmp/disklabel", 1432 mr_free(command); 1433 1434 mr_asprintf(&command, "disklabel -R %s /tmp/disklabel", 1457 1435 canonical_name(drivename)); 1458 1436 retval += run_program_and_log_output(command, TRUE); 1437 mr_free(command); 1459 1438 if (ret) 1460 1439 *ret = *lp; … … 1482 1461 #ifdef __FreeBSD__ 1483 1462 bool fbsd_part = FALSE; 1484 char subdev_str[MAX_STR_LEN]; 1463 char *subdev_str = NULL; 1464 char *command = NULL; 1465 int r = 0; 1485 1466 #endif 1486 1467 … … 1491 1472 char *device_str; 1492 1473 char *format; 1493 char *tmp ;1474 char *tmp = NULL; 1494 1475 1495 1476 /** end *************************************************************/ … … 1500 1481 malloc_string(device_str); 1501 1482 malloc_string(format); 1502 malloc_string(tmp); 1503 1504 sprintf(tmp, "Partitioning drive %s", drivename); 1483 1484 mr_asprintf(&tmp, "Partitioning drive %s", drivename); 1505 1485 log_it(tmp); 1486 mr_free(tmp); 1506 1487 1507 1488 #if __FreeBSD__ … … 1510 1491 #else 1511 1492 make_hole_for_file(FDISK_LOG); 1512 sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);1493 mr_asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG); 1513 1494 pout_to_fdisk = popen(tmp, "w"); 1495 mr_free(tmp); 1514 1496 if (!pout_to_fdisk) { 1515 1497 log_to_screen("Cannot call parted2fdisk to configure %s", drivename); 1516 1498 paranoid_free(device_str); 1517 1499 paranoid_free(format); 1518 paranoid_free(tmp);1519 1500 return (1); 1520 1501 } … … 1534 1515 // try DangerouslyDedicated mode 1535 1516 for (c = 'a'; c <= 'z'; c++) { 1536 sprintf(subdev_str, "%s%c", drivename, c); 1537 if (find_device_in_mountlist(mountlist, subdev_str) > 1538 0) { 1517 mr_asprintf(&subdev_str, "%s%c", drivename, c); 1518 if (find_device_in_mountlist(mountlist, subdev_str) > 0) { 1539 1519 fbsd_part = TRUE; 1540 1520 } 1521 mr_free(subdev_str); 1541 1522 } 1542 1523 if (fbsd_part) { 1543 intr = label_drive_or_slice(mountlist,1524 r = label_drive_or_slice(mountlist, 1544 1525 drivename, 1545 1526 0); 1546 char command[MAX_STR_LEN]; 1547 sprintf(command, "disklabel -B %s", 1548 basename(drivename)); 1527 mr_asprintf(&command, "disklabel -B %s", basename(drivename)); 1549 1528 if (system(command)) { 1550 1529 log_to_screen 1551 1530 ("Warning! Unable to make the drive bootable."); 1552 1531 } 1532 mr_free(command); 1553 1533 paranoid_free(device_str); 1554 1534 paranoid_free(format); 1555 paranoid_free(tmp);1556 1535 return r; 1557 1536 } 1558 1537 } 1559 1538 for (c = 'a'; c <= 'z'; c++) { 1560 sprintf(subdev_str, "%s%c", device_str, c);1539 mr_asprintf(&subdev_str, "%s%c", device_str, c); 1561 1540 if (find_device_in_mountlist(mountlist, subdev_str) > 0) { 1562 1541 fbsd_part = TRUE; 1563 1542 } 1543 mr_free(subdev_str); 1564 1544 } 1565 1545 // Now we check the subpartitions of the current partition. … … 1570 1550 partsize = 0; 1571 1551 for (i = 'a'; i < 'z'; ++i) { 1572 sprintf(subdev_str, "%s%c", device_str, i);1552 mr_asprintf(&subdev_str, "%s%c", device_str, i); 1573 1553 line = find_device_in_mountlist(mountlist, subdev_str); 1554 mr_free(subdev_str); 1555 1574 1556 if (line > 0) { 1575 1557 // We found one! Add its size to the total size. … … 1594 1576 #if __FreeBSD__ 1595 1577 // FreeBSD doesn't let you write to blk devices in <512byte chunks. 1596 // sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);1597 // if (run_program_and_log_output(tmp, TRUE)) {1598 1578 file = open(drivename, O_WRONLY); 1599 1579 if (file != -1) { 1600 sprintf(tmp,1580 mr_asprintf(&tmp, 1601 1581 "Warning - unable to open %s for wiping it's partition table", 1602 1582 drivename); 1603 1583 log_to_screen(tmp); 1584 mr_free(tmp); 1604 1585 } 1605 1586 1606 1587 for (i = 0; i < 512; i++) { 1607 1588 if (!write(file, "\0", 1)) { 1608 sprintf(tmp, "Warning - unable to write to %s",1589 mr_asprintf(&tmp, "Warning - unable to write to %s", 1609 1590 drivename); 1610 1591 log_to_screen(tmp); 1592 mr_free(tmp); 1611 1593 } 1612 1594 } … … 1618 1600 fflush(pout_to_fdisk); 1619 1601 } 1620 // sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);1621 // run_program_and_log_output(tmp, 1);1622 1602 #endif 1623 1603 if (current_devno > 1) { … … 1644 1624 paranoid_free(device_str); 1645 1625 paranoid_free(format); 1646 paranoid_free(tmp);1647 1626 return (1); 1648 1627 } … … 1655 1634 #ifdef __FreeBSD__ 1656 1635 if ((current_devno <= 4) && fbsd_part) { 1657 sprintf(tmp, "disklabel -B %s", basename(device_str));1636 mr_asprintf(&tmp, "disklabel -B %s", basename(device_str)); 1658 1637 retval += label_drive_or_slice(mountlist, device_str, 0); 1659 1638 if (system(tmp)) { … … 1661 1640 ("Warning! Unable to make the slice bootable."); 1662 1641 } 1642 mr_free(tmp); 1663 1643 } 1664 1644 #endif … … 1669 1649 if (pout_to_fdisk) { 1670 1650 // mark relevant partition as bootable 1671 sprintf(tmp, "a\n%s\n",1651 mr_asprintf(&tmp, "a\n%s\n", 1672 1652 call_program_and_get_last_line_of_output 1673 1653 ("make-me-bootable /tmp/mountlist.txt dummy")); 1674 1654 fput_string_one_char_at_a_time(pout_to_fdisk, tmp); 1655 mr_free(tmp); 1656 1675 1657 // close fdisk 1676 1658 fput_string_one_char_at_a_time(pout_to_fdisk, "w\n"); … … 1679 1661 log_msg(0, 1680 1662 "------------------- fdisk.log looks like this ------------------"); 1681 sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);1663 mr_asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE); 1682 1664 system(tmp); 1665 mr_free(tmp); 1666 1683 1667 log_msg(0, 1684 1668 "------------------- end of fdisk.log... word! ------------------"); 1685 sprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);1669 mr_asprintf(&tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG); 1686 1670 if (!run_program_and_log_output(tmp, 5)) { 1687 1671 g_partition_table_locked_up++; 1688 1672 } 1689 sprintf(tmp, "partprobe %s", drivename); 1673 mr_free(tmp); 1674 1675 mr_asprintf(&tmp, "partprobe %s", drivename); 1690 1676 if (!run_program_and_log_output(tmp, 5)) { 1691 1677 g_partition_table_locked_up--; 1692 1678 } 1679 mr_free(tmp); 1680 1693 1681 if (g_partition_table_locked_up > 0) { 1694 1682 log_to_screen … … 1698 1686 paranoid_free(device_str); 1699 1687 paranoid_free(format); 1700 paranoid_free(tmp);1701 1688 return (retval); 1702 1689 } … … 1720 1707 1721 1708 /** buffers **********************************************************/ 1722 char *program ;1709 char *program = NULL; 1723 1710 char *partition_name; 1724 char *tmp; 1725 char *logfile; 1711 char *tmp = NULL; 1726 1712 char *output = NULL; 1727 1713 … … 1733 1719 /** end ***************************************************************/ 1734 1720 1735 malloc_string(program);1736 1721 malloc_string(partition_name); 1737 malloc_string(tmp);1738 malloc_string(logfile);1739 1722 1740 1723 assert_string_is_neither_NULL_nor_zerolength(drive); … … 1745 1728 1746 1729 if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) { 1747 sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);1730 mr_asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive); 1748 1731 log_it(tmp); 1749 paranoid_free(program); 1732 mr_free(tmp); 1733 1750 1734 paranoid_free(partition_name); 1751 paranoid_free(tmp);1752 paranoid_free(logfile);1753 1735 return (0); 1754 1736 } 1755 1737 build_partition_name(partition_name, drive, partno); 1756 1738 if (partsize <= 0) { 1757 sprintf(tmp, "Partitioning device %s (max size)", partition_name);1739 mr_asprintf(&tmp, "Partitioning device %s (max size)", partition_name); 1758 1740 } else { 1759 sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, 1760 (long long) partsize / 1024); 1741 mr_asprintf(&tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024); 1761 1742 } 1762 1743 update_progress_form(tmp); 1763 1744 log_it(tmp); 1745 mr_free(tmp); 1764 1746 1765 1747 if (is_this_device_mounted(partition_name)) { 1766 sprintf(tmp, "%s is mounted, and should not be partitioned",1748 mr_asprintf(&tmp, "%s is mounted, and should not be partitioned", 1767 1749 partition_name); 1768 1750 log_to_screen(tmp); 1769 paranoid_free(program);1751 mr_free(tmp); 1770 1752 paranoid_free(partition_name); 1771 paranoid_free(tmp);1772 paranoid_free(logfile);1773 1753 return (1); 1774 /* 1775 } else if (does_partition_exist(drive, partno)) { 1776 sprintf(tmp, "%s already has a partition", partition_name); 1777 log_to_screen(tmp); 1778 return (1); 1779 */ 1780 } 1781 1782 1783 /* sprintf(tmp,"Partitioning %s ",partition_name); */ 1784 /* mvaddstr_and_log_it(g_currentY+1,30,tmp); */ 1754 } 1755 1756 1785 1757 p = (char *) strrchr(partition_name, '/'); 1786 sprintf(logfile, "/tmp/fdisk.log.%s", ++p);1787 sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,1788 MONDO_LOGFILE);1789 1758 1790 1759 /* BERLIOS: should not be called each time */ … … 1801 1770 log_to_screen 1802 1771 ("You need to leave at least one partition free, for 'extended/logical'"); 1803 paranoid_free(program);1804 1772 paranoid_free(partition_name); 1805 paranoid_free(tmp);1806 paranoid_free(logfile);1807 1773 paranoid_free(output); 1808 1774 return (1); … … 1826 1792 } 1827 1793 mr_strcat(output, "\n"); 1828 #if 0 1829 /* 1830 #endif 1831 sprintf(tmp,"PARTSIZE = +%ld",(long)partsize); 1794 mr_asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize); 1832 1795 log_it(tmp); 1796 mr_free(tmp); 1833 1797 log_it("---fdisk command---"); 1834 1798 log_it(output); 1835 1799 log_it("---end of fdisk---"); 1836 #if 0 1837 */ 1838 #endif 1839 1840 1800 1801 mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE); 1841 1802 if (pout_to_fdisk) { 1842 1803 log_msg(1, "Doing the new all-in-one fdisk thing"); … … 1844 1805 fput_string_one_char_at_a_time(pout_to_fdisk, output); 1845 1806 fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n"); 1846 strcpy(tmp, last_line_of_file(FDISK_LOG));1807 mr_asprintf(&tmp, "%s", last_line_of_file(FDISK_LOG)); 1847 1808 if (strstr(tmp, " (m ")) { 1848 1809 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); 1852 1813 } 1814 mr_free(tmp); 1815 1853 1816 if (!retval) { 1854 1817 log_msg(1, "Trying to set partition %d type now on %s", partno, drive); … … 1885 1848 format, -1); 1886 1849 if (res) { 1887 sprintf(tmp, "Failed to vacuum-pack %s", partition_name);1850 mr_asprintf(&tmp, "Failed to vacuum-pack %s", partition_name); 1888 1851 log_it(tmp); 1852 mr_free(tmp); 1853 1889 1854 retval++; 1890 1855 } else { … … 1897 1862 partsize); 1898 1863 if (retval) { 1899 sprintf(tmp, "Partitioned %s but failed to set its type", 1900 partition_name); 1864 mr_asprintf(&tmp, "Partitioned %s but failed to set its type", partition_name); 1901 1865 log_it(tmp); 1866 mr_free(tmp); 1902 1867 } else { 1903 1868 if (partsize > 0) { 1904 sprintf(tmp, "Partition %s created+configured OK", 1905 partition_name); 1869 mr_asprintf(&tmp, "Partition %s created+configured OK", partition_name); 1906 1870 log_to_screen(tmp); 1871 mr_free(tmp); 1907 1872 } else { 1908 1873 log_it("Returning from a successful vacuum-pack"); … … 1910 1875 } 1911 1876 } else { 1912 sprintf(tmp, "Failed to partition %s", partition_name);1877 mr_asprintf(&tmp, "Failed to partition %s", partition_name); 1913 1878 if (partsize > 0) { 1914 1879 log_to_screen(tmp); … … 1916 1881 log_it(tmp); 1917 1882 } 1883 mr_free(tmp); 1918 1884 retval++; 1919 1885 } 1920 1886 } 1887 mr_free(program); 1921 1888 paranoid_free(output); 1922 1889 1923 1890 g_current_progress++; 1924 1891 log_it("partition_device() --- leaving"); 1925 paranoid_free(program);1926 1892 paranoid_free(partition_name); 1927 paranoid_free(tmp);1928 paranoid_free(logfile);1929 1893 return (retval); 1930 1894 } … … 2035 1999 /** buffers *********************************************************/ 2036 2000 char *partition; 2037 char *command ;2001 char *command = NULL; 2038 2002 char *output = NULL; 2039 char *tmp ;2003 char *tmp = NULL; 2040 2004 char *partcode; 2041 char *logfile;2042 2005 2043 2006 /** pointers *********************************************************/ … … 2054 2017 2055 2018 malloc_string(partition); 2056 malloc_string(command);2057 malloc_string(tmp);2058 2019 malloc_string(partcode); 2059 malloc_string(logfile);2060 2020 2061 2021 build_partition_name(partition, drive, partno); 2062 2022 p = (char *) strrchr(partition, '/'); 2063 sprintf(logfile, "/tmp/fdisk-set-type.%s.log", ++p);2064 2023 if (strcmp(format, "swap") == 0) { 2065 2024 strcpy(partcode, "82"); … … 2098 2057 } else { 2099 2058 /* probably an image */ 2100 sprintf(tmp,2059 mr_asprintf(&tmp, 2101 2060 "Unknown format ('%s') - using supplied string anyway", 2102 2061 format); 2103 2062 mvaddstr_and_log_it(g_currentY++, 0, tmp); 2063 mr_free(tmp); 2104 2064 #ifdef __FreeBSD__ 2105 2065 strcpy(partcode, format); // was a5 … … 2108 2068 #endif 2109 2069 } 2110 sprintf(tmp, "Setting %s's type to %s (%s)", partition, format, 2111 partcode); 2112 log_msg(1, tmp); 2070 log_msg(1, tmp, "Setting %s's type to %s (%s)", partition, format, partcode); 2113 2071 if (partcode[0] != '\0' && strcmp(partcode, "83")) { /* no need to set type if 83: 83 is default */ 2114 2072 … … 2119 2077 || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) { 2120 2078 log_msg(5, "Specifying partno (%d) - yay", partno); 2121 sprintf(tmp, "%d\n", partno);2079 mr_asprintf(&tmp, "%d\n", partno); 2122 2080 fput_string_one_char_at_a_time(pout_to_fdisk, tmp); 2081 mr_free(tmp); 2082 2123 2083 log_msg(5, "A - last line = '%s'", 2124 2084 last_line_of_file(FDISK_LOG)); 2125 2085 } 2126 2086 2127 sprintf(tmp, "%s\n", partcode);2087 mr_asprintf(&tmp, "%s\n", partcode); 2128 2088 fput_string_one_char_at_a_time(pout_to_fdisk, tmp); 2089 mr_free(tmp); 2090 2129 2091 log_msg(5, "B - last line = '%s'", 2130 2092 last_line_of_file(FDISK_LOG)); … … 2133 2095 last_line_of_file(FDISK_LOG)); 2134 2096 2135 strcpy(tmp, last_line_of_file(FDISK_LOG));2097 mr_asprintf(&tmp, "%s", last_line_of_file(FDISK_LOG)); 2136 2098 if (!strstr(tmp, " (m ")) { 2137 2099 log_msg(1, "last line = '%s'; part type set failed", tmp); … … 2139 2101 fput_string_one_char_at_a_time(pout_to_fdisk, "\n"); 2140 2102 } 2103 mr_free(tmp); 2104 2141 2105 fput_string_one_char_at_a_time(pout_to_fdisk, "p\n"); 2142 2106 } else { 2143 2107 mr_asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode); 2144 sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,2108 mr_asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive, 2145 2109 MONDO_LOGFILE, MONDO_LOGFILE); 2146 2110 log_msg(5, "output = '%s'", output); … … 2157 2121 } 2158 2122 paranoid_free(output); 2159 } 2160 if (res) { 2161 log_OS_error(command); 2123 mr_free(command); 2162 2124 } 2163 2125 } 2164 2126 2165 2127 paranoid_free(partition); 2166 paranoid_free(command);2167 paranoid_free(tmp);2168 2128 paranoid_free(partcode); 2169 paranoid_free(logfile);2170 2129 2171 2130 return (res); … … 2180 2139 2181 2140 /** buffers *********************************************************/ 2182 char *program ;2141 char *program = NULL; 2183 2142 2184 2143 /** end *************************************************************/ 2185 2144 2186 2145 assert_string_is_neither_NULL_nor_zerolength(raid_device); 2187 malloc_string(program);2188 2146 2189 2147 #ifdef __FreeBSD__ … … 2192 2150 return 1; 2193 2151 } 2194 sprintf(program, "vinum start -f %s", raid_device);2152 mr_asprintf(&program, "vinum start -f %s", raid_device); 2195 2153 #else 2196 sprintf(program, "raidstart %s", raid_device);2154 mr_asprintf(&program, "raidstart %s", raid_device); 2197 2155 #endif 2198 2156 log_msg(1, "program = %s", program); … … 2201 2159 fprintf(g_fprep, "%s\n", program); 2202 2160 } 2161 mr_free(program); 2162 2203 2163 if (res) { 2204 2164 log_msg(1, "Warning - failed to start RAID device %s", … … 2224 2184 2225 2185 /** buffers *********************************************************/ 2226 char *program ;2186 char *program = NULL; 2227 2187 2228 2188 /** end *************************************************************/ 2229 2189 2230 2190 assert_string_is_neither_NULL_nor_zerolength(raid_device); 2231 malloc_string(program);2232 2191 2233 2192 #ifdef __FreeBSD__ … … 2236 2195 return 1; 2237 2196 } 2238 sprintf(program, "vinum stop -f %s", raid_device);2197 mr_asprintf(&program, "vinum stop -f %s", raid_device); 2239 2198 #else 2240 2199 // use raidstop if it exists, otherwise use mdadm 2241 2200 if (run_program_and_log_output("which raidstop", FALSE)) { 2242 sprintf(program, "mdadm -S %s", raid_device);2201 mr_asprintf(&program, "mdadm -S %s", raid_device); 2243 2202 } else { 2244 sprintf(program, "raidstop %s", raid_device);2203 mr_asprintf(&program, "raidstop %s", raid_device); 2245 2204 } 2246 2205 #endif … … 2250 2209 fprintf(g_fprep, "%s\n", program); 2251 2210 } 2211 mr_free(program); 2212 2252 2213 if (res) { 2253 2214 log_msg(1, "Warning - failed to stop RAID device %s", raid_device); … … 2371 2332 * @return 0 for success, nonzero for failure. 2372 2333 */ 2373 int which_format_command_do_i_need(char *format, char *program)2334 char *which_format_command_do_i_need(char *format) 2374 2335 { 2375 2336 /** int *************************************************************/ … … 2377 2338 2378 2339 /** buffers *********************************************************/ 2379 char *tmp; 2340 char *tmp = NULL; 2341 char *program = NULL; 2380 2342 2381 2343 /** end ***************************************************************/ 2382 2344 2383 malloc_string(tmp);2384 2345 assert_string_is_neither_NULL_nor_zerolength(format); 2385 assert(program != NULL);2386 2346 2387 2347 if (strcmp(format, "swap") == 0) { 2388 2348 #ifdef __FreeBSD__ 2389 strcpy(program, "true");2349 mr_asprintf(&program, "true"); 2390 2350 #else 2391 strcpy(program, "mkswap");2351 mr_asprintf(&program, "mkswap"); 2392 2352 #endif 2393 2353 } else if (strcmp(format, "vfat") == 0) { 2394 strcpy(program, "format-and-kludge-vfat");2354 mr_asprintf(&program, "format-and-kludge-vfat"); 2395 2355 #ifndef __FreeBSD__ 2396 2356 } else if (strcmp(format, "reiserfs") == 0) { 2397 strcpy(program, "mkreiserfs -ff");2357 mr_asprintf(&program, "mkreiserfs -ff"); 2398 2358 } else if (strcmp(format, "xfs") == 0) { 2399 strcpy(program, "mkfs.xfs -f -q");2359 mr_asprintf(&program, "mkfs.xfs -f -q"); 2400 2360 } else if (strcmp(format, "jfs") == 0) { 2401 strcpy(program, "mkfs.jfs");2361 mr_asprintf(&program, "mkfs.jfs"); 2402 2362 } else if (strcmp(format, "ext3") == 0) { 2403 strcpy(program, "mkfs -t ext3 -F -q");2363 mr_asprintf(&program, "mkfs -t ext3 -F -q"); 2404 2364 } else if (strcmp(format, "ext4") == 0) { 2405 strcpy(program, "mkfs -t ext4 -F -q");2365 mr_asprintf(&program, "mkfs -t ext4 -F -q"); 2406 2366 } else if (strcmp(format, "minix") == 0) { 2407 strcpy(program, "mkfs.minix");2367 mr_asprintf(&program, "mkfs.minix"); 2408 2368 } else if (strcmp(format, "vmfs") == 0) { 2409 strcpy(program, "mkfs -t vmfs");2369 mr_asprintf(&program, "mkfs -t vmfs"); 2410 2370 } else if (strcmp(format, "ntfs") == 0) { 2411 2371 /* … … 2413 2373 * so the default "mkfs -t %s -c" command structure fails 2414 2374 */ 2415 strcpy(program, "mkfs -t ntfs");2375 mr_asprintf(&program, "mkfs -t ntfs"); 2416 2376 } else if (strcmp(format, "ocfs2") == 0) { 2417 2377 /* … … 2419 2379 * 2420 2380 */ 2421 strcpy(program, "mkfs -t ocfs2 -F");2381 mr_asprintf(&program, "mkfs -t ocfs2 -F"); 2422 2382 #endif 2423 2383 } else if (strcmp(format, "ext2") == 0) { 2424 strcpy(program, "mke2fs -F -q");2384 mr_asprintf(&program, "mke2fs -F -q"); 2425 2385 } else { 2426 2386 #ifdef __FreeBSD__ 2427 sprintf(program, "newfs_%s", format);2387 mr_asprintf(&program, "newfs_%s", format); 2428 2388 #else 2429 sprintf(program, "mkfs -t %s -c", format); // -c checks for bad blocks2389 mr_asprintf(&program, "mkfs -t %s -c", format); // -c checks for bad blocks 2430 2390 #endif 2431 sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format, 2432 program); 2391 mr_asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format, program); 2433 2392 log_it(tmp); 2393 mr_free(tmp); 2434 2394 res = 0; 2435 2395 } 2436 paranoid_free(tmp); 2437 return (res); 2396 return (program); 2438 2397 } 2439 2398 … … 2455 2414 { 2456 2415 /**buffers **********************************************************/ 2457 char *tmp ;2416 char *tmp = NULL; 2458 2417 2459 2418 /** int *************************************************************/ … … 2477 2436 /** end **************************************************************/ 2478 2437 2479 malloc_string(tmp);2480 2438 assert(mountlist != NULL); 2481 2439 assert_string_is_neither_NULL_nor_zerolength(drive_name); … … 2484 2442 if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)) 2485 2443 == 0) { 2486 paranoid_free(tmp);2487 2444 return; 2488 2445 } … … 2493 2450 if (current_size_of_drive <= 0) { 2494 2451 log_it("Not resizing to match %s - can't find drive", drive_name); 2495 paranoid_free(tmp);2496 2452 return; 2497 2453 } 2498 sprintf(tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name, 2499 current_size_of_drive); 2454 mr_asprintf(&tmp, "Expanding entries to suit drive %s (%ld MB)", drive_name, current_size_of_drive); 2500 2455 log_to_screen(tmp); 2456 mr_free(tmp); 2501 2457 2502 2458 drivemntlist = malloc(sizeof(struct mountlist_reference)); … … 2516 2472 2517 2473 if (original_size_of_drive <= 0) { 2518 sprintf(tmp, "Cannot resize %s's entries. Drive not found.", 2519 drive_name); 2474 mr_asprintf(&tmp, "Cannot resize %s's entries. Drive not found.", drive_name); 2520 2475 log_to_screen(tmp); 2521 paranoid_free(tmp);2476 mr_free(tmp); 2522 2477 return; 2523 2478 } 2524 factor = 2525 (float) (current_size_of_drive) / (float) (original_size_of_drive); 2526 sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f", 2527 drive_name, original_size_of_drive, current_size_of_drive, 2528 factor); 2479 factor = (float) (current_size_of_drive) / (float) (original_size_of_drive); 2480 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); 2529 2481 log_to_screen(tmp); 2482 mr_free(tmp); 2530 2483 2531 2484 lastpart = drivemntlist->entries - 1; … … 2552 2505 } 2553 2506 2554 sprintf(tmp, "Changing %s from %lld KB to %ld KB", 2555 drivemntlist->el[partno]->device, 2556 drivemntlist->el[partno]->size, newsizL); 2507 mr_asprintf(&tmp, "Changing %s from %lld KB to %ld KB", drivemntlist->el[partno]->device, drivemntlist->el[partno]->size, newsizL); 2557 2508 log_to_screen(tmp); 2509 mr_free(tmp); 2558 2510 drivemntlist->el[partno]->size = newsizL; 2559 2511 } 2560 2512 final_size = get_phys_size_of_drive(drive_name); 2561 sprintf(tmp, "final_size = %ld MB", final_size);2513 mr_asprintf(&tmp, "final_size = %ld MB", final_size); 2562 2514 log_to_screen(tmp); 2563 paranoid_free(tmp);2515 mr_free(tmp); 2564 2516 } 2565 2517 -
branches/2.2.10/mondo/src/mondorestore/mondoprep.h
r684 r2281 69 69 int partition_everything(struct mountlist_itself *); 70 70 int do_my_funky_lvm_stuff(bool, bool); 71 int which_format_command_do_i_need(char *,char *);71 char *which_format_command_do_i_need(char *); 72 72 int make_dummy_partitions(FILE *, char *, int); 73 73 int make_list_of_drives(struct mountlist_itself *, -
branches/2.2.10/mondo/src/mondorestore/mr-externs.h
r2109 r2281 80 80 extern int verify_tape_backups(); 81 81 extern char which_restore_mode(void); 82 extern int which_format_command_do_i_need(char *,char *);82 extern char *which_format_command_do_i_need(char *); 83 83 extern int write_cfg_var(char *, char *, char *); 84 84 extern void wrong_marker(int, int);
Note:
See TracChangeset
for help on using the changeset viewer.