source: branches/stable/mondo/src/mondorestore/mondo-rstr-newt.c @ 1124

Last change on this file since 1124 was 1124, checked in by Bruno Cornec, 13 years ago

Linker fixes for mondo
mount in logfile added for mindi

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