#include <assert.h>
#include <errno.h>
#include <string.h>
+#include <stdlib.h>
+#include <wctype.h>
+#include <util/util.h>
#include "log/log.h"
#include "talloc/talloc.h"
+#include "i18n/i18n.h"
#include "ui/common/ui-system.h"
#include "nc-cui.h"
#include "nc-menu.h"
result = post_menu(menu->ncm);
nc_scr_frame_draw(scr);
- redrawwin(menu->scr.main_ncw);
wrefresh(menu->scr.main_ncw);
return result;
pmenu_post(scr);
}
+static int pmenu_item_destructor(void *arg)
+{
+ struct pmenu_item *item = arg;
+ free_item(item->nci);
+ return 0;
+}
+
+static const char *pmenu_item_label(struct pmenu_item *item, const char *name)
+{
+ static int invalid_idx;
+ unsigned int i;
+ wchar_t *tmp;
+ char *label;
+ size_t len;
+
+ len = mbstowcs(NULL, name, 0);
+
+ /* if we have an invalid multibyte sequence, create an entirely
+ * new name, indicating that we had invalid input */
+ if (len == SIZE_MAX) {
+ name = talloc_asprintf(item, _("!Invalid option %d"),
+ ++invalid_idx);
+ return name;
+ }
+
+ tmp = talloc_array(item, wchar_t, len + 1);
+ mbstowcs(tmp, name, len + 1);
+
+ /* replace anything unprintable with U+FFFD REPLACEMENT CHARACTER */
+ for (i = 0; i < len; i++) {
+ if (!iswprint(tmp[i]))
+ tmp[i] = 0xfffd;
+ }
+
+ len = wcstombs(NULL, tmp, 0);
+ label = talloc_array(item, char, len + 1);
+ wcstombs(label, tmp, len + 1);
+
+ pb_log("%s: %s\n", __func__, label);
+
+ talloc_free(tmp);
+ return label;
+}
+
/**
* pmenu_item_create - Allocate and initialize a new pmenu_item instance.
*
struct pmenu_item *pmenu_item_create(struct pmenu *menu, const char *name)
{
struct pmenu_item *item = talloc_zero(menu, struct pmenu_item);
+ const char *label;
+
+ label = pmenu_item_label(item, name);
item->i_sig = pb_item_sig;
item->pmenu = menu;
- item->nci = new_item(name, NULL);
+ item->nci = new_item(label, NULL);
if (!item->nci) {
talloc_free(item);
return NULL;
}
+ talloc_set_destructor(item, pmenu_item_destructor);
+
set_item_userptr(item->nci, item);
return item;
menu->items[index] = item->nci;
}
+/**
+ * pmenu_item_add - Insert item into appropriate position
+ *
+ * Inserts boot entry under matching, predefined device header entry,
+ * moving items in the list if necessary
+ */
+
+void pmenu_item_add(struct pmenu *menu, struct pmenu_item *item,
+ unsigned int insert_pt)
+{
+ struct cui_opt_data *cod = item->data;
+ bool found = false;
+ unsigned int dev;
+
+ /* Items array should already be disconnected */
+
+ for (dev = 0; dev < menu->item_count; dev++) {
+ if (!menu->items[dev])
+ continue;
+
+ struct pmenu_item *i = item_userptr(menu->items[dev]);
+ struct cui_opt_data *d = i->data;
+ /* Device header will have opt == NULL */
+ if (d && !d->opt) {
+ if (cod->dev == d->dev) {
+ found = true;
+ break;
+ }
+ }
+ }
+
+ if (found) {
+ assert(dev < insert_pt);
+ /* Shift down entries between header and insert_pt */
+ memmove(menu->items + dev + 2, menu->items + dev + 1,
+ ((menu->items + insert_pt) - (menu->items + dev + 1))
+ * sizeof(menu->items[0]));
+ memset(menu->items + dev + 1, 0, sizeof(menu->items[0]));
+ insert_pt = dev + 1;
+ }
+ /* If for some reason we didn't find the matching device,
+ * at least add it to a valid position */
+ pmenu_item_insert(menu, item, insert_pt);
+}
+
+/**
+ * pmenu_find_device - Determine if a boot option is new, and if
+ * so return a new pmenu_item to represent its parent device
+ */
+
+struct pmenu_item *pmenu_find_device(struct pmenu *menu, struct device *dev,
+ struct boot_option *opt)
+{
+ struct pmenu_item *item, *dev_hdr = NULL;
+ struct cui *cui = cui_from_pmenu(menu);
+ bool newdev = true, matched = false;
+ struct interface_info *intf;
+ struct blockdev_info *bd;
+ struct cui_opt_data *cod;
+ struct system_info *sys;
+ char hwaddr[32];
+ unsigned int i;
+ char buf[256];
+
+ for (i = 0; i < menu->item_count; i++) {
+ item = item_userptr(menu->items[i]);
+ cod = item->data;
+ /* boot entries will have opt defined */
+ if (!cod || cod->opt)
+ continue;
+ if (cod->dev == dev) {
+ pb_debug("%s: opt %s fits under %s\n",__func__,
+ opt->name, opt->device_id);
+ newdev = false;
+ break;
+ }
+ }
+
+ if (!newdev) {
+ pb_debug("%s: No new device\n",__func__);
+ return NULL;
+ }
+
+ /* Create a dummy pmenu_item to represent the dev */
+ pb_debug("%s: Building new item\n",__func__);
+ sys = cui->sysinfo;
+ switch (dev->type) {
+ case DEVICE_TYPE_OPTICAL:
+ case DEVICE_TYPE_DISK:
+ case DEVICE_TYPE_USB:
+ /* Find block info */
+ for (i = 0; sys && i < sys->n_blockdevs; i++) {
+ bd = sys->blockdevs[i];
+ if (!strcmp(opt->device_id, bd->name)) {
+ matched = true;
+ break;
+ }
+ }
+ if (matched) {
+ snprintf(buf,sizeof(buf),"[%s: %s / %s]",
+ device_type_display_name(dev->type),
+ bd->name, bd->uuid);
+ }
+ break;
+
+ case DEVICE_TYPE_NETWORK:
+ /* Find interface info */
+ for (i = 0; sys && i < sys->n_interfaces; i++) {
+ intf = sys->interfaces[i];
+ if (!strcmp(opt->device_id, intf->name)) {
+ matched = true;
+ break;
+ }
+ }
+ if (matched) {
+ mac_str(intf->hwaddr, intf->hwaddr_size,
+ hwaddr, sizeof(hwaddr));
+ snprintf(buf,sizeof(buf),"[%s: %s / %s]",
+ _("Network"), intf->name, hwaddr);
+ }
+ break;
+ case DEVICE_TYPE_ANY:
+ /* This is an option found from a file:// url, not associated
+ * with any device */
+ snprintf(buf, sizeof(buf), "[Custom Local Options]");
+ matched = true;
+ break;
+
+ default:
+ /* Assume the device may be able to boot */
+ break;
+ }
+ if (!matched) {
+ pb_debug("%s: No matching device found for %s (%s)\n",
+ __func__,opt->device_id, dev->id);
+ snprintf(buf, sizeof(buf), "[%s: %s]",
+ _("Unknown Device"), dev->id);
+ }
+
+ dev_hdr = pmenu_item_create(menu, buf);
+ if (!dev_hdr) {
+ pb_log("%s: Failed to create item\n",__func__);
+ return NULL;
+ }
+
+ dev_hdr->on_execute = NULL;
+ item_opts_off(dev_hdr->nci, O_SELECTABLE);
+
+ /* We identify dev_hdr items as having a valid c->name,
+ * but a NULL c->opt */
+ cod = talloc(dev_hdr, struct cui_opt_data);
+ cod->name = talloc_strdup(dev_hdr, opt->device_id);
+ cod->dev = dev;
+ cod->opt = NULL;
+ dev_hdr->data = cod;
+
+ pb_debug("%s: returning %s\n",__func__,cod->name);
+ return dev_hdr;
+}
+
static int pmenu_item_get_index(const struct pmenu_item *item)
{
unsigned int i;
- for (i = 0; i < item->pmenu->item_count; i++)
- if (item->pmenu->items[i] == item->nci)
- return i;
+ if (item)
+ for (i = 0; i < item->pmenu->item_count; i++)
+ if (item->pmenu->items[i] == item->nci)
+ return i;
pb_log("%s: not found: %p %s\n", __func__, item,
(item ? item->nci->name.str : "(null)"));
case 'c':
cui_show_config(cui_from_arg(scr->ui_ctx));
break;
+ case 'l':
+ cui_show_lang(cui_from_arg(scr->ui_ctx));
+ break;
+ case 'g':
+ cui_show_statuslog(cui_from_arg(scr->ui_ctx));
+ break;
case KEY_F(1):
case 'h':
if (menu->help_text)
if (index < 0)
return -1;
- free_item(item->nci);
talloc_free(item);
/* Note that items array has a null terminator. */
return 0;
}
+static int pmenu_destructor(void *ptr)
+{
+ struct pmenu *menu = ptr;
+ assert(menu->scr.sig == pb_pmenu_sig);
+ menu->scr.sig = pb_removed_sig;
+
+ unpost_menu(menu->ncm);
+ free_menu(menu->ncm);
+ delwin(menu->scr.sub_ncw);
+ delwin(menu->scr.main_ncw);
+ return 0;
+}
+
/**
* pmenu_init - Allocate and initialize a new menu instance.
*
void (*on_exit)(struct pmenu *))
{
struct pmenu *menu = talloc_zero(ui_ctx, struct pmenu);
-
if (!menu)
return NULL;
- /* note items array has a null terminator */
+ talloc_set_destructor(menu, pmenu_destructor);
+ /* note items array has a null terminator */
menu->items = talloc_zero_array(menu, ITEM *, item_count + 1);
-
if (!menu->items) {
talloc_free(menu);
return NULL;
return 0;
}
-/**
- * pmenu_delete - Delete a menu instance.
- *
- */
-
-void pmenu_delete(struct pmenu *menu)
-{
- unsigned int i;
-
- assert(menu->scr.sig == pb_pmenu_sig);
- menu->scr.sig = pb_removed_sig;
-
- for (i = item_count(menu->ncm); i; i--)
- free_item(menu->items[i - 1]);
-
- free_menu(menu->ncm);
- delwin(menu->scr.sub_ncw);
- delwin(menu->scr.main_ncw);
- talloc_free(menu);
-}
projects / petitboot / blobdiff