Context Navigation

source: MondoRescue/branches/3.1/mondo/src/mondorestore/mondo-rstr-newt.c@ 3161

Visit:

Last change on this file since 3161 was 3161, checked in by Bruno Cornec, 11 years ago
Apply fixes to 3.1 tree so that at least mondo compiles again (but that branch probably doesn't work at all again).
Property svn:keywords set to `Id`
File size: 86.7 KB

Line
1	/***************************************************************************
2	* $Id: mondo-rstr-newt.c 3161 2013-06-25 20:53:14Z bruno $
3	* Functions for handling GUI interfaces in the restore.
4	*/
5
6	#ifdef __FreeBSD__
7	#define OSSWAP(linux,fbsd) fbsd
8	#else
9	#define OSSWAP(linux,fbsd) linux
10	#endif
11
12	#include "mondo-rstr-newt.h"
13	#include "mr_mem.h"
14	#include "mr_str.h"
15
16	//static char cvsid[] = "$Id: mondo-rstr-newt.c 3161 2013-06-25 20:53:14Z bruno $";
17
18	extern bool popup_with_buttons(char p, char button1, char *button2);
19	extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
20
21	/**
22	* @defgroup restoreGuiDisklist Disklist GUI
23	* Functions for manipulating the disklist GUI.
24	* @ingroup restoreGuiGroup
25	*/
26	/**
27	* @defgroup restoreGuiMountlist Mountlist GUI
28	* Functions for manipulating the mountlist/raidlist GUI.
29	* @ingroup restoreGuiGroup
30	*/
31	/**
32	* @defgroup restoreGuiVarslist RAID Variables GUI
33	* Functions for manipulating the RAID variables GUI.
34	* @ingroup restoreGuiGroup
35	*/
36
37	/**
38	* @addtogroup restoreGuiGroup
39	* @{
40	*/
41	/**
42	* Add an entry in @p disklist from the list in @p unallocated_raid_partitions.
43	* @param disklist The disklist to add an entry to.
44	* @param raid_device Unused; make sure it's non-NULL non-"".
45	* @param unallocated_raid_partitions The list of unallocated RAID partitions
46	* that the user may choose from.
47	* @bug raid_device is unused.
48	* @ingroup restoreGuiDisklist
49	*/
50	void
51	add_disklist_entry(struct list_of_disks disklist, char raid_device,
52	struct mountlist_itself *unallocated_raid_partitions)
53	{
54	/ buffers *********************************************************/
55	char *tmp = NULL;
56
57	/ newt ************************************************************/
58	newtComponent myForm;
59	newtComponent bOK;
60	newtComponent bCancel;
61	newtComponent b_res;
62	newtComponent partitionsListbox;
63	newtComponent headerMsg;
64
65	/ prototypes *******************************************************/
66	void *keylist[ARBITRARY_MAXIMUM];
67	void *curr_choice;
68
69	/ int **************************************************************/
70	int i = 0;
71	int index = 0;
72	int currline = 0;
73	int items = 0;
74
75	assert(disklist != NULL);
76	assert_string_is_neither_NULL_nor_zerolength(raid_device);
77	assert(unallocated_raid_partitions != NULL);
78
79	newtPushHelpLine
80	(" Add one of the following unallocated RAID partitions to this RAID device.");
81	mr_asprintf(tmp, "%-26s %s", "Device", "Size");
82	headerMsg = newtLabel(1, 1, tmp);
83	partitionsListbox =
84	newtListbox(1, 2, 6, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
85	redraw_unallocpartnslist(unallocated_raid_partitions, keylist,
86	partitionsListbox);
87	i = 7;
88	bOK = newtCompactButton(i, 9, " OK ");
89	bCancel = newtCompactButton(i += 9, 9, "Cancel");
90	newtOpenWindow(22, 6, 36, 10, "Unallocated RAID partitions");
91	myForm = newtForm(NULL, NULL, 0);
92	newtFormAddComponents(myForm, headerMsg, partitionsListbox, bOK,
93	bCancel, NULL);
94	b_res = newtRunForm(myForm);
95	if (b_res != bCancel) {
96	curr_choice = newtListboxGetCurrent(partitionsListbox);
97	for (currline = 0;
98	currline < unallocated_raid_partitions->entries
99	&& keylist[currline] != curr_choice; currline++);
100	if (currline == unallocated_raid_partitions->entries
101	&& unallocated_raid_partitions->entries > 0) {
102	log_it("I don't know what this button does");
103	} else {
104	index = find_next_free_index_in_disklist(disklist);
105
106	items = disklist->entries;
107	strcpy(disklist->el[items].device, unallocated_raid_partitions->el[currline].device);
108	disklist->el[items].index = index;
109	disklist->entries = ++items;
110
111	}
112	}
113	newtFormDestroy(myForm);
114	mr_free(tmp);
115	newtPopWindow();
116	newtPopHelpLine();
117	}
118
119
120
121
122	/**
123	* Add an entry to @p mountlist.
124	* @param mountlist The mountlist to add an entry to.
125	* @param raidlist The raidlist that accompanies @p mountlist.
126	* @param listbox The listbox component in the mountlist editor.
127	* @param currline The line selected in @p listbox.
128	* @param keylist The list of keys for @p listbox.
129	* @ingroup restoreGuiMountlist
130	*/
131	void
132	add_mountlist_entry(struct mountlist_itself *mountlist,
133	struct raidlist_itself *raidlist,
134	newtComponent listbox, int currline, void *keylist[])
135	{
136
137	/ int ************************************************************/
138	int i = 0;
139
140	/ newt ***********************************************************/
141	newtComponent myForm;
142	newtComponent bOK;
143	newtComponent bCancel;
144	newtComponent b_res;
145	newtComponent mountpointComp;
146	newtComponent label0;
147	newtComponent label1;
148	newtComponent label2;
149	newtComponent label3;
150	newtComponent sizeComp;
151	newtComponent deviceComp;
152	newtComponent formatComp;
153
154	/ buffers ********************************************************/
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;
160
161	/ pointers *******************************************************/
162	char *mountpoint_here;
163	char *size_here;
164	char *device_here;
165	char *format_here;
166
167	assert(mountlist != NULL);
168	assert(raidlist != NULL);
169	assert(listbox != NULL);
170	assert(keylist != NULL);
171
172	mr_asprintf(device_str, "/dev/");
173	mr_asprintf(mountpoint_str, "/");
174	mr_asprintf(size_str, "");
175	#ifdef __FreeBSD__
176	mr_asprintf(format_str, "ufs");
177	#else
178	mr_asprintf(format_str, "ext3");
179	#endif
180	newtOpenWindow(20, 5, 48, 10, "Add entry");
181	label0 = newtLabel(2, 1, "Device: ");
182	label1 = newtLabel(2, 2, "Mountpoint:");
183	label2 = newtLabel(2, 3, "Size (MB): ");
184	label3 = newtLabel(2, 4, "Format: ");
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);
188	sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
189	bOK = newtButton(5, 6, " OK ");
190	bCancel = newtButton(17, 6, "Cancel");
191	newtPushHelpLine
192	("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
193	myForm = newtForm(NULL, NULL, 0);
194	newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
195	formatComp, label0, label1, label2, label3, bOK,
196	bCancel, NULL);
197	for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
198	b_res = newtRunForm(myForm);
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	strip_spaces(device_str);
215	if (b_res == bOK) {
216	if (device_str[strlen(device_str) - 1] == '/') {
217	popup_and_OK("You left the device nearly blank!");
218	b_res = NULL;
219	}
220	if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
221	popup_and_OK("Can't add this - you've got one already!");
222	b_res = NULL;
223	}
224	}
225	}
226	newtFormDestroy(myForm);
227	newtPopHelpLine();
228	newtPopWindow();
229	if (b_res == bCancel) {
230	return;
231	}
232	mr_asprintf(drive_to_add, "%s", device_str);
233	for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
234	mr_free(drive_to_add);
235
236	currline = mountlist->entries;
237	strcpy(mountlist->el[currline].device, device_str);
238	strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
239	mr_free(mountpoint_str);
240
241	strcpy(mountlist->el[currline].format, format_str);
242	mr_free(format_str);
243
244	mountlist->el[currline].size = atol(size_str) * 1024L;
245	mr_free(size_str);
246
247	mountlist->entries++;
248	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
249	initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
250	}
251	mr_free(device_str);
252
253	redraw_mountlist(mountlist, keylist, listbox);
254	}
255
256
257	#ifndef __FreeBSD__
258	/**
259	* Add an entry to the additional RAID variables section of @p raidrec.
260	* @param raidrec The RAID device record containing the RAID variables list to add to.
261	* @ingroup restoreGuiVarslist
262	*/
263	void add_varslist_entry(struct raid_device_record *raidrec)
264	{
265
266	/ int **************************************************************/
267	int items = 0;
268	int i = 0;
269
270	char *p = NULL;
271
272	assert(raidrec != NULL);
273
274	p = popup_and_get_string("Add variable", "Enter the name of the variable to add", "");
275	if (p != NULL) {
276	mr_strip_spaces(p);
277	items = raidrec->additional_vars.entries;
278	for (i = 0;
279	i < items
280	&& strcmp(raidrec->additional_vars.el[i].label, p); i++);
281	if (i < items) {
282	popup_and_OK
283	("No need to add that variable. It is already listed here.");
284	} else {
285	strcpy(raidrec->additional_vars.el[items].label, p);
286	edit_varslist_entry(raidrec, items);
287	raidrec->additional_vars.entries = ++items;
288	}
289	}
290	mr_free(p);
291	}
292	#endif
293
294	/**
295	* Calculate the size of @p raid_device.
296	* @param mountlist The mountlist containing information about the user's partitions.
297	* @param raidlist The raidlist that goes with @p mountlist.
298	* @param raid_device The device to calculate the size of.
299	* @return The size of the RAID device in Kilobytes.
300	* @ingroup restoreUtilityGroup
301	*/
302	long
303	calculate_raid_device_size(struct mountlist_itself *mountlist,
304	struct raidlist_itself *raidlist,
305	char *raid_device)
306	{
307	#ifdef __FreeBSD__
308	/ FreeBSD-specific version of calculate_raid_device_size() /
309
310	/ structures ******************************************************/
311	struct vinum_volume *raidrec;
312
313	/ int *************************************************************/
314	int i = 0, j = 0;
315	int noof_partitions = 0;
316
317	/ long ************************************************************/
318	long total_size = 0;
319	long plex_size = 0;
320	long smallest_partition = 999999999;
321	long smallest_plex = 999999999;
322	long sp = 0;
323
324	/ buffers *********************************************************/
325	char tmp = NULL;
326	char *devname = NULL;
327
328	for (i = 0;
329	i < raidlist->entries
330	&& strcmp(raidlist->el[i].volname, basename(raid_device)); i++);
331	if (i == raidlist->entries) {
332	log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
333	return (0); // Isn't this more sensible than 999999999? If the raid dev !exists,
334	// then it has no size, right?
335	}
336	raidrec = &raidlist->el[i];
337	total_size = 0;
338	if (raidrec->plexes == 0)
339	return 0;
340	for (j = 0; j < raidrec->plexes; j++) {
341	plex_size = 0;
342	int k = 0, l = 0;
343	for (k = 0; k < raidrec->plex[j].subdisks; ++k) {
344	mr_asprintf(devname, "%s", raidrec->plex[j].sd[k].which_device);
345	for (l = 0; l < raidlist->disks.entries; ++l) {
346	if (!strcmp(devname, raidlist->disks.el[l].name)) {
347	switch (raidrec->plex[j].raidlevel) {
348	case -1:
349	plex_size +=
350	size_of_specific_device_in_mountlist(mountlist,
351	raidlist->
352	disks.
353	el[l].
354	device);
355	break;
356	case 0:
357	case 5:
358	if (size_of_specific_device_in_mountlist(mountlist,
359	raidlist->
360	disks.
361	el[l].
362	device) <
363	smallest_partition) {
364	smallest_partition =
365	size_of_specific_device_in_mountlist
366	(mountlist, raidlist->disks.el[l].device);
367	}
368	break;
369	}
370	}
371	}
372	mr_free(devname);
373	}
374
375	if (!is_this_raid_personality_registered
376	(raidrec->plex[j].raidlevel)) {
377	log_it
378	("%s has a really weird RAID level - couldn't calc size :(",
379	raid_device);
380	return (999999999);
381	}
382	if (raidrec->plex[j].raidlevel != -1) {
383	plex_size = smallest_partition * (raidrec->plex[j].subdisks -
384	(raidrec->plex[j].
385	raidlevel == 5 ? 1 : 0));
386	}
387	if (plex_size < smallest_plex)
388	smallest_plex = plex_size;
389
390	smallest_partition = 999999999;
391	}
392
393	log_it("I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex);
394	return (smallest_plex);
395	#else
396	/ Linux-specific version of calculate_raid_device_size() /
397
398	/ structures ******************************************************/
399	struct raid_device_record *raidrec;
400
401	/ int *************************************************************/
402	int i = 0;
403	int noof_partitions = 0;
404
405	/ long ************************************************************/
406	long total_size = 0;
407	long smallest_partition = 999999999;
408	long sp = 0;
409
410	assert(mountlist != NULL);
411	assert(raidlist != NULL);
412	assert_string_is_neither_NULL_nor_zerolength(raid_device);
413
414	for (i = 0;
415	i < raidlist->entries
416	&& strcmp(raidlist->el[i].raid_device, raid_device); i++);
417	if (i == raidlist->entries) {
418	log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
419	return (999999999);
420	}
421	raidrec = &raidlist->el[i];
422	noof_partitions = raidrec->data_disks.entries;
423	if (raidrec->raid_level == -1 \|\| raidrec->raid_level == 0) {
424	for (total_size = 0, i = 0; i < noof_partitions; i++) {
425	total_size +=
426	size_of_specific_device_in_mountlist(mountlist,
427	raidrec->data_disks.
428	el[i].device);
429	}
430	} else {
431	for (i = 0; i < noof_partitions; i++) {
432	sp = size_of_specific_device_in_mountlist(mountlist,
433	raidrec->data_disks.
434	el[i].device);
435	if (smallest_partition > sp) {
436	smallest_partition = sp;
437	}
438	}
439	total_size = smallest_partition * (noof_partitions - 1);
440	}
441	log_it("I have calculated %s's real size to be %ld", raid_device, (long) total_size);
442	return (total_size);
443	#endif
444	}
445
446
447
448	/**
449	* Choose the RAID level for the RAID device record in @p raidrec.
450	* @param raidrec The RAID device record to set the RAID level of.
451	* @ingroup restoreGuiMountlist
452	*/
453	void
454	choose_raid_level(struct OSSWAP (raid_device_record, vinum_plex) * raidrec)
455	{
456
457	#ifdef __FreeBSD__
458
459	/ int *************************************************************/
460	int out = 0;
461	int i = 0;
462
463	/ buffers *********************************************************/
464	char *tmp = NULL;
465	char *p = NULL;
466	char *q = NULL;
467	char *prompt = NULL;
468
469	mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
470	if (raidrec->raidlevel == -1) {
471	mr_asprintf(tmp, "concat");
472	} else if (raidrec->raidlevel == 0) {
473	mr_asprintf(tmp, "striped");
474	} else {
475	mr_asprintf(tmp, "raid%i", raidrec->raidlevel);
476	}
477	for (out = 999; out == 999;) {
478	p = popup_and_get_string("Specify RAID level", prompt, tmp);
479	if (p == NULL) {
480	mr_free(tmp);
481	mr_free(prompt);
482	mr_free(prompt);
483	return;
484	}
485	mr_strip_spaces(p);
486	/* Suppress brakets at each hend */
487	if (p[0] == '[' && p[strlen(p) - 1] == ']') {
488	q = p+1;
489	i = 0;
490	while (*q != ']') {
491	p[i] = *q;
492	i++;
493	q++;
494	}
495	p[i] = '\0';
496	}
497	if (!strcmp(p, "concat")) {
498	out = -1;
499	} else if (!strcmp(p, "striped")) {
500	out = 0;
501	} else if (!strcmp(p, "raid5")) {
502	out = 5;
503	}
504	log_it("Raid level : %s",p);
505	mr_free(p);
506
507	if (is_this_raid_personality_registered(out)) {
508	log_it("Groovy. You've picked a RAID personality which is registered.");
509	} else {
510	if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
511	{
512	out = 999;
513	}
514	}
515	}
516	mr_free(tmp);
517	mr_free(prompt);
518
519	raidrec->raidlevel = out;
520	#else
521	/ buffers *********************************************************/
522	char *tmp = NULL;
523	char *personalities = NULL;
524	char *prompt = NULL;
525	char *p = NULL;
526	char *q = NULL;
527	int out = 0;
528	int i = 0;
529
530
531	assert(raidrec != NULL);
532
533	if (system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null")) {
534	// FIXME
535	}
536	personalities = last_line_of_file("/tmp/raid-personalities.txt");
537	mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
538	mr_free(personalities);
539
540	if (raidrec->raid_level == -1) {
541	mr_asprintf(tmp, "linear");
542	} else {
543	mr_asprintf(tmp, "%d", raidrec->raid_level);
544	}
545	for (out = 999;
546	out != -1 && out != 0 && out != 1 && out != 4 && out != 5
547	&& out != 10;) {
548	p = popup_and_get_string("Specify RAID level", prompt, tmp);
549
550	if (p == NULL) {
551	mr_free(tmp);
552	mr_free(prompt);
553	mr_free(prompt);
554	return;
555	}
556	mr_strip_spaces(p);
557	if (p[0] == '[' && p[strlen(p) - 1] == ']') {
558	q = p+1;
559	i = 0;
560	while (*q != ']') {
561	p[i] = *q;
562	i++;
563	q++;
564	}
565	p[i] = '\0';
566	}
567	if (!strcmp(p, "linear")) {
568	out = -1;
569	} else if (!strncmp(p, "raid", 4)) {
570	out = atoi(p + 4);
571	} else {
572	out = atoi(p);
573	}
574	log_it("Raid level : %s",p);
575	if (is_this_raid_personality_registered(out)) {
576	log_it("Groovy. You've picked a RAID personality which is registered.");
577	} else {
578	if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
579	out = 999;
580	}
581	}
582	}
583	mr_free(tmp);
584	mr_free(prompt);
585	raidrec->raid_level = out;
586	#endif
587	}
588
589
590
591	/**
592	* Delete the partitions in @p disklist from @p mountlist because they
593	* were part of a deleted RAID device.
594	* @param mountlist The mountlist containing information about the user's partitions.
595	* @param raidlist The raidlist that goes with @p mounntlist.
596	* @param disklist The list of disks to remove from @p mountlist.
597	* @ingroup restoreGuiDisklist
598	*/
599	void
600	del_partns_listed_in_disklist(struct mountlist_itself *mountlist,
601	struct raidlist_itself *raidlist,
602	struct list_of_disks *disklist)
603	{
604
605	/ int *************************************************************/
606	int i = 0;
607	int pos = 0;
608
609	/ buffers *********************************************************/
610	assert(mountlist != NULL);
611	assert(raidlist != NULL);
612	assert(disklist != NULL);
613
614	for (i = 0; i < disklist->entries; i++) {
615	for (pos = 0;
616	pos < mountlist->entries
617	&& strcmp(mountlist->el[pos].device, disklist->el[i].device);
618	pos++);
619	if (pos < mountlist->entries) {
620	log_it("Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device);
621
622	memcpy((void *) &mountlist->el[pos],
623	(void *) &mountlist->el[mountlist->entries - 1],
624	sizeof(struct mountlist_line));
625	mountlist->entries--;
626	}
627	}
628	}
629
630
631
632	/**
633	* Delete entry number @p currline from @p disklist.
634	* @param disklist The disklist to remove the entry from.
635	* @param raid_device The RAID device containing the partition we're removing.
636	* Used only in the popup "are you sure?" box.
637	* @param currline The line number (starting from 0) of the item to delete.
638	* @ingroup restoreGuiDisklist
639	*/
640	void
641	delete_disklist_entry(struct list_of_disks disklist, char raid_device,
642	int currline)
643	{
644
645	/ int *************************************************************/
646	int pos = 0;
647	int res = 0;
648
649	/ buffers *********************************************************/
650	char *tmp = NULL;
651
652	assert(disklist != NULL);
653	assert_string_is_neither_NULL_nor_zerolength(raid_device);
654
655	mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
656	res = ask_me_yes_or_no(tmp);
657	mr_free(tmp);
658
659	if (!res) {
660	return;
661	}
662	for (pos = currline; pos < disklist->entries - 1; pos++) {
663	strcpy(disklist->el[pos].device, disklist->el[pos + 1].device);
664	}
665	disklist->entries--;
666	}
667
668
669
670	/**
671	* Delete entry number @p currline from @p mountlist.
672	* @param mountlist The mountlist to delete the entry from.
673	* @param raidlist The raidlist that goes with @p mountlist.
674	* @param listbox The Newt listbox component in the mountlist editor.
675	* @param currline The line number (starting from 0) of the item to delete.
676	* @param keylist The list of keys for @p listbox.
677	* @ingroup restoreGuiMountlist
678	*/
679	void
680	delete_mountlist_entry(struct mountlist_itself *mountlist,
681	struct raidlist_itself *raidlist,
682	newtComponent listbox, int currline,
683	void *keylist[])
684	{
685
686	/ int *************************************************************/
687	int pos = 0;
688	int res = 0;
689
690	/ buffers *********************************************************/
691	char *tmp = NULL;
692	char *device = NULL;
693
694
695	assert(mountlist != NULL);
696	assert(raidlist != NULL);
697	assert(listbox != NULL);
698	assert(keylist != NULL);
699
700	pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
701	if (pos >= 0) {
702	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));
703	popup_and_OK(tmp);
704	mr_free(tmp);
705	return;
706	}
707	mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
708	res = ask_me_yes_or_no(tmp);
709	mr_free(tmp);
710
711	if (!res) {
712	return;
713	}
714	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
715	mr_asprintf(device, "%s", mountlist->el[currline].device);
716	delete_raidlist_entry(mountlist, raidlist, device);
717	for (currline = 0;
718	currline < mountlist->entries
719	&& strcmp(mountlist->el[currline].device, device);
720	currline++);
721	mr_free(device);
722
723	if (currline == mountlist->entries) {
724	log_it("Dev is gone. I can't delete it. Ho-hum");
725	return;
726	}
727	}
728	memcpy((void *) &mountlist->el[currline],
729	(void *) &mountlist->el[mountlist->entries - 1],
730	sizeof(struct mountlist_line));
731	mountlist->entries--;
732	redraw_mountlist(mountlist, keylist, listbox);
733	}
734
735
736	/**
737	* Delete @p device from @p raidlist.
738	* @param mountlist The mountlist containing information about the user's partitions.
739	* @param raidlist The raidlist containing the RAID device to delete.
740	* @param device The device (e.g. /dev/md0) to delete.
741	* @ingroup restoreGuiMountlist
742	*/
743	void
744	delete_raidlist_entry(struct mountlist_itself *mountlist,
745	struct raidlist_itself raidlist, char device)
746	{
747
748	/ int *************************************************************/
749	int i = 0;
750	int items = 0;
751
752	/ bool ************************************************************/
753	bool delete_partitions_too;
754
755	/ buffers *********************************************************/
756	char *tmp = NULL;
757
758	assert(mountlist != NULL);
759	assert(raidlist != NULL);
760	assert_string_is_neither_NULL_nor_zerolength(device);
761
762	i = find_raid_device_in_raidlist(raidlist, device);
763	if (i < 0) {
764	return;
765	}
766	mr_asprintf(tmp, "Do you want me to delete %s's partitions, too?", device);
767	delete_partitions_too = ask_me_yes_or_no(tmp);
768	if (delete_partitions_too) {
769	#ifdef __FreeBSD__
770	// static so it's zeroed
771	static struct list_of_disks d;
772	int x, y, z;
773
774	for (x = 0; x < raidlist->el[i].plexes; ++x) {
775	for (y = 0; y < raidlist->el[i].plex[x].subdisks; ++y) {
776	for (z = 0; z < raidlist->disks.entries; ++z) {
777	if (!strcmp(raidlist->el[i].plex[x].sd[y].which_device,
778	raidlist->disks.el[z].name)) {
779	strcpy(d.el[d.entries].name, raidlist->disks.el[z].name);
780	strcpy(d.el[d.entries++].device, raidlist->disks.el[z].device);
781	}
782	}
783	}
784	}
785
786	del_partns_listed_in_disklist(mountlist, raidlist, &d);
787	#else
788	del_partns_listed_in_disklist(mountlist, raidlist,
789	&raidlist->el[i].data_disks);
790	del_partns_listed_in_disklist(mountlist, raidlist,
791	&raidlist->el[i].spare_disks);
792	del_partns_listed_in_disklist(mountlist, raidlist,
793	&raidlist->el[i].parity_disks);
794	del_partns_listed_in_disklist(mountlist, raidlist,
795	&raidlist->el[i].failed_disks);
796	#endif
797	}
798	items = raidlist->entries;
799	if (items == 1) {
800	items = 0;
801	} else {
802	log_it(tmp);
803	memcpy((void *) &raidlist->el[i],
804	(void *) &raidlist->el[items - 1],
805	sizeof(struct OSSWAP (raid_device_record, vinum_volume)));
806	items--;
807	}
808	mr_free(tmp);
809	raidlist->entries = items;
810	}
811
812
813	#ifndef __FreeBSD__
814	/**
815	* Delete entry number @p lino in the additional RAID variables section of @p raidrec.
816	* @param raidrec The RAID device record containing the RAID variable to delete.
817	* @param lino The line number (starting from 0) of the variable to delete.
818	* @ingroup restoreGuiVarslist
819	*/
820	void delete_varslist_entry(struct raid_device_record *raidrec, int lino)
821	{
822
823	/ buffers **********************************************************/
824	char *tmp = NULL;
825	int res = 0;
826
827	/ structures *******************************************************/
828	struct additional_raid_variables *av;
829
830	assert(raidrec != NULL);
831
832	av = &raidrec->additional_vars;
833	mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
834	res = ask_me_yes_or_no(tmp);
835	mr_free(tmp);
836
837	if (res) {
838	if (!strcmp(av->el[lino].label, "persistent-superblock")
839	\|\| !strcmp(av->el[lino].label, "chunk-size")) {
840	mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
841	popup_and_OK(tmp);
842	mr_free(tmp);
843	} else {
844	memcpy((void ) &av->el[lino], (void ) &av->el[av->entries--],
845	sizeof(struct raid_var_line));
846	}
847	}
848	}
849	#endif
850
851
852	/**
853	* Redraw the filelist display.
854	* @param filelist The filelist structure to edit.
855	* @param keylist The list of keys for @p listbox.
856	* @param listbox The Newt listbox component containing some of the filelist entries.
857	* @return The number of lines currently being displayed.
858	* @ingroup restoreGuiGroup
859	*/
860	int
861	redraw_filelist(struct s_node filelist, void keylist[ARBITRARY_MAXIMUM],
862	newtComponent listbox)
863	{
864
865	/ int *************************************************************/
866	static int lines_in_flist_window = 0;
867	static int depth = 0;
868
869	/ long ************************************************************/
870	long i = 0;
871
872	/ structures *****************************************************/
873	struct s_node *node;
874
875	/ buffers ********************************************************/
876	static char current_filename[MAX_STR_LEN];
877	char tmp[MAX_STR_LEN + 2];
878	char *tmp1 = NULL;
879
880	/ bool ***********************************************************/
881	/* voiddummyptr; /
882	bool dummybool;
883	static bool warned_already;
884
885	assert(filelist != NULL);
886	assert(keylist != NULL);
887	assert(listbox != NULL);
888
889
890	if (depth == 0) {
891	lines_in_flist_window = 0;
892	warned_already = FALSE;
893	for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
894	g_strings_of_flist_window[i][0] = '\0';
895	g_is_path_selected[i] = FALSE;
896	}
897	}
898	for (node = filelist; node != NULL; node = node->right) {
899	current_filename[depth] = node->ch;
900	if (node->down) {
901	depth++;
902	i = redraw_filelist(node->down, keylist, listbox);
903	depth--;
904	}
905	if (node->ch == '\0' && node->expanded) {
906	if (lines_in_flist_window == ARBITRARY_MAXIMUM) {
907	if (!warned_already) {
908	warned_already = TRUE;
909	mr_asprintf(tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM);
910	popup_and_OK(tmp1);
911	mr_free(tmp1);
912	}
913	} else {
914	strcpy(g_strings_of_flist_window[lines_in_flist_window], current_filename);
915	g_is_path_selected[lines_in_flist_window] = node->selected;
916	lines_in_flist_window++;
917	}
918	}
919	}
920	if (depth == 0) {
921	if (lines_in_flist_window > ARBITRARY_MAXIMUM) {
922	lines_in_flist_window = ARBITRARY_MAXIMUM;
923	}
924	/* do an elementary sort */
925	for (i = 1; i < lines_in_flist_window; i++) {
926	if (strcmp
927	(g_strings_of_flist_window[i],
928	g_strings_of_flist_window[i - 1]) < 0) {
929	mr_asprintf(tmp1, "%s", g_strings_of_flist_window[i]);
930	strcpy(g_strings_of_flist_window[i], g_strings_of_flist_window[i - 1]);
931	strcpy(g_strings_of_flist_window[i - 1], tmp1);
932	mr_free(tmp1);
933	dummybool = g_is_path_selected[i];
934	g_is_path_selected[i] = g_is_path_selected[i - 1];
935	g_is_path_selected[i - 1] = dummybool;
936	i = 0;
937	}
938	}
939	/* write list to screen */
940	newtListboxClear(listbox);
941	for (i = 0; i < lines_in_flist_window; i++) {
942	sprintf(tmp, "%c%c %-80s", (g_is_path_selected[i] ? '*' : ' '),
943	(g_is_path_expanded[i] ? '+' : '-'),
944	strip_path(g_strings_of_flist_window[i]));
945	tmp[70] = '\0';
946	keylist[i] = (void *) i;
947	newtListboxAppendEntry(listbox, tmp, keylist[i]);
948	}
949	return (lines_in_flist_window);
950	} else {
951	return (0);
952	}
953	}
954
955
956	/**
957	* Strip a path to the bare minimum (^ pointing to the directory above, plus filename).
958	* @param tmp The path to strip.
959	* @return The stripped path.
960	* @author Conor Daly
961	* @ingroup restoreUtilityGroup
962	*/
963	char strip_path(char tmp)
964	{
965
966	int i = 0, j = 0, slashcount = 0;
967	int slashloc = 0, lastslashloc = 0;
968
969	while (tmp[i] != '\0') { /* Count the slashes in tmp
970	1 slash per dir */
971	if (tmp[i] == '/') {
972	slashcount++;
973	lastslashloc = slashloc;
974	slashloc = i;
975	if (tmp[i + 1] == '\0') { /* if this slash is last char, back off */
976	slashcount--;
977	slashloc = lastslashloc;
978	}
979	}
980	i++;
981	}
982	if (slashcount > 0)
983	slashcount--; /* Keep one slash 'cos Hugh does... */
984
985	for (i = 0; i < slashcount; i++) { /* Replace each dir with a space char */
986	tmpnopath[i] = ' ';
987	}
988
989	i = slashloc;
990	j = slashcount;
991	while (tmp[i] != '\0') { /* Now add what's left of tmp */
992	if ((tmpprevpath[j] == ' ' \|\| tmpprevpath[j] == '^')
993	&& tmp[i] == '/' && tmpnopath[j - 1] != '^' && j != 0) { /* Add a pointer upwards if this is not in the same dir as line above */
994	tmpnopath[j - 1] = '^';
995	} else {
996	tmpnopath[j++] = tmp[i++];
997	}
998	}
999	tmpnopath[j] = '\0';
1000
1001	strcpy(tmpprevpath, tmpnopath); /* Make a copy for next iteration */
1002
1003	return (tmpnopath);
1004	}
1005
1006
1007	/**
1008	* Allow the user to edit the filelist and choose which files to restore.
1009	* @param filelist The node structure containing the filelist.
1010	* @return 0 if the user pressed OK, 1 if they pressed Cancel.
1011	*/
1012	int edit_filelist(struct s_node *filelist)
1013	{
1014
1015	/ newt ************************************************************/
1016	newtComponent myForm;
1017	newtComponent bLess = NULL;
1018	newtComponent bMore = NULL;
1019	newtComponent bToggle = NULL;
1020	newtComponent bOK = NULL;
1021	newtComponent bCancel = NULL;
1022	newtComponent b_res = NULL;
1023	newtComponent filelistListbox = NULL;
1024	newtComponent bRegex = NULL;
1025
1026	/ int *************************************************************/
1027	int finished = FALSE;
1028	int lines_in_flist_window = 0;
1029	int indexno = 0;
1030	int j = 0;
1031
1032	/ ???? ************************************************************/
1033	void *curr_choice;
1034	void *keylist[ARBITRARY_MAXIMUM];
1035
1036	/ bool ************************************************************/
1037	bool dummybool;
1038
1039	/* struct s_node node; /
1040
1041	assert(filelist != NULL);
1042
1043	log_to_screen("Editing filelist");
1044	newtPushHelpLine
1045	(" Please edit the filelist to your satisfaction, then click OK or Cancel.");
1046	j = 4;
1047	bLess = newtCompactButton(j, 17, " Less ");
1048	bMore = newtCompactButton(j += 12, 17, " More ");
1049	bToggle = newtCompactButton(j += 12, 17, "Toggle");
1050	bRegex = newtCompactButton(j += 12, 17, "RegEx");
1051	bCancel = newtCompactButton(j += 12, 17, "Cancel");
1052	bOK = newtCompactButton(j += 12, 17, " OK ");
1053	filelistListbox =
1054	newtListbox(2, 1, 15, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
1055	toggle_all_root_dirs_on(filelist);
1056	lines_in_flist_window =
1057	redraw_filelist(filelist, keylist, filelistListbox);
1058	newtOpenWindow(1, 3, 77, 18, "Editing filelist");
1059	myForm = newtForm(NULL, NULL, 0);
1060	newtFormAddComponents(myForm, filelistListbox, bLess, bMore, bToggle,
1061	bRegex, bCancel, bOK, NULL);
1062	while (!finished) {
1063	b_res = newtRunForm(myForm);
1064	if (b_res == bOK) {
1065	finished =
1066	ask_me_yes_or_no
1067	("Are you happy with your file selection?");
1068	} else if (b_res == bCancel) {
1069	finished = TRUE;
1070	} else if (b_res == bRegex) {
1071	popup_and_OK("I haven't implemented this yet...");
1072	} else {
1073	curr_choice = newtListboxGetCurrent(filelistListbox);
1074	for (indexno = 0;
1075	indexno < lines_in_flist_window
1076	&& keylist[indexno] != curr_choice; indexno++);
1077	if (indexno == lines_in_flist_window) {
1078	log_it
1079	("I don't know what this button does; assuming I am to toggle 1st entry");
1080	indexno = 0;
1081	}
1082	log_it("You selected '%s'", g_strings_of_flist_window[indexno]);
1083
1084	if (b_res == bMore) {
1085	g_is_path_expanded[indexno] = TRUE;
1086	toggle_path_expandability(filelist,
1087	g_strings_of_flist_window
1088	[indexno], TRUE);
1089	lines_in_flist_window =
1090	redraw_filelist(filelist, keylist, filelistListbox);
1091	newtListboxSetCurrentByKey(filelistListbox, curr_choice);
1092	} else if (b_res == bLess) {
1093	g_is_path_expanded[indexno] = FALSE;
1094	toggle_path_expandability(filelist,
1095	g_strings_of_flist_window
1096	[indexno], FALSE);
1097	lines_in_flist_window =
1098	redraw_filelist(filelist, keylist, filelistListbox);
1099	newtListboxSetCurrentByKey(filelistListbox, curr_choice);
1100	} else {
1101	if (!strcmp(g_strings_of_flist_window[indexno], "/")) {
1102	dummybool = !g_is_path_selected[indexno];
1103	for (j = 1; j < lines_in_flist_window; j++) {
1104	toggle_path_selection(filelist,
1105	g_strings_of_flist_window[j],
1106	dummybool);
1107	}
1108	} else {
1109	toggle_path_selection(filelist,
1110	g_strings_of_flist_window
1111	[indexno],
1112	!g_is_path_selected[indexno]);
1113	lines_in_flist_window =
1114	redraw_filelist(filelist, keylist,
1115	filelistListbox);
1116	}
1117	newtListboxSetCurrentByKey(filelistListbox, curr_choice);
1118	}
1119	for (indexno = 0;
1120	indexno < lines_in_flist_window
1121	&& keylist[indexno] != curr_choice; indexno++);
1122	if (indexno == lines_in_flist_window) {
1123	log_it
1124	("Layout of table has changed. Y pointer is reverting to zero.");
1125	indexno = 0;
1126	}
1127	}
1128	}
1129	newtFormDestroy(myForm);
1130	newtPopWindow();
1131	newtPopHelpLine();
1132	if (b_res == bOK) {
1133	return (0);
1134	} else {
1135	/* popup_and_OK("You pushed 'cancel'. I shall now abort."); */
1136	return (1);
1137	}
1138	}
1139
1140
1141	/**
1142	* Edit an entry in @p mountlist.
1143	* @param mountlist The mountlist containing information about the user's partitions.
1144	* @param raidlist The raidlist to accompany @p mountlist.
1145	* @param listbox The Newt listbox component in the mountlist editor.
1146	* @param currline The selected line (starting from 0) in @p listbox.
1147	* @param keylist The list of keys for @p listbox.
1148	* @ingroup restoreGuiMountlist
1149	*/
1150	void
1151	edit_mountlist_entry(struct mountlist_itself *mountlist,
1152	struct raidlist_itself *raidlist,
1153	newtComponent listbox, int currline, void *keylist[])
1154	{
1155
1156	/ structures ******************************************************/
1157	static struct raidlist_itself bkp_raidlist;
1158
1159	/ newt ************************************************************/
1160	newtComponent myForm;
1161	newtComponent bOK;
1162	newtComponent bCancel;
1163	newtComponent b_res;
1164	newtComponent mountpointComp;
1165	newtComponent label0;
1166	newtComponent label1;
1167	newtComponent label2;
1168	newtComponent label3;
1169	newtComponent sizeComp;
1170	newtComponent deviceComp;
1171	newtComponent formatComp;
1172	newtComponent b_raid = NULL;
1173
1174	/ buffers *********************************************************/
1175	char *device_str = NULL;
1176	char *mountpoint_str = NULL;
1177	char *size_str = NULL;
1178	char *format_str = NULL;
1179	char *tmp = NULL;
1180	char *device_used_to_be = NULL;
1181	char *mountpt_used_to_be = NULL;
1182
1183	/ pointers ********************************************************/
1184	char *device_here;
1185	char *mountpoint_here;
1186	char *size_here;
1187	char *format_here;
1188
1189	/ int *************************************************************/
1190	int j = 0;
1191
1192	assert(mountlist != NULL);
1193	assert(raidlist != NULL);
1194	assert(listbox != NULL);
1195	assert(keylist != NULL);
1196
1197	memcpy((void ) &bkp_raidlist, (void ) raidlist,
1198	sizeof(struct raidlist_itself));
1199	mr_asprintf(device_str, "%s", mountlist->el[currline].device);
1200	mr_asprintf(device_used_to_be, "%s", mountlist->el[currline].device);
1201	mr_asprintf(mountpoint_str, "%s", mountlist->el[currline].mountpoint);
1202	mr_asprintf(mountpt_used_to_be, "%s", mountlist->el[currline].mountpoint);
1203	mr_asprintf(format_str, "%s", mountlist->el[currline].format);
1204	mr_asprintf(size_str, "%lld", mountlist->el[currline].size / 1024L);
1205	newtOpenWindow(20, 5, 48, 10, "Edit entry");
1206	label0 = newtLabel(2, 1, "Device:");
1207	label1 = newtLabel(2, 2, "Mountpoint:");
1208	label2 = newtLabel(2, 3, "Size (MB): ");
1209	label3 = newtLabel(2, 4, "Format: ");
1210	deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
1211	mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
1212	formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
1213	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
1214	\|\| !strcmp(mountlist->el[currline].mountpoint, "image")) {
1215	sizeComp = newtLabel(14, 3, size_str);
1216	} else {
1217	sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
1218	}
1219	bOK = newtButton(2, 6, " OK ");
1220	bCancel = newtButton(14, 6, "Cancel");
1221	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
1222	b_raid = newtButton(26, 6, "RAID..");
1223	}
1224	newtPushHelpLine
1225	(" Edit this partition's mountpoint, size and format; then click 'OK'.");
1226	myForm = newtForm(NULL, NULL, 0);
1227	newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
1228	formatComp, label0, label1, label2, label3, bOK,
1229	bCancel, b_raid, NULL);
1230	for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
1231	b_res = newtRunForm(myForm);
1232	mr_free(device_str);
1233	mr_asprintf(device_str, "%s", device_here);
1234	mr_strip_spaces(device_str);
1235
1236	mr_free(mountpoint_str);
1237	mr_asprintf(mountpoint_str, "%s", mountpoint_here);
1238	mr_strip_spaces(mountpoint_str);
1239
1240	mr_free(format_str);
1241	mr_asprintf(format_str, "%s", format_here);
1242	mr_strip_spaces(format_str);
1243
1244	if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB)
1245	&& strstr(device_used_to_be, RAID_DEVICE_STUB)
1246	&& strcmp(device_str, device_used_to_be)) {
1247	popup_and_OK("You can't change /dev/mdX to /dev/mdY.");
1248	b_res = NULL;
1249	continue;
1250	} else if (b_res == bOK && !strcmp(mountpoint_str, "image")
1251	&& strcmp(mountpt_used_to_be, "image")) {
1252	popup_and_OK("You can't change a regular device to an image.");
1253	b_res = NULL;
1254	continue;
1255	}
1256	if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
1257	&& strcmp(mountlist->el[currline].mountpoint, "image")) {
1258	mr_free(size_str);
1259	mr_asprintf(size_str, "%s", size_here);
1260	mr_strip_spaces(size_str);
1261	} else {
1262	mr_asprintf(size_str, "%ld", calculate_raid_device_size(mountlist, raidlist, mountlist->el[currline].device) / 1024);
1263	newtLabelSetText(sizeComp, size_str);
1264	}
1265	/* do not let user click RAID button if user has changed device_str */
1266	if (b_res == b_raid) {
1267	if (strcmp(device_str, mountlist->el[currline].device)) {
1268	/*
1269	can't change mountlist's entry from /dex/mdX to /dev/mdY: it would ugly
1270	when you try to map the changes over to the raidtab list, trust me
1271	*/
1272	popup_and_OK
1273	("You cannot edit the RAID settings until you have OK'd your change to the device node.");
1274	} else {
1275	j = find_raid_device_in_raidlist(raidlist,
1276	mountlist->el[currline].
1277	device);
1278	if (j < 0) {
1279	mr_asprintf(tmp, "/etc/raidtab does not have an entry for %s; please delete it and add it again", mountlist->el[currline].device);
1280	popup_and_OK(tmp);
1281	mr_free(tmp);
1282	} else {
1283	log_it("edit_raidlist_entry - calling");
1284	edit_raidlist_entry(mountlist, raidlist,
1285	&raidlist->el[j], currline);
1286	}
1287	}
1288	}
1289	}
1290	newtFormDestroy(myForm);
1291	newtPopHelpLine();
1292	newtPopWindow();
1293	mr_free(mountpt_used_to_be);
1294
1295	if (b_res == bCancel) {
1296	memcpy((void ) raidlist, (void ) &bkp_raidlist,
1297	sizeof(struct raidlist_itself));
1298	mr_free(device_str);
1299	mr_free(device_used_to_be);
1300	mr_free(format_str);
1301	mr_free(size_str);
1302	return;
1303	}
1304	strcpy(mountlist->el[currline].device, device_str);
1305	strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
1306	mr_free(mountpoint_str);
1307
1308	strcpy(mountlist->el[currline].format, format_str);
1309	mr_free(format_str);
1310
1311	if (strcmp(mountlist->el[currline].mountpoint, "image")) {
1312	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
1313	mountlist->el[currline].size =
1314	calculate_raid_device_size(mountlist, raidlist,
1315	mountlist->el[currline].device);
1316	} else {
1317	mountlist->el[currline].size = atol(size_str) * 1024L;
1318	}
1319	}
1320	mr_free(size_str);
1321	newtListboxSetEntry(listbox, (long) keylist[currline],
1322	mountlist_entry_to_string(mountlist, currline));
1323	/* if new /dev/md RAID device then do funky stuff */
1324	if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
1325	&& !strstr(device_used_to_be, RAID_DEVICE_STUB)) {
1326	initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
1327	}
1328	/* if moving from RAID to non-RAID then do funky stuff */
1329	else if (strstr(device_used_to_be, RAID_DEVICE_STUB)
1330	&& !strstr(device_str, RAID_DEVICE_STUB)) {
1331	delete_raidlist_entry(mountlist, raidlist, device_str);
1332	}
1333	/* if moving a non-RAID to another non-RAID then re-jig any RAID disks, if necessary */
1334	else if (!strstr(device_used_to_be, RAID_DEVICE_STUB)
1335	&& !strstr(device_str, RAID_DEVICE_STUB)) {
1336	rejig_partition_name_in_raidlist_if_necessary(raidlist,
1337	device_used_to_be,
1338	device_str);
1339	}
1340	/* else, moving a RAID to another RAID; bad idea, or so I thought */
1341	#ifndef __FreeBSD__ /* It works fine under FBSD. */
1342	else if (strcmp(device_used_to_be, device_str)) {
1343	popup_and_OK("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it.");
1344	}
1345	#endif
1346	mr_free(device_str);
1347	mr_free(device_used_to_be);
1348
1349	redraw_mountlist(mountlist, keylist, listbox);
1350	}
1351
1352
1353	#if __FreeBSD__
1354	/**
1355	* Add a subdisk to @p raidrec.
1356	* @param raidlist The raidlist containing information about RAID partitions.
1357	* @param raidrec The RAID device record to add the subdisk to.
1358	* @param temp The device name of the RAID disk to add it to.
1359	* @author Joshua Oreman
1360	* @ingroup restoreGuiMountlist
1361	*/
1362	void
1363	add_raid_subdisk(struct raidlist_itself *raidlist,
1364	struct vinum_plex raidrec, char temp)
1365	{
1366	int i;
1367	bool found = FALSE;
1368
1369	for (i = 0; i < raidlist->disks.entries; ++i) {
1370	if (!strcmp(raidlist->disks.el[i].device, temp)) {
1371	strcpy(raidrec->sd[raidrec->subdisks].which_device, raidlist->disks.el[i].name);
1372	found = TRUE;
1373	}
1374	}
1375	if (!found) {
1376	sprintf(raidlist->disks.el[raidlist->disks.entries].name, "drive%i", raidlist->disks.entries);
1377	sprintf(raidrec->sd[raidrec->subdisks].which_device, "drive%i", raidlist->disks.entries);
1378	strcpy(raidlist->disks.el[raidlist->disks.entries++].device, temp);
1379	}
1380	raidrec->subdisks++;
1381	}
1382
1383
1384	/**
1385	* Determine the /dev entry for @p vinum_name.
1386	* @param raidlist The raidlist containing information about RAID devices.
1387	* @param vinum_name The name of the Vinum drive to map to a /dev entry.
1388	* @return The /dev entry, or NULL if none was found.
1389	* @note The returned string points to static storage that will be overwritten with each call.
1390	* @author Joshua Oreman
1391	* @ingroup restoreUtilityGroup
1392	*/
1393	char find_dev_entry_for_raid_device_name(struct raidlist_itself raidlist,
1394	char *vinum_name)
1395	{
1396	int i;
1397	for (i = 0; i < raidlist->disks.entries; ++i) {
1398	if (!strcmp(raidlist->disks.el[i].name, vinum_name)) {
1399	return raidlist->disks.el[i].device;
1400	}
1401	}
1402	return NULL;
1403	}
1404
1405	void
1406	edit_raidlist_plex(struct mountlist_itself *mountlist,
1407	struct raidlist_itself *raidlist,
1408	struct vinum_plex *raidrec, int currline,
1409	int currline2);
1410
1411	#endif
1412
1413
1414	/**
1415	* Edit the entry for @p raidrec in @p raidlist.
1416	* @param mountlist The mountlist to get some information from.
1417	* @param raidlist The raidlist containing information about RAID devices.
1418	* @param raidrec The RAID device record for this partition.
1419	* @param currline The line number (starting from 0) in the mountlist of the RAID device.
1420	* @ingroup restoreGuiMountlist
1421	*/
1422	void
1423	edit_raidlist_entry(struct mountlist_itself *mountlist,
1424	struct raidlist_itself *raidlist,
1425	struct OSSWAP (raid_device_record,
1426	vinum_volume) * raidrec, int currline)
1427	{
1428
1429	#ifdef __FreeBSD__
1430	/ structures ******************************************************/
1431	struct vinum_volume bkp_raidrec;
1432
1433
1434	/ buffers *********************************************************/
1435	char title_of_editraidForm_window[MAX_STR_LEN];
1436
1437	/ newt ************************************************************/
1438	newtComponent editraidForm;
1439	newtComponent bOK;
1440	newtComponent bCancel;
1441	newtComponent bEdit;
1442	newtComponent bAdd;
1443	newtComponent bDelete;
1444	newtComponent b_res;
1445	newtComponent plexesListbox;
1446	newtComponent plexesHeader;
1447
1448	void *keylist[10];
1449	void *curr_choice;
1450	char *raidlevel = NULL;
1451	char *chunksize = NULL;
1452	char *msg = NULL;
1453
1454	int currline2 = 0;
1455	int res = 0;
1456
1457	log_it("Started edit_raidlist_entry");
1458	memcpy((void ) &bkp_raidrec, (void ) raidrec,
1459	sizeof(struct vinum_volume));
1460	sprintf(title_of_editraidForm_window, "Plexes on %s",
1461	raidrec->volname);
1462	newtPushHelpLine(" Please select a plex to edit");
1463	newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
1464	for (;;) {
1465	int i;
1466	char headerstr[MAX_STR_LEN];
1467	snprintf(headerstr, MAX_STR_LEN, "%-14s %-8s %11s %8s",
1468	"Plex", "Level", "Stripe Size", "Subdisks");
1469
1470	bOK = newtCompactButton(2, 13, " OK ");
1471	bCancel = newtCompactButton(12, 13, "Cancel");
1472	bAdd = newtCompactButton(22, 13, " Add ");
1473	bEdit = newtCompactButton(32, 13, " Edit ");
1474	bDelete = newtCompactButton(42, 13, "Delete");
1475
1476	plexesListbox =
1477	newtListbox(2, 3, 9, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
1478	plexesHeader = newtLabel(2, 2, headerstr);
1479	editraidForm = newtForm(NULL, NULL, 0);
1480
1481	newtListboxClear(plexesListbox);
1482	for (i = 0; i < 10; ++i) {
1483	keylist[i] = (void *) i;
1484	if (i < raidrec->plexes) {
1485	char pname[64], entry[MAX_STR_LEN];
1486	switch (raidrec->plex[i].raidlevel) {
1487	case -1:
1488	mr_asprintf(raidlevel, "concat");
1489	break;
1490	case 0:
1491	mr_asprintf(raidlevel, "striped");
1492	break;
1493	case 5:
1494	mr_asprintf(raidlevel, "raid5");
1495	break;
1496	default:
1497	mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
1498	break;
1499	}
1500
1501	if (raidrec->plex[i].raidlevel == -1) {
1502	mr_asprintf(chunksize, "N/A");
1503	} else {
1504	mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
1505	}
1506	snprintf(pname, 64, "%s.p%i", raidrec->volname, i);
1507	snprintf(entry, MAX_STR_LEN, "%-14s %-8s %11s %8d",
1508	pname, raidlevel, chunksize,
1509	raidrec->plex[i].subdisks);
1510	mr_free(raidlevel);
1511	mr_free(chunksize);
1512
1513	newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
1514	}
1515	}
1516
1517	newtFormAddComponents(editraidForm, bOK, bCancel, bAdd, bEdit,
1518	bDelete, plexesListbox, plexesHeader, NULL);
1519
1520	b_res = newtRunForm(editraidForm);
1521	if (b_res == bOK \|\| b_res == bCancel) {
1522	break;
1523	}
1524
1525	curr_choice = newtListboxGetCurrent(plexesListbox);
1526	for (currline2 = 0; currline2 < raidrec->plexes; ++currline2) {
1527	if (currline2 > 9)
1528	break;
1529	if (keylist[currline2] == curr_choice)
1530	break;
1531	}
1532
1533	if (b_res == bDelete) {
1534	mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
1535	res = ask_me_yes_or_no(msg);
1536	mr_free(msg);
1537
1538	if (res) {
1539	log_it("Deleting RAID plex");
1540	memcpy((void *) &raidrec->plex[currline2],
1541	(void *) &raidrec->plex[raidrec->plexes - 1],
1542	sizeof(struct vinum_plex));
1543	raidrec->plexes--;
1544	}
1545	continue;
1546	}
1547	if (b_res == bAdd) {
1548	raidrec->plex[raidrec->plexes].raidlevel = 0;
1549	raidrec->plex[raidrec->plexes].stripesize = 279;
1550	raidrec->plex[raidrec->plexes].subdisks = 0;
1551	currline2 = raidrec->plexes++;
1552	}
1553	edit_raidlist_plex(mountlist, raidlist, &raidrec->plex[currline2],
1554	currline, currline2);
1555	newtFormDestroy(editraidForm);
1556	}
1557	if (b_res == bCancel) {
1558	memcpy((void ) raidrec, (void ) &bkp_raidrec,
1559	sizeof(struct vinum_volume));
1560	}
1561	newtPopHelpLine();
1562	newtPopWindow();
1563	mountlist->el[currline].size =
1564	calculate_raid_device_size(mountlist, raidlist, raidrec->volname);
1565	#else
1566	/ structures ******************************************************/
1567	struct raid_device_record *bkp_raidrec;
1568
1569
1570	/ buffers *********************************************************/
1571	char *title_of_editraidForm_window;
1572	char *sz_raid_level = NULL;
1573	char *sz_data_disks = NULL;
1574	char *sz_spare_disks = NULL;
1575	char *sz_parity_disks = NULL;
1576	char *sz_failed_disks = NULL;
1577
1578	/ newt ************************************************************/
1579	newtComponent editraidForm;
1580	newtComponent bOK;
1581	newtComponent bCancel;
1582	newtComponent bAdditional;
1583	newtComponent bChangeRaid;
1584	newtComponent bSelectData;
1585	newtComponent bSelectSpare;
1586	newtComponent bSelectParity;
1587	newtComponent bSelectFailed;
1588	newtComponent b_res;
1589
1590	assert(mountlist != NULL);
1591	assert(raidlist != NULL);
1592	assert(raidrec != NULL);
1593
1594	bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
1595	log_it("Started edit_raidlist_entry");
1596
1597	memcpy((void ) bkp_raidrec, (void ) raidrec, sizeof(struct raid_device_record));
1598	mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
1599	log_msg(2, "Opening newt window");
1600	newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
1601	for (;;) {
1602	log_msg(2, "Main loop");
1603	mr_free(title_of_editraidForm_window);
1604	mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
1605	mr_asprintf(sz_raid_level, "%s", turn_raid_level_number_to_string(raidrec->raid_level));
1606	/* Those 4 strings are allocated by the function */
1607	sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
1608	sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
1609	sz_parity_disks = number_of_disks_as_string(raidrec->parity_disks.entries, "parity");
1610	sz_failed_disks = number_of_disks_as_string(raidrec->failed_disks.entries, "failed");
1611	bSelectData = newtButton(1, 1, sz_data_disks);
1612	bSelectSpare = newtButton(20, 1, sz_spare_disks);
1613	bSelectParity = newtButton(1, 5, sz_parity_disks);
1614	bSelectFailed = newtButton(20, 5, sz_failed_disks);
1615	bChangeRaid = newtButton(1, 9, sz_raid_level);
1616	bOK = newtButton(16 + (raidrec->raid_level == -1), 9, " OK ");
1617	bCancel = newtButton(28, 9, "Cancel");
1618	bAdditional =
1619	newtCompactButton(1, 13,
1620	"Additional settings and information");
1621	newtPushHelpLine
1622	(" Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
1623	editraidForm = newtForm(NULL, NULL, 0);
1624	newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
1625	bChangeRaid, bSelectSpare, bSelectFailed,
1626	bOK, bCancel, bAdditional);
1627	b_res = newtRunForm(editraidForm);
1628	if (b_res == bChangeRaid) {
1629	choose_raid_level(raidrec);
1630	} else if (b_res == bSelectData) {
1631	select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks);
1632	} else if (b_res == bSelectSpare) {
1633	select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks);
1634	} else if (b_res == bSelectParity) {
1635	select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks);
1636	} else if (b_res == bSelectFailed) {
1637	select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks);
1638	} else if (b_res == bAdditional) {
1639	edit_raidrec_additional_vars(raidrec);
1640	}
1641	newtFormDestroy(editraidForm);
1642	if (b_res == bOK \|\| b_res == bCancel) {
1643	break;
1644	}
1645	mr_free(sz_data_disks);
1646	mr_free(sz_spare_disks);
1647	mr_free(sz_parity_disks);
1648	mr_free(sz_failed_disks);
1649	}
1650	if (b_res == bCancel) {
1651	memcpy((void ) raidrec, (void ) bkp_raidrec, sizeof(struct raid_device_record));
1652	}
1653	newtPopHelpLine();
1654	newtPopWindow();
1655	mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
1656	mr_free(title_of_editraidForm_window);
1657	mr_free(sz_raid_level);
1658	paranoid_free(bkp_raidrec);
1659	#endif
1660	}
1661
1662	#ifdef __FreeBSD__
1663
1664	/**
1665	* Edit the plex @p raidrec in @p raidlist.
1666	* @param mountlist The mountlist to get some of the information from.
1667	* @param raidlist The raidlist containing information about RAID devices.
1668	* @param raidrec The plex to edit.
1669	* @param currline The line number (starting from 0) of the RAID device in @p mountlist.
1670	* @param currline2 The line number (starting from 0) of the plex within the RAID device.
1671	* @author Joshua Oreman
1672	* @ingroup restoreGuiMountlist
1673	*/
1674	void
1675	edit_raidlist_plex(struct mountlist_itself *mountlist,
1676	struct raidlist_itself *raidlist,
1677	struct vinum_plex *raidrec, int currline, int currline2)
1678	{
1679
1680	/ structures ******************************************************/
1681	struct vinum_plex bkp_raidrec;
1682
1683
1684	/ buffers *********************************************************/
1685	char title_of_editraidForm_window[MAX_STR_LEN];
1686
1687	/ newt ************************************************************/
1688	newtComponent editraidForm;
1689	newtComponent bOK;
1690	newtComponent bCancel;
1691	newtComponent bEdit;
1692	newtComponent bAdd;
1693	newtComponent bDelete;
1694	newtComponent b_res;
1695	newtComponent unallocListbox, allocListbox;
1696	newtComponent bLevel, sLevel;
1697	newtComponent bStripeSize, sStripeSize;
1698	newtComponent bAlloc, bUnalloc;
1699
1700	void *keylist[ARBITRARY_MAXIMUM];
1701	void curr_choice_a, curr_choice_u;
1702	int currline_a, currline_u;
1703
1704	char *p = NULL;
1705	char *tmp = NULL;
1706	char *entry = NULL;
1707
1708	struct mountlist_itself *unallocparts;
1709
1710	unallocparts = malloc(sizeof(struct mountlist_itself));
1711
1712	log_it("Started edit_raidlist_entry");
1713	memcpy((void ) &bkp_raidrec, (void ) raidrec,
1714	sizeof(struct vinum_plex));
1715	sprintf(title_of_editraidForm_window, "%s.p%i",
1716	raidlist->el[currline].volname, currline2);
1717	newtPushHelpLine
1718	(" Please select a subdisk to edit, or edit this plex's parameters");
1719	newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
1720	for (;;) {
1721	int i;
1722
1723	switch (raidrec->raidlevel) {
1724	case -1:
1725	mr_asprintf(tmp, "concat");
1726	break;
1727	case 0:
1728	mr_asprintf(tmp, "striped");
1729	break;
1730	case 5:
1731	mr_asprintf(tmp, "raid5");
1732	break;
1733	default:
1734	mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
1735	break;
1736	}
1737	bLevel = newtCompactButton(2, 2, " RAID level ");
1738	sLevel = newtLabel(19, 2, tmp);
1739	mr_free(tmp);
1740
1741	if (raidrec->raidlevel >= 0) {
1742	mr_asprintf(tmp, "%ik", raidrec->stripesize);
1743	bStripeSize = newtCompactButton(2, 4, " Stripe size ");
1744	} else {
1745	mr_asprintf(tmp, "N/A");
1746	bStripeSize = newtLabel(2, 4, "Stripe size:");
1747	}
1748	sStripeSize = newtLabel(19, 4, tmp);
1749	mr_free(tmp);
1750
1751	bOK = newtCompactButton(2, 16, " OK ");
1752	bCancel = newtCompactButton(12, 16, "Cancel");
1753	bAdd = newtCompactButton(22, 16, " Add ");
1754	bEdit = newtCompactButton(32, 16, " Edit ");
1755	bDelete = newtCompactButton(42, 16, "Delete");
1756
1757
1758	unallocListbox =
1759	newtListbox(2, 7, 7, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
1760	allocListbox =
1761	newtListbox(33, 7, 7, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
1762	bAlloc = newtButton(23, 7, " -> ");
1763	bUnalloc = newtButton(23, 11, " <- ");
1764
1765	editraidForm = newtForm(NULL, NULL, 0);
1766
1767	newtListboxClear(allocListbox);
1768	newtListboxClear(unallocListbox);
1769	bzero(unallocparts, sizeof(struct mountlist_itself));
1770	make_list_of_unallocated_raid_partitions(unallocparts, mountlist,
1771	raidlist);
1772	for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
1773	keylist[i] = (void *) i;
1774	if (i < raidrec->subdisks) {
1775	mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
1776	newtListboxAppendEntry(allocListbox, entry, keylist[i]);
1777	mr_free(entry);
1778	}
1779	if (i < unallocparts->entries) {
1780	mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
1781	newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
1782	mr_free(entry);
1783	}
1784	}
1785
1786	#define COMP(x) newtFormAddComponent (editraidForm, x)
1787	#define UCOMP(x) if (unallocparts->entries > 0) COMP(x)
1788	#define ACOMP(x) if (raidrec->subdisks > 0) COMP(x)
1789	editraidForm = newtForm(NULL, NULL, 0);
1790	UCOMP(unallocListbox);
1791	UCOMP(bAlloc);
1792	ACOMP(allocListbox);
1793	ACOMP(bUnalloc);
1794	COMP(bOK);
1795	COMP(bCancel);
1796	COMP(bLevel);
1797	COMP(sLevel);
1798	if (raidrec->raidlevel != -1) {
1799	COMP(bStripeSize);
1800	COMP(sStripeSize);
1801	}
1802	#undef COMP
1803	#undef UCOMP
1804	#undef ACOMP
1805
1806	newtDrawForm(editraidForm);
1807	newtRefresh();
1808	b_res = newtRunForm(editraidForm);
1809	if (b_res == bOK \|\| b_res == bCancel) {
1810	break;
1811	}
1812
1813	curr_choice_a = (raidrec->subdisks > 0) ?
1814	newtListboxGetCurrent(allocListbox) : (void *) 1234;
1815	curr_choice_u = (unallocparts->entries > 0) ?
1816	newtListboxGetCurrent(unallocListbox) : (void *) 1234;
1817	for (currline_a = 0; currline_a < raidrec->subdisks; ++currline_a) {
1818	if (currline_a > ARBITRARY_MAXIMUM)
1819	break;
1820	if (keylist[currline_a] == curr_choice_a)
1821	break;
1822	}
1823	for (currline_u = 0; currline_u < unallocparts->entries;
1824	++currline_u) {
1825	if (currline_u > ARBITRARY_MAXIMUM)
1826	break;
1827	if (keylist[currline_u] == curr_choice_u)
1828	break;
1829	}
1830	if (b_res == bLevel) {
1831	choose_raid_level(raidrec);
1832	} else if (b_res == bStripeSize) {
1833	mr_asprintf(tmp, "%i", raidrec->stripesize);
1834	p = popup_and_get_string("Stripe size", "Please enter the stripe size in kilobytes.", tmp);
1835	mr_free(tmp);
1836
1837	if (p != NULL) {
1838	raidrec->stripesize = atoi(p);
1839	}
1840	mr_free(p);
1841	} else if ((b_res == bAlloc) \|\| (b_res == unallocListbox)) {
1842	if (currline_u <= unallocparts->entries)
1843	add_raid_subdisk(raidlist, raidrec,
1844	unallocparts->el[currline_u].device);
1845	} else if ((b_res == bUnalloc) \|\| (b_res == allocListbox)) {
1846	if (currline_a <= raidrec->subdisks) {
1847	memcpy((void *) &raidrec->sd[currline_a],
1848	(void *) &raidrec->sd[raidrec->subdisks - 1],
1849	sizeof(struct vinum_subdisk));
1850	raidrec->subdisks--;
1851	}
1852	}
1853	newtFormDestroy(editraidForm);
1854	newtRefresh();
1855	}
1856
1857	if (b_res == bCancel) {
1858	memcpy((void ) raidrec, (void ) &bkp_raidrec, sizeof(struct vinum_plex));
1859	}
1860	newtPopWindow();
1861	newtPopHelpLine();
1862	}
1863	#else
1864	/**
1865	* Edit additional RAID variable number @p lino.
1866	* @param raidrec The RAID device record to edit the variable in.
1867	* @param lino The line number (starting from 0) of the variable to edit.
1868	* @ingroup restoreGuiVarslist
1869	*/
1870	void edit_varslist_entry(struct raid_device_record *raidrec, int lino)
1871	{
1872
1873	/ buffers *********************************************************/
1874	char *header = NULL;
1875	char *comment = NULL;
1876	char *sz_out = NULL;
1877	char *p = NULL;
1878
1879	assert(raidrec != 0);
1880	assert(lino >= 0);
1881
1882	mr_asprintf(sz_out, "%s", raidrec->additional_vars.el[lino].value);
1883	mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
1884	mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
1885	p = popup_and_get_string(header, comment, sz_out);
1886	if (p != NULL) {
1887	mr_strip_spaces(p);
1888	strcpy(raidrec->additional_vars.el[lino].value, p);
1889	}
1890	mr_free(p);
1891	}
1892
1893	#endif
1894
1895	/**
1896	* Edit the mountlist using Newt.
1897	* @param mountlist The mountlist to edit.
1898	* @param raidlist The raidlist that goes with @p mountlist.
1899	* @return 0 if the user pressed OK, 1 if they pressed Cancel.
1900	*/
1901	int
1902	edit_mountlist_in_newt(char *mountlist_fname,
1903	struct mountlist_itself *mountlist,
1904	struct raidlist_itself *raidlist)
1905	{
1906
1907	/ newt ************************************************************/
1908	newtComponent myForm;
1909	newtComponent bAdd;
1910	newtComponent bEdit;
1911	newtComponent bDelete;
1912	newtComponent bOK;
1913	newtComponent bCancel;
1914	newtComponent b_res = NULL;
1915	newtComponent partitionsListbox;
1916	newtComponent headerMsg;
1917	newtComponent flawsLabelA;
1918	newtComponent flawsLabelB;
1919	newtComponent flawsLabelC;
1920	newtComponent bReload;
1921
1922	/ ???? ***********************************************************/
1923	void *curr_choice;
1924	void *keylist[ARBITRARY_MAXIMUM];
1925
1926	/ int ************************************************************/
1927	int i = 0;
1928	int currline = 0;
1929	int finished = FALSE;
1930
1931	/ buffers ********************************************************/
1932	char *tmp = NULL;
1933	char *flaws_str = NULL;
1934	char *flaws_str_A = NULL;
1935	char *flaws_str_B = NULL;
1936	char *flaws_str_C = NULL;
1937
1938	assert(mountlist != NULL);
1939	assert(raidlist != NULL);
1940
1941	if (mountlist->entries > ARBITRARY_MAXIMUM) {
1942	log_to_screen("Arbitrary limits suck, man!");
1943	finish(1);
1944	}
1945	newtPushHelpLine("WARNING: No LVM modification possible here. Edit /tmp/i-want-my-lvm instead");
1946	i = 4;
1947	bAdd = newtCompactButton(i, 17, " Add ");
1948	bEdit = newtCompactButton(i += 11, 17, " Edit ");
1949	bDelete = newtCompactButton(i += 12, 17, "Delete");
1950	bReload = newtCompactButton(i += 12, 17, "Reload");
1951	bCancel = newtCompactButton(i += 12, 17, "Cancel");
1952	bOK = newtCompactButton(i += 12, 17, " OK ");
1953	mr_asprintf(tmp, "%-24s %-24s %-8s %s", "Device", "Mountpoint", "Format", "Size (MB)");
1954	headerMsg = newtLabel(2, 1, tmp);
1955	flawsLabelA = newtLabel(2, 13, " ");
1956	flawsLabelB = newtLabel(2, 14, " ");
1957	flawsLabelC = newtLabel(2, 15, " ");
1958	partitionsListbox =
1959	newtListbox(2, 2, 10, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
1960	redraw_mountlist(mountlist, keylist, partitionsListbox);
1961	newtOpenWindow(1, 3, 77, 18, "Editing mountlist");
1962	myForm = newtForm(NULL, NULL, 0);
1963	newtFormAddComponents(myForm, headerMsg, partitionsListbox,
1964	flawsLabelA, flawsLabelB, flawsLabelC, bAdd,
1965	bEdit, bDelete, bReload, bCancel, bOK, NULL);
1966	while (!finished) {
1967	flaws_str = evaluate_mountlist(mountlist);
1968	/* flaws_str can be NULL */
1969	if ((flaws_str == NULL) \|\| (strlen(flaws_str) == 0)) {
1970	mr_asprintf(flaws_str_A, "");
1971	} else {
1972	mr_asprintf(flaws_str_A, "%s", flaws_str + 1);
1973	}
1974	if (strlen(flaws_str_A) >= 74) {
1975	for (i = 74; flaws_str_A[i] != ' '; i--);
1976	mr_asprintf(flaws_str_B, "%s", flaws_str_A + i + 1);
1977	flaws_str_A[i] = '\0';
1978	} else {
1979	mr_asprintf(flaws_str_B, "");
1980	}
1981	if (strlen(flaws_str_B) >= 74) {
1982	for (i = 74; flaws_str_B[i] != ' '; i--);
1983	mr_asprintf(flaws_str_C, "%s", flaws_str_B + i + 1);
1984	flaws_str_B[i] = '\0';
1985	} else {
1986	mr_asprintf(flaws_str_C, "");
1987	}
1988
1989	newtLabelSetText(flawsLabelA, flaws_str_A);
1990	newtLabelSetText(flawsLabelB, flaws_str_B);
1991	newtLabelSetText(flawsLabelC, flaws_str_C);
1992	b_res = newtRunForm(myForm);
1993	mr_free(flaws_str_A);
1994	mr_free(flaws_str_B);
1995	mr_free(flaws_str_C);
1996
1997	if (b_res == bOK) {
1998	if (flaws_str != NULL) {
1999	finished =
2000	ask_me_yes_or_no
2001	("Your mountlist might not work. Continue anyway?");
2002	} else {
2003	finished =
2004	ask_me_yes_or_no
2005	("Are you sure you want to save your mountlist and continue? (No changes will be made to your partition table at this time.)");
2006	}
2007	} else if (b_res == bCancel) {
2008	finished = TRUE;
2009	} else if (b_res == bReload) {
2010	if (ask_me_yes_or_no("Reload original mountlist?")) {
2011	load_mountlist(mountlist, mountlist_fname);
2012	load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
2013	redraw_mountlist(mountlist, keylist, partitionsListbox);
2014	}
2015	} else {
2016	curr_choice = newtListboxGetCurrent(partitionsListbox);
2017	for (i = 0;
2018	i < mountlist->entries && keylist[i] != curr_choice; i++);
2019	if (i == mountlist->entries && mountlist->entries > 0) {
2020	log_to_screen("I don't know what that button does!");
2021	} else {
2022	currline = i;
2023	if (b_res == bAdd) {
2024	add_mountlist_entry(mountlist, raidlist,
2025	partitionsListbox, currline,
2026	keylist);
2027	} else if (b_res == bDelete) {
2028	delete_mountlist_entry(mountlist, raidlist,
2029	partitionsListbox, currline,
2030	keylist);
2031	} else {
2032	if (mountlist->entries > 0) {
2033	edit_mountlist_entry(mountlist, raidlist,
2034	partitionsListbox, currline,
2035	keylist);
2036	} else {
2037	popup_and_OK
2038	("Please add an entry. Then press ENTER to edit it.");
2039	}
2040	}
2041	}
2042	}
2043	mr_free(flaws_str);
2044	}
2045	newtFormDestroy(myForm);
2046
2047	mr_free(flaws_str_A);
2048	mr_free(flaws_str_B);
2049	mr_free(flaws_str_C);
2050	mr_free(tmp);
2051
2052	newtPopWindow();
2053	newtPopHelpLine();
2054	if (b_res == bOK) {
2055	log_it("You pushed 'OK'. I shall now continue.");
2056	return (0);
2057	} else {
2058	/* popup_and_OK("You pushed 'cancel'. I shall now abort."); */
2059	return (1);
2060	}
2061	}
2062
2063
2064
2065	/**
2066	* Edit the mountlist.
2067	* @param mountlist The mountlist to edit.
2068	* @param raidlist The raidlist that goes with @p mountlist.
2069	* @return 0 if the user pressed OK, 1 if they pressed Cancel.
2070	*/
2071	int
2072	edit_mountlist(char mountlist_fname, struct mountlist_itself mountlist,
2073	struct raidlist_itself *raidlist)
2074	{
2075	int res = 0;
2076
2077	log_it("entering eml");
2078
2079	if (g_text_mode) {
2080	fatal_error("Don't call edit_mountlist() in text mode");
2081	} else {
2082	log_it
2083	("I'm in GUI mode, so I shall edit mountlist using edit_mountlist()");
2084	res = edit_mountlist_in_newt(mountlist_fname, mountlist, raidlist);
2085	}
2086	log_it("leaving eml");
2087	return (res);
2088	}
2089
2090
2091
2092
2093	#ifndef __FreeBSD__
2094	/**
2095	* Edit the additional RAID variables in @p raidrec.
2096	* @param raidrec The RAID device record to edit the RAID variables in.
2097	* @ingroup restoreGuiVarslist
2098	*/
2099	void edit_raidrec_additional_vars(struct raid_device_record *raidrec)
2100	{
2101
2102	/ structure *******************************************************/
2103	struct raid_device_record bkp_raidrec;
2104
2105	/ newt ************************************************************/
2106	newtComponent myForm;
2107	newtComponent bAdd;
2108	newtComponent bEdit;
2109	newtComponent bDelete;
2110	newtComponent bOK;
2111	newtComponent bCancel;
2112	newtComponent b_res;
2113	newtComponent varsListbox;
2114	newtComponent headerMsg;
2115
2116	/ ?? *************************************************************/
2117	void keylist[ARBITRARY_MAXIMUM], curr_choice;
2118
2119	/ buffers ********************************************************/
2120	char title_of_window[MAX_STR_LEN];
2121
2122	/ int ************************************************************/
2123	int i = 0;
2124	int currline = 0;
2125
2126
2127	assert(raidrec != NULL);
2128
2129	memcpy((void ) &bkp_raidrec, (void ) raidrec,
2130	sizeof(struct raid_device_record));
2131	sprintf(title_of_window, "Additional variables");
2132	newtPushHelpLine
2133	(" Edit the additional fields to your heart's content, then click OK or Cancel.");
2134	headerMsg = newtLabel(1, 1, "Label Value");
2135	varsListbox =
2136	newtListbox(1, 2, 6, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
2137	i = 1;
2138	bAdd = newtCompactButton(i, 9, " Add ");
2139	bEdit = newtCompactButton(i += 8, 9, " Edit ");
2140	bDelete = newtCompactButton(i += 9, 9, "Delete");
2141	bOK = newtCompactButton(i += 9, 9, " OK ");
2142	bCancel = newtCompactButton(i += 9, 9, "Cancel");
2143	newtOpenWindow(17, 7, 46, 10, title_of_window);
2144	myForm = newtForm(NULL, NULL, 0);
2145	newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
2146	bDelete, bOK, bCancel, NULL);
2147	insert_essential_additionalvars(raidrec);
2148	redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
2149	for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
2150	b_res = newtRunForm(myForm);
2151	curr_choice = newtListboxGetCurrent(varsListbox);
2152	for (currline = 0;
2153	currline < raidrec->additional_vars.entries
2154	&& keylist[currline] != curr_choice; currline++);
2155	if (currline == raidrec->additional_vars.entries
2156	&& raidrec->additional_vars.entries > 0) {
2157	log_it("Warning - I don't know what this button does");
2158	}
2159	if (b_res == bOK) { /* do nothing */
2160	} else if (b_res == bCancel) { /* do nothing */
2161	} else if (b_res == bAdd) {
2162	add_varslist_entry(raidrec);
2163	} else if (b_res == bDelete) {
2164	delete_varslist_entry(raidrec, currline);
2165	} else {
2166	edit_varslist_entry(raidrec, currline);
2167	}
2168	redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
2169	}
2170	remove_essential_additionalvars(raidrec);
2171	newtFormDestroy(myForm);
2172	newtPopWindow();
2173	newtPopHelpLine();
2174	if (b_res == bCancel) {
2175	memcpy((void ) raidrec, (void ) &bkp_raidrec,
2176	sizeof(struct raid_device_record));
2177	}
2178	return;
2179	}
2180	#endif
2181
2182
2183	/**
2184	* Find the next free location to place a disk in @p disklist.
2185	* @param disklist The disklist to operate on.
2186	* @return The next free location (starting from 0).
2187	* @ingroup restoreGuiDisklist
2188	*/
2189	int find_next_free_index_in_disklist(struct list_of_disks *disklist)
2190	{
2191
2192	/ int *************************************************************/
2193	int index = -1;
2194	int pos = 0;
2195
2196	/ bool ************************************************************/
2197	bool done;
2198
2199	assert(disklist != NULL);
2200
2201	for (done = FALSE; !done;) {
2202	for (pos = 0;
2203	pos < disklist->entries && disklist->el[pos].index <= index;
2204	pos++);
2205	if (pos >= disklist->entries) {
2206	done = TRUE;
2207	} else {
2208	index = disklist->el[pos].index;
2209	}
2210	}
2211	return (index + 1);
2212	}
2213
2214
2215
2216	/**
2217	* Locate @p device in @p raidlist.
2218	* @param raidlist The raidlist ot search in.
2219	* @param device The RAID device to search for.
2220	* @return The index of the device, or -1 if it could not be found.
2221	* @ingroup restoreGuiMountlist
2222	*/
2223	int
2224	find_raid_device_in_raidlist(struct raidlist_itself *raidlist,
2225	char *device)
2226	{
2227
2228	/ int *************************************************************/
2229	int i = 0;
2230	#ifdef __FreeBSD__
2231	char *vdev = NULL;
2232	int res = 0;
2233	#else
2234	// Linux
2235	#endif
2236
2237	assert(raidlist != NULL);
2238	assert_string_is_neither_NULL_nor_zerolength(device);
2239
2240	#ifdef __FreeBSD__
2241	for (i = 0; i < raidlist->entries; i++) {
2242	mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
2243	res = strcmp(device, vdev);
2244	mr_free(vdev);
2245
2246	if (!res)
2247	break;
2248	}
2249	#else
2250
2251	for (i = 0;
2252	strcmp(raidlist->el[i].raid_device, device)
2253	&& i < raidlist->entries; i++);
2254	#endif
2255	if (i == raidlist->entries) {
2256	return (-1);
2257	} else {
2258	return (i);
2259	}
2260	}
2261
2262
2263	/**
2264	* Get information about the location of ISO images from the user.
2265	* @param isodir_device Where to put the device (e.g. /dev/hda4) the user enters. Allocted by the function
2266	* @param isodir_format Where to put the format (e.g. ext2) the user enters.
2267	* @param isodir_path Where to put the path (e.g. /var/cache/mondo) the user enters.
2268	* @param nuke_me_please Whether we're planning on nuking or not.
2269	* @return TRUE if OK was pressed, FALSE otherwise.
2270	*/
2271	bool get_isodir_info(char isodir_device, char isodir_format, char isodir_path, char subdir_path, bool nuke_me_please) {
2272
2273	char *p = NULL;
2274	char *q = NULL;
2275	char *r = NULL;
2276	char *idev = NULL;
2277	bool ret = FALSE; /* Should be false by default, and modfiy if conditions respected */
2278	bool HDD = FALSE;
2279	/ initialize ******************************************************/
2280
2281	assert(isodir_path != NULL);
2282
2283	log_it("isodir_path = %s", isodir_path);
2284	if (isodir_device == NULL) {
2285	mr_asprintf(idev, "/dev/");
2286	} else {
2287	mr_asprintf(idev, "%s", isodir_device);
2288	}
2289
2290	if (does_file_exist("/tmp/NETFS-SERVER-PATH")) {
2291	mr_free(idev);
2292	idev = last_line_of_file("/tmp/NETFS-SERVER-MOUNT");
2293	mr_asprintf(isodir_format, "netfs");
2294	mr_free(isodir_path);
2295	isodir_path = last_line_of_file("/tmp/NETFS-SERVER-PATH");
2296	}
2297
2298	/* modify for the caller */
2299	mr_free(isodir_device);
2300	isodir_device = idev;
2301	if (nuke_me_please) {
2302	ret = TRUE;
2303	} else {
2304	p = popup_and_get_string("ISO Mode - device", "On what device do the ISO files live?", idev);
2305	if (p != NULL) {
2306	if (popup_with_buttons("Are you restoring from an external hard drive ?", "Yes", "No")) {
2307	HDD = TRUE;
2308	}
2309	q = popup_and_get_string("ISO Mode - format", "What is the disk format of the device? (Hit ENTER if you don't know.)", isodir_format);
2310	mr_free(isodir_format);
2311
2312	if (q != NULL) {
2313	r = popup_and_get_string("ISO Mode - path", "At what path on this device can the ISO files be found?", isodir_path);
2314	if (r != NULL) {
2315	mr_strip_spaces(p);
2316	mr_strip_spaces(q);
2317	mr_strip_spaces(r);
2318
2319	isodir_format = q;
2320
2321	/* modify for the caller */
2322	mr_free(isodir_device);
2323	isodir_device = p;
2324	mr_free(isodir_path);
2325	isodir_path = r;
2326	log_it("isodir_device = %s - isodir_format = %s - isodir_path = %s", isodir_device, isodir_format, isodir_path);
2327
2328	ret = TRUE;
2329	}
2330	if (HDD) {
2331	/* We need an additional param */
2332	subdir_path = isodir_path;
2333	mr_asprintf(isodir_path, "/tmp/isodir");
2334	}
2335	}
2336	}
2337	mr_free(p);
2338	}
2339	mr_free(isodir_format);
2340	return(ret);
2341	}
2342
2343
2344	/**
2345	* Create a new raidtab entry for @p device in @p raidlist.
2346	* @param raidlist The raidlist to add the device to.
2347	* @param mountlist The mountlist containing information about the user's partitions.
2348	* @param currline The selected line in the mountlist.
2349	* @param device The RAID device (e.g. /dev/md0) to use.
2350	* @ingroup restoreGuiMountlist
2351	*/
2352	void
2353	initiate_new_raidlist_entry(struct raidlist_itself *raidlist,
2354	struct mountlist_itself *mountlist,
2355	int currline, char *device)
2356	{
2357
2358	/ structure *******************************************************/
2359	struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
2360
2361	/ int *************************************************************/
2362	int pos_in_raidlist = 0;
2363
2364	assert(raidlist != NULL);
2365	assert(mountlist != NULL);
2366	assert_string_is_neither_NULL_nor_zerolength(device);
2367
2368	pos_in_raidlist =
2369	find_raid_device_in_raidlist(raidlist,
2370	mountlist->el[currline].device);
2371	if (pos_in_raidlist >= 0) {
2372	fatal_error("Sorry, that RAID device already exists. Weird.");
2373	}
2374	pos_in_raidlist = raidlist->entries++;
2375	raidrec = &raidlist->el[pos_in_raidlist];
2376	initialize_raidrec(raidrec);
2377	strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
2378	#ifndef __FreeBSD__
2379	choose_raid_level(raidrec);
2380	select_raid_disks(mountlist, raidlist, raidrec, "data",
2381	&raidrec->data_disks);
2382	#endif
2383	edit_raidlist_entry(mountlist, raidlist, raidrec, currline);
2384	}
2385
2386
2387	#ifndef __FreeBSD__
2388	/**
2389	* Insert the RAID variables not stored in the "additional RAID variables" list there too.
2390	* @param raidrec The RAID device record to operate on.
2391	* @ingroup restoreGuiVarslist
2392	*/
2393	void insert_essential_additionalvars(struct raid_device_record *raidrec)
2394	{
2395
2396	/ int ************************************************************/
2397	int items = 0;
2398
2399	assert(raidrec != NULL);
2400
2401	items = raidrec->additional_vars.entries;
2402	write_variableINT_to_raid_var_line(raidrec, items++,
2403	"persistent-superblock",
2404	raidrec->persistent_superblock);
2405	write_variableINT_to_raid_var_line(raidrec, items++, "chunk-size",
2406	raidrec->chunk_size);
2407	raidrec->additional_vars.entries = items;
2408	}
2409
2410	#endif
2411
2412	/**
2413	* Dummy function that proves that we can get to the point where Mondo is run.
2414	*/
2415	void nuke_mode_dummy()
2416	{
2417
2418	/ newt ***********************************************************/
2419	newtComponent myForm;
2420	newtComponent b1;
2421	newtComponent b2;
2422	newtComponent b3;
2423
2424
2425	newtPushHelpLine
2426	("This is where I nuke your hard drives. Mhahahahaha. No-one can stop Mojo Jojo!");
2427	newtOpenWindow(24, 3, 32, 13, "Nuking");
2428	b1 = newtButton(7, 1, "Slowly");
2429	b2 = newtButton(7, 5, "Medium");
2430	b3 = newtButton(7, 9, "Quickly");
2431	myForm = newtForm(NULL, NULL, 0);
2432	newtFormAddComponents(myForm, b1, b2, b3, NULL);
2433	newtFormDestroy(myForm);
2434	newtPopWindow();
2435	newtPopHelpLine();
2436	}
2437
2438
2439
2440	/**
2441	* Redraw the disklist.
2442	* @param disklist The disklist to read from.
2443	* @param keylist The list of keys for @p listbox.
2444	* @param listbox The Newt listbox component to redraw.
2445	* @ingroup restoreGuiDisklist
2446	*/
2447	void
2448	redraw_disklist(struct list_of_disks *disklist,
2449	void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
2450	{
2451
2452	/ long ************************************************************/
2453	long i = 0;
2454
2455	assert(disklist != NULL);
2456	assert(keylist != NULL);
2457	assert(listbox != NULL);
2458
2459	newtListboxClear(listbox);
2460
2461	for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
2462	keylist[i] = (void *) i;
2463	}
2464	for (i = 0; i < disklist->entries; i++) {
2465	newtListboxAppendEntry(listbox,
2466	disklist_entry_to_string(disklist, i),
2467	keylist[i]);
2468	}
2469	}
2470
2471
2472	/**
2473	* Redraw the mountlist.
2474	* @param mountlist The mountlist to read from.
2475	* @param keylist The list of keys for @p listbox.
2476	* @param listbox The Newt listbox component to redraw.
2477	* @ingroup restoreGuiMountlist
2478	*/
2479	void
2480	redraw_mountlist(struct mountlist_itself *mountlist,
2481	void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
2482	{
2483
2484	/ long ************************************************************/
2485	long i = 0;
2486
2487	assert(mountlist != NULL);
2488	assert(keylist != NULL);
2489	assert(listbox != NULL);
2490
2491	newtListboxClear(listbox);
2492	// sort_mountlist_by_device (mountlist);
2493	for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
2494	keylist[i] = (void *) i;
2495	}
2496	for (i = 0; i < mountlist->entries; i++) {
2497	newtListboxAppendEntry(listbox,
2498	mountlist_entry_to_string(mountlist, i),
2499	keylist[i]);
2500	}
2501	}
2502
2503
2504
2505
2506	/**
2507	* Redraw the list of unallocated RAID partitions.
2508	* @param unallocated_raid_partitions The mountlist containing unallocated RAID partitions.
2509	* @param keylist The list of keys for @p listbox.
2510	* @param listbox The Newt listbox component to redraw.
2511	* @ingroup restoreGuiDisklist
2512	*/
2513	void redraw_unallocpartnslist(struct mountlist_itself
2514	*unallocated_raid_partitions,
2515	void *keylist[ARBITRARY_MAXIMUM],
2516	newtComponent listbox)
2517	{
2518
2519	/ long ***********************************************************/
2520	long i = 0;
2521
2522	/ buffers ********************************************************/
2523	char tmp[MAX_STR_LEN];
2524
2525	assert(unallocated_raid_partitions != NULL);
2526	assert(keylist != NULL);
2527	assert(listbox != NULL);
2528
2529	newtListboxClear(listbox);
2530	for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
2531	keylist[i] = (void *) i;
2532	}
2533	for (i = 0; i < unallocated_raid_partitions->entries; i++) {
2534	sprintf(tmp, "%-22s %8lld",
2535	unallocated_raid_partitions->el[i].device,
2536	unallocated_raid_partitions->el[i].size / 1024L);
2537	newtListboxAppendEntry(listbox, tmp, keylist[i]);
2538	}
2539	}
2540
2541	#ifndef __FreeBSD__
2542	/**
2543	* Redraw the list of additional RAID variables.
2544	* @param additional_vars The list of additional RAID varibals.
2545	* @param keylist The list of keys for @p listbox.
2546	* @param listbox The Newt listbox component to redraw.
2547	* @ingroup restoreGuiVarslist
2548	*/
2549	void
2550	redraw_varslist(struct additional_raid_variables *additional_vars,
2551	void *keylist[], newtComponent listbox)
2552	{
2553	/ long **********************************************************/
2554	long i = 0;
2555
2556	/ buffers *******************************************************/
2557	char tmp[MAX_STR_LEN];
2558
2559	assert(additional_vars != NULL);
2560	assert(keylist != NULL);
2561	assert(listbox != NULL);
2562
2563	newtListboxClear(listbox);
2564
2565	for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
2566	keylist[i] = (void *) i;
2567	}
2568	for (i = 0; i < additional_vars->entries; i++) {
2569	sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
2570	additional_vars->el[i].value);
2571	newtListboxAppendEntry(listbox, tmp, keylist[i]);
2572	}
2573	}
2574
2575
2576	/**
2577	* Remove variable @p label from the RAID variables list in @p raidrec.
2578	* @param raidrec The RAID device record to remove the variable from.
2579	* @param label The variable name to remove.
2580	* @return The value of the variable removed.
2581	* @ingroup restoreUtilityGroup
2582	*/
2583	int
2584	read_variableINT_and_remove_from_raidvars(struct
2585	OSSWAP (raid_device_record,
2586	vinum_volume) * raidrec,
2587	char *label)
2588	{
2589	/ int *************************************************************/
2590	int i = 0;
2591	int res = 0;
2592
2593
2594	assert(raidrec != NULL);
2595	assert(label != NULL);
2596
2597	for (i = 0;
2598	i < raidrec->additional_vars.entries
2599	&& strcmp(raidrec->additional_vars.el[i].label, label); i++);
2600	if (i == raidrec->additional_vars.entries) {
2601	res = -1;
2602	} else {
2603	res = atoi(raidrec->additional_vars.el[i].value);
2604	for (i++; i < raidrec->additional_vars.entries; i++) {
2605	memcpy((void *) &raidrec->additional_vars.el[i - 1],
2606	(void *) &raidrec->additional_vars.el[i],
2607	sizeof(struct raid_var_line));
2608	}
2609	raidrec->additional_vars.entries--;
2610	}
2611	return (res);
2612	}
2613	#endif
2614
2615	/**
2616	* Change all RAID devices to use @p new_dev instead of @p old_dev.
2617	* @param raidlist The raidlist to make the changes in.
2618	* @param old_dev The old name of the device (what it used to be).
2619	* @param new_dev The new name of the device (what it is now).
2620	* @ingroup restoreGuiMountlist
2621	*/
2622	void rejig_partition_name_in_raidlist_if_necessary(struct raidlist_itself
2623	*raidlist,
2624	char *old_dev,
2625	char *new_dev)
2626	{
2627	/ int **********************************************************/
2628	int pos = 0;
2629	int j = 0;
2630
2631	assert(raidlist != NULL);
2632	assert_string_is_neither_NULL_nor_zerolength(old_dev);
2633	assert_string_is_neither_NULL_nor_zerolength(new_dev);
2634
2635	pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
2636	if (pos < 0) {
2637	log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
2638	} else {
2639	if ((j =
2640	where_in_drivelist_is_drive(&raidlist->
2641	OSSWAP(el[pos].data_disks, disks),
2642	old_dev)) >= 0) {
2643	strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
2644	} else
2645	if ((j =
2646	where_in_drivelist_is_drive(&raidlist->
2647	OSSWAP(el[pos].spare_disks,
2648	spares),
2649	old_dev)) >= 0) {
2650	strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
2651	}
2652	#ifndef __FreeBSD__
2653	else if ((j =
2654	where_in_drivelist_is_drive(&raidlist->el[pos].
2655	parity_disks,
2656	old_dev)) >= 0) {
2657	strcpy(raidlist->el[pos].parity_disks.el[j].device, new_dev);
2658	} else
2659	if ((j =
2660	where_in_drivelist_is_drive(&raidlist->el[pos].
2661	failed_disks,
2662	old_dev)) >= 0) {
2663	strcpy(raidlist->el[pos].failed_disks.el[j].device, new_dev);
2664	}
2665	#endif
2666	else {
2667	log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
2668	}
2669	}
2670	}
2671
2672
2673	#ifndef __FreeBSD__
2674	/**
2675	* Remove the essential RAID variables from the "additional variables" section.
2676	* If they have been changed, set them in their normal locations too.
2677	* @param raidrec The RAID device record to operate on.
2678	* @ingroup restoreUtilityVarslist
2679	*/
2680	void remove_essential_additionalvars(struct raid_device_record *raidrec)
2681	{
2682
2683	/ int ************************************************************/
2684	int res = 0;
2685
2686	assert(raidrec != NULL);
2687
2688	res =
2689	read_variableINT_and_remove_from_raidvars(raidrec,
2690	"persistent-superblock");
2691	if (res > 0) {
2692	raidrec->persistent_superblock = res;
2693	}
2694	res = read_variableINT_and_remove_from_raidvars(raidrec, "chunk-size");
2695	if (res > 0) {
2696	raidrec->chunk_size = res;
2697	}
2698	res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
2699	}
2700
2701	/**
2702	* Select the RAID disks to use in @p raidrec.
2703	* @param mountlist_dontedit The mountlist (will not be edited).
2704	* @param raidlist The raidlist to modify.
2705	* @param raidrec The RAID device record in @p raidlist to work on.
2706	* @param description_of_list The type of disks we're selecting (e.g. "data").
2707	* @param disklist The disklist to put the user-selected disks in.
2708	* @ingroup restoreGuiMountlist
2709	*/
2710	void
2711	select_raid_disks(struct mountlist_itself *mountlist_dontedit,
2712	struct raidlist_itself *raidlist,
2713	struct raid_device_record *raidrec,
2714	char *description_of_list,
2715	struct list_of_disks *disklist)
2716	{
2717	void *curr_choice;
2718
2719	/ ??? *************************************************************/
2720
2721	/ structures ******************************************************/
2722	struct raidlist_itself *bkp_raidlist;
2723	struct raid_device_record *bkp_raidrec;
2724	struct list_of_disks *bkp_disklist;
2725	struct mountlist_itself *unallocated_raid_partitions;
2726
2727	/ newt ************************************************************/
2728	newtComponent myForm = NULL;
2729	newtComponent bAdd = NULL;
2730	newtComponent bDelete = NULL;
2731	newtComponent bOK = NULL;
2732	newtComponent bCancel = NULL;
2733	newtComponent b_res = NULL;
2734	newtComponent partitionsListbox = NULL;
2735	newtComponent headerMsg = NULL;
2736
2737	/ buffers ********************************************************/
2738	void *keylist[ARBITRARY_MAXIMUM];
2739	char *tmp = NULL;
2740	char *help_text = NULL;
2741	char *title_of_window = NULL;
2742	char *sz_res = NULL;
2743	char *header_text = NULL;
2744	char *p = NULL;
2745
2746	/ int ************************************************************/
2747	int i = 0;
2748	int currline = 0;
2749
2750	assert(mountlist_dontedit != NULL);
2751	assert(raidlist != NULL);
2752	assert(raidrec != NULL);
2753	assert(description_of_list != NULL);
2754	assert(disklist != NULL);
2755
2756	log_it("malloc'ing");
2757	bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
2758	bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
2759	bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
2760	unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
2761
2762	memcpy((void ) bkp_raidlist, (void ) raidlist, sizeof(struct raidlist_itself));
2763	memcpy((void ) bkp_raidrec, (void ) raidrec, sizeof(struct raid_device_record));
2764	memcpy((void ) bkp_disklist, (void ) disklist, sizeof(struct list_of_disks));
2765
2766	log_it("Post-malloc");
2767	mr_asprintf(help_text, " Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
2768	mr_asprintf(header_text, "%-24s %s", "Device", "Index");
2769	mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device);
2770	newtPushHelpLine(help_text);
2771	for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
2772	headerMsg = newtLabel(1, 1, header_text);
2773	partitionsListbox =
2774	newtListbox(1, 2, 6, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
2775	redraw_disklist(disklist, keylist, partitionsListbox);
2776	i = 1;
2777	bAdd = newtCompactButton(i, 9, " Add ");
2778	bDelete = newtCompactButton(i += 8, 9, "Delete");
2779	bOK = newtCompactButton(i += 9, 9, " OK ");
2780	bCancel = newtCompactButton(i += 9, 9, "Cancel");
2781	newtOpenWindow(21, 7, 38, 10, title_of_window);
2782	myForm = newtForm(NULL, NULL, 0);
2783	if (disklist->entries == 0) {
2784	newtFormAddComponents(myForm, headerMsg, bAdd, bDelete, bOK,
2785	bCancel, NULL);
2786	} else {
2787	newtFormAddComponents(myForm, headerMsg, partitionsListbox,
2788	bAdd, bDelete, bOK, bCancel, NULL);
2789	}
2790	b_res = newtRunForm(myForm);
2791	if (b_res == bOK \|\| b_res == bCancel) { /* do nothing */
2792	// That's OK. At the end of this subroutine (after this do/while loop),
2793	// we'll throw away the changes if Cancel was pushed.
2794	} else {
2795	curr_choice = newtListboxGetCurrent(partitionsListbox);
2796	for (i = 0; i < disklist->entries && keylist[i] != curr_choice;
2797	i++);
2798	if (i == disklist->entries && disklist->entries > 0) {
2799	log_to_screen("I don't know what that button does!");
2800	} else {
2801	currline = i;
2802	if (b_res == bAdd) {
2803	log_it("Making list of unallocated RAID slices");
2804	make_list_of_unallocated_raid_partitions
2805	(unallocated_raid_partitions, mountlist_dontedit,
2806	raidlist);
2807	if (unallocated_raid_partitions->entries <= 0) {
2808	popup_and_OK
2809	("There are no unallocated partitions marked for RAID.");
2810	} else {
2811	log_it
2812	("Done. The user may add one or more of the above to RAID device");
2813	add_disklist_entry(disklist, raidrec->raid_device,
2814	unallocated_raid_partitions);
2815	log_it("I have finished adding a disklist entry.");
2816	redraw_disklist(disklist, keylist,
2817	partitionsListbox);
2818	}
2819	} else if (b_res == bDelete) {
2820	delete_disklist_entry(disklist, raidrec->raid_device,
2821	currline);
2822	redraw_disklist(disklist, keylist, partitionsListbox);
2823	} else {
2824	mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
2825	mr_asprintf(sz_res, "%d", disklist->el[currline].index);
2826	p = popup_and_get_string("Set index", tmp, sz_res);
2827	mr_free(tmp);
2828	if (p != NULL) {
2829	disklist->el[currline].index = atoi(sz_res);
2830	}
2831	redraw_disklist(disklist, keylist, partitionsListbox);
2832	mr_free(sz_res);
2833	}
2834	}
2835	}
2836	newtFormDestroy(myForm);
2837	newtPopWindow();
2838	}
2839	newtPopHelpLine();
2840	mr_free(help_text);
2841	mr_free(header_text);
2842	mr_free(title_of_window);
2843
2844	if (b_res == bCancel) {
2845	memcpy((void ) raidlist, (void ) bkp_raidlist, sizeof(struct raidlist_itself));
2846	memcpy((void ) raidrec, (void ) bkp_raidrec, sizeof(struct raid_device_record));
2847	memcpy((void ) disklist, (void ) bkp_disklist, sizeof(struct list_of_disks));
2848	}
2849	mr_free(bkp_raidrec);
2850	mr_free(bkp_disklist);
2851	mr_free(bkp_raidlist);
2852	mr_free(unallocated_raid_partitions);
2853	}
2854	#endif
2855
2856
2857
2858	/**
2859	* Ask the user which restore mode (nuke, interactive, or compare) we should use.
2860	* @return The mode selected: 'I' for interactive, 'N' for nuke, 'C' for compare,
2861	* or 'E' (or any other letter) for exit.
2862	*/
2863	char which_restore_mode()
2864	{
2865
2866	/ char ***********************************************************/
2867	char output = '\0';
2868	char *tmp = NULL;
2869
2870	/ newt ***********************************************************/
2871
2872	newtComponent b1;
2873	newtComponent b2;
2874	newtComponent b3;
2875	newtComponent b4;
2876	newtComponent b_res;
2877	newtComponent myForm;
2878
2879	if (g_text_mode) {
2880	while (!strchr("AICE", output)) {
2881	printf("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> ");
2882	mr_getline(tmp, stdin);
2883	output = tmp[0];
2884	mr_free(tmp);
2885	}
2886	return (output);
2887	}
2888
2889	newtPushHelpLine(" Do you want to 'nuke' your system, restore interactively, or just compare?");
2890	newtOpenWindow(24, 3, 32, 17, "How should I restore?");
2891	b1 = newtButton(7, 1, "Automatically");
2892	b2 = newtButton(7, 5, "Interactively");
2893	b3 = newtButton(7, 9, "Compare only!");
2894	b4 = newtButton(7, 13, "Exit to shell");
2895	myForm = newtForm(NULL, NULL, 0);
2896	newtFormAddComponents(myForm, b1, b2, b3, b4, NULL);
2897	b_res = newtRunForm(myForm);
2898	newtFormDestroy(myForm);
2899	newtPopWindow();
2900	if (b_res == b1) {
2901	output = 'N';
2902	}
2903	if (b_res == b2) {
2904	output = 'I';
2905	}
2906	if (b_res == b3) {
2907	output = 'C';
2908	}
2909	if (b_res == b4) {
2910	output = 'E';
2911	}
2912	newtPopHelpLine();
2913	return (output);
2914	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: