notice.c File Reference

Go to the source code of this file.

Data Structures
struct	notice_snapshot_t

Macros
#define	FIRST_USE_LINE_COUNT   64
#define	FIRST_USE_LINE_BYTES   512
#define	FIRST_USE_CONTENT_COLUMNS   66

Functions
int	ui_notice_render (frame_buffer_t *buffer, const char *text, ui_notice_severity_t severity, int cols, bool unicode, bool color)
const char *	ui_notice_title (const void *data)
asciichat_error_t	ui_notice_present (ui_notice_severity_t severity, const char *text)
asciichat_error_t	ui_notice_present_first_use (const char *title, const char *text, const char *marker_path)
void	ui_notice_frame_presented (const void *data)
ui_notice_key_result_t	ui_notice_first_use_key (const void *data, int key)
void	ui_notice_first_use_complete (const void *data)
bool	ui_notice_confirm (ui_notice_severity_t severity, const char *text, unsigned timeout_seconds)
bool	ui_notice_confirm_kind (ui_prompt_kind_t kind, ui_notice_severity_t severity, const char *text, unsigned timeout_seconds)
ui_prompt_kind_t	ui_notice_prompt_kind (void)
ui_notice_severity_t	ui_notice_prompt_severity (void)
void	ui_notice_flush_snapshot (int fd, const void *data)
void	ui_notice_dismiss (void)

Macro Definition Documentation

FIRST_USE_CONTENT_COLUMNS

#define FIRST_USE_CONTENT_COLUMNS   66

Definition at line 203 of file notice.c.

FIRST_USE_LINE_BYTES

#define FIRST_USE_LINE_BYTES   512

Definition at line 202 of file notice.c.

FIRST_USE_LINE_COUNT

#define FIRST_USE_LINE_COUNT   64

Definition at line 201 of file notice.c.

Function Documentation

ui_notice_confirm()

bool ui_notice_confirm	(	ui_notice_severity_t	severity,
		const char *	text,
		unsigned	timeout_seconds )

Explicitly styled yes/no prompt; default remains No.

Definition at line 494 of file notice.c.

                                                                                                  {
  return ui_notice_confirm_kind(UI_PROMPT_CONFIRMATION, severity, text, timeout_seconds);
}

References ui_notice_confirm_kind().

ui_notice_confirm_kind()

bool ui_notice_confirm_kind	(	ui_prompt_kind_t	kind,
		ui_notice_severity_t	severity,
		const char *	text,
		unsigned	timeout_seconds )

Definition at line 498 of file notice.c.

                                                      {
  ui_prompt_kind_t previous_kind = g_prompt_kind;
  g_prompt_kind = kind;
  ui_notice_severity_t previous = g_prompt_severity;
  g_prompt_severity = severity;
  if (terminal_can_prompt_user(!GET_OPTION(snapshot_mode)))
    log_msg(severity == UI_NOTICE_FATAL     ? LOG_FATAL
            : severity == UI_NOTICE_DANGER  ? LOG_ERROR
            : severity == UI_NOTICE_WARNING ? LOG_WARN
                                            : LOG_INFO,
            __FILE__, __LINE__, __func__, "%s", text);
  else
    ui_notice_log(severity, __FILE__, __LINE__, __func__, "CONFIRMATION REQUIRED", "%s", text);
  bool accepted = platform_prompt_yes_no_timeout(text, false, timeout_seconds);
  g_prompt_kind = previous_kind;
  g_prompt_severity = previous;
  return accepted;
}

References GET_OPTION, LOG_ERROR, LOG_FATAL, LOG_INFO, log_msg(), LOG_WARN, UI_NOTICE_DANGER, UI_NOTICE_FATAL, ui_notice_log(), and UI_NOTICE_WARNING.

Referenced by action_completions(), config_create_default(), discovery_keys_verify_change(), prompt_unknown_host(), prompt_unknown_host_no_identity(), and ui_notice_confirm().

ui_notice_dismiss()

void ui_notice_dismiss

(

void

)

Definition at line 541 of file notice.c.

                             {
  ui_controller_remove(UI_SCREEN_NOTICE);
}

References ui_controller_remove(), and UI_SCREEN_NOTICE.

ui_notice_first_use_complete()

void ui_notice_first_use_complete

(

const void *

data

)

Definition at line 478 of file notice.c.

                                                    {
  const notice_snapshot_t *notice = data;
  if (!notice || !notice->marker_offset)
    return;
  asciichat_errno_scope_t scope = errno_scope_begin();
  FILE *marker = platform_fopen("first-use instructions", notice->text + notice->marker_offset, "w");
  if (!marker) {
    log_warn("Could not save first-use instructions state; the notice may appear again: %s",
             notice->text + notice->marker_offset);
  } else if (fclose(marker) != 0) {
    log_warn("Could not finish saving first-use instructions state; the notice may appear again: %s",
             notice->text + notice->marker_offset);
  }
  errno_scope_end(scope, ASCIICHAT_ERRNO_DISMISSED);
}

References ASCIICHAT_ERRNO_DISMISSED, errno_scope_begin(), errno_scope_end(), log_warn, notice_snapshot_t::marker_offset, and notice_snapshot_t::text.

Referenced by ui_controller_first_use_key().

ui_notice_first_use_key()

ui_notice_key_result_t ui_notice_first_use_key	(	const void *	data,
		int	key )

Definition at line 453 of file notice.c.

                                                                          {
  notice_snapshot_t *notice = (notice_snapshot_t *)data;
  if (!notice || !notice->marker_offset)
    return UI_NOTICE_KEY_ORDINARY;
  if (key == KEY_ESCAPE || key == 'q' || key == 3)
    return UI_NOTICE_KEY_DISMISS;
  if (key == KEY_QUESTION)
    return UI_NOTICE_KEY_HELP;
  int page = atomic_load(&notice->page);
  int pages = atomic_load(&notice->pages);
  if (key == KEY_LEFT && page > 0) {
    atomic_store(&notice->presented_page, -1);
    atomic_store(&notice->page, page - 1);
  } else if ((key == '\r' || key == '\n' || key == KEY_RIGHT) && pages > 0 &&
             atomic_load(&notice->presented_page) == page) {
    if (page + 1 < pages) {
      atomic_store(&notice->presented_page, -1);
      atomic_store(&notice->page, page + 1);
    } else if (key == '\r' || key == '\n') {
      return UI_NOTICE_KEY_COMPLETE;
    }
  }
  return UI_NOTICE_KEY_HANDLED;
}

References KEY_ESCAPE, KEY_LEFT, KEY_QUESTION, KEY_RIGHT, notice_snapshot_t::marker_offset, notice_snapshot_t::page, notice_snapshot_t::pages, notice_snapshot_t::presented_page, UI_NOTICE_KEY_COMPLETE, UI_NOTICE_KEY_DISMISS, UI_NOTICE_KEY_HANDLED, UI_NOTICE_KEY_HELP, and UI_NOTICE_KEY_ORDINARY.

Referenced by ui_controller_first_use_key().

ui_notice_flush_snapshot()

void ui_notice_flush_snapshot	(	int	fd,
		const void *	snapshot )

Controller teardown writes pending notices to scrollback before releasing them.

Definition at line 526 of file notice.c.

                                                        {
  const notice_snapshot_t *notice = data;
  frame_buffer_t *buffer = frame_buffer_create(0, 0);
  if (!buffer)
    return;
  if (platform_isatty(fd))
    frame_buffer_append(buffer, "\033[0m\n", 5);
  terminal_size_t size = {.cols = 80};
  if (platform_isatty(fd))
    (void)terminal_get_size_fd(fd, &size);
  ui_notice_render(buffer, notice->text, notice->severity, size.cols, notice->unicode, notice->color);
  platform_write_all(fd, frame_buffer_get_content(buffer), frame_buffer_get_length(buffer));
  frame_buffer_destroy(buffer);
}

References notice_snapshot_t::color, frame_buffer_append(), frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), platform_write_all(), notice_snapshot_t::severity, notice_snapshot_t::text, ui_notice_render(), and notice_snapshot_t::unicode.

ui_notice_frame_presented()

void ui_notice_frame_presented

(

const void *

snapshot

)

Record which first-use page reached the terminal after a successful frame.

Definition at line 447 of file notice.c.

                                                 {
  notice_snapshot_t *notice = (notice_snapshot_t *)data;
  if (notice && notice->marker_offset)
    atomic_store(&notice->presented_page, notice->rendered_page);
}

References notice_snapshot_t::marker_offset, notice_snapshot_t::presented_page, and notice_snapshot_t::rendered_page.

ui_notice_present()

asciichat_error_t ui_notice_present	(	ui_notice_severity_t	severity,
		const char *	text )

Present a notice without changing authentication or input policy.

Definition at line 371 of file notice.c.

                                                                                     {
  if (!text)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing notice text");
  bool tty = platform_isatty(STDERR_FILENO);
  bool color = !GET_OPTION(strip_ansi) && terminal_should_color_output(STDERR_FILENO, options_terminal_settings());
  bool unicode = tty && terminal_should_use_utf8(GET_OPTION(force_utf8));
  if (severity != UI_NOTICE_FATAL && tty && ui_controller_is_presenting() && !ui_controller_is_owner() &&
      !GET_OPTION(snapshot_mode)) {
    size_t text_bytes = strlen(text) + 1;
    size_t bytes = sizeof(notice_snapshot_t) + text_bytes;
    notice_snapshot_t *snapshot = SAFE_MALLOC(bytes, notice_snapshot_t *);
    if (!snapshot)
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate notice");
    snapshot->severity = severity;
    snapshot->unicode = unicode;
    snapshot->color = color;
    snapshot->started = time_get_ns();
    snapshot->marker_offset = snapshot->title_offset = 0;
    atomic_init(&snapshot->page, 0);
    atomic_init(&snapshot->pages, 0);
    atomic_init(&snapshot->presented_page, -1);
    snapshot->rendered_page = -1;
    snapshot->rendered_cols = snapshot->rendered_rows = 0;
    memcpy(snapshot->text, text, text_bytes);
    asciichat_error_t result = ui_controller_submit(
        UI_SCREEN_NOTICE, STDERR_FILENO, (terminal_size_t){.cols = 1, .rows = 1}, render_notice, snapshot, bytes);
    SAFE_FREE(snapshot);
    return result;
  }
  frame_buffer_t *buffer = frame_buffer_create(0, 0);
  if (!buffer)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate notice buffer");
  if (severity == UI_NOTICE_FATAL && tty)
    frame_buffer_append(buffer, "\033[0m\033[?25h\r\n", 12);
  int cols = tty ? ui_controller_size().cols : 80;
  ui_notice_render(buffer, text, severity, cols, unicode, color);
  asciichat_error_t result = ASCIICHAT_OK;
  if (severity == UI_NOTICE_FATAL && !ui_controller_is_owner())
    ui_controller_finish(STDERR_FILENO, frame_buffer_get_content(buffer), frame_buffer_get_length(buffer));
  else
    result = ui_controller_write(STDERR_FILENO, frame_buffer_get_content(buffer), frame_buffer_get_length(buffer));
  frame_buffer_destroy(buffer);
  return result;
}

References ASCIICHAT_OK, notice_snapshot_t::color, ERROR_INVALID_PARAM, ERROR_MEMORY, frame_buffer_append(), frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), GET_OPTION, notice_snapshot_t::marker_offset, options_terminal_settings, notice_snapshot_t::page, notice_snapshot_t::pages, notice_snapshot_t::presented_page, notice_snapshot_t::rendered_cols, notice_snapshot_t::rendered_page, notice_snapshot_t::rendered_rows, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, notice_snapshot_t::severity, notice_snapshot_t::started, notice_snapshot_t::text, notice_snapshot_t::title_offset, ui_controller_finish(), ui_controller_is_owner(), ui_controller_is_presenting(), ui_controller_size(), ui_controller_submit(), ui_controller_write(), UI_NOTICE_FATAL, ui_notice_render(), UI_SCREEN_NOTICE, and notice_snapshot_t::unicode.

ui_notice_present_first_use()

asciichat_error_t ui_notice_present_first_use	(	const char *	title,
		const char *	text,
		const char *	marker_path )

Show a first-use notice until the user dismisses it.

Definition at line 416 of file notice.c.

                                                                                                            {
  if (!title || !text || !marker_path || !platform_isatty(STDERR_FILENO) || GET_OPTION(snapshot_mode))
    return SET_ERRNO(ERROR_INVALID_PARAM, "First-use notice requires an interactive terminal and marker path");
  size_t text_bytes = strlen(text) + 1, title_bytes = strlen(title) + 1, marker_bytes = strlen(marker_path) + 1;
  if (title_bytes > SIZE_MAX - marker_bytes - sizeof(notice_snapshot_t) ||
      text_bytes > SIZE_MAX - title_bytes - marker_bytes - sizeof(notice_snapshot_t))
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "First-use notice is too large");
  size_t bytes = sizeof(notice_snapshot_t) + text_bytes + title_bytes + marker_bytes;
  notice_snapshot_t *snapshot = SAFE_MALLOC(bytes, notice_snapshot_t *);
  if (!snapshot)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate first-use notice");
  snapshot->severity = UI_NOTICE_INFO;
  snapshot->unicode = terminal_should_use_utf8(GET_OPTION(force_utf8));
  snapshot->color = !GET_OPTION(strip_ansi) && terminal_should_color_output(STDERR_FILENO, options_terminal_settings());
  snapshot->started = time_get_ns();
  snapshot->title_offset = text_bytes;
  snapshot->marker_offset = text_bytes + title_bytes;
  atomic_init(&snapshot->page, 0);
  atomic_init(&snapshot->pages, 0);
  atomic_init(&snapshot->presented_page, -1);
  snapshot->rendered_page = -1;
  snapshot->rendered_cols = snapshot->rendered_rows = 0;
  memcpy(snapshot->text, text, text_bytes);
  memcpy(snapshot->text + text_bytes, title, title_bytes);
  memcpy(snapshot->text + snapshot->marker_offset, marker_path, marker_bytes);
  asciichat_error_t result = ui_controller_submit(
      UI_SCREEN_NOTICE, STDERR_FILENO, (terminal_size_t){.cols = 20, .rows = 8}, render_notice, snapshot, bytes);
  SAFE_FREE(snapshot);
  return result;
}

References notice_snapshot_t::color, ERROR_BUFFER_OVERFLOW, ERROR_INVALID_PARAM, ERROR_MEMORY, GET_OPTION, notice_snapshot_t::marker_offset, options_terminal_settings, notice_snapshot_t::page, notice_snapshot_t::pages, notice_snapshot_t::presented_page, notice_snapshot_t::rendered_cols, notice_snapshot_t::rendered_page, notice_snapshot_t::rendered_rows, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, notice_snapshot_t::severity, notice_snapshot_t::started, notice_snapshot_t::text, notice_snapshot_t::title_offset, ui_controller_submit(), UI_NOTICE_INFO, UI_SCREEN_NOTICE, and notice_snapshot_t::unicode.

ui_notice_prompt_kind()

ui_prompt_kind_t ui_notice_prompt_kind

(

void

)

Definition at line 518 of file notice.c.

                                             {
  return g_prompt_kind;
}

Referenced by main().

ui_notice_prompt_severity()

ui_notice_severity_t ui_notice_prompt_severity

(

void

)

Definition at line 522 of file notice.c.

                                                     {
  return g_prompt_severity;
}

Referenced by ui_prompt_present_kind().

ui_notice_render()

int ui_notice_render	(	frame_buffer_t *	buffer,
		const char *	text,
		ui_notice_severity_t	severity,
		int	cols,
		bool	unicode,
		bool	color )

Append a complete box, or measure it when buffer is NULL. Returns its row count. Text is plain UTF-8. Terminal control characters are made visible, never executed.

Definition at line 64 of file notice.c.

                                 {
  if (!text)
    text = "";
  const char *body = text;
  text = notice_label(severity);
  bool rendering_label = true;
  const char *text_end = text + strlen(text);
  // Reserve the final column to avoid terminal autowrap at the right border.
  int width = cols > 81 ? 80 : cols - 1;
  bool boxed = width >= 8;
  int content = boxed ? width - 4 : (cols > 2 ? cols - 1 : 2);
  const char *side = unicode ? "║" : "|";
  if (buffer && color)
    frame_buffer_printf(buffer, "\033[1m%s", notice_color(severity));
  if (boxed)
    border(buffer, width, UI_POPUP_TOP, unicode, severity, color);
  int rows = boxed ? 2 : 0;
  const char *art_end = NULL;
  const char *word_end = NULL;
  bool title_word = false;
  bool first_letter = false;
  do {
    // The Keymask formatter identifies complete plain-text blocks; input ANSI
    // escapes still pass through the normal control-character sanitization.
    const char *block_end = key_identity_art_end(text);
    if (block_end)
      art_end = block_end;
    bool neutral = art_end && text < art_end;
    int used = 0;
    if (buffer && boxed)
      frame_buffer_printf(buffer, "%s ", side);
    if (buffer && color && neutral)
      frame_buffer_append(buffer, "\033[0;39m", 7);
    while (*text && *text != '\n') {
      int bytes = utf8_next_char_bytes(text, (size_t)(text_end - text));
      if (bytes <= 0)
        bytes = 1;
      bool control = (unsigned char)*text < 32 || (unsigned char)*text == 127 ||
                     (bytes == 2 && (unsigned char)text[0] == 0xc2 && (unsigned char)text[1] >= 0x80 &&
                      (unsigned char)text[1] <= 0x9f);
      int cells = control ? 1 : utf8_display_width_n(text, (size_t)bytes);
      if (cells < 0)
        cells = 1;
      if (used + cells > content && used)
        break;
      if (buffer) {
        if (control)
          frame_buffer_append(buffer, "?", 1);
        else if (!rendering_label && !neutral) {
          if (!word_end || text >= word_end) {
            word_end = text;
            title_word = (*text >= 'A' && *text <= 'Z') || (*text >= 'a' && *text <= 'z');
            first_letter = true;
            while (*word_end && *word_end != ' ' && *word_end != '\n' && *word_end != '\t') {
              unsigned char c = (unsigned char)*word_end;
              bool letter = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
              bool punctuation = strchr(",.;:!?", c) && (!word_end[1] || word_end[1] == ' ' || word_end[1] == '\n');
              if (!letter && !punctuation)
                title_word = false;
              ++word_end;
            }
          }
          if (title_word && bytes == 1) {
            char c = *text;
            if (first_letter && c >= 'a' && c <= 'z')
              c -= 'a' - 'A';
            else if (!first_letter && c >= 'A' && c <= 'Z')
              c += 'a' - 'A';
            first_letter = false;
            frame_buffer_append(buffer, &c, 1);
          } else {
            frame_buffer_append(buffer, text, (size_t)bytes);
          }
        } else
          frame_buffer_append(buffer, text, (size_t)bytes);
      }
      used += cells;
      text += bytes;
    }
    if (buffer) {
      if (color && neutral)
        frame_buffer_printf(buffer, "\033[1m%s", notice_color(severity));
      if (boxed)
        frame_buffer_printf(buffer, "%*s %s", content - used, "", side);
      frame_buffer_append(buffer, "\n", 1);
    }
    ++rows;
    if (*text == '\n')
      ++text;
    if (!*text) {
      if (!rendering_label)
        break;
      if (boxed) {
        border(buffer, width, UI_POPUP_SEPARATOR, unicode, severity, color);
        ++rows;
      }
      rendering_label = false;
      text = body;
      text_end = text + strlen(text);
    }
  } while (true);
  if (boxed)
    border(buffer, width, UI_POPUP_BOTTOM, unicode, severity, color);
  if (buffer && color)
    frame_buffer_append(buffer, "\033[0m", 4);
  return rows;
}

References cells, frame_buffer_append(), frame_buffer_printf(), key_identity_art_end(), UI_POPUP_BOTTOM, UI_POPUP_SEPARATOR, UI_POPUP_TOP, utf8_display_width_n(), utf8_next_char_bytes(), and width.

Referenced by ui_notice_flush_snapshot(), ui_notice_present(), ui_prompt_present_kind(), and ui_prompt_required_rows().

ui_notice_title()

const char * ui_notice_title

(

const void *

data

)

Definition at line 194 of file notice.c.

                                              {
  const notice_snapshot_t *notice = data;
  return notice->severity == UI_NOTICE_WARNING                                         ? "warning"
         : notice->severity == UI_NOTICE_DANGER || notice->severity == UI_NOTICE_FATAL ? "error"
                                                                                       : "notice";
}

References notice_snapshot_t::severity, UI_NOTICE_DANGER, UI_NOTICE_FATAL, and UI_NOTICE_WARNING.