#include <efi.h>

#include <efigpt.h>

#include <efilib.h>

#include "bcd.h"

#include "bootspec-fundamental.h"

#include "console.h"

#include "devicetree.h"

#include "disk.h"

#include "drivers.h"

#include "efivars-fundamental.h"

#include "graphics.h"

#include "linux.h"

#include "measure.h"

#include "pe.h"

#include "random-seed.h"

#include "secure-boot.h"

#include "shim.h"

#include "ticks.h"

#include "util.h"

#include "xbootldr.h"

#ifndef GNU_EFI_USE_MS_ABI

/* We do not use uefi_call_wrapper() in systemd-boot. As such, we rely on the

#error systemd-boot requires compilation with GNU_EFI_USE_MS_ABI defined.

#define TEXT_ATTR_SWAP(c) EFI_TEXT_ATTR(((c) & 0b11110000) >> 4, (c) & 0b1111)

_used_ _section_(".sdmagic") static const char magic[] =

"#### LoaderInfo: systemd-boot " GIT_VERSION " ####";

_used_ _section_(".osrel") static const char osrel[] =

"ID=systemd-boot\n"

"VERSION=\"" GIT_VERSION "\"\n"

"NAME=\"systemd-boot " GIT_VERSION "\"\n";

enum loader_type {

};

typedef struct {

CHAR16 *id; /* The unique identifier for this entry (typically the filename of the file defining the entry) */

CHAR16 *title_show; /* The string to actually display (this is made unique before showing) */

CHAR16 *title; /* The raw (human readable) title string of the entry (not necessarily unique) */

CHAR16 *sort_key; /* The string to use as primary sort key, usually ID= from os-release, possibly suffixed */

CHAR16 *version; /* The raw (human readable) version string of the entry */

CHAR16 *machine_id;

EFI_HANDLE *device;

enum loader_type type;

CHAR16 *loader;

CHAR16 *devicetree;

CHAR16 *options;

CHAR16 key;

EFI_STATUS (*call)(void);

UINTN tries_done;

UINTN tries_left;

CHAR16 *path;

CHAR16 *current_name;

CHAR16 *next_name;

} ConfigEntry;

typedef struct {

ConfigEntry **entries;

UINTN entry_count;

UINTN idx_default;

UINTN idx_default_efivar;

UINT32 timeout_sec; /* Actual timeout used (efi_main() override > efivar > config). */

UINT32 timeout_sec_config;

UINT32 timeout_sec_efivar;

CHAR16 *entry_default_config;

CHAR16 *entry_default_efivar;

CHAR16 *entry_oneshot;

CHAR16 *entry_saved;

CHAR16 *options_edit;

BOOLEAN editor;

BOOLEAN auto_entries;

BOOLEAN auto_firmware;

BOOLEAN reboot_for_bitlocker;

BOOLEAN force_menu;

BOOLEAN use_saved_entry;

BOOLEAN use_saved_entry_efivar;

BOOLEAN beep;

INT64 console_mode;

INT64 console_mode_efivar;

RandomSeedMode random_seed_mode;

} Config;

enum {

TIMEOUT_MIN = 1,

TIMEOUT_MAX = UINT32_MAX - 2U,

TIMEOUT_UNSET = UINT32_MAX - 1U,

TIMEOUT_MENU_FORCE = UINT32_MAX,

TIMEOUT_MENU_HIDDEN = 0,

TIMEOUT_TYPE_MAX = UINT32_MAX,

};

enum {

IDX_MAX = INT16_MAX,

IDX_INVALID,

};

static void cursor_left(UINTN *cursor, UINTN *first) {

assert(cursor);

assert(first);

if ((*cursor) > 0)

(*cursor)--;

else if ((*first) > 0)

(*first)--;

}

static void cursor_right(

UINTN len) {

assert(cursor);

assert(first);

if ((*cursor)+1 < x_max)

(*cursor)++;

else if ((*first) + (*cursor) < len)

(*first)++;

}

static BOOLEAN line_edit(

UINTN y_pos) {

_cleanup_freepool_ CHAR16 *line = NULL, *print = NULL;

UINTN size, len, first = 0, cursor = 0, clear = 0;

assert(line_out);

if (!line_in)

line_in = L"";

len = StrLen(line_in);

size = len + 1024;

line = xnew(CHAR16, size);

print = xnew(CHAR16, x_max + 1);

StrCpy(line, line_in);

for (;;) {

EFI_STATUS err;

UINT64 key;

UINTN j;

UINTN cursor_color = TEXT_ATTR_SWAP(COLOR_EDIT);

j = MIN(len - first, x_max);

CopyMem(print, line + first, j * sizeof(CHAR16));

while (clear > 0 && j < x_max) {

clear--;

print[j++] = ' ';

}

print[j] = '\0';

/* See comment at edit_line() call site for why we start at 1. */

print_at(1, y_pos, COLOR_EDIT, print);

if (!print[cursor])

print[cursor] = ' ';

print[cursor+1] = '\0';

do {

print_at(cursor + 1, y_pos, cursor_color, print + cursor);

cursor_color = TEXT_ATTR_SWAP(cursor_color);

err = console_key_read(&key, 750 * 1000);

if (!IN_SET(err, EFI_SUCCESS, EFI_TIMEOUT, EFI_NOT_READY))

return FALSE;

print_at(cursor + 1, y_pos, COLOR_EDIT, print + cursor);

} while (EFI_ERROR(err));

switch (key) {

case KEYPRESS(0, SCAN_ESC, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'c'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'g'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('c')):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('g')):

return FALSE;

case KEYPRESS(0, SCAN_HOME, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'a'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('a')):

/* beginning-of-line */

cursor = 0;

first = 0;

continue;

case KEYPRESS(0, SCAN_END, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'e'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('e')):

/* end-of-line */

cursor = len - first;

if (cursor+1 >= x_max) {

cursor = x_max-1;

first = len - (x_max-1);

}

continue;

case KEYPRESS(0, SCAN_DOWN, 0):

case KEYPRESS(EFI_ALT_PRESSED, 0, 'f'):

case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_RIGHT, 0):

/* forward-word */

while (line[first + cursor] == ' ')

cursor_right(&cursor, &first, x_max, len);

while (line[first + cursor] && line[first + cursor] != ' ')

cursor_right(&cursor, &first, x_max, len);

continue;

case KEYPRESS(0, SCAN_UP, 0):

case KEYPRESS(EFI_ALT_PRESSED, 0, 'b'):

case KEYPRESS(EFI_CONTROL_PRESSED, SCAN_LEFT, 0):

/* backward-word */

if ((first + cursor) > 0 && line[first + cursor-1] == ' ') {

cursor_left(&cursor, &first);

while ((first + cursor) > 0 && line[first + cursor] == ' ')

cursor_left(&cursor, &first);

}

while ((first + cursor) > 0 && line[first + cursor-1] != ' ')

cursor_left(&cursor, &first);

continue;

case KEYPRESS(0, SCAN_RIGHT, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'f'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('f')):

/* forward-char */

if (first + cursor == len)

continue;

cursor_right(&cursor, &first, x_max, len);

continue;

case KEYPRESS(0, SCAN_LEFT, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'b'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('b')):

/* backward-char */

cursor_left(&cursor, &first);

continue;

case KEYPRESS(EFI_ALT_PRESSED, 0, 'd'):

/* kill-word */

clear = 0;

UINTN k;

for (k = first + cursor; k < len && line[k] == ' '; k++)

clear++;

for (; k < len && line[k] != ' '; k++)

clear++;

for (UINTN i = first + cursor; i + clear < len; i++)

line[i] = line[i + clear];

len -= clear;

line[len] = '\0';

continue;

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'w'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('w')):

case KEYPRESS(EFI_ALT_PRESSED, 0, CHAR_BACKSPACE):

/* backward-kill-word */

clear = 0;

if ((first + cursor) > 0 && line[first + cursor-1] == ' ') {

cursor_left(&cursor, &first);

clear++;

while ((first + cursor) > 0 && line[first + cursor] == ' ') {

cursor_left(&cursor, &first);

clear++;

}

}

while ((first + cursor) > 0 && line[first + cursor-1] != ' ') {

cursor_left(&cursor, &first);

clear++;

}

for (UINTN i = first + cursor; i + clear < len; i++)

line[i] = line[i + clear];

len -= clear;

line[len] = '\0';

continue;

case KEYPRESS(0, SCAN_DELETE, 0):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'd'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('d')):

if (len == 0)

continue;

if (first + cursor == len)

continue;

for (UINTN i = first + cursor; i < len; i++)

line[i] = line[i+1];

clear = 1;

len--;

continue;

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'k'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('k')):

/* kill-line */

line[first + cursor] = '\0';

clear = len - (first + cursor);

len = first + cursor;

continue;

case KEYPRESS(0, 0, CHAR_LINEFEED):

case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN):

case KEYPRESS(0, CHAR_CARRIAGE_RETURN, 0): /* EZpad Mini 4s firmware sends malformed events */

case KEYPRESS(0, CHAR_CARRIAGE_RETURN, CHAR_CARRIAGE_RETURN): /* Teclast X98+ II firmware sends malformed events */

if (StrCmp(line, line_in) != 0)

*line_out = TAKE_PTR(line);

return TRUE;

case KEYPRESS(0, 0, CHAR_BACKSPACE):

if (len == 0)

continue;

if (first == 0 && cursor == 0)

continue;

for (UINTN i = first + cursor-1; i < len; i++)

line[i] = line[i+1];

clear = 1;

len--;

if (cursor > 0)

cursor--;

if (cursor > 0 || first == 0)

continue;

/* show full line if it fits */

if (len < x_max) {

cursor = first;

first = 0;

continue;

}

/* jump left to see what we delete */

if (first > 10) {

first -= 10;

cursor = 10;

} else {

cursor = first;

first = 0;

}

continue;

case KEYPRESS(0, 0, ' ') ... KEYPRESS(0, 0, '~'):

case KEYPRESS(0, 0, 0x80) ... KEYPRESS(0, 0, 0xffff):

if (len+1 == size)

continue;

for (UINTN i = len; i > first + cursor; i--)

line[i] = line[i-1];

line[first + cursor] = KEYCHAR(key);

len++;

line[len] = '\0';

if (cursor+1 < x_max)

cursor++;

else if (first + cursor < len)

first++;

continue;

}

}

}

static UINTN entry_lookup_key(Config *config, UINTN start, CHAR16 key) {

assert(config);

if (key == 0)

return IDX_INVALID;

/* select entry by number key */

if (key >= '1' && key <= '9') {

UINTN i = key - '0';

if (i > config->entry_count)

i = config->entry_count;

return i-1;

}

/* find matching key in config entries */

for (UINTN i = start; i < config->entry_count; i++)

if (config->entries[i]->key == key)

return i;

for (UINTN i = 0; i < start; i++)

if (config->entries[i]->key == key)

return i;

return IDX_INVALID;

}

static CHAR16 *update_timeout_efivar(UINT32 *t, BOOLEAN inc) {

assert(t);

switch (*t) {

case TIMEOUT_MAX:

*t = inc ? TIMEOUT_MAX : (*t - 1);

break;

case TIMEOUT_UNSET:

*t = inc ? TIMEOUT_MENU_FORCE : TIMEOUT_UNSET;

break;

case TIMEOUT_MENU_FORCE:

*t = inc ? TIMEOUT_MENU_HIDDEN : TIMEOUT_UNSET;

break;

case TIMEOUT_MENU_HIDDEN:

*t = inc ? TIMEOUT_MIN : TIMEOUT_MENU_FORCE;

break;

default:

*t += inc ? 1 : -1;

}

switch (*t) {

case TIMEOUT_UNSET:

return xstrdup(L"Menu timeout defined by configuration file.");

case TIMEOUT_MENU_FORCE:

return xstrdup(L"Timeout disabled, menu will always be shown.");

case TIMEOUT_MENU_HIDDEN:

return xstrdup(L"Menu disabled. Hold down key at bootup to show menu.");

default:

return xpool_print(L"Menu timeout set to %u s.", *t);

}

}

static BOOLEAN unicode_supported(void) {

static INTN cache = -1;

if (cache < 0)

/* Basic unicode box drawing support is mandated by the spec, but it does

cache = !EFI_ERROR(ST->ConOut->TestString(ST->ConOut, (CHAR16 *) L"─"));

return cache;

}

static void ps_string(const CHAR16 *fmt, const void *value) {

assert(fmt);

if (value)

Print(fmt, value);

}

static void ps_bool(const CHAR16 *fmt, BOOLEAN value) {

assert(fmt);

Print(fmt, yes_no(value));

}

static BOOLEAN ps_continue(void) {

UINT64 key;

EFI_STATUS err;

if (unicode_supported())

Print(L"\n─── Press any key to continue, ESC or q to quit. ───\n\n");

else

Print(L"\n--- Press any key to continue, ESC or q to quit. ---\n\n");

err = console_key_read(&key, UINT64_MAX);

return !EFI_ERROR(err) && !IN_SET(key, KEYPRESS(0, SCAN_ESC, 0), KEYPRESS(0, 0, 'q'), KEYPRESS(0, 0, 'Q'));

}

static void print_status(Config *config, CHAR16 *loaded_image_path) {

UINTN x_max, y_max;

UINT32 screen_width = 0, screen_height = 0;

SecureBootMode secure;

_cleanup_freepool_ CHAR16 *device_part_uuid = NULL;

assert(config);

assert(loaded_image_path);

clear_screen(COLOR_NORMAL);

console_query_mode(&x_max, &y_max);

query_screen_resolution(&screen_width, &screen_height);

secure = secure_boot_mode();

(void) efivar_get(LOADER_GUID, L"LoaderDevicePartUUID", &device_part_uuid);

/* We employ some unusual indentation here for readability. */

ps_string(L" systemd-boot version: %a\n", GIT_VERSION);

ps_string(L" loaded image: %s\n", loaded_image_path);

ps_string(L" loader partition UUID: %s\n", device_part_uuid);

ps_string(L" architecture: %a\n", EFI_MACHINE_TYPE_NAME);

Print(L" UEFI specification: %u.%02u\n", ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff);

ps_string(L" firmware vendor: %s\n", ST->FirmwareVendor);

Print(L" firmware version: %u.%02u\n", ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff);

Print(L" OS indications: %lu\n", get_os_indications_supported());

Print(L" secure boot: %s (%s)\n", yes_no(IN_SET(secure, SECURE_BOOT_USER, SECURE_BOOT_DEPLOYED)), secure_boot_mode_to_string(secure));

ps_bool(L" shim: %s\n", shim_loaded());

ps_bool(L" TPM: %s\n", tpm_present());

Print(L" console mode: %d/%d (%lux%lu @%ux%u)\n", ST->ConOut->Mode->Mode, ST->ConOut->Mode->MaxMode - 1LL, x_max, y_max, screen_width, screen_height);

if (!ps_continue())

return;

switch (config->timeout_sec_config) {

case TIMEOUT_UNSET:

break;

case TIMEOUT_MENU_FORCE:

Print(L" timeout: menu-force\n"); break;

case TIMEOUT_MENU_HIDDEN:

Print(L" timeout: menu-hidden\n"); break;

default:

Print(L" timeout: %lu s\n", config->timeout_sec_config);

}

switch (config->timeout_sec_efivar) {

case TIMEOUT_UNSET:

break;

case TIMEOUT_MENU_FORCE:

Print(L" timeout (EFI var): menu-force\n"); break;

case TIMEOUT_MENU_HIDDEN:

Print(L" timeout (EFI var): menu-hidden\n"); break;

default:

Print(L" timeout (EFI var): %lu s\n", config->timeout_sec_efivar);

}

ps_string(L" default: %s\n", config->entry_default_config);

ps_string(L" default (EFI var): %s\n", config->entry_default_efivar);

ps_string(L" default (one-shot): %s\n", config->entry_oneshot);

ps_string(L" saved entry: %s\n", config->entry_saved);

ps_bool(L" editor: %s\n", config->editor);

ps_bool(L" auto-entries: %s\n", config->auto_entries);

ps_bool(L" auto-firmware: %s\n", config->auto_firmware);

ps_bool(L" beep: %s\n", config->beep);

ps_bool(L" reboot-for-bitlocker: %s\n", config->reboot_for_bitlocker);

ps_string(L" random-seed-mode: %s\n", random_seed_modes_table[config->random_seed_mode]);

switch (config->console_mode) {

case CONSOLE_MODE_AUTO:

Print(L" console-mode: %s\n", L"auto"); break;

case CONSOLE_MODE_KEEP:

Print(L" console-mode: %s\n", L"keep"); break;

case CONSOLE_MODE_FIRMWARE_MAX:

Print(L" console-mode: %s\n", L"max"); break;

default:

Print(L" console-mode: %ld\n", config->console_mode); break;

}

/* EFI var console mode is always a concrete value or unset. */

if (config->console_mode_efivar != CONSOLE_MODE_KEEP)

Print(L"console-mode (EFI var): %ld\n", config->console_mode_efivar);

if (!ps_continue())

return;

for (UINTN i = 0; i < config->entry_count; i++) {

ConfigEntry *entry = config->entries[i];

Print(L" config entry: %lu/%lu\n", i + 1, config->entry_count);

ps_string(L" id: %s\n", entry->id);

ps_string(L" title: %s\n", entry->title);

ps_string(L" title show: %s\n", streq_ptr(entry->title, entry->title_show) ? NULL : entry->title_show);

ps_string(L" sort key: %s\n", entry->sort_key);

ps_string(L" version: %s\n", entry->version);

ps_string(L" machine-id: %s\n", entry->machine_id);

if (entry->device)

Print(L" device: %D\n", DevicePathFromHandle(entry->device));

ps_string(L" loader: %s\n", entry->loader);

ps_string(L" devicetree: %s\n", entry->devicetree);

ps_string(L" options: %s\n", entry->options);

ps_bool(L" internal call: %s\n", !!entry->call);

ps_bool(L"counting boots: %s\n", entry->tries_left != UINTN_MAX);

if (entry->tries_left != UINTN_MAX) {

Print(L" tries: %lu done, %lu left\n", entry->tries_done, entry->tries_left);

Print(L" current path: %s\\%s\n", entry->path, entry->current_name);

Print(L" next path: %s\\%s\n", entry->path, entry->next_name);

}

if (!ps_continue())

return;

}

}

static EFI_STATUS reboot_into_firmware(void) {

UINT64 osind = 0;

EFI_STATUS err;

if (!FLAGS_SET(get_os_indications_supported(), EFI_OS_INDICATIONS_BOOT_TO_FW_UI))

return log_error_status_stall(EFI_UNSUPPORTED, L"Reboot to firmware interface not supported.");

(void) efivar_get_uint64_le(EFI_GLOBAL_GUID, L"OsIndications", &osind);

osind |= EFI_OS_INDICATIONS_BOOT_TO_FW_UI;

err = efivar_set_uint64_le(EFI_GLOBAL_GUID, L"OsIndications", osind, EFI_VARIABLE_NON_VOLATILE);

if (EFI_ERROR(err))

return log_error_status_stall(err, L"Error setting OsIndications: %r", err);

err = RT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);

return log_error_status_stall(err, L"Error calling ResetSystem: %r", err);

}

static BOOLEAN menu_run(

Config *config,

ConfigEntry **chosen_entry,

CHAR16 *loaded_image_path) {

assert(config);

assert(chosen_entry);

assert(loaded_image_path);

EFI_STATUS err;

UINTN visible_max = 0;

UINTN idx_highlight = config->idx_default;

UINTN idx_highlight_prev = 0;

UINTN idx, idx_first = 0, idx_last = 0;

BOOLEAN new_mode = TRUE, clear = TRUE;

BOOLEAN refresh = TRUE, highlight = FALSE;

UINTN x_start = 0, y_start = 0, y_status = 0;

UINTN x_max, y_max;

_cleanup_(strv_freep) CHAR16 **lines = NULL;

_cleanup_freepool_ CHAR16 *clearline = NULL, *separator = NULL, *status = NULL;

UINT32 timeout_efivar_saved = config->timeout_sec_efivar;

UINT32 timeout_remain = config->timeout_sec == TIMEOUT_MENU_FORCE ? 0 : config->timeout_sec;

BOOLEAN exit = FALSE, run = TRUE, firmware_setup = FALSE;

INT64 console_mode_initial = ST->ConOut->Mode->Mode, console_mode_efivar_saved = config->console_mode_efivar;

UINTN default_efivar_saved = config->idx_default_efivar;

graphics_mode(FALSE);

ST->ConIn->Reset(ST->ConIn, FALSE);

ST->ConOut->EnableCursor(ST->ConOut, FALSE);

/* draw a single character to make ClearScreen work on some firmware */

Print(L" ");

err = console_set_mode(config->console_mode_efivar != CONSOLE_MODE_KEEP ?

config->console_mode_efivar : config->console_mode);

if (EFI_ERROR(err)) {

clear_screen(COLOR_NORMAL);

log_error_stall(L"Error switching console mode: %r", err);

}

UINTN line_width = 0, entry_padding = 3;

while (!exit) {

UINT64 key;

if (new_mode) {

console_query_mode(&x_max, &y_max);

/* account for padding+status */

visible_max = y_max - 2;

/* Drawing entries starts at idx_first until idx_last. We want to make

if (config->entry_count <= visible_max || idx_highlight <= visible_max / 2)

idx_first = 0;

else if (idx_highlight >= config->entry_count - (visible_max / 2))

idx_first = config->entry_count - visible_max;

else

idx_first = idx_highlight - (visible_max / 2);

idx_last = idx_first + visible_max - 1;

/* length of the longest entry */

line_width = 0;

for (UINTN i = 0; i < config->entry_count; i++)

line_width = MAX(line_width, StrLen(config->entries[i]->title_show));

line_width = MIN(line_width + 2 * entry_padding, x_max);

/* offsets to center the entries on the screen */

x_start = (x_max - (line_width)) / 2;

if (config->entry_count < visible_max)

y_start = ((visible_max - config->entry_count) / 2) + 1;

else

y_start = 0;

/* Put status line after the entry list, but give it some breathing room. */

y_status = MIN(y_start + MIN(visible_max, config->entry_count) + 1, y_max - 1);

lines = strv_free(lines);

clearline = mfree(clearline);

separator = mfree(separator);

/* menu entries title lines */

lines = xnew(CHAR16*, config->entry_count + 1);

for (UINTN i = 0; i < config->entry_count; i++) {

UINTN j, padding;

lines[i] = xnew(CHAR16, line_width + 1);

padding = (line_width - MIN(StrLen(config->entries[i]->title_show), line_width)) / 2;

for (j = 0; j < padding; j++)

lines[i][j] = ' ';

for (UINTN k = 0; config->entries[i]->title_show[k] != '\0' && j < line_width; j++, k++)

lines[i][j] = config->entries[i]->title_show[k];

for (; j < line_width; j++)

lines[i][j] = ' ';

lines[i][line_width] = '\0';

}

lines[config->entry_count] = NULL;

clearline = xnew(CHAR16, x_max + 1);

separator = xnew(CHAR16, x_max + 1);

for (UINTN i = 0; i < x_max; i++) {

clearline[i] = ' ';

separator[i] = unicode_supported() ? L'─' : L'-';

}

clearline[x_max] = 0;

separator[x_max] = 0;

new_mode = FALSE;

clear = TRUE;

}

if (clear) {

clear_screen(COLOR_NORMAL);

clear = FALSE;

refresh = TRUE;

}

if (refresh) {

for (UINTN i = idx_first; i <= idx_last && i < config->entry_count; i++) {

print_at(x_start, y_start + i - idx_first,

(i == idx_highlight) ? COLOR_HIGHLIGHT : COLOR_ENTRY,

lines[i]);

if (i == config->idx_default_efivar)

print_at(x_start, y_start + i - idx_first,

(i == idx_highlight) ? COLOR_HIGHLIGHT : COLOR_ENTRY,

(CHAR16*) (unicode_supported() ? L" ►" : L"=>"));

}

refresh = FALSE;

} else if (highlight) {

print_at(x_start, y_start + idx_highlight_prev - idx_first, COLOR_ENTRY, lines[idx_highlight_prev]);

print_at(x_start, y_start + idx_highlight - idx_first, COLOR_HIGHLIGHT, lines[idx_highlight]);

if (idx_highlight_prev == config->idx_default_efivar)

print_at(x_start , y_start + idx_highlight_prev - idx_first, COLOR_ENTRY, (CHAR16*) (unicode_supported() ? L" ►" : L"=>"));

if (idx_highlight == config->idx_default_efivar)

print_at(x_start, y_start + idx_highlight - idx_first, COLOR_HIGHLIGHT, (CHAR16*) (unicode_supported() ? L" ►" : L"=>"));

highlight = FALSE;

}

if (timeout_remain > 0) {

FreePool(status);

status = xpool_print(L"Boot in %u s.", timeout_remain);

}

if (status) {

/* If we draw the last char of the last line, the screen will scroll and break our

UINTN len = StrnLen(status, x_max - 1);

UINTN x = (x_max - len) / 2;

status[len] = '\0';

print_at(0, y_status, COLOR_NORMAL, clearline + x_max - x);

ST->ConOut->OutputString(ST->ConOut, status);

ST->ConOut->OutputString(ST->ConOut, clearline + 1 + x + len);

len = MIN(MAX(len, line_width) + 2 * entry_padding, x_max);

x = (x_max - len) / 2;

print_at(x, y_status - 1, COLOR_NORMAL, separator + x_max - len);

} else {

print_at(0, y_status - 1, COLOR_NORMAL, clearline);

print_at(0, y_status, COLOR_NORMAL, clearline + 1); /* See comment above. */

}

/* Beep several times so that the selected entry can be distinguished. */

if (config->beep)

beep(idx_highlight + 1);

err = console_key_read(&key, timeout_remain > 0 ? 1000 * 1000 : UINT64_MAX);

if (err == EFI_NOT_READY)

/* No input device returned a key, try again. This

continue;

if (err == EFI_TIMEOUT) {

assert(timeout_remain > 0);

timeout_remain--;

if (timeout_remain == 0) {

exit = TRUE;

break;

}

/* update status */

continue;

}

if (EFI_ERROR(err)) {

exit = TRUE;

break;

}

timeout_remain = 0;

/* clear status after keystroke */

status = mfree(status);

idx_highlight_prev = idx_highlight;

if (firmware_setup) {

firmware_setup = FALSE;

if (key == KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN))

reboot_into_firmware();

continue;

}

switch (key) {

case KEYPRESS(0, SCAN_UP, 0):

case KEYPRESS(0, 0, 'k'):

case KEYPRESS(0, 0, 'K'):

if (idx_highlight > 0)

idx_highlight--;

break;

case KEYPRESS(0, SCAN_DOWN, 0):

case KEYPRESS(0, 0, 'j'):

case KEYPRESS(0, 0, 'J'):

if (idx_highlight < config->entry_count-1)

idx_highlight++;

break;

case KEYPRESS(0, SCAN_HOME, 0):

case KEYPRESS(EFI_ALT_PRESSED, 0, '<'):

if (idx_highlight > 0) {

refresh = TRUE;

idx_highlight = 0;

}

break;

case KEYPRESS(0, SCAN_END, 0):

case KEYPRESS(EFI_ALT_PRESSED, 0, '>'):

if (idx_highlight < config->entry_count-1) {

refresh = TRUE;

idx_highlight = config->entry_count-1;

}

break;

case KEYPRESS(0, SCAN_PAGE_UP, 0):

if (idx_highlight > visible_max)

idx_highlight -= visible_max;

else

idx_highlight = 0;

break;

case KEYPRESS(0, SCAN_PAGE_DOWN, 0):

idx_highlight += visible_max;

if (idx_highlight > config->entry_count-1)

idx_highlight = config->entry_count-1;

break;

case KEYPRESS(0, 0, CHAR_LINEFEED):

case KEYPRESS(0, 0, CHAR_CARRIAGE_RETURN):

case KEYPRESS(0, CHAR_CARRIAGE_RETURN, 0): /* EZpad Mini 4s firmware sends malformed events */

case KEYPRESS(0, CHAR_CARRIAGE_RETURN, CHAR_CARRIAGE_RETURN): /* Teclast X98+ II firmware sends malformed events */

case KEYPRESS(0, SCAN_RIGHT, 0):

exit = TRUE;

break;

case KEYPRESS(0, SCAN_F1, 0):

case KEYPRESS(0, 0, 'h'):

case KEYPRESS(0, 0, 'H'):

case KEYPRESS(0, 0, '?'):

/* This must stay below 80 characters! Q/v/Ctrl+l/f deliberately not advertised. */

status = xstrdup(L"(d)efault (t/T)timeout (e)dit (r/R)resolution (p)rint (h)elp");

break;

case KEYPRESS(0, 0, 'Q'):

exit = TRUE;

run = FALSE;

break;

case KEYPRESS(0, 0, 'd'):

case KEYPRESS(0, 0, 'D'):

if (config->idx_default_efivar != idx_highlight) {

FreePool(config->entry_default_efivar);

config->entry_default_efivar = xstrdup(config->entries[idx_highlight]->id);

config->idx_default_efivar = idx_highlight;

status = xstrdup(L"Default boot entry selected.");

} else {

config->entry_default_efivar = mfree(config->entry_default_efivar);

config->idx_default_efivar = IDX_INVALID;

status = xstrdup(L"Default boot entry cleared.");

}

config->use_saved_entry_efivar = FALSE;

refresh = TRUE;

break;

case KEYPRESS(0, 0, '-'):

case KEYPRESS(0, 0, 'T'):

status = update_timeout_efivar(&config->timeout_sec_efivar, FALSE);

break;

case KEYPRESS(0, 0, '+'):

case KEYPRESS(0, 0, 't'):

status = update_timeout_efivar(&config->timeout_sec_efivar, TRUE);

break;

case KEYPRESS(0, 0, 'e'):

case KEYPRESS(0, 0, 'E'):

/* only the options of configured entries can be edited */

if (!config->editor || !IN_SET(config->entries[idx_highlight]->type,

LOADER_EFI, LOADER_LINUX, LOADER_UNIFIED_LINUX))

break;

/* Unified kernels that are signed as a whole will not accept command line options

if (config->entries[idx_highlight]->type == LOADER_UNIFIED_LINUX &&

secure_boot_enabled() &&

config->entries[idx_highlight]->options)

break;

/* The edit line may end up on the last line of the screen. And even though we're

print_at(1, y_status, COLOR_EDIT, clearline + 2);

exit = line_edit(config->entries[idx_highlight]->options, &config->options_edit, x_max - 2, y_status);

print_at(1, y_status, COLOR_NORMAL, clearline + 2);

break;

case KEYPRESS(0, 0, 'v'):

status = xpool_print(L"systemd-boot " GIT_VERSION " (" EFI_MACHINE_TYPE_NAME "), "

L"UEFI Specification %d.%02d, Vendor %s %d.%02d",

ST->Hdr.Revision >> 16, ST->Hdr.Revision & 0xffff,

ST->FirmwareVendor, ST->FirmwareRevision >> 16, ST->FirmwareRevision & 0xffff);

break;

case KEYPRESS(0, 0, 'p'):

case KEYPRESS(0, 0, 'P'):

print_status(config, loaded_image_path);

clear = TRUE;

break;

case KEYPRESS(EFI_CONTROL_PRESSED, 0, 'l'):

case KEYPRESS(EFI_CONTROL_PRESSED, 0, CHAR_CTRL('l')):

clear = TRUE;

break;

case KEYPRESS(0, 0, 'r'):

err = console_set_mode(CONSOLE_MODE_NEXT);

if (EFI_ERROR(err))

status = xpool_print(L"Error changing console mode: %r", err);

else {

config->console_mode_efivar = ST->ConOut->Mode->Mode;

status = xpool_print(L"Console mode changed to %ld.", config->console_mode_efivar);

}

new_mode = TRUE;

break;

case KEYPRESS(0, 0, 'R'):

config->console_mode_efivar = CONSOLE_MODE_KEEP;

err = console_set_mode(config->console_mode == CONSOLE_MODE_KEEP ?

console_mode_initial : config->console_mode);

if (EFI_ERROR(err))

status = xpool_print(L"Error resetting console mode: %r", err);

else

status = xpool_print(L"Console mode reset to %s default.",

config->console_mode == CONSOLE_MODE_KEEP ? L"firmware" : L"configuration file");

new_mode = TRUE;

break;

case KEYPRESS(0, 0, 'f'):

case KEYPRESS(0, 0, 'F'):

case KEYPRESS(0, SCAN_F2, 0): /* Most vendors. */

case KEYPRESS(0, SCAN_F10, 0): /* HP and Lenovo. */

case KEYPRESS(0, SCAN_DELETE, 0): /* Same as F2. */

case KEYPRESS(0, SCAN_ESC, 0): /* HP. */

if (FLAGS_SET(get_os_indications_supported(), EFI_OS_INDICATIONS_BOOT_TO_FW_UI)) {

firmware_setup = TRUE;

/* Let's make sure the user really wants to do this. */

status = xpool_print(L"Press Enter to reboot into firmware interface.");

} else

status = xpool_print(L"Reboot into firmware interface not supported.");

break;

default:

/* jump with a hotkey directly to a matching entry */

idx = entry_lookup_key(config, idx_highlight+1, KEYCHAR(key));

if (idx == IDX_INVALID)

break;

idx_highlight = idx;

refresh = TRUE;

}

if (idx_highlight > idx_last) {

idx_last = idx_highlight;

idx_first = 1 + idx_highlight - visible_max;

refresh = TRUE;

} else if (idx_highlight < idx_first) {

idx_first = idx_highlight;

idx_last = idx_highlight + visible_max-1;

refresh = TRUE;

}

if (!refresh && idx_highlight != idx_highlight_prev)

highlight = TRUE;

}

*chosen_entry = config->entries[idx_highlight];