Changeset 3193 in MondoRescue for branches/3.2/mondo/src/mondorestore/mondo-rstr-newt.c
- Timestamp:
- Sep 29, 2013, 9:31:34 AM (11 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/3.2/mondo/src/mondorestore/mondo-rstr-newt.c
r3185 r3193 12 12 #include "mondo-rstr-newt.h" 13 13 #include "mr_mem.h" 14 #include "mr_str.h" 14 15 15 16 //static char cvsid[] = "$Id$"; … … 52 53 { 53 54 /** buffers ***********************************************************/ 54 char tmp[MAX_STR_LEN];55 char *tmp = NULL; 55 56 56 57 /** newt **************************************************************/ … … 78 79 newtPushHelpLine 79 80 (" Add one of the following unallocated RAID partitions to this RAID device."); 80 sprintf(tmp, "%-26s %s", "Device", "Size");81 mr_asprintf(tmp, "%-26s %s", "Device", "Size"); 81 82 headerMsg = newtLabel(1, 1, tmp); 82 83 partitionsListbox = … … 104 105 105 106 items = disklist->entries; 106 strcpy(disklist->el[items].device, 107 unallocated_raid_partitions->el[currline].device); 107 strcpy(disklist->el[items].device, unallocated_raid_partitions->el[currline].device); 108 108 disklist->el[items].index = index; 109 109 disklist->entries = ++items; … … 112 112 } 113 113 newtFormDestroy(myForm); 114 mr_free(tmp); 114 115 newtPopWindow(); 115 116 newtPopHelpLine(); … … 152 153 153 154 /** buffers **********************************************************/ 154 char drive_to_add[MAX_STR_LEN];155 char mountpoint_str[MAX_STR_LEN];156 char size_str[MAX_STR_LEN];157 char device_str[MAX_STR_LEN];158 char format_str[MAX_STR_LEN];155 char *drive_to_add = NULL; 156 char *mountpoint_str = NULL; 157 char *size_str = NULL; 158 char *device_str = NULL; 159 char *format_str = NULL; 159 160 160 161 /** pointers *********************************************************/ … … 169 170 assert(keylist != NULL); 170 171 171 strcpy(device_str, "/dev/"); 172 strcpy(mountpoint_str, "/"); 172 mr_asprintf(device_str, "/dev/"); 173 mr_asprintf(mountpoint_str, "/"); 174 mr_asprintf(size_str, ""); 173 175 #ifdef __FreeBSD__ 174 strcpy(format_str, "ufs");176 mr_asprintf(format_str, "ufs"); 175 177 #else 176 strcpy(format_str, "ext3");178 mr_asprintf(format_str, "ext3"); 177 179 #endif 178 size_str[0] = '\0';179 /* sprintf(size_str,""); */180 180 newtOpenWindow(20, 5, 48, 10, "Add entry"); 181 181 label0 = newtLabel(2, 1, "Device: "); … … 183 183 label2 = newtLabel(2, 3, "Size (MB): "); 184 184 label3 = newtLabel(2, 4, "Format: "); 185 deviceComp = 186 newtEntry(14, 1, device_str, 30, (void *) &device_here, 0); 187 mountpointComp = 188 newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0); 189 formatComp = 190 newtEntry(14, 4, format_str, 15, (void *) &format_here, 0); 185 deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0); 186 mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0); 187 formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0); 191 188 sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0); 192 189 bOK = newtButton(5, 6, " OK "); … … 200 197 for (b_res = NULL; b_res != bOK && b_res != bCancel;) { 201 198 b_res = newtRunForm(myForm); 202 strcpy(device_str, device_here); 203 strcpy(mountpoint_str, mountpoint_here); 204 strcpy(format_str, format_here); 205 strcpy(size_str, size_here); 206 // log_it ("Originals = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str); 207 strip_spaces(device_str); 208 strip_spaces(mountpoint_str); 209 strip_spaces(format_str); 210 strip_spaces(size_str); 211 // log_it ("Modified = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str); 199 mr_free(device_str); 200 mr_asprintf(device_str, "%s", device_here); 201 202 mr_free(mountpoint_str); 203 mr_asprintf(mountpoint_str, "%s", mountpoint_here); 204 mr_strip_spaces(mountpoint_str); 205 206 mr_free(format_str); 207 mr_asprintf(format_str, "%s", format_here); 208 mr_strip_spaces(format_str); 209 210 mr_free(size_str); 211 mr_asprintf(size_str, "%s", size_here); 212 mr_strip_spaces(size_str); 213 214 mr_strip_spaces(device_str); 212 215 if (b_res == bOK) { 213 216 if (device_str[strlen(device_str) - 1] == '/') { … … 215 218 b_res = NULL; 216 219 } 217 if (size_of_specific_device_in_mountlist(mountlist, device_str) 218 >= 0) { 220 if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) { 219 221 popup_and_OK("Can't add this - you've got one already!"); 220 222 b_res = NULL; … … 228 230 return; 229 231 } 230 strcpy(drive_to_add, device_str);232 mr_asprintf(drive_to_add, "%s", device_str); 231 233 for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--); 232 drive_to_add[i] = '\0'; 234 mr_free(drive_to_add); 235 233 236 currline = mountlist->entries; 234 237 strcpy(mountlist->el[currline].device, device_str); 235 238 strcpy(mountlist->el[currline].mountpoint, mountpoint_str); 239 mr_free(mountpoint_str); 240 236 241 strcpy(mountlist->el[currline].format, format_str); 242 mr_free(format_str); 243 237 244 mountlist->el[currline].size = atol(size_str) * 1024L; 245 mr_free(size_str); 246 238 247 mountlist->entries++; 239 248 if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) { 240 initiate_new_raidlist_entry(raidlist, mountlist, currline, 241 device_str); 242 } 249 initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str); 250 } 251 mr_free(device_str); 252 243 253 redraw_mountlist(mountlist, keylist, listbox); 244 254 } … … 315 325 316 326 /** buffers ***********************************************************/ 317 char tmp[MAX_STR_LEN]; 318 319 320 327 char tmp = NULL; 328 char *devname = NULL; 321 329 322 330 for (i = 0; … … 324 332 && strcmp(raidlist->el[i].volname, basename(raid_device)); i++); 325 333 if (i == raidlist->entries) { 326 sprintf(tmp, 327 "Cannot calc size of raid device %s - cannot find it in raidlist", 328 raid_device); 329 log_it(tmp); 334 log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device); 330 335 return (0); // Isn't this more sensible than 999999999? If the raid dev !exists, 331 336 // then it has no size, right? … … 339 344 int k = 0, l = 0; 340 345 for (k = 0; k < raidrec->plex[j].subdisks; ++k) { 341 char devname[64]; 342 strcpy(devname, raidrec->plex[j].sd[k].which_device); 346 mr_asprintf(devname, "%s", raidrec->plex[j].sd[k].which_device); 343 347 for (l = 0; l < raidlist->disks.entries; ++l) { 344 348 if (!strcmp(devname, raidlist->disks.el[l].name)) { … … 368 372 } 369 373 } 374 mr_free(devname); 370 375 } 371 376 … … 388 393 } 389 394 390 sprintf(tmp, "I have calculated %s's real size to be %ld", raid_device, 391 (long) smallest_plex); 392 log_it(tmp); 395 log_it("I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex); 393 396 return (smallest_plex); 394 397 #else … … 407 410 long sp = 0; 408 411 409 /** buffers ***********************************************************/410 char tmp[MAX_STR_LEN];411 412 412 assert(mountlist != NULL); 413 413 assert(raidlist != NULL); … … 418 418 && strcmp(raidlist->el[i].raid_device, raid_device); i++); 419 419 if (i == raidlist->entries) { 420 sprintf(tmp, 421 "Cannot calc size of raid device %s - cannot find it in raidlist", 422 raid_device); 423 log_it(tmp); 420 log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device); 424 421 return (999999999); 425 422 } … … 444 441 total_size = smallest_partition * (noof_partitions - 1); 445 442 } 446 sprintf(tmp, "I have calculated %s's real size to be %ld", raid_device, 447 (long) total_size); 448 log_it(tmp); 443 log_it("I have calculated %s's real size to be %ld", raid_device, (long) total_size); 449 444 return (total_size); 450 445 #endif … … 470 465 /** buffers ***********************************************************/ 471 466 char tmp[MAX_STR_LEN]; 472 char prompt[MAX_STR_LEN];467 char *prompt = NULL; 473 468 char sz[MAX_STR_LEN]; 474 469 475 sprintf(prompt, 476 "Please enter the RAID level you want. (concat, striped, raid5)"); 470 mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)"); 477 471 if (raidrec->raidlevel == -1) { 478 472 strcpy(tmp, "concat"); … … 485 479 res = popup_and_get_string("Specify RAID level", prompt, tmp, 10); 486 480 if (!res) { 481 mr_free(prompt); 487 482 return; 488 483 } … … 502 497 log_it(tmp); 503 498 if (is_this_raid_personality_registered(out)) { 504 log_it 505 ("Groovy. You've picked a RAID personality which is registered."); 499 log_it("Groovy. You've picked a RAID personality which is registered."); 506 500 } else { 507 if (ask_me_yes_or_no 508 ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) 501 if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) 509 502 { 510 503 out = 999; … … 512 505 } 513 506 } 507 mr_free(prompt); 508 514 509 raidrec->raidlevel = out; 515 510 #else 516 511 /** buffers ***********************************************************/ 517 512 char tmp[MAX_STR_LEN]; 518 char personalities[MAX_STR_LEN];519 char prompt[MAX_STR_LEN];513 char *personalities = NULL; 514 char *prompt = NULL; 520 515 char sz[MAX_STR_LEN]; 521 int out = 0, res = 0; 516 int out = 0; 517 int res = 0; 522 518 523 519 524 520 assert(raidrec != NULL); 525 521 paranoid_system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null"); 526 strcpy(personalities,527 last_line_of_file("/tmp/raid-personalities.txt"));528 sprintf(prompt, "Please enter the RAID level you want. %s",529 personalities); 522 mr_asprintf(personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt")); 523 mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities); 524 mr_free(personalities); 525 530 526 if (raidrec->raid_level == -1) { 531 527 strcpy(tmp, "linear"); … … 555 551 log_it(tmp); 556 552 if (is_this_raid_personality_registered(out)) { 557 log_it 558 ("Groovy. You've picked a RAID personality which is registered."); 553 log_it("Groovy. You've picked a RAID personality which is registered."); 559 554 } else { 560 if (ask_me_yes_or_no 561 ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) 562 { 555 if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) { 563 556 out = 999; 564 557 } 565 558 } 566 559 } 560 mr_free(prompt); 561 567 562 raidrec->raid_level = out; 568 563 #endif … … 589 584 int pos = 0; 590 585 591 /** buffers ***********************************************************/592 char tmp[MAX_STR_LEN];593 594 586 assert(mountlist != NULL); 595 587 assert(raidlist != NULL); … … 602 594 pos++); 603 595 if (pos < mountlist->entries) { 604 sprintf(tmp, 605 "Deleting partition %s cos it was part of a now-defunct RAID", 606 mountlist->el[pos].device); 607 log_it(tmp); 596 log_it("Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device); 597 608 598 memcpy((void *) &mountlist->el[pos], 609 599 (void *) &mountlist->el[mountlist->entries - 1], … … 631 621 /** int ***************************************************************/ 632 622 int pos = 0; 623 int res = 0; 633 624 634 625 /** buffers ***********************************************************/ 635 char tmp[MAX_STR_LEN];626 char *tmp = NULL; 636 627 637 628 assert(disklist != NULL); 638 629 assert_string_is_neither_NULL_nor_zerolength(raid_device); 639 630 640 sprintf(tmp, "Delete %s from RAID device %s - are you sure?", 641 disklist->el[currline].device, raid_device); 642 if (!ask_me_yes_or_no(tmp)) { 631 mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device); 632 res = ask_me_yes_or_no(tmp); 633 mr_free(tmp); 634 635 if (!res) { 643 636 return; 644 637 } 645 638 for (pos = currline; pos < disklist->entries - 1; pos++) { 646 /* memcpy((void*)&disklist->el[pos], (void*)&disklist->el[pos+1], sizeof(struct s_disk)); */647 639 strcpy(disklist->el[pos].device, disklist->el[pos + 1].device); 648 640 } … … 670 662 /** int ***************************************************************/ 671 663 int pos = 0; 664 int res = 0; 672 665 673 666 /** buffers ***********************************************************/ 674 char tmp[MAX_STR_LEN];675 char device[MAX_STR_LEN];667 char *tmp = NULL; 668 char *device = NULL; 676 669 677 670 … … 681 674 assert(keylist != NULL); 682 675 683 pos = 684 which_raid_device_is_using_this_partition(raidlist, 685 mountlist->el[currline]. 686 device); 676 pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device); 687 677 if (pos >= 0) { 688 sprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", 689 mountlist->el[currline].device, 690 raidlist->el[pos].OSSWAP(raid_device, volname)); 678 mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname)); 691 679 popup_and_OK(tmp); 680 mr_free(tmp); 692 681 return; 693 682 } 694 sprintf(tmp, "Delete %s - are you sure?", 695 mountlist->el[currline].device); 696 if (!ask_me_yes_or_no(tmp)) { 683 mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device); 684 res = ask_me_yes_or_no(tmp); 685 mr_free(tmp); 686 687 if (!res) { 697 688 return; 698 689 } 699 690 if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) { 700 strcpy(device, mountlist->el[currline].device);691 mr_asprintf(device, "%s", mountlist->el[currline].device); 701 692 delete_raidlist_entry(mountlist, raidlist, device); 702 693 for (currline = 0; … … 704 695 && strcmp(mountlist->el[currline].device, device); 705 696 currline++); 697 mr_free(device); 698 706 699 if (currline == mountlist->entries) { 707 700 log_it("Dev is gone. I can't delete it. Ho-hum"); … … 737 730 738 731 /** buffers ***********************************************************/ 739 char tmp[MAX_STR_LEN];732 char *tmp = NULL; 740 733 741 734 assert(mountlist != NULL); … … 747 740 return; 748 741 } 749 sprintf(tmp, "Do you want me to delete %s's partitions, too?", device);742 mr_asprintf(tmp, "Do you want me to delete %s's partitions, too?", device); 750 743 delete_partitions_too = ask_me_yes_or_no(tmp); 751 744 if (delete_partitions_too) { … … 760 753 if (!strcmp(raidlist->el[i].plex[x].sd[y].which_device, 761 754 raidlist->disks.el[z].name)) { 762 strcpy(d.el[d.entries].name, 763 raidlist->disks.el[z].name); 764 strcpy(d.el[d.entries++].device, 765 raidlist->disks.el[z].device); 755 strcpy(d.el[d.entries].name, raidlist->disks.el[z].name); 756 strcpy(d.el[d.entries++].device, raidlist->disks.el[z].device); 766 757 } 767 758 } … … 791 782 items--; 792 783 } 784 mr_free(tmp); 793 785 raidlist->entries = items; 794 786 } … … 806 798 807 799 /** buffers ************************************************************/ 808 char tmp[MAX_STR_LEN]; 800 char *tmp = NULL; 801 int res = 0; 809 802 810 803 /** structures *********************************************************/ … … 814 807 815 808 av = &raidrec->additional_vars; 816 sprintf(tmp, "Delete %s - are you sure?", av->el[lino].label); 817 if (ask_me_yes_or_no(tmp)) { 809 mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label); 810 res = ask_me_yes_or_no(tmp); 811 mr_free(tmp); 812 813 if (res) { 818 814 if (!strcmp(av->el[lino].label, "persistent-superblock") 819 815 || !strcmp(av->el[lino].label, "chunk-size")) { 820 sprintf(tmp, "%s must not be deleted. It would be bad.", 821 av->el[lino].label); 816 mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label); 822 817 popup_and_OK(tmp); 818 mr_free(tmp); 823 819 } else { 824 820 memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--], … … 856 852 static char current_filename[MAX_STR_LEN]; 857 853 char tmp[MAX_STR_LEN + 2]; 854 char *tmp1 = NULL; 858 855 859 856 /** bool *************************************************************/ … … 886 883 if (!warned_already) { 887 884 warned_already = TRUE; 888 sprintf(tmp, 889 "Too many lines. Displaying first %d entries only. Close a directory to see more.", 890 ARBITRARY_MAXIMUM); 891 popup_and_OK(tmp); 885 mr_asprintf(tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM); 886 popup_and_OK(tmp1); 887 mr_free(tmp1); 892 888 } 893 889 } else { 894 strcpy(g_strings_of_flist_window[lines_in_flist_window], 895 current_filename); 890 strcpy(g_strings_of_flist_window[lines_in_flist_window], current_filename); 896 891 g_is_path_selected[lines_in_flist_window] = node->selected; 897 892 lines_in_flist_window++; … … 908 903 (g_strings_of_flist_window[i], 909 904 g_strings_of_flist_window[i - 1]) < 0) { 910 strcpy(tmp, g_strings_of_flist_window[i]); 911 strcpy(g_strings_of_flist_window[i], 912 g_strings_of_flist_window[i - 1]); 913 strcpy(g_strings_of_flist_window[i - 1], tmp); 905 mr_asprintf(tmp1, "%s", g_strings_of_flist_window[i]); 906 strcpy(g_strings_of_flist_window[i], g_strings_of_flist_window[i - 1]); 907 strcpy(g_strings_of_flist_window[i - 1], tmp1); 908 mr_free(tmp1); 909 914 910 dummybool = g_is_path_selected[i]; 915 911 g_is_path_selected[i] = g_is_path_selected[i - 1]; … … 1014 1010 void *curr_choice; 1015 1011 void *keylist[ARBITRARY_MAXIMUM]; 1016 1017 /** buffers ***********************************************************/1018 char tmp[MAX_STR_LEN];1019 1012 1020 1013 /** bool **************************************************************/ … … 1064 1057 indexno = 0; 1065 1058 } 1066 sprintf(tmp, "You selected '%s'", 1067 g_strings_of_flist_window[indexno]); 1068 log_it(tmp); 1059 log_it("You selected '%s'", g_strings_of_flist_window[indexno]); 1060 1069 1061 if (b_res == bMore) { 1070 1062 g_is_path_expanded[indexno] = TRUE; … … 1158 1150 1159 1151 /** buffers ***********************************************************/ 1160 char device_str[MAX_STR_LEN];1161 char mountpoint_str[MAX_STR_LEN];1162 char size_str[MAX_STR_LEN];1163 char format_str[MAX_STR_LEN];1164 char tmp[MAX_STR_LEN];1165 char device_used_to_be[MAX_STR_LEN];1166 char mountpt_used_to_be[MAX_STR_LEN];1152 char *device_str = NULL; 1153 char *mountpoint_str = NULL; 1154 char *size_str = NULL; 1155 char *format_str = NULL; 1156 char *tmp = NULL; 1157 char *device_used_to_be = NULL; 1158 char *mountpt_used_to_be = NULL; 1167 1159 1168 1160 /** pointers **********************************************************/ … … 1182 1174 memcpy((void *) &bkp_raidlist, (void *) raidlist, 1183 1175 sizeof(struct raidlist_itself)); 1184 strcpy(device_str, mountlist->el[currline].device);1185 strcpy(device_used_to_be, mountlist->el[currline].device);1186 strcpy(mountpoint_str, mountlist->el[currline].mountpoint);1187 strcpy(mountpt_used_to_be, mountlist->el[currline].mountpoint);1188 strcpy(format_str, mountlist->el[currline].format);1189 sprintf(size_str, "%lld", mountlist->el[currline].size / 1024L);1176 mr_asprintf(device_str, "%s", mountlist->el[currline].device); 1177 mr_asprintf(device_used_to_be, "%s", mountlist->el[currline].device); 1178 mr_asprintf(mountpoint_str, "%s", mountlist->el[currline].mountpoint); 1179 mr_asprintf(mountpt_used_to_be, "%s", mountlist->el[currline].mountpoint); 1180 mr_asprintf(format_str, "%s", mountlist->el[currline].format); 1181 mr_asprintf(size_str, "%lld", mountlist->el[currline].size / 1024L); 1190 1182 newtOpenWindow(20, 5, 48, 10, "Edit entry"); 1191 1183 label0 = newtLabel(2, 1, "Device:"); … … 1193 1185 label2 = newtLabel(2, 3, "Size (MB): "); 1194 1186 label3 = newtLabel(2, 4, "Format: "); 1195 deviceComp = 1196 newtEntry(14, 1, device_str, 30, (void *) &device_here, 0); 1197 mountpointComp = 1198 newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0); 1199 formatComp = 1200 newtEntry(14, 4, format_str, 15, (void *) &format_here, 0); 1187 deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0); 1188 mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0); 1189 formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0); 1201 1190 if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB) 1202 1191 || !strcmp(mountlist->el[currline].mountpoint, "image")) { … … 1218 1207 for (b_res = NULL; b_res != bOK && b_res != bCancel;) { 1219 1208 b_res = newtRunForm(myForm); 1220 strcpy(device_str, device_here); 1221 strip_spaces(device_str); 1222 strcpy(mountpoint_str, mountpoint_here); 1223 strip_spaces(mountpoint_str); 1224 strcpy(format_str, format_here); 1225 strip_spaces(format_str); 1209 mr_free(device_str); 1210 mr_asprintf(device_str, "%s", device_here); 1211 mr_strip_spaces(device_str); 1212 1213 mr_free(mountpoint_str); 1214 mr_asprintf(mountpoint_str, "%s", mountpoint_here); 1215 mr_strip_spaces(mountpoint_str); 1216 1217 mr_free(format_str); 1218 mr_asprintf(format_str, "%s", format_here); 1219 mr_strip_spaces(format_str); 1220 1226 1221 if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB) 1227 1222 && strstr(device_used_to_be, RAID_DEVICE_STUB) … … 1238 1233 if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB) 1239 1234 && strcmp(mountlist->el[currline].mountpoint, "image")) { 1240 strcpy(size_str, size_here); 1241 strip_spaces(size_str); 1235 mr_free(size_str); 1236 mr_asprintf(size_str, "%s", size_here); 1237 mr_strip_spaces(size_str); 1242 1238 } else { 1243 sprintf(size_str, "%ld", 1244 calculate_raid_device_size(mountlist, raidlist, 1245 mountlist->el[currline]. 1246 device) / 1024); 1239 mr_asprintf(size_str, "%ld", calculate_raid_device_size(mountlist, raidlist, mountlist->el[currline].device) / 1024); 1247 1240 newtLabelSetText(sizeComp, size_str); 1248 1241 } … … 1261 1254 device); 1262 1255 if (j < 0) { 1263 sprintf(tmp, 1264 "/etc/raidtab does not have an entry for %s; please delete it and add it again", 1265 mountlist->el[currline].device); 1256 mr_asprintf(tmp, "/etc/raidtab does not have an entry for %s; please delete it and add it again", mountlist->el[currline].device); 1266 1257 popup_and_OK(tmp); 1258 mr_free(tmp); 1267 1259 } else { 1268 1260 log_it("edit_raidlist_entry - calling"); … … 1276 1268 newtPopHelpLine(); 1277 1269 newtPopWindow(); 1270 mr_free(mountpt_used_to_be); 1271 1278 1272 if (b_res == bCancel) { 1279 1273 memcpy((void *) raidlist, (void *) &bkp_raidlist, 1280 1274 sizeof(struct raidlist_itself)); 1275 mr_free(device_str); 1276 mr_free(device_used_to_be); 1277 mr_free(format_str); 1278 mr_free(size_str); 1281 1279 return; 1282 1280 } 1283 1281 strcpy(mountlist->el[currline].device, device_str); 1284 1282 strcpy(mountlist->el[currline].mountpoint, mountpoint_str); 1283 mr_free(mountpoint_str); 1284 1285 1285 strcpy(mountlist->el[currline].format, format_str); 1286 mr_free(format_str); 1287 1286 1288 if (strcmp(mountlist->el[currline].mountpoint, "image")) { 1287 1289 if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) { … … 1293 1295 } 1294 1296 } 1297 mr_free(size_str); 1295 1298 newtListboxSetEntry(listbox, (long) keylist[currline], 1296 1299 mountlist_entry_to_string(mountlist, currline)); … … 1298 1301 if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB) 1299 1302 && !strstr(device_used_to_be, RAID_DEVICE_STUB)) { 1300 initiate_new_raidlist_entry(raidlist, mountlist, currline, 1301 device_str); 1303 initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str); 1302 1304 } 1303 1305 /* if moving from RAID to non-RAID then do funky stuff */ … … 1316 1318 #ifndef __FreeBSD__ /* It works fine under FBSD. */ 1317 1319 else if (strcmp(device_used_to_be, device_str)) { 1318 popup_and_OK 1319 ("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it."); 1320 popup_and_OK("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it."); 1320 1321 } 1321 1322 #endif 1323 mr_free(device_str); 1324 mr_free(device_used_to_be); 1325 1322 1326 redraw_mountlist(mountlist, keylist, listbox); 1323 1327 } … … 1342 1346 for (i = 0; i < raidlist->disks.entries; ++i) { 1343 1347 if (!strcmp(raidlist->disks.el[i].device, temp)) { 1344 strcpy(raidrec->sd[raidrec->subdisks].which_device, 1345 raidlist->disks.el[i].name); 1348 strcpy(raidrec->sd[raidrec->subdisks].which_device, raidlist->disks.el[i].name); 1346 1349 found = TRUE; 1347 1350 } 1348 1351 } 1349 1352 if (!found) { 1350 sprintf(raidlist->disks.el[raidlist->disks.entries].name, 1351 "drive%i", raidlist->disks.entries); 1352 sprintf(raidrec->sd[raidrec->subdisks].which_device, "drive%i", 1353 raidlist->disks.entries); 1353 sprintf(raidlist->disks.el[raidlist->disks.entries].name, "drive%i", raidlist->disks.entries); 1354 sprintf(raidrec->sd[raidrec->subdisks].which_device, "drive%i", raidlist->disks.entries); 1354 1355 strcpy(raidlist->disks.el[raidlist->disks.entries++].device, temp); 1355 1356 } … … 1424 1425 void *keylist[10]; 1425 1426 void *curr_choice; 1427 char *raidlevel = NULL; 1428 char *chunksize = NULL; 1429 char *msg = NULL; 1426 1430 1427 1431 int currline2 = 0; 1432 int res = 0; 1428 1433 1429 1434 log_it("Started edit_raidlist_entry"); … … 1455 1460 keylist[i] = (void *) i; 1456 1461 if (i < raidrec->plexes) { 1457 char pname[64], entry[MAX_STR_LEN], raidlevel[64], 1458 chunksize[64]; 1462 char pname[64], entry[MAX_STR_LEN]; 1459 1463 switch (raidrec->plex[i].raidlevel) { 1460 1464 case -1: 1461 strcpy(raidlevel, "concat");1465 mr_asprintf(raidlevel, "concat"); 1462 1466 break; 1463 1467 case 0: 1464 strcpy(raidlevel, "striped");1468 mr_asprintf(raidlevel, "striped"); 1465 1469 break; 1466 1470 case 5: 1467 strcpy(raidlevel, "raid5");1471 mr_asprintf(raidlevel, "raid5"); 1468 1472 break; 1469 1473 default: 1470 sprintf(raidlevel, "raid%i", 1471 raidrec->plex[i].raidlevel); 1474 mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel); 1472 1475 break; 1473 1476 } 1474 1477 1475 1478 if (raidrec->plex[i].raidlevel == -1) { 1476 strcpy(chunksize, "N/A");1479 mr_asprintf(chunksize, "N/A"); 1477 1480 } else { 1478 sprintf(chunksize, "%dk", raidrec->plex[i].stripesize);1481 mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize); 1479 1482 } 1480 1483 snprintf(pname, 64, "%s.p%i", raidrec->volname, i); … … 1482 1485 pname, raidlevel, chunksize, 1483 1486 raidrec->plex[i].subdisks); 1487 mr_free(raidlevel); 1488 mr_free(chunksize); 1489 1484 1490 newtListboxAppendEntry(plexesListbox, entry, keylist[i]); 1485 1491 } … … 1503 1509 1504 1510 if (b_res == bDelete) { 1505 char msg[MAX_STR_LEN]; 1506 sprintf(msg, "Are you sure you want to delete %s.p%i?", 1507 raidrec->volname, currline2); 1508 if (ask_me_yes_or_no(msg)) { 1511 mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2); 1512 res = ask_me_yes_or_no(msg); 1513 mr_free(msg); 1514 1515 if (res) { 1509 1516 log_it("Deleting RAID plex"); 1510 1517 memcpy((void *) &raidrec->plex[currline2], … … 1540 1547 /** buffers ***********************************************************/ 1541 1548 char *title_of_editraidForm_window; 1542 char *sz_raid_level ;1543 char *sz_data_disks ;1544 char *sz_spare_disks ;1545 char *sz_parity_disks ;1546 char *sz_failed_disks ;1549 char *sz_raid_level = NULL; 1550 char *sz_data_disks = NULL; 1551 char *sz_spare_disks = NULL; 1552 char *sz_parity_disks = NULL; 1553 char *sz_failed_disks = NULL; 1547 1554 1548 1555 /** newt **************************************************************/ … … 1562 1569 assert(raidrec != NULL); 1563 1570 1564 malloc_string(title_of_editraidForm_window); 1565 malloc_string(sz_raid_level); 1566 malloc_string(sz_data_disks); 1567 malloc_string(sz_spare_disks); 1568 malloc_string(sz_parity_disks); 1569 malloc_string(sz_failed_disks); 1570 if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) { 1571 fatal_error("Cannot malloc space for raidrec"); 1572 } 1573 1571 bkp_raidrec = mr_malloc(sizeof(struct raid_device_record)); 1574 1572 log_it("Started edit_raidlist_entry"); 1575 1573 1576 memcpy((void *) bkp_raidrec, (void *) raidrec, 1577 sizeof(struct raid_device_record)); 1578 sprintf(title_of_editraidForm_window, "%s", raidrec->raid_device); 1574 memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record)); 1575 mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device); 1579 1576 log_msg(2, "Opening newt window"); 1580 1577 newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window); 1581 1578 for (;;) { 1582 1579 log_msg(2, "Main loop"); 1583 sprintf(title_of_editraidForm_window, "Edit %s", 1584 raidrec->raid_device); 1585 strcpy(sz_raid_level, 1586 turn_raid_level_number_to_string(raidrec->raid_level)); 1587 strcpy(sz_data_disks, 1588 number_of_disks_as_string(raidrec->data_disks.entries, 1589 "data")); 1590 strcpy(sz_spare_disks, 1591 number_of_disks_as_string(raidrec->spare_disks.entries, 1592 "spare")); 1593 strcpy(sz_parity_disks, 1594 number_of_disks_as_string(raidrec->parity_disks.entries, 1595 "parity")); 1596 strcpy(sz_failed_disks, 1597 number_of_disks_as_string(raidrec->failed_disks.entries, 1598 "failed")); 1580 mr_free(title_of_editraidForm_window); 1581 mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device); 1582 mr_asprintf(sz_raid_level, "%s", turn_raid_level_number_to_string(raidrec->raid_level)); 1583 mr_asprintf(sz_data_disks, "%s", number_of_disks_as_string(raidrec->data_disks.entries, "data")); 1584 mr_asprintf(sz_spare_disks, "%s", number_of_disks_as_string(raidrec->spare_disks.entries, "spare")); 1585 mr_asprintf(sz_parity_disks, "%s", number_of_disks_as_string(raidrec->parity_disks.entries, "parity")); 1586 mr_asprintf(sz_failed_disks, "%s", number_of_disks_as_string(raidrec->failed_disks.entries, "failed")); 1599 1587 bSelectData = newtButton(1, 1, sz_data_disks); 1600 1588 bSelectSpare = newtButton(20, 1, sz_spare_disks); … … 1617 1605 choose_raid_level(raidrec); 1618 1606 } else if (b_res == bSelectData) { 1619 select_raid_disks(mountlist, raidlist, raidrec, "data", 1620 &raidrec->data_disks); 1607 select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks); 1621 1608 } else if (b_res == bSelectSpare) { 1622 select_raid_disks(mountlist, raidlist, raidrec, "spare", 1623 &raidrec->spare_disks); 1609 select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks); 1624 1610 } else if (b_res == bSelectParity) { 1625 select_raid_disks(mountlist, raidlist, raidrec, "parity", 1626 &raidrec->parity_disks); 1611 select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks); 1627 1612 } else if (b_res == bSelectFailed) { 1628 select_raid_disks(mountlist, raidlist, raidrec, "failed", 1629 &raidrec->failed_disks); 1613 select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks); 1630 1614 } else if (b_res == bAdditional) { 1631 1615 edit_raidrec_additional_vars(raidrec); … … 1635 1619 break; 1636 1620 } 1621 mr_free(sz_data_disks); 1622 mr_free(sz_spare_disks); 1623 mr_free(sz_parity_disks); 1624 mr_free(sz_failed_disks); 1637 1625 } 1638 1626 if (b_res == bCancel) { 1639 memcpy((void *) raidrec, (void *) bkp_raidrec, 1640 sizeof(struct raid_device_record)); 1627 memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record)); 1641 1628 } 1642 1629 newtPopHelpLine(); 1643 1630 newtPopWindow(); 1644 mountlist->el[currline].size = 1645 calculate_raid_device_size(mountlist, raidlist, 1646 raidrec->raid_device); 1647 paranoid_free(title_of_editraidForm_window); 1648 paranoid_free(sz_raid_level); 1649 paranoid_free(sz_data_disks); 1650 paranoid_free(sz_spare_disks); 1651 paranoid_free(sz_parity_disks); 1652 paranoid_free(sz_failed_disks); 1631 mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device); 1632 mr_free(title_of_editraidForm_window); 1633 mr_free(sz_raid_level); 1653 1634 paranoid_free(bkp_raidrec); 1654 1635 #endif … … 1678 1659 1679 1660 /** buffers ***********************************************************/ 1680 char title_of_editraidForm_window[MAX_STR_LEN];1661 char *title_of_editraidForm_window = NULL; 1681 1662 1682 1663 /** newt **************************************************************/ … … 1697 1678 int currline_a, currline_u; 1698 1679 1680 char *p = NULL; 1681 char *tmp = NULL; 1682 char *entry = NULL; 1683 1699 1684 struct mountlist_itself *unallocparts; 1700 1685 … … 1704 1689 memcpy((void *) &bkp_raidrec, (void *) raidrec, 1705 1690 sizeof(struct vinum_plex)); 1706 sprintf(title_of_editraidForm_window, "%s.p%i", 1707 raidlist->el[currline].volname, currline2); 1691 mr_asprintf(title_of_editraidForm_window, "%s.p%i", raidlist->el[currline].volname, currline2); 1708 1692 newtPushHelpLine 1709 1693 (" Please select a subdisk to edit, or edit this plex's parameters"); 1710 1694 newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window); 1695 mr_free(title_of_editraidForm_window); 1696 1711 1697 for (;;) { 1712 1698 int i; 1713 char headerstr[MAX_STR_LEN];1714 char tmp[64];1715 snprintf(headerstr, MAX_STR_LEN, "%-24s %s", "Subdisk", "Device");1716 1717 1699 1718 1700 switch (raidrec->raidlevel) { 1719 1701 case -1: 1720 strcpy(tmp, "concat");1702 mr_asprintf(tmp, "concat"); 1721 1703 break; 1722 1704 case 0: 1723 strcpy(tmp, "striped");1705 mr_asprintf(tmp, "striped"); 1724 1706 break; 1725 1707 case 5: 1726 strcpy(tmp, "raid5");1708 mr_asprintf(tmp, "raid5"); 1727 1709 break; 1728 1710 default: 1729 sprintf(tmp, "unknown (%i)", raidrec->raidlevel);1711 mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel); 1730 1712 break; 1731 1713 } 1732 1714 bLevel = newtCompactButton(2, 2, " RAID level "); 1733 1715 sLevel = newtLabel(19, 2, tmp); 1716 mr_free(tmp); 1734 1717 1735 1718 if (raidrec->raidlevel >= 0) { 1736 sprintf(tmp, "%ik", raidrec->stripesize);1719 mr_asprintf(tmp, "%ik", raidrec->stripesize); 1737 1720 bStripeSize = newtCompactButton(2, 4, " Stripe size "); 1738 1721 } else { 1739 strcpy(tmp, "N/A");1722 mr_asprintf(tmp, "N/A"); 1740 1723 bStripeSize = newtLabel(2, 4, "Stripe size:"); 1741 1724 } 1742 1725 sStripeSize = newtLabel(19, 4, tmp); 1726 mr_free(tmp); 1743 1727 1744 1728 bOK = newtCompactButton(2, 16, " OK "); … … 1749 1733 1750 1734 1751 // plexesListbox = newtListbox (2, 7, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);1752 // plexesHeader = newtLabel (2, 6, headerstr);1753 1735 unallocListbox = 1754 1736 newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT); … … 1766 1748 raidlist); 1767 1749 for (i = 0; i < ARBITRARY_MAXIMUM; ++i) { 1768 char entry[MAX_STR_LEN];1769 1750 keylist[i] = (void *) i; 1770 1751 if (i < raidrec->subdisks) { 1771 snprintf(entry, MAX_STR_LEN, "%-17s", 1772 find_dev_entry_for_raid_device_name(raidlist, 1773 raidrec-> 1774 sd[i]. 1775 which_device)); 1752 mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device)); 1776 1753 newtListboxAppendEntry(allocListbox, entry, keylist[i]); 1754 mr_free(entry); 1777 1755 } 1778 1756 if (i < unallocparts->entries) { 1779 snprintf(entry, MAX_STR_LEN, "%-17s", 1780 unallocparts->el[i].device); 1757 mr_asprintf(entry, "%-17s", unallocparts->el[i].device); 1781 1758 newtListboxAppendEntry(unallocListbox, entry, keylist[i]); 1759 mr_free(entry); 1782 1760 } 1783 1761 } … … 1830 1808 choose_raid_level(raidrec); 1831 1809 } else if (b_res == bStripeSize) { 1832 char tmp [64];1833 sprintf(tmp , "%i", raidrec->stripesize);1810 char tmp1[64]; 1811 sprintf(tmp1, "%i", raidrec->stripesize); 1834 1812 if (popup_and_get_string 1835 1813 ("Stripe size", 1836 "Please enter the stripe size in kilobytes.", tmp , 20)) {1837 raidrec->stripesize = atoi(tmp );1814 "Please enter the stripe size in kilobytes.", tmp1, 20)) { 1815 raidrec->stripesize = atoi(tmp1); 1838 1816 } 1839 1817 } else if ((b_res == bAlloc) || (b_res == unallocListbox)) { … … 1849 1827 } 1850 1828 } 1851 #if 01852 } else {1853 edit_raid_subdisk(raidlist, raidrec, &raidrec->sd[currline3],1854 currline3);1855 }1856 #endif1857 1829 newtFormDestroy(editraidForm); 1858 1830 newtRefresh(); … … 1860 1832 1861 1833 if (b_res == bCancel) { 1862 memcpy((void *) raidrec, (void *) &bkp_raidrec, 1863 sizeof(struct vinum_plex)); 1834 memcpy((void *) raidrec, (void *) &bkp_raidrec, sizeof(struct vinum_plex)); 1864 1835 } 1865 1836 newtPopWindow(); … … 1877 1848 1878 1849 /** buffers ***********************************************************/ 1879 char header[MAX_STR_LEN];1880 char comment[MAX_STR_LEN];1850 char *header = NULL; 1851 char *comment = NULL; 1881 1852 char sz_out[MAX_STR_LEN]; 1882 1853 … … 1885 1856 1886 1857 strcpy(sz_out, raidrec->additional_vars.el[lino].value); 1887 sprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label); 1888 sprintf(comment, "Please set %s's value (currently '%s')", 1889 raidrec->additional_vars.el[lino].label, sz_out); 1858 mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label); 1859 mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out); 1890 1860 if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) { 1891 1861 strip_spaces(sz_out); 1892 1862 strcpy(raidrec->additional_vars.el[lino].value, sz_out); 1893 1863 } 1894 } 1895 1896 1897 /* I'm not racist against white people. I just don't like people who think Liberia is near Spain. - Hugo, 09/01/2001 */ 1864 mr_free(header); 1865 mr_free(comment); 1866 } 1898 1867 1899 1868 #endif … … 1936 1905 1937 1906 /** buffers **********************************************************/ 1938 char tmp[MAX_STR_LEN];1907 char *tmp = NULL; 1939 1908 char *flaws_str = NULL; 1940 1909 char *flaws_str_A = NULL; … … 1957 1926 bCancel = newtCompactButton(i += 12, 17, "Cancel"); 1958 1927 bOK = newtCompactButton(i += 12, 17, " OK "); 1959 sprintf(tmp, "%-24s %-24s %-8s %s", "Device", "Mountpoint", "Format", "Size (MB)");1928 mr_asprintf(tmp, "%-24s %-24s %-8s %s", "Device", "Mountpoint", "Format", "Size (MB)"); 1960 1929 headerMsg = newtLabel(2, 1, tmp); 1930 mr_free(tmp); 1931 1961 1932 flawsLabelA = newtLabel(2, 13, " "); 1962 1933 flawsLabelB = newtLabel(2, 14, " "); … … 2015 1986 } else if (b_res == bReload) { 2016 1987 if (ask_me_yes_or_no("Reload original mountlist?")) { 2017 /*2018 This would be really dumb. RAIDTAB_FNAME is #define'd. --- Hugo, 2003/04/242019 if (!RAIDTAB_FNAME[0])2020 {2021 strcpy(RAIDTAB_FNAME, "/etc/raidtab");2022 log_it("Warning - raidtab_fname is blank. Assuming %s", g_raidtab_fname);2023 }2024 */2025 1988 load_mountlist(mountlist, mountlist_fname); 2026 1989 load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME); … … 2237 2200 int i = 0; 2238 2201 #ifdef __FreeBSD__ 2239 char vdev[64]; 2202 char *vdev = NULL; 2203 int res = 0; 2240 2204 #else 2241 2205 // Linux … … 2247 2211 #ifdef __FreeBSD__ 2248 2212 for (i = 0; i < raidlist->entries; i++) { 2249 sprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname); 2250 if (!strcmp(device, vdev)) 2213 mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname); 2214 res = strcmp(device, vdev); 2215 mr_free(vdev); 2216 2217 if (!res) 2251 2218 break; 2252 2219 } … … 2298 2265 raidrec = &raidlist->el[pos_in_raidlist]; 2299 2266 initialize_raidrec(raidrec); 2300 strcpy(raidrec->OSSWAP(raid_device, volname), 2301 OSSWAP(device, basename(device))); 2267 strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device))); 2302 2268 #ifndef __FreeBSD__ 2303 2269 choose_raid_level(raidrec); … … 2549 2515 char *new_dev) 2550 2516 { 2551 /** buffers ********************************************************/2552 char tmp[MAX_STR_LEN];2553 2554 2517 /** int ************************************************************/ 2555 2518 int pos = 0; … … 2562 2525 pos = which_raid_device_is_using_this_partition(raidlist, old_dev); 2563 2526 if (pos < 0) { 2564 sprintf(tmp, "No need to rejig %s in raidlist: it's not listed.", 2565 old_dev); 2566 log_it(tmp); 2527 log_it("No need to rejig %s in raidlist: it's not listed.", old_dev); 2567 2528 } else { 2568 2529 if ((j = … … 2570 2531 OSSWAP(el[pos].data_disks, disks), 2571 2532 old_dev)) >= 0) { 2572 strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j]. 2573 device, new_dev); 2533 strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev); 2574 2534 } else 2575 2535 if ((j = … … 2578 2538 spares), 2579 2539 old_dev)) >= 0) { 2580 strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j]. 2581 device, new_dev); 2540 strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev); 2582 2541 } 2583 2542 #ifndef __FreeBSD__ … … 2596 2555 #endif 2597 2556 else { 2598 sprintf(tmp, 2599 "%s is supposed to be listed in this raid dev but it's not...", 2600 old_dev); 2601 log_it(tmp); 2557 log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev); 2602 2558 } 2603 2559 } … … 2671 2627 /** buffers **********************************************************/ 2672 2628 void *keylist[ARBITRARY_MAXIMUM]; 2673 char *tmp; 2674 char *help_text; 2675 char *title_of_window; 2676 char *sz_res; 2677 char *header_text; 2629 char *tmp = NULL; 2630 char *help_text = NULL; 2631 char *title_of_window = NULL; 2632 char sz_res[MAX_STR_LEN]; 2633 char *header_text = NULL; 2634 char *p = NULL; 2678 2635 2679 2636 /** int **************************************************************/ … … 2688 2645 2689 2646 log_it("malloc'ing"); 2690 malloc_string(tmp); 2691 malloc_string(help_text); 2692 malloc_string(title_of_window); 2693 malloc_string(sz_res); 2694 malloc_string(header_text); 2695 if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) { 2696 fatal_error("Cannot malloc space for raidrec"); 2697 } 2698 if (!(bkp_disklist = malloc(sizeof(struct list_of_disks)))) { 2699 fatal_error("Cannot malloc space for disklist"); 2700 } 2701 if (!(bkp_raidlist = malloc(sizeof(struct raidlist_itself)))) { 2702 fatal_error("Cannot malloc space for raidlist"); 2703 } 2704 if (! 2705 (unallocated_raid_partitions = 2706 malloc(sizeof(struct mountlist_itself)))) { 2707 fatal_error("Cannot malloc space for unallocated_raid_partitions"); 2708 } 2709 2710 memcpy((void *) bkp_raidlist, (void *) raidlist, 2711 sizeof(struct raidlist_itself)); 2712 memcpy((void *) bkp_raidrec, (void *) raidrec, 2713 sizeof(struct raid_device_record)); 2714 memcpy((void *) bkp_disklist, (void *) disklist, 2715 sizeof(struct list_of_disks)); 2647 bkp_raidrec = mr_malloc(sizeof(struct raid_device_record)); 2648 bkp_disklist = mr_malloc(sizeof(struct list_of_disks)); 2649 bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself)); 2650 unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself)); 2651 2652 memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself)); 2653 memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record)); 2654 memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks)); 2716 2655 2717 2656 log_it("Post-malloc"); 2718 strcpy(help_text, 2719 " Edit this RAID device's list of partitions. Choose OK or Cancel when done."); 2720 sprintf(header_text, "%-24s %s", "Device", "Index"); 2721 sprintf(title_of_window, "%s contains...", raidrec->raid_device); 2657 mr_asprintf(help_text, " Edit this RAID device's list of partitions. Choose OK or Cancel when done."); 2658 mr_asprintf(header_text, "%-24s %s", "Device", "Index"); 2659 mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device); 2722 2660 newtPushHelpLine(help_text); 2723 2661 for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) { … … 2774 2712 redraw_disklist(disklist, keylist, partitionsListbox); 2775 2713 } else { 2776 sprintf(tmp, "%s's index is %d. What should it be?", 2777 raidrec->raid_device, 2778 disklist->el[currline].index); 2714 mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index); 2779 2715 sprintf(sz_res, "%d", disklist->el[currline].index); 2780 2716 if (popup_and_get_string("Set index", tmp, sz_res, 10)) { 2781 2717 disklist->el[currline].index = atoi(sz_res); 2782 2718 } 2719 mr_free(tmp); 2720 2783 2721 redraw_disklist(disklist, keylist, partitionsListbox); 2784 2722 } … … 2789 2727 } 2790 2728 newtPopHelpLine(); 2729 mr_free(help_text); 2730 mr_free(header_text); 2731 mr_free(title_of_window); 2732 2791 2733 if (b_res == bCancel) { 2792 memcpy((void *) raidlist, (void *) bkp_raidlist, 2793 sizeof(struct raidlist_itself)); 2794 memcpy((void *) raidrec, (void *) bkp_raidrec, 2795 sizeof(struct raid_device_record)); 2796 memcpy((void *) disklist, (void *) bkp_disklist, 2797 sizeof(struct list_of_disks)); 2798 } 2799 paranoid_free(tmp); 2800 paranoid_free(help_text); 2801 paranoid_free(title_of_window); 2734 memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself)); 2735 memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record)); 2736 memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks)); 2737 } 2802 2738 paranoid_free(sz_res); 2803 paranoid_free(header_text); 2804 paranoid_free(bkp_raidrec); 2805 paranoid_free(bkp_disklist); 2806 paranoid_free(bkp_raidlist); 2807 paranoid_free(unallocated_raid_partitions); 2739 mr_free(bkp_raidrec); 2740 mr_free(bkp_disklist); 2741 mr_free(bkp_raidlist); 2742 mr_free(unallocated_raid_partitions); 2808 2743 } 2809 2744 #endif … … 2821 2756 /** char *************************************************************/ 2822 2757 char output = '\0'; 2823 char tmp[MAX_STR_LEN];2758 char *tmp = NULL; 2824 2759 2825 2760 /** newt *************************************************************/ … … 2833 2768 2834 2769 if (g_text_mode) { 2835 for (output = 'z'; !strchr("AICE", output); output = tmp[0]) { 2836 printf 2837 ("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "); 2838 if (fgets(tmp, MAX_STR_LEN - 1, stdin)) { 2839 // FIXME 2840 } 2770 while (!strchr("AICE", output)) { 2771 printf("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "); 2772 mr_getline(tmp, stdin); 2773 output = tmp[0]; 2774 mr_free(tmp); 2841 2775 } 2842 2776 return (output); 2843 2777 } 2844 2778 2845 newtPushHelpLine 2846 (" Do you want to 'nuke' your system, restore interactively, or just compare?"); 2779 newtPushHelpLine(" Do you want to 'nuke' your system, restore interactively, or just compare?"); 2847 2780 newtOpenWindow(24, 3, 32, 17, "How should I restore?"); 2848 2781 b1 = newtButton(7, 1, "Automatically");
Note:
See TracChangeset
for help on using the changeset viewer.