command.c

/*  RetroArch - A frontend for libretro.
 *  Copyright (C) 2010-2014 - Hans-Kristian Arntzen
 *  Copyright (C) 2011-2017 - Daniel De Matteis
 *  Copyright (C) 2021      - David G.F.
 *
 *  RetroArch is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 *  PURPOSE.  See the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along with RetroArch.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#include "input/input_driver.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stddef.h>
#include <errno.h>
#include <locale.h>
#ifdef HAVE_NETWORKING
#include <net/net_compat.h>
#include <net/net_socket.h>
#endif
#include <lists/dir_list.h>
#include <file/file_path.h>
#include <streams/stdin_stream.h>
#include <streams/file_stream.h>
#include <string/stdstring.h>
#include <features/features_cpu.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_CHEEVOS
#include "cheevos/cheevos.h"
#endif

#ifdef HAVE_GFX_WIDGETS
#include "gfx/gfx_widgets.h"
#endif

#ifdef HAVE_MENU
#include "menu/menu_driver.h"
#endif

#ifdef HAVE_NETWORKING
#include "network/netplay/netplay.h"
#endif

#include "audio/audio_driver.h"
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
#include "gfx/video_shader_parse.h"
#endif
#include "autosave.h"
#include "command.h"
#include "core.h"
#include "core_info.h"
#include "playlist.h"
#include <queues/task_queue.h>
#include <retro_atomic.h>
#include "cheat_manager.h"
#include "content.h"
#include "dynamic.h"
#include "file_path_special.h"
#include "list_special.h"
#include "paths.h"
#include "record/record_driver.h"
#include "retroarch.h"
#include "runloop.h"
#include "verbosity.h"
#include "version.h"
#include "version_git.h"
#include "tasks/task_content.h"
#ifdef HAVE_TRANSLATE
#include "accessibility.h"
#endif
#ifdef HAVE_SCREENSHOTS
#include "tasks/tasks_internal.h"
#endif
#include <compat/strl.h>
#ifdef __MACH__
#include <TargetConditionals.h>
#endif

#define CMD_BUF_SIZE 4096

/* Replies with a failure and why, and marks the reply as one: a line
 * client reads the text, a structured one is told outright. The text
 * opens with @name and ERROR, as a deferred reply's does. */
void command_reply_error(command_t *cmd, const char *name,
      const char *fmt, ...)
{
   char    msg[512];
   int     n;
   size_t  _len;
   va_list ap;

   if (!cmd || !cmd->replier)
      return;

   /* Both of these report the length they wanted rather than the one
    * they wrote, so each is brought back inside the buffer before the
    * next writes past its end. */
   if ((n = snprintf(msg, sizeof(msg), "%s ERROR ", name)) < 0)
      return;
   _len = (size_t)n;
   if (_len >= sizeof(msg))
      _len = sizeof(msg) - 1;

   va_start(ap, fmt);
   n = vsnprintf(msg + _len, sizeof(msg) - _len, fmt, ap);
   va_end(ap);
   if (n > 0)
   {
      _len += (size_t)n;
      if (_len >= sizeof(msg))
         _len = sizeof(msg) - 1;
   }

   cmd->error = true;
   cmd->replier(cmd, msg, _len);
}

#ifdef HAVE_COMMAND
/* a queued STEPS was dropped since the reply now sent began */
static bool command_queue_ended;
#endif

static void command_post_state_loaded(void)
{
#ifdef HAVE_COMMAND
   /* steps queued from the state it left would play on from this one */
   command_run_frames_forget();
#endif
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
   {
      const char *_msg = msg_hash_to_str(MSG_CHEEVOS_HARDCORE_MODE_DISABLED);
      rcheevos_pause_hardcore();
      runloop_msg_queue_push(_msg, strlen(_msg), 0, 180, true, NULL,
            MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
   }
#endif
#ifdef HAVE_NETWORKING
   netplay_driver_ctl(RARCH_NETPLAY_CTL_LOAD_SAVESTATE, NULL);
#endif
   {
     video_driver_state_t *video_st                 =
       video_state_get_ptr();
     bool frame_time_counter_auto_reset             =
       config_get_ptr()->bools.frame_time_counter_auto_reset;
     if (frame_time_counter_auto_reset)
        video_st->frame_time_count = 0;
   }
#if defined(HAVE_GFX_WIDGETS) && defined(HAVE_SCREENSHOTS)
   {
      gfx_widget_state_slot_show(dispwidget_get_ptr(), NULL, NULL);
   }
#endif
}

#if defined(HAVE_COMMAND)

/* Generic command parse utilities */

static bool command_get_arg(const char *tok,
      const char **arg, unsigned *index)
{
   unsigned i;

   for (i = 0; i < ARRAY_SIZE(map); i++)
   {
      if (string_is_equal(tok, map[i].str))
      {
         if (arg)
            *arg = NULL;

         if (index)
            *index = i;

         return true;
      }
   }

   for (i = 0; i < ARRAY_SIZE(action_map); i++)
   {
      const char *str = strstr(tok, action_map[i].str);
      if (str == tok)
      {
         const char *argument = str + strlen(action_map[i].str);
         if (!argument)
            return false;
         if (*argument != ' ' && *argument != '\0')
            return false;

         /* past the separating space; a bare command gets "", not the
          * byte after its terminator */
         if (arg)
            *arg = *argument ? argument + 1 : argument;

         if (index)
            *index = i;

         return true;
      }
   }

   return false;
}

static void command_parse_sub_msg(command_t *handle, const char *tok)
{
   const char *arg = NULL;
   unsigned index  = 0;

   handle->error   = false;

   if (command_get_arg(tok, &arg, &index))
   {
      if (arg)
      {
         if (!action_map[index].action(handle, arg))
            RARCH_ERR("[Command] Command \"%s\" failed.\n", arg);
      }
      else
      {
         /* For MENU_TOGGLE, bypass the press-and-release mechanism
          * by directly invoking the command event.  This avoids
          * timing issues with runahead (single-instance) where the
          * 1-frame pulse from network commands can be lost. */
         if (map[index].id == RARCH_MENU_TOGGLE)
            command_event(CMD_EVENT_MENU_TOGGLE, NULL);
         else
            handle->state[map[index].id] = true;
      }
   }
   else
      RARCH_WARN(msg_hash_to_str(MSG_UNRECOGNIZED_COMMAND), tok);
}

static void command_parse_msg(command_t *handle, char *buf)
{
   char     *save  = NULL;
   char     *tok   = strtok_r(buf, "\n", &save);
   unsigned gen    = input_driver_command_generation();

   while (tok)
   {
      /* a client ending its lines in CRLF leaves no \r on the last word;
       * a \r anywhere else is the command's own */
      size_t len = strlen(tok);
      if (len && tok[len - 1] == '\r')
         tok[len - 1] = '\0';
      command_parse_sub_msg(handle, tok);
      /* The command may have reinitialised the input driver, which
       * owns and has now freed 'handle'. Nothing further may use it. */
      if (input_driver_command_generation() != gen)
         return;
      tok = strtok_r(NULL, "\n", &save);
   }
}

#if defined(HAVE_NETWORK_CMD)
typedef struct
{
   /* Network socket FD */
   int net_fd;
   /* Source address for the command received */
   struct sockaddr_storage cmd_source;
   /* Size of the previous structure in use */
   socklen_t cmd_source_len;
} command_network_t;

static void network_command_reply(command_t *cmd,
   const char *s, size_t len)
{
   command_network_t *netcmd = (command_network_t*)cmd->userptr;
   /* Respond (fire and forget since it's UDP) */
   sendto(netcmd->net_fd, s, len, 0,
      (struct sockaddr*)&netcmd->cmd_source, netcmd->cmd_source_len);
}

typedef struct
{
   struct sockaddr_storage addr;
   socklen_t addr_len;
} command_network_dest_t;

static void *network_command_reply_dest(command_t *cmd)
{
   command_network_t      *netcmd = (command_network_t*)cmd->userptr;
   command_network_dest_t *dest   = (command_network_dest_t*)
      malloc(sizeof(*dest));
   if (dest)
   {
      dest->addr     = netcmd->cmd_source;
      dest->addr_len = netcmd->cmd_source_len;
   }
   return dest;
}

static void network_command_reply_to(command_t *cmd, void *data,
   const char *s, size_t len)
{
   command_network_t      *netcmd = (command_network_t*)cmd->userptr;
   command_network_dest_t *dest   = (command_network_dest_t*)data;
   sendto(netcmd->net_fd, s, len, 0,
      (struct sockaddr*)&dest->addr, dest->addr_len);
}

static void network_command_free(command_t *handle)
{
   command_network_t *netcmd = (command_network_t*)handle->userptr;

   if (netcmd->net_fd >= 0)
      socket_close(netcmd->net_fd);

   free(netcmd);
   free(handle);
}

static void command_network_poll(command_t *handle)
{
   ssize_t ret;
   unsigned gen = input_driver_command_generation();
   char buf[2048];
   command_network_t *netcmd = (command_network_t*)handle->userptr;

   if (netcmd->net_fd < 0)
      return;

   for (;;)
   {
      netcmd->cmd_source_len = sizeof(netcmd->cmd_source);

      if ((ret = recvfrom(netcmd->net_fd, buf, sizeof(buf) - 1, 0,
                  (struct sockaddr*)&netcmd->cmd_source,
                  &netcmd->cmd_source_len)) <= 0)
         return;

      buf[ret] = '\0';

      command_parse_msg(handle, buf);
      /* See command_generation: the command may have freed this
       * object. The remaining datagrams wait for the next poll. */
      if (     input_driver_command_generation() != gen
            || command_interfaces_held())
         return;
   }
}

command_t* command_network_new(uint16_t port, const char *bind_address)
{
   struct addrinfo     *res  = NULL;
   command_t            *cmd = NULL;
   command_network_t *netcmd = NULL;
   int                    fd = -1;

   /* Allocate-then-check in sequence, matching command_uds_new.
    * The previous code allocated cmd + netcmd back-to-back and then
    * assigned netcmd->net_fd / cmd->userptr before NULL-checking
    * either pointer - an OOM on either calloc would NULL-deref on
    * line 252/253.  It also leaked netcmd on the '!cmd' failure
    * path via the 'error' label (which now cleanly frees both
    * because they are initialised to NULL up-front; free(NULL) is
    * a no-op). */
   if (!(cmd = (command_t*)calloc(1, sizeof(*cmd))))
      goto error;

   if (!(netcmd = (command_network_t*)calloc(1, sizeof(command_network_t))))
      goto error;

   /* An empty bind address means every interface (NULL server ->
    * AI_PASSIVE -> 0.0.0.0), which is what this interface has always
    * done. Anyone on that network can then send LOAD_CORE or
    * WRITE_CORE_RAM, so users who only drive RetroArch from the same
    * machine can set network_cmd_bind_address = "127.0.0.1". */
   if (bind_address && !*bind_address)
      bind_address = NULL;

   fd = socket_init((void**)&res, port, bind_address,
         SOCKET_TYPE_DATAGRAM, AF_INET);

   RARCH_LOG("[NetCMD] %s %hu (%s).\n",
         msg_hash_to_str(MSG_BRINGING_UP_COMMAND_INTERFACE_ON_PORT),
         (unsigned short)port,
         bind_address ? bind_address : "all interfaces");

   if (fd < 0)
      goto error;

   netcmd->net_fd = fd;
   cmd->userptr   = netcmd;
   cmd->poll      = command_network_poll;
   cmd->replier    = network_command_reply;
   cmd->reply_dest = network_command_reply_dest;
   cmd->reply_to   = network_command_reply_to;
   cmd->destroy    = network_command_free;

   if (!socket_nonblock(netcmd->net_fd))
      goto error;

   if (!socket_bind(netcmd->net_fd, (void*)res))
   {
      RARCH_ERR("[NetCMD] %s\n",
            msg_hash_to_str(MSG_FAILED_TO_BIND_SOCKET));
      goto error;
   }

   freeaddrinfo_retro(res);
   return cmd;

error:
   if (res)
      freeaddrinfo_retro(res);
   /* The only path that reaches 'error' with fd >= 0 is the
    * socket_nonblock / socket_bind failure after fd was already
    * stored in netcmd->net_fd.  Close it so we don't leak the
    * socket file descriptor along with the allocations. */
   if (fd >= 0)
      socket_close(fd);
   free(netcmd);
   free(cmd);
   return NULL;
}
#endif

#if defined(HAVE_STDIN_CMD)
typedef struct
{
   /* Buffer and pointer for stdin reads */
   size_t stdin_buf_ptr;
   char stdin_buf[CMD_BUF_SIZE];
} command_stdin_t;

static void stdin_command_reply(command_t *cmd,
   const char *s, size_t len)
{
   /* Just write to stdout! */
   fwrite(s, 1, len, stdout);
   fflush(stdout);
}

static void stdin_command_free(command_t *handle)
{
   free(handle->userptr);
   free(handle);
}

static void command_stdin_poll(command_t *handle)
{
   command_stdin_t *stdincmd = (command_stdin_t*)handle->userptr;
   ssize_t               ret = read_stdin(
         stdincmd->stdin_buf + stdincmd->stdin_buf_ptr,
         CMD_BUF_SIZE - stdincmd->stdin_buf_ptr - 1);

   if (ret != 0)
   {
      char *last_newline = NULL;
      stdincmd->stdin_buf_ptr                      += ret;
      
      /* Ensure we don't write past buffer bounds */
      if (stdincmd->stdin_buf_ptr >= CMD_BUF_SIZE)
         stdincmd->stdin_buf_ptr = CMD_BUF_SIZE - 1;
         
      stdincmd->stdin_buf[stdincmd->stdin_buf_ptr]  = '\0';

      last_newline = strrchr(stdincmd->stdin_buf, '\n');

      if (!last_newline)
      {
         /* We're receiving bogus data in pipe
          * (no terminating newline), flush out the buffer. */
         if (stdincmd->stdin_buf_ptr + 1 >= CMD_BUF_SIZE)
         {
            stdincmd->stdin_buf_ptr = 0;
            stdincmd->stdin_buf[0]  = '\0';
         }
      }
      else
      {
         ptrdiff_t msg_len;
         size_t    rest;
         char     *msg;
         *last_newline++ = '\0';
         msg_len         = last_newline - stdincmd->stdin_buf;
         rest            = stdincmd->stdin_buf_ptr - msg_len;

         /* A command can free this object from under us (see
          * command_generation): take the message off the buffer, tidy the
          * buffer, and only then run the message from a private copy,
          * touching nothing of this object afterwards. */
         msg = strdup(stdincmd->stdin_buf);
         memmove(stdincmd->stdin_buf, last_newline, rest);
         stdincmd->stdin_buf_ptr = rest;
         if (msg)
         {
            command_parse_msg(handle, msg);
            free(msg);
         }
         return;
      }
   }
}

command_t* command_stdin_new(void)
{
   command_t *cmd;
   command_stdin_t *stdincmd;

#if !(defined(_WIN32) || defined(__EMSCRIPTEN__))
#ifdef HAVE_NETWORKING
   if (!socket_nonblock(STDIN_FILENO))
      return NULL;
#endif
#endif

   /* Allocate in order with per-step failure handling.  The earlier
    * form allocated both cmd and stdincmd back-to-back then checked
    * them, which leaked stdincmd on the '!cmd' failure path (the
    * '!cmd' return simply dropped the stdincmd pointer).  Also
    * matches the command_uds_new pattern further down. */
   if (!(cmd = (command_t*)calloc(1, sizeof(command_t))))
      return NULL;

   if (!(stdincmd = (command_stdin_t*)calloc(1, sizeof(command_stdin_t))))
   {
      free(cmd);
      return NULL;
   }

   cmd->userptr = stdincmd;
   cmd->poll    = command_stdin_poll;
   cmd->replier = stdin_command_reply;
   cmd->destroy = stdin_command_free;

   return cmd;
}
#endif

#if defined(__EMSCRIPTEN__)
#include "frontend/drivers/platform_emscripten.h"
typedef struct
{
   char command_buf[CMD_BUF_SIZE];
} command_emscripten_t;

static void emscripten_command_reply(command_t *_cmd,
   const char *s, size_t len)
{
   platform_emscripten_command_reply(s, len);
}

static void emscripten_command_free(command_t *handle)
{
   free(handle->userptr);
   free(handle);
}

static void command_emscripten_poll(command_t *handle)
{
   command_emscripten_t *emscriptencmd = (command_emscripten_t*)handle->userptr;
   ptrdiff_t msg_len = platform_emscripten_command_read((char **)(&emscriptencmd->command_buf), CMD_BUF_SIZE);
   if (msg_len != 0)
      command_parse_msg(handle, emscriptencmd->command_buf);
}

command_t* command_emscripten_new(void)
{
   command_t *cmd;
   command_emscripten_t *emscriptencmd;

   /* Same sequential-allocation-with-per-step-cleanup pattern as
    * command_stdin_new / command_uds_new.  Previously allocated both
    * structs before any NULL check, leaking emscriptencmd on the
    * '!cmd' failure path. */
   if (!(cmd = (command_t*)calloc(1, sizeof(command_t))))
      return NULL;

   if (!(emscriptencmd = (command_emscripten_t*)calloc(1, sizeof(command_emscripten_t))))
   {
      free(cmd);
      return NULL;
   }

   cmd->userptr = emscriptencmd;
   cmd->poll    = command_emscripten_poll;
   cmd->replier = emscripten_command_reply;
   cmd->destroy = emscripten_command_free;

   return cmd;
}
#endif

#if defined(HAVE_LAKKA)
#include <sys/un.h>
#define MAX_USER_CONNECTIONS  4
typedef struct
{
   /* File descriptor for the domain socket */
   int sfd;
   /* Client sockets */
   int userfd[MAX_USER_CONNECTIONS];
   /* Which connection holds each slot: a closed descriptor's number
    * is handed out again, so the number alone does not say. */
   unsigned serial[MAX_USER_CONNECTIONS];
   unsigned next_serial;
   /* Last received user socket */
   int last_fd;
   unsigned last_serial;
} command_uds_t;

typedef struct
{
   int fd;
   unsigned serial;
} command_uds_dest_t;

static void uds_command_reply(command_t *cmd,
      const char *s, size_t len)
{
   command_uds_t *subcmd = (command_uds_t*)cmd->userptr;
   write(subcmd->last_fd, s, len);
}

static void *uds_command_reply_dest(command_t *cmd)
{
   command_uds_t      *subcmd = (command_uds_t*)cmd->userptr;
   command_uds_dest_t *dest   = (command_uds_dest_t*)malloc(sizeof(*dest));
   if (dest)
   {
      dest->fd     = subcmd->last_fd;
      dest->serial = subcmd->last_serial;
   }
   return dest;
}

/* Only to the connection that asked: gone, the reply is dropped. */
static void uds_command_reply_to(command_t *cmd, void *data,
      const char *s, size_t len)
{
   int i;
   command_uds_t      *subcmd = (command_uds_t*)cmd->userptr;
   command_uds_dest_t *dest   = (command_uds_dest_t*)data;
   for (i = 0; i < MAX_USER_CONNECTIONS; i++)
      if (   subcmd->userfd[i] == dest->fd
          && subcmd->serial[i] == dest->serial)
      {
         write(dest->fd, s, len);
         return;
      }
}

static void uds_command_free(command_t *handle)
{
   int i;
   command_uds_t *udscmd = (command_uds_t*)handle->userptr;

   for (i = 0; i < MAX_USER_CONNECTIONS; i++)
      if (udscmd->userfd[i] >= 0)
         socket_close(udscmd->userfd[i]);
   socket_close(udscmd->sfd);

   free(handle->userptr);
   free(handle);
}

static void command_uds_poll(command_t *handle)
{
   unsigned gen = input_driver_command_generation();
   int i;
   int fd;
   ssize_t ret;
   char buf[2048];
   command_uds_t *udscmd = (command_uds_t*)handle->userptr;

   if (udscmd->sfd < 0)
      return;

   /* Read data from clients and process commands */
   for (i = 0; i < MAX_USER_CONNECTIONS; i++)
   {
      bool err = false;

      fd = udscmd->userfd[i];
      if (fd < 0)
         continue;

      ret = socket_receive_all_nonblocking(fd, &err, buf, sizeof(buf) - 1);
      if (!ret)
         continue;

      if (!err)
      {
         buf[ret]            = '\0';
         udscmd->last_fd     = fd;
         udscmd->last_serial = udscmd->serial[i];

         command_parse_msg(handle, buf);
         /* See command_generation: this object may be gone now. */
         if (     input_driver_command_generation() != gen
               || command_interfaces_held())
            return;
      }
      else
      {
         socket_close(fd);
         udscmd->userfd[i] = -1;
      }
   }

   /* Accepts new connections from clients */
   fd = accept(udscmd->sfd, NULL, NULL);
   if (fd >= 0)
   {
      if (socket_nonblock(fd))
      {
         for (i = 0; i < MAX_USER_CONNECTIONS; i++)
         {
            if (udscmd->userfd[i] < 0)
            {
               udscmd->userfd[i] = fd;
               udscmd->serial[i] = ++udscmd->next_serial;
               return;
            }
         }
      }

      socket_close(fd);
   }
}

command_t* command_uds_new(void)
{
   int i;
   command_t *cmd;
   command_uds_t *subcmd;
   struct sockaddr_un addr;
   socklen_t addrsz = offsetof(struct sockaddr_un, sun_path) + STRLEN_CONST("retroarch/cmd") + 1;
   int           fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd < 0)
      return NULL;
   /* use an abstract socket for simplicity */
   memset(&addr, 0, sizeof(addr));
   addr.sun_family = AF_UNIX;
   strlcpy_lit(&addr.sun_path[1], "retroarch/cmd", sizeof(addr.sun_path) - 1);
   if (   bind(fd, (struct sockaddr*)&addr, addrsz) < 0
       || listen(fd, MAX_USER_CONNECTIONS) < 0
       || !socket_nonblock(fd))
   {
      socket_close(fd);
      return NULL;
   }
   cmd = (command_t*)calloc(1, sizeof(command_t));
   if (!cmd)
   {
      socket_close(fd);
      return NULL;
   }
   subcmd = (command_uds_t*)calloc(1, sizeof(command_uds_t));
   if (!subcmd)
   {
      free(cmd);
      socket_close(fd);
      return NULL;
   }
   subcmd->sfd          = fd;
   subcmd->last_fd      = -1;
   for (i = 0; i < MAX_USER_CONNECTIONS; i++)
      subcmd->userfd[i] = -1;
   cmd->userptr         = subcmd;
   cmd->poll            = command_uds_poll;
   cmd->replier         = uds_command_reply;
   cmd->reply_dest      = uds_command_reply_dest;
   cmd->reply_to        = uds_command_reply_to;
   cmd->destroy         = uds_command_free;
   return cmd;
}
#endif


/* Routines used to invoke retroarch command ... */

/* The family tool a command runs for, so its answers carry the tool's
 * name: STATE save 1 rather than SAVE_STATE_SLOT 1. */
struct command_family
{
   const char        *family;
   const char        *word;
   const char        *name;
   command_replier_t  replier;
   /* the command answered, or will */
   bool               answered;
};
static struct command_family command_family_now;

/* @msg under @f's name, allocated, its length in @out_len; NULL where
 * it could not be, or where it is to go as it is. */
static char *command_family_rename(const struct command_family *f,
      const char *msg, size_t len, size_t *out_len)
{
   size_t n    = strlen(f->name);
   size_t size = len + strlen(f->family) + strlen(f->word) + 3;
   char  *s    = (char*)malloc(size);
   int    _len;
   if (!s)
      return NULL;
   if (     len > n && !strncmp(msg, f->name, n)
         && (msg[n] == ' ' || msg[n] == '\n' || msg[n] == ','))
   {
      msg += n;
      len -= n;
      if (!strncmp(msg, " ERROR", 6))
         _len = snprintf(s, size, "%s%.*s", f->family, (int)len, msg);
      else
         _len = snprintf(s, size, "%s %s%.*s", f->family, f->word,
               (int)len, msg);
   }
   else if (len == n && !strncmp(msg, f->name, n))
      _len = snprintf(s, size, "%s %s", f->family, f->word);
   /* rows, which name nothing, are the tool's answer as they are */
   else
   {
      free(s);
      return NULL;
   }
   if (_len <= 0 || (size_t)_len >= size)
   {
      free(s);
      return NULL;
   }
   *out_len = (size_t)_len;
   return s;
}

static void command_family_replier(command_t *cmd, const char *data,
      size_t len)
{
   size_t _len = 0;
   char  *msg  = command_family_rename(&command_family_now, data, len,
         &_len);
   command_family_now.answered = true;
   if (msg)
      command_family_now.replier(cmd, msg, _len);
   else
      command_family_now.replier(cmd, data, len);
   free(msg);
}

/* A reply sent after its command has returned: where it goes is taken
 * while the command runs, as afterwards the interface may be answering
 * someone else. */
typedef struct
{
   command_t            *cmd;
   void                 *dest;
   struct command_family family;
   unsigned              gen;
} command_deferred_t;

static void command_deferred_take(command_deferred_t *d, command_t *cmd)
{
   d->cmd  = cmd;
   d->dest = cmd->reply_dest ? cmd->reply_dest(cmd) : NULL;
   d->gen    = input_driver_command_generation();
   d->family = command_family_now;
   if (command_family_now.family)
      command_family_now.answered = true;
}

/* Sends @msg (none when NULL) and releases @d.  Dropped, unsent, if the
 * interface was torn down meanwhile (the command generation moved).
 * @is_error says the reply reports a failure, so the interface sending
 * it is told rather than left to read the text. */
static void command_deferred_send(command_deferred_t *d,
      const char *msg, size_t len, bool is_error)
{
   char *renamed = NULL;
   if (msg && input_driver_command_generation() == d->gen)
   {
      size_t _len = 0;
      if (d->family.family && (renamed = command_family_rename(&d->family,
               msg, len, &_len)))
      {
         msg = renamed;
         len = _len;
      }
      d->cmd->error = is_error;
      if (d->cmd->reply_to && d->dest)
         d->cmd->reply_to(d->cmd, d->dest, msg, len);
      else if (!d->cmd->reply_dest)
         d->cmd->replier(d->cmd, msg, len);
   }
   free(renamed);
   free(d->dest);
   d->dest = NULL;
}

#ifdef HAVE_SCREENSHOTS
/* SCREENSHOT's answer, and GET_FRAME's - the frame written nowhere, so
 * with no path: the picture where the interface takes one, with the
 * file's path or the frame's size as its text. */
static void command_screenshot_done(retro_task_t *task, void *task_data,
      void *user_data, const char *error)
{
   command_deferred_t             *d = (command_deferred_t*)user_data;
   const struct screenshot_result *r = (const struct screenshot_result*)task_data;
   bool                        frame = r && !*r->path;
   char msg[PATH_MAX_LENGTH];
   if (error || !r || (frame && !r->png_base64))
   {
      snprintf(msg, sizeof(msg), "%s ERROR %s",
            frame ? "GET_FRAME" : "SCREENSHOT",
            error ? error : "no result");
      command_deferred_send(d, msg, strlen(msg), true);
   }
   else
   {
      if (frame)
         snprintf(msg, sizeof(msg), "GET_FRAME %ux%u", r->width, r->height);
      else
         strlcpy(msg, r->path, sizeof(msg));
      if (     r->png_base64 && d->cmd->reply_image_to && d->dest
            && input_driver_command_generation() == d->gen)
      {
         d->cmd->reply_image_to(d->cmd, d->dest, msg, strlen(msg),
               "image/png", r->png_base64, r->png_base64_len);
         command_deferred_send(d, NULL, 0, false);
      }
      else
         command_deferred_send(d, msg, strlen(msg), false);
   }
   free(d);
}

/* SCREENSHOT run by command_run(): answered with the file's path once
 * the screenshot task has written it. */
static bool command_screenshot(command_t *cmd)
{
   settings_t      *settings   = config_get_ptr();
   runloop_state_t *runloop_st = runloop_state_get_ptr();
   command_deferred_t *d       = (command_deferred_t*)calloc(1, sizeof(*d));
   if (!d)
      return false;
   /* Threaded (use_thread true), so the callback, which reads @d, runs
    * from the task queue on a later frame, after it is taken below.
    * Unthreaded, the callback would run inside this call and free @d
    * before it was taken. It is taken only once the screenshot is
    * queued, as taking it marks the asking MCP request as waiting. */
   if (!take_screenshot_notify(settings->paths.directory_screenshot,
            runloop_st->runtime_content_path_basename, false,
            video_driver_cached_frame_is_hw_render(), false, true,
            command_screenshot_done, d))
   {
      free(d);
      return false;
   }
   /* the task's callback, which uses this, runs on a later frame */
   command_deferred_take(d, cmd);
   return true;
}

#ifdef HAVE_RPNG
/* GET_FRAME [size]: the frame on screen as image content, scaled to fit
 * a square of @size and never up. Nothing is written: a software core's
 * frame is copied, a hardware core's read back from the GPU. */
bool command_get_frame(command_t *cmd, const char *arg)
{
   command_deferred_t *d;
   unsigned long       size = COMMAND_FRAME_SIZE;
   char               *end  = NULL;
   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg)
   {
      size = strtoul(arg, &end, 10);
      if (     *arg < '0' || *arg > '9' || *end
            || size < COMMAND_FRAME_SIZE_MIN || size > COMMAND_FRAME_SIZE_MAX)
      {
         command_reply_error(cmd, "GET_FRAME", "a size from %u to %u",
               COMMAND_FRAME_SIZE_MIN, COMMAND_FRAME_SIZE_MAX);
         return false;
      }
   }
   /* the line interfaces carry text alone */
   if (!cmd->reply_image_to)
   {
      command_reply_error(cmd, "GET_FRAME", "this interface carries no "
            "image; SCREENSHOT writes one to a file");
      return false;
   }
   if (!(runloop_get_flags() & RUNLOOP_FLAG_CORE_RUNNING))
   {
      command_reply_error(cmd, "GET_FRAME", "no content is running");
      return false;
   }
   if (!(d = (command_deferred_t*)calloc(1, sizeof(*d))))
      return false;
   if (!take_frame_notify((unsigned)size, (unsigned)size,
            command_screenshot_done, d))
   {
      free(d);
      command_reply_error(cmd, "GET_FRAME", "the frame could not be "
            "taken: none has been drawn, or a screenshot is being taken");
      return false;
   }
   command_deferred_take(d, cmd);
   return true;
}
#endif
#endif

/* A command answered once the work it starts is through: by @ok, else
 * by @name and the task's result, or by @name, ERROR and the reason. */
struct command_reply
{
   command_deferred_t   deferred;
   enum event_command   event;
   /* Run instead of the event, when set; false has the failure
    * reported for it. */
   bool               (*start)(struct command_reply *r);
   const char          *name;
   char                 ok[64];
   char                 path[PATH_MAX_LENGTH];
   /* a load that ends on the dummy core failed */
   bool                 want_core;
   /* LOAD_CONTENT ... paused: pause once it has loaded */
   bool                 pause;
   /* what succeeded loaded a state */
   bool                 state_loaded;
   bool                 reset;
};

static struct command_reply *command_reply_new(const char *name)
{
   struct command_reply *r = (struct command_reply*)calloc(1, sizeof(*r));
   if (r)
      r->name = name;
   return r;
}

static void command_reply_done(retro_task_t *task, void *task_data,
      void *user_data, const char *error)
{
   struct command_reply *r = (struct command_reply*)user_data;
   char msg[PATH_MAX_LENGTH + 128];
   /* a core that fails to start is replaced by the dummy core, and the
    * load goes on to succeed */
   if (     !error && r->want_core
         && runloop_state_get_ptr()->current_core_type == CORE_TYPE_DUMMY)
      error = msg_hash_to_str(MSG_FAILED_TO_LOAD_CONTENT);
   if (error)
      snprintf(msg, sizeof(msg), "%s ERROR %s", r->name, error);
   else
   {
      if (*r->ok)
         strlcpy(msg, r->ok, sizeof(msg));
      else if (task_data)
         snprintf(msg, sizeof(msg), "%s %s", r->name, (const char*)task_data);
      else
         strlcpy(msg, r->name, sizeof(msg));
      if (r->state_loaded)
         command_post_state_loaded();
#ifdef HAVE_COMMAND
      if (     command_queue_ended
            && (r->state_loaded || r->reset))
         strlcat(msg, ", queue ended", sizeof(msg));
#endif
      /* a pause is dropped with no core running yet, as after a cold
       * start: then it is the first frame's to do */
      if (r->pause)
      {
         if (runloop_get_flags() & RUNLOOP_FLAG_CORE_RUNNING)
            command_event(CMD_EVENT_PAUSE, NULL);
         else
            runloop_frame_work_set(RUNLOOP_WORK_PAUSE_LOADED, true);
      }
   }
   command_deferred_send(&r->deferred, msg, strlen(msg), error != NULL);
   free(r);
}

/* Runs the work from a main-thread task, outside the core's run: a
 * command can arrive from the core's own input poll. */
static void command_reply_handler(retro_task_t *task)
{
   struct command_reply *r = (struct command_reply*)task->state;
   task_notify_t notify;
   task->state      = NULL;
   task_set_flags(task, RETRO_TASK_FLG_FINISHED, true);
   notify.cb        = command_reply_done;
   notify.user_data = r;
#ifdef HAVE_COMMAND
   command_queue_ended = false;
#endif
   if (!(r->start ? r->start(r) : command_event(r->event, &notify)))
      command_reply_done(NULL, NULL, r, "The command failed.");
}

/* Takes @r, NULL included. */
static bool command_reply_push(command_t *cmd, struct command_reply *r)
{
   retro_task_t *task;
   if (!r)
      return false;
   if (!(task = task_init()))
   {
      free(r);
      return false;
   }
   task->handler = command_reply_handler;
   task->state   = r;
   task->flags  |= RETRO_TASK_FLG_MAIN_THREAD | RETRO_TASK_FLG_MUTE;
   if (!task_queue_push(task))
   {
      free(task);
      free(r);
      return false;
   }
   command_deferred_take(&r->deferred, cmd);
   return true;
}

#ifdef HAVE_BSV_MOVIE
/* Pushes @event as the work of command @name. */
static bool command_reply_event(command_t *cmd, enum event_command event,
      const char *name)
{
   struct command_reply *r = command_reply_new(name);
   if (r)
      r->event = event;
   return command_reply_push(cmd, r);
}
#endif

#ifdef HAVE_TRANSLATE
/* AI_SERVICE run by command_run(): one translation of the screen,
 * answered with the service's text. */
static bool command_ai_service_start(struct command_reply *r)
{
   settings_t *settings = config_get_ptr();
   if (!settings->bools.ai_service_enable)
      return false;
   return run_translation_service_notify(settings,
         (runloop_get_flags() & RUNLOOP_FLAG_PAUSED) != 0,
         command_reply_done, r);
}
#endif

/* Answers @cmd once the content load in progress, or with @next the
 * one the command leads to, is through. */
static bool command_content_reply(command_t *cmd, const char *name,
      bool next, bool want_core, bool pause)
{
   struct command_reply *r;
   /* a line client is answered too where it asked for a pause, which
    * happens here */
   if (     (!cmd->structured && !pause)
         || (!next && !task_content_load_pending())
         || !(r = command_reply_new(name)))
      return true;
   r->want_core = want_core;
   r->pause     = pause;
   task_notify_set(&content_state_get_ptr()->load_notify,
         command_reply_done, r);
   command_deferred_take(&r->deferred, cmd);
   return true;
}

/* Runs @name with @arg (NULL or "" for none) as if it had arrived as a
 * command line on @handle: replies go to @handle's replier, a hotkey
 * presses on @handle for one frame. For interfaces that receive
 * commands as structured requests rather than lines.
 *
 * Returns: false for an unknown command or one whose handler failed. */
bool command_run(command_t *handle, const char *name, const char *arg)
{
   unsigned i;
   handle->error = false;
   for (i = 0; i < ARRAY_SIZE(action_map); i++)
      if (string_is_equal(name, action_map[i].str))
         return action_map[i].action(handle, arg ? arg : "");
   for (i = 0; i < ARRAY_SIZE(map); i++)
      if (string_is_equal(name, map[i].str))
      {
         if (map[i].id == RARCH_MENU_TOGGLE)
            command_event(CMD_EVENT_MENU_TOGGLE, NULL);
#ifdef HAVE_SCREENSHOTS
         else if (map[i].id == RARCH_SCREENSHOT)
            return command_screenshot(handle);
#endif
#ifdef HAVE_BSV_MOVIE
         else if (map[i].id == RARCH_RECORD_REPLAY_KEY)
            return command_reply_event(handle,
                  CMD_EVENT_RECORD_REPLAY, map[i].str);
         else if (map[i].id == RARCH_SAVE_REPLAY_CHECKPOINT_KEY)
            return command_reply_event(handle,
                  CMD_EVENT_SAVE_REPLAY_CHECKPOINT, map[i].str);
         else if (map[i].id == RARCH_PREV_REPLAY_CHECKPOINT_KEY)
            return command_reply_event(handle,
                  CMD_EVENT_PREV_REPLAY_CHECKPOINT, map[i].str);
         else if (map[i].id == RARCH_NEXT_REPLAY_CHECKPOINT_KEY)
            return command_reply_event(handle,
                  CMD_EVENT_NEXT_REPLAY_CHECKPOINT, map[i].str);
#endif
#ifdef HAVE_TRANSLATE
         else if (map[i].id == RARCH_AI_SERVICE)
         {
            struct command_reply *r = command_reply_new(map[i].str);
            if (r)
               r->start = command_ai_service_start;
            return command_reply_push(handle, r);
         }
#endif
         else
            handle->state[map[i].id] = true;
         /* The press goes out on the next poll and the hotkey acts a
          * frame later, so there is nothing yet to report but that it
          * was sent. A structured client is told that much rather than
          * a bare "done": what the hotkey changed is read back with
          * GET_OPTION. MENU_TOGGLE is the one that has already acted,
          * above, and reports the menu instead. */
         if (handle->structured)
         {
            char   reply[NAME_MAX_LENGTH + 16];
            size_t _len;
#ifdef HAVE_MENU
            if (map[i].id == RARCH_MENU_TOGGLE)
            {
               struct menu_state *menu_st = menu_state_get_ptr();
               _len = (size_t)snprintf(reply, sizeof(reply), "%s %s\n",
                     map[i].str,
                     (menu_st && (menu_st->flags & MENU_ST_FLAG_ALIVE))
                        ? "open" : "closed");
            }
            else
#endif
               _len = (size_t)snprintf(reply, sizeof(reply), "%s pressed\n",
                     map[i].str);
            handle->replier(handle, reply, _len);
         }
         return true;
      }
   return false;
}

/* MENU, DISK, REINIT, STATE, REPLAY and CORE: a family of commands as one,
 * so a structured client is offered one tool with a choice rather than
 * a tool apiece. Each word runs as the command it stands for, which
 * line clients can still send by name; @rest says it takes what
 * follows the word, a slot or a frame. */
struct cmd_choice
{
   const char *word;
   const char *name;
   bool        rest;
};

static bool command_run_choice(command_t *cmd, const char *family,
      const struct cmd_choice *choices, size_t count, const char *values,
      const char *arg)
{
   size_t      i;
   size_t      n;
   const char *rest;
   while (arg && *arg == ' ')
      arg++;
   if (!arg)
      arg = "";
   for (rest = arg; *rest && *rest != ' '; rest++)
      ;
   n = (size_t)(rest - arg);
   while (*rest == ' ')
      rest++;
   for (i = 0; i < count; i++)
   {
      if (strncmp(arg, choices[i].word, n) || choices[i].word[n])
         continue;
      if (!choices[i].rest && *rest)
      {
         command_reply_error(cmd, family, "nothing after %s",
               choices[i].word);
         return false;
      }
      {
         bool ret;
         command_family_now.family  = family;
         command_family_now.word    = choices[i].word;
         command_family_now.name    = choices[i].name;
         command_family_now.replier = cmd->replier;
         cmd->replier               = command_family_replier;
         ret                        = command_run(cmd, choices[i].name, rest);
         cmd->replier               = command_family_now.replier;
         /* what answers nothing of its own still answers as the tool */
         if (ret && !command_family_now.answered && cmd->structured)
         {
            char   msg[64];
            int    _len = snprintf(msg, sizeof(msg), "%s %s\n", family,
                  choices[i].word);
            if (_len > 0 && (size_t)_len < sizeof(msg))
               cmd->replier(cmd, msg, (size_t)_len);
         }
         memset(&command_family_now, 0, sizeof(command_family_now));
         return ret;
      }
   }
   command_reply_error(cmd, family, "one of %s", values);
   return false;
}

#ifdef HAVE_MENU
/* MENU: the request whose action the next menu frame runs, as the
 * menu's own input would, answered a frame after that with what the
 * menu shows then: a list or a message an action opens is filled in by
 * the frame that follows it. */
static struct
{
   command_deferred_t deferred;
   size_t             index;
   unsigned           from;
   unsigned           action;
   /* menu frames still to run before the answer: the action's, then one */
   unsigned           frames;
   bool               pending;
   bool               has_index;
   bool               has_from;
   bool               lost;
   /* the list the index was given in: how deep, and its label */
   size_t             depth;
   char               list[64];
} command_menu_st;

/* How deep the list shown is, and its label in @s. */
static size_t command_menu_where(char *s, size_t len)
{
   menu_list_t *list  = menu_state_get_ptr()->entries.list;
   file_list_t *stack = list ? MENU_LIST_GET(list, 0) : NULL;
   s[0] = '\0';
   if (!stack || !stack->size)
      return 0;
   if (stack->list[stack->size - 1].label)
      strlcpy(s, stack->list[stack->size - 1].label, len);
   return stack->size;
}

static void command_menu_clean(char *s)
{
   for (; *s; s++)
      if (*s == '\t' || *s == '\n' || *s == '\r')
         *s = ' ';
}

/* The title of the list @i deep in @stack. A playlist's tab is titled
 * "Horizontal Menu" there; its playlist's name says which it is. */
static void command_menu_level_title(const file_list_t *stack, size_t i,
      char *s, size_t len)
{
   struct menu_state       *menu_st = menu_state_get_ptr();
   const menu_ctx_driver_t *drv     = menu_st->driver_ctx;
   menu_file_list_cbs_t    *cbs     =
      (menu_file_list_cbs_t*)stack->list[i].actiondata;
   s[0] = '\0';
   if (     stack->list[i].type == MENU_SETTING_HORIZONTAL_MENU
         && drv && drv->list_get_entry && drv->list_get_selection
         && drv->list_get_size)
   {
      size_t sel  = drv->list_get_selection(menu_st->userdata);
      size_t tabs = drv->list_get_size(menu_st->userdata, MENU_LIST_TABS);
      struct item_file *item = sel > tabs
         ? (struct item_file*)drv->list_get_entry(menu_st->userdata,
               MENU_LIST_HORIZONTAL, (unsigned)(sel - (tabs + 1)))
         : NULL;
      if (item && item->path && *item->path)
      {
         strlcpy(s, path_basename(item->path), len);
         path_remove_extension(s);
         return;
      }
   }
   if (i + 1 == stack->size)
      menu_entries_get_title(s, len);
   else if (cbs && cbs->action_get_title)
      cbs->action_get_title(stack->list[i].path, stack->list[i].label,
            stack->list[i].type, s, len);
}

/* What the menu shows: its title, a page of entries - number, label
 * and value - holding the selection, or from @from, and which entry is
 * selected of how many. NULL where out of memory; the length in
 * @out_len. */
static char *command_menu_answer(bool has_from, unsigned from,
      size_t *out_len)
{
   struct menu_state *menu_st = menu_state_get_ptr();
   menu_list_t       *list    = menu_st->entries.list;
   file_list_t       *buf     = list
      ? MENU_LIST_GET_SELECTION(list, (unsigned)0) : NULL;
   size_t             count   = buf ? buf->size : 0;
   size_t             sel     = menu_st->selection_ptr;
   size_t             size    = 8192 + COMMAND_MENU_PAGE * 560;
   size_t             _len;
   size_t             i;
   size_t             first;
   char              *out;
   menu_entry_t      *entry;

   if (!(out = (char*)malloc(size)))
      return NULL;
   if (!(menu_st->flags & MENU_ST_FLAG_ALIVE) || !buf)
   {
      *out_len = strlcpy(out, "CLOSED\n", size);
      return out;
   }
   if (!(entry = (menu_entry_t*)malloc(sizeof(*entry))))
   {
      free(out);
      return NULL;
   }
   {
      file_list_t *stack = MENU_LIST_GET(list, 0);
      char         title[256];
      title[0] = '\0';
      if (stack && stack->size)
         command_menu_level_title(stack, stack->size - 1, title,
               sizeof(title));
      command_menu_clean(title);
      _len = (size_t)snprintf(out, size, "MENU %s\n", title);
      /* how it got there: the open menu remembers where it was left */
      if (stack && stack->size > 1)
      {
         size_t d;
         _len += strlcpy(out + _len, "PATH ", size - _len);
         for (d = 0; d < stack->size && d < 16; d++)
         {
            command_menu_level_title(stack, d, title, sizeof(title));
            command_menu_clean(title);
            _len += (size_t)snprintf(out + _len, size - _len, "%s%s",
                  d ? " > " : "", title);
         }
         _len += strlcpy(out + _len, "\n", size - _len);
      }
   }
   /* what waits on the user over the list: typing, or a message that a
    * second a confirms - "Press again to quit" */
   if (menu_input_dialog_get_display_kb())
   {
      char label[sizeof(menu_st->input_dialog_kb_label)];
      strlcpy(label, menu_st->input_dialog_kb_label, sizeof(label));
      command_menu_clean(label);
      _len += (size_t)snprintf(out + _len, size - _len, "KEYBOARD %s\n",
            label);
   }
   else if (menu_st->driver_data && *menu_st->driver_data->menu_state_msg)
   {
      char msg[sizeof(menu_st->driver_data->menu_state_msg)];
      strlcpy(msg, menu_st->driver_data->menu_state_msg, sizeof(msg));
      command_menu_clean(msg);
      _len += (size_t)snprintf(out + _len, size - _len, "MESSAGE %s\n",
            msg);
   }
   first = has_from ? from : sel - sel % COMMAND_MENU_PAGE;
   for (i = first; i < count && i < first + COMMAND_MENU_PAGE; i++)
   {
      char       *label;
      char       *value;
      const char *shown;
      MENU_ENTRY_INITIALIZE((*entry));
      entry->flags |= MENU_ENTRY_FLAG_PATH_ENABLED
                    | MENU_ENTRY_FLAG_RICH_LABEL_ENABLED
                    | MENU_ENTRY_FLAG_VALUE_ENABLED;
      menu_entry_get(entry, 0, i, NULL, true);
      label = *entry->rich_label ? entry->rich_label : entry->path;
      value = entry->enum_idx == MENU_ENUM_LABEL_CHEEVOS_PASSWORD
         ? entry->password_value : entry->value;
      command_menu_clean(label);
      command_menu_clean(value);
      /* a choice in a list of them has no value, only whether it is the
       * one chosen */
      shown = !*value && (entry->flags & MENU_ENTRY_FLAG_CHECKED)
         ? "checked" : value;
      _len += (size_t)snprintf(out + _len, size - _len, "%u\t%.255s\t%.255s\n",
            (unsigned)i, label, shown);
   }
   _len += (size_t)snprintf(out + _len, size - _len, "SELECTED %u\nCOUNT %u\n",
         (unsigned)sel, (unsigned)count);
   if (i < count)
      _len += (size_t)snprintf(out + _len, size - _len, "MORE %u\n",
            (unsigned)i);
   free(entry);
   *out_len = _len;
   return out;
}

/* The menu's own action for this frame, or the one a MENU request
 * asks for in its place: on the entry it names, where it names one. */
unsigned command_menu_action(unsigned action)
{
   struct menu_state *menu_st = menu_state_get_ptr();
   char               where[sizeof(command_menu_st.list)];
   if (!command_menu_st.pending || command_menu_st.frames < 2)
      return action;
   /* a request is input, as a press is: no screensaver comes over it,
    * and one up takes the press that ends it */
   menu_st->input_last_time_us = menu_st->current_time_us;
   if (menu_st->flags & MENU_ST_FLAG_SCREENSAVER_ACTIVE)
   {
      menu_st->flags &= ~MENU_ST_FLAG_SCREENSAVER_ACTIVE;
      if (menu_st->driver_ctx && menu_st->driver_ctx->environ_cb)
         menu_st->driver_ctx->environ_cb(MENU_ENVIRON_DISABLE_SCREENSAVER,
               NULL, menu_st->userdata);
   }
   if (command_menu_st.has_index)
   {
      command_menu_st.has_index = false;
      /* the list may have changed since the request checked it - another
       * list, or this one shorter: then nothing is done to whichever
       * entry took that place */
      if (     !menu_st->entries.list
            || command_menu_where(where, sizeof(where))
               != command_menu_st.depth
            || !string_is_equal(where, command_menu_st.list)
            || command_menu_st.index
               >= MENU_LIST_GET_SELECTION(menu_st->entries.list, 0)->size)
      {
         command_menu_st.lost   = true;
         command_menu_st.action = MENU_ACTION_NOOP;
         return action;
      }
      menu_st->selection_ptr = command_menu_st.index;
      if (menu_st->driver_ctx && menu_st->driver_ctx->navigation_set)
         menu_st->driver_ctx->navigation_set(menu_st->userdata, true);
   }
   return command_menu_st.action;
}

/* Before commands are read: a MENU request whose menu closed before
 * running it - a hotkey, another client - is answered that it is
 * closed, as no menu frame will answer it. */
void command_menu_closed(void)
{
   if (     command_menu_st.pending
         && !(menu_state_get_ptr()->flags & MENU_ST_FLAG_ALIVE))
      command_menu_iterated();
}

/* After a menu frame: answers the MENU request it ran. */
void command_menu_iterated(void)
{
   char  *out;
   size_t _len = 0;
   if (!command_menu_st.pending)
      return;
   if (     --command_menu_st.frames
         && (menu_state_get_ptr()->flags & MENU_ST_FLAG_ALIVE))
      return;
   command_menu_st.pending = false;
   if (command_menu_st.lost)
   {
      command_menu_st.lost = false;
      command_deferred_send(&command_menu_st.deferred,
            "MENU ERROR the list changed before the entry could be "
            "reached\n", STRLEN_CONST("MENU ERROR the list changed before "
               "the entry could be reached\n"), true);
      return;
   }
   if ((out = command_menu_answer(command_menu_st.has_from,
               command_menu_st.from, &_len)))
      command_deferred_send(&command_menu_st.deferred, out, _len, false);
   else
      command_deferred_send(&command_menu_st.deferred,
            "MENU ERROR out of memory\n",
            STRLEN_CONST("MENU ERROR out of memory\n"), true);
   free(out);
}
#endif

/* MENU <action> [index] [from <entry>] */
bool command_menu(command_t *cmd, const char *arg)
{
#ifdef HAVE_MENU
   static const struct
   {
      const char *word;
      unsigned    action;
      bool        index;
   } actions[] = {
      { "show",   MENU_ACTION_NOOP,   false },
      { "open",   MENU_ACTION_NOOP,   false },
      { "close",  MENU_ACTION_NOOP,   false },
      { "select", MENU_ACTION_NOOP,   true  },
      { "up",     MENU_ACTION_UP,     false },
      { "down",   MENU_ACTION_DOWN,   false },
      { "left",   MENU_ACTION_LEFT,   true  },
      { "right",  MENU_ACTION_RIGHT,  true  },
      { "a",      MENU_ACTION_OK,     true  },
      { "b",      MENU_ACTION_CANCEL, false },
      { "type",   MENU_ACTION_NOOP,   false }
   };
   struct menu_state *menu_st = menu_state_get_ptr();
   menu_list_t       *list    = menu_st->entries.list;
   file_list_t       *buf     = list
      ? MENU_LIST_GET_SELECTION(list, (unsigned)0) : NULL;
   bool               alive   = (menu_st->flags & MENU_ST_FLAG_ALIVE) && buf;
   const char        *p       = arg ? arg : "";
   char              *end;
   unsigned long      index   = 0;
   unsigned long      from    = 0;
   bool               has_index = false;
   bool               has_from  = false;
   size_t             n;
   size_t             i;

   while (*p == ' ')
      p++;
   for (n = 0; p[n] && p[n] != ' '; n++)
      ;
   for (i = 0; i < ARRAY_SIZE(actions); i++)
      if (!strncmp(p, actions[i].word, n) && !actions[i].word[n])
         break;
   if (!n || i == ARRAY_SIZE(actions))
   {
      command_reply_error(cmd, "MENU", "one of %s", COMMAND_MENU_ACTIONS);
      return false;
   }
   for (p += n; *p == ' '; p++)
      ;
   /* the rest of the line is the text, spaces and all */
   if (string_is_equal(actions[i].word, "type"))
   {
      if (!alive || !menu_input_dialog_get_display_kb())
      {
         command_reply_error(cmd, "MENU", "no keyboard is open: a on an "
               "entry that asks for text opens one");
         return false;
      }
      for (n = 0; p[n]; n++)
         if ((unsigned char)p[n] < 0x20 || p[n] == 0x7f)
         {
            command_reply_error(cmd, "MENU", "type takes one line of text, "
                  "with no tab or control character");
            return false;
         }
      input_driver_keyboard_line_set(p, n);
      input_keyboard_event(true,  '\n', '\n', 0, RETRO_DEVICE_KEYBOARD);
      input_keyboard_event(false, '\n', 0,    0, RETRO_DEVICE_KEYBOARD);
      p += n;
   }
   else if (*p >= '0' && *p <= '9')
   {
      index     = strtoul(p, &end, 10);
      has_index = true;
      for (p = end; *p == ' '; p++)
         ;
   }
   if (!strncmp(p, "from ", 5))
   {
      for (p += 5; *p == ' '; p++)
         ;
      if (*p < '0' || *p > '9')
      {
         command_reply_error(cmd, "MENU", "an entry number after from");
         return false;
      }
      from     = strtoul(p, &end, 10);
      has_from = true;
      for (p = end; *p == ' '; p++)
         ;
   }
   if (*p)
   {
      command_reply_error(cmd, "MENU", "%s [index] [from <entry>], not %s",
            actions[i].word, p);
      return false;
   }
   if (has_index && !actions[i].index)
   {
      command_reply_error(cmd, "MENU", "%s takes no index", actions[i].word);
      return false;
   }
   if (!has_index && string_is_equal(actions[i].word, "select"))
   {
      command_reply_error(cmd, "MENU", "select needs an index");
      return false;
   }
   if (string_is_equal(actions[i].word, "close"))
   {
      char  *out;
      size_t _len = 0;
      if (menu_st->flags & MENU_ST_FLAG_ALIVE)
         command_event(CMD_EVENT_MENU_TOGGLE, NULL);
      if (menu_st->flags & MENU_ST_FLAG_ALIVE)
      {
         command_reply_error(cmd, "MENU", "the menu stays open with no "
               "content running");
         return false;
      }
      if (!(out = command_menu_answer(false, 0, &_len)))
         return false;
      cmd->replier(cmd, out, _len);
      free(out);
      return true;
   }
   if (string_is_equal(actions[i].word, "open"))
   {
      if (!(menu_st->flags & MENU_ST_FLAG_ALIVE))
         command_event(CMD_EVENT_MENU_TOGGLE, NULL);
      if (!(menu_st->flags & MENU_ST_FLAG_ALIVE))
      {
         command_reply_error(cmd, "MENU", "the menu cannot open now");
         return false;
      }
   }
   else if (!alive && !string_is_equal(actions[i].word, "show"))
   {
      command_reply_error(cmd, "MENU", "the menu is closed: MENU open "
            "opens it");
      return false;
   }
   else if (has_index && index >= buf->size)
   {
      command_reply_error(cmd, "MENU", "no entry %lu: the list has %u",
            index, (unsigned)buf->size);
      return false;
   }
   /* what nothing changes is answered now */
   if (string_is_equal(actions[i].word, "show"))
   {
      char  *out;
      size_t _len = 0;
      if (!(out = command_menu_answer(has_from, (unsigned)from, &_len)))
         return false;
      cmd->replier(cmd, out, _len);
      free(out);
      return true;
   }
   if (command_menu_st.pending)
      command_deferred_send(&command_menu_st.deferred,
            "MENU ERROR replaced by another MENU request\n",
            STRLEN_CONST("MENU ERROR replaced by another MENU request\n"),
            true);
   command_menu_st.action    = actions[i].action;
   command_menu_st.index     = (size_t)index;
   command_menu_st.has_index = has_index;
   command_menu_st.from      = (unsigned)from;
   command_menu_st.has_from  = has_from;
   command_menu_st.depth     = command_menu_where(command_menu_st.list,
         sizeof(command_menu_st.list));
   command_menu_st.lost      = false;
   command_menu_st.frames    = 2;
   command_menu_st.pending   = true;
   command_deferred_take(&command_menu_st.deferred, cmd);
   return true;
#else
   command_reply_error(cmd, "MENU", "this build has no menu");
   return false;
#endif
}

bool command_disk(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "eject", "DISK_EJECT_TOGGLE", false },
      { "next",  "DISK_NEXT",         false },
      { "prev",  "DISK_PREV",         false }
   };
   /* the hotkeys are pressed regardless; the tool says when they can
    * do nothing */
   if (!disk_control_enabled(&runloop_state_get_ptr()->system.disk_control))
   {
      command_reply_error(cmd, "DISK", "this core has no disk control");
      return false;
   }
   return command_run_choice(cmd, "DISK", choices, ARRAY_SIZE(choices),
         COMMAND_DISK_ACTIONS, arg);
}

bool command_reinit(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "video", "VIDEO_REINIT",   false },
      { "audio", "AUDIO_REINIT",   false },
      { "all",   "DRIVERS_REINIT", false }
   };
   return command_run_choice(cmd, "REINIT", choices, ARRAY_SIZE(choices),
         COMMAND_REINIT_DRIVERS, arg);
}

bool command_state(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "save",       "SAVE_STATE_SLOT",  true  },
      { "load",       "LOAD_STATE_SLOT",  true  },
      { "checkpoint", "CHECKPOINT_STATE", false },
      { "rollback",   "ROLLBACK_STATE",   false }
   };
   return command_run_choice(cmd, "STATE", choices, ARRAY_SIZE(choices),
         COMMAND_STATE_ACTIONS, arg);
}

bool command_core(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "load",   "LOAD_CORE",   true  },
      { "start",  "START_CORE",  false },
      { "unload", "UNLOAD_CORE", false }
   };
   return command_run_choice(cmd, "CORE", choices, ARRAY_SIZE(choices),
         COMMAND_CORE_ACTIONS, arg);
}

bool command_replay(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "play",       "PLAY_REPLAY_SLOT",       true  },
      { "seek",       "SEEK_REPLAY",            true  },
      { "record",     "RECORD_REPLAY",          false },
      { "halt",       "HALT_REPLAY",            false },
      { "checkpoint", "SAVE_REPLAY_CHECKPOINT", false }
   };
   return command_run_choice(cmd, "REPLAY", choices, ARRAY_SIZE(choices),
         COMMAND_REPLAY_ACTIONS, arg);
}

bool command_input(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "set",     "SET_INPUT",     true },
      { "release", "RELEASE_INPUT", true },
      { "show",    "GET_INPUT",     true }
   };
   return command_run_choice(cmd, "INPUT", choices, ARRAY_SIZE(choices),
         COMMAND_INPUT_ACTIONS, arg);
}

bool command_option(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "show", "GET_OPTION", true },
      { "set",  "SET_OPTION", true }
   };
   return command_run_choice(cmd, "OPTION", choices, ARRAY_SIZE(choices),
         COMMAND_OPTION_ACTIONS, arg);
}

bool command_core_option(command_t *cmd, const char *arg)
{
   static const struct cmd_choice choices[] = {
      { "show", "GET_CORE_OPTION", true },
      { "set",  "SET_CORE_OPTION", true }
   };
   return command_run_choice(cmd, "CORE_OPTION", choices,
         ARRAY_SIZE(choices), COMMAND_OPTION_ACTIONS, arg);
}

bool command_interfaces_held(void)
{
   return runloop_is_content_switching();
}

const struct cmd_action_map *command_action_list(size_t *count)
{
   *count = ARRAY_SIZE(action_map);
   return action_map;
}

const struct cmd_map *command_hotkey_list(size_t *count)
{
   *count = ARRAY_SIZE(map);
   return map;
}

#ifdef HAVE_NETWORK_CMD
static bool command_verify(const char *cmd)
{
   size_t i;
   if (command_get_arg(cmd, NULL, NULL))
      return true;

   RARCH_ERR("[NetCMD] Command \"%s\" is not recognized by the program.\n", cmd);
   RARCH_ERR("[NetCMD] \tValid commands:\n");
   for (i = 0; i < ARRAY_SIZE(map); i++)
      RARCH_ERR("[NetCMD] \t\t%s\n", map[i].str);

   for (i = 0; i < ARRAY_SIZE(action_map); i++)
      RARCH_ERR("[NetCMD] \t\t%s %s\n", action_map[i].str, action_map[i].arg_desc);

   return false;
}

static bool udp_send_packet(const char *host, uint16_t port, const char *msg)
{
   char port_buf[6];
   const struct addrinfo *tmp_info;
   struct addrinfo *addr = NULL;
   struct addrinfo hints = {0};
   size_t          len   = strlen(msg);
   bool            ret   = false;

   snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);

   hints.ai_socktype = SOCK_DGRAM;
   hints.ai_flags    = AI_NUMERICSERV;

   if (getaddrinfo_retro(host, port_buf, &hints, &addr))
      return false;
   if (!addr)
      return false;

   /* Send to all possible targets. */
   tmp_info = addr;

   do
   {
      int fd = socket(tmp_info->ai_family,
         tmp_info->ai_socktype, tmp_info->ai_protocol);

      if (fd < 0)
         continue;

      if (sendto(fd, msg, len, 0, tmp_info->ai_addr, tmp_info->ai_addrlen) ==
            (ssize_t)len)
         ret = true;

      socket_close(fd);
   } while ((tmp_info = tmp_info->ai_next));

   freeaddrinfo_retro(addr);

   return ret;
}

/* Whether @s, after a ";", can be a host or a port rather than a STEPS
 * step: no space, no "|" (a list's "|on"), and not "checkpoint". Empty
 * is the default, as in "CMD;;PORT". */
static bool command_network_host_like(const char *s)
{
   return !strchr(s, ' ') && !strchr(s, '|')
      && !string_is_equal(s, "checkpoint");
}

bool command_network_send(const char *cmd_)
{
   char buf[4096];
   char *ptr;
   const char *cmd      = NULL;
   const char *host     = NULL;
   const char *port_str = NULL;
   uint16_t port        = DEFAULT_NETWORK_CMD_PORT;
   size_t len;

   if (!cmd_ || !*cmd_)
      return false;

   len = strlen(cmd_);
   if (len >= sizeof(buf))
      return false;

   if (!network_init())
      return false;

   memcpy(buf, cmd_, len + 1);

   /* ";host;port" ends it, the two read from the end and only where they
    * can be no STEPS step: a list separates its steps with ";" too */
   cmd = buf;
   if ((ptr = strrchr(buf, ';')) && command_network_host_like(ptr + 1))
   {
      char *prev;
      *ptr = '\0';
      host = ptr + 1;
      if ((prev = strrchr(buf, ';')) && command_network_host_like(prev + 1))
      {
         *prev    = '\0';
         port_str = host;
         host     = prev + 1;
      }
   }

   if (!cmd || !*cmd)
      return false;

   if (!host || !*host)
   {
#ifdef _WIN32
      host = "127.0.0.1";
#else
      host = "localhost";
#endif
   }

   if (port_str && *port_str)
   {
      unsigned long val = strtoul(port_str, NULL, 0);
      if (val > 0 && val <= 0xFFFF)
         port = (uint16_t)val;
   }

   RARCH_LOG("[NetCMD] %s: \"%s\" to %s:%hu.\n",
         msg_hash_to_str(MSG_SENDING_COMMAND),
         cmd, host, (unsigned short)port);

   if (!command_verify(cmd))
      return false;

   return udp_send_packet(host, port, cmd);
}
#endif

bool command_show_osd_msg(command_t *cmd, const char* arg)
{
    runloop_msg_queue_push(arg, strlen(arg), 1, 180, false, NULL,
          MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
    return true;
}


/* A whole number and nothing after it but spaces, into @out. "3xyz" is
 * not one: it used to come out as 3, and a save then overwrote that
 * slot on an argument its sender had got wrong. */
static bool command_arg_uint(const char *arg, unsigned *out)
{
   char         *end = NULL;
   unsigned long v;

   while (arg && *arg == ' ')
      arg++;
   if (!arg || *arg < '0' || *arg > '9')
      return false;
   errno = 0;
   v     = strtoul(arg, &end, 10);
   while (*end == ' ')
      end++;
   if (*end)
      return false;
   *out = (unsigned)v;
   /* range-checked before narrowing, so 4294967297 is not slot 1, and
    * where long is 32 bits strtoul clamps it and says so */
   return errno != ERANGE && (unsigned long)*out == v;
}

/* A state or replay slot: past INT_MAX one turns negative, which is the
 * auto slot's file. */
static bool command_arg_slot(const char *arg, unsigned *out)
{
   return command_arg_uint(arg, out) && *out <= INT_MAX;
}

static bool command_load_state_start(struct command_reply *r)
{
   return content_load_state_notify(r->path, false, false,
         command_reply_done, r);
}

/* Serializing re-enters the core, so this must not run from a command's
 * own poll. */
static bool command_save_state_start(struct command_reply *r)
{
   if (!content_save_state_notify(r->path, true, command_reply_done, r))
   {
      /* on the heap: this runs from a task, whose thread may have a
       * small stack */
      const char *what = msg_hash_to_str(MSG_FAILED_TO_SAVE_STATE_TO);
      size_t      len  = strlen(what) + strlen(r->path) + 8;
      char       *msg  = (char*)malloc(len);
      if (msg)
         snprintf(msg, len, "%s \"%s\".", what, r->path);
      command_reply_done(NULL, NULL, r, msg ? msg : what);
      free(msg);
   }
   return true;
}

/* LOAD_STATE_SLOT and SAVE_STATE_SLOT, answered once their task is
 * through. */
static bool command_state_slot(command_t *cmd, const char *arg, bool load)
{
   const char *name             = load ? "LOAD_STATE_SLOT" : "SAVE_STATE_SLOT";
   unsigned int slot            = 0;
   bool savestates_enabled      = core_info_current_supports_savestate();
   struct command_reply *r;

   if (!command_arg_slot(arg, &slot))
   {
      command_reply_error(cmd, name, "a slot number, not %s",
            (arg && *arg) ? arg : "nothing");
      return false;
   }

   if ((r = command_reply_new(name)))
   {
      runloop_get_savestate_path(r->path, sizeof(r->path), slot);
      /* For LOADING, an existing state file outranks metadata and
       * save-capability probes: core_serialize_size() measures whether
       * the core can SAVE right now (0 at e.g. a game's own main menu),
       * which says nothing about whether it can restore. Let the load
       * task and retro_unserialize() arbitrate. */
      if (load && !savestates_enabled)
         savestates_enabled = path_is_valid(r->path);
      if (savestates_enabled)
      {
         snprintf(r->ok, sizeof(r->ok), "%s %u", name, slot);
         r->state_loaded = load;
         r->start        = load ? command_load_state_start
                                : command_save_state_start;
         return command_reply_push(cmd, r);
      }
      free(r);
      command_reply_error(cmd, name,
            load ? "no state in slot %u, and this core cannot restore one"
                 : "this core cannot save a state to slot %u right now",
            slot);
      return false;
   }

   command_reply_error(cmd, name, "out of memory");
   return false;
}

/* The state STATE checkpoint keeps, in memory rather than a slot's
 * file, for STATE rollback; dropped when the content closes. */
static struct
{
   void  *data;
   size_t size;
} command_checkpoint;

void command_checkpoint_clear(void)
{
   free(command_checkpoint.data);
   command_checkpoint.data = NULL;
   command_checkpoint.size = 0;
}

/* Keeps the core's state as the checkpoint. Serializing re-enters the
 * core, so only with the core off the stack. */
static bool command_checkpoint_take(void)
{
   retro_ctx_serialize_info_t info;
   size_t len = core_serialize_size();
   void  *buf = len ? malloc(len) : NULL;
   info.data_const = NULL;
   info.data       = buf;
   info.size       = len;
   if (!buf || !core_serialize(&info))
   {
      free(buf);
      return false;
   }
   free(command_checkpoint.data);
   command_checkpoint.data = buf;
   command_checkpoint.size = len;
   return true;
}

/* Serializing re-enters the core, so this runs from the reply's main
 * thread task, as a save to a slot does. */
static bool command_checkpoint_start(struct command_reply *r)
{
   const char *error = NULL;
   if (r->state_loaded)
   {
      bool ramped;
      if (!command_checkpoint.data)
         error = "no checkpoint to roll back to; STATE checkpoint keeps one";
      /* as a load from a slot is refused: the recording would go on
       * from a state it never saw */
      else if (input_driver_replay_recording())
         error = "a replay is recording, which a rollback would break";
      else
      {
         /* through the loader of states without RetroArch's wrapper,
          * which resets the achievements and stops a replay playing,
          * as a load does */
         ramped = audio_driver_jump_fade_begin();
         if (!content_deserialize_state(command_checkpoint.data,
                  command_checkpoint.size))
            error = "the core could not restore the checkpoint";
         audio_driver_jump_fade_end(ramped);
      }
   }
   else if (!command_checkpoint_take())
      error = "this core cannot save a state right now";
   command_reply_done(NULL, NULL, r, error);
   return true;
}

static bool command_checkpoint_state(command_t *cmd, const char *arg,
      bool rollback)
{
   const char *name = rollback ? "ROLLBACK_STATE" : "CHECKPOINT_STATE";
   struct command_reply *r;
   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg)
   {
      command_reply_error(cmd, name, "nothing after it");
      return false;
   }
   if (!core_info_current_supports_savestate())
   {
      command_reply_error(cmd, name, "this core cannot save a state");
      return false;
   }
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
   {
      command_reply_error(cmd, name,
            "achievements hardcore mode forbids states");
      return false;
   }
#endif
   if (!(r = command_reply_new(name)))
   {
      command_reply_error(cmd, name, "out of memory");
      return false;
   }
   r->state_loaded = rollback;
   r->start        = command_checkpoint_start;
   return command_reply_push(cmd, r);
}

bool command_checkpoint_save(command_t *cmd, const char *arg)
{
   return command_checkpoint_state(cmd, arg, false);
}

bool command_checkpoint_rollback(command_t *cmd, const char *arg)
{
   return command_checkpoint_state(cmd, arg, true);
}

/* RESET [on|off]: from the reply's main thread task, since a reset
 * re-enters the core; with on, paused after it, as LOAD_CONTENT ...
 * paused is, so nothing runs before the first step. */
static bool command_reset_start(struct command_reply *r)
{
   command_event(CMD_EVENT_RESET, NULL);
   command_reply_done(NULL, NULL, r, NULL);
   return true;
}

bool command_reset(command_t *cmd, const char *arg)
{
   struct command_reply *r;
   bool                  pause = false;
   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg)
   {
      if (string_is_equal(arg, "on"))
         pause = true;
      else if (!string_is_equal(arg, "off"))
      {
         command_reply_error(cmd, "RESET", "on or off, not %s", arg);
         return false;
      }
   }
   if (!(runloop_get_flags() & RUNLOOP_FLAG_CORE_RUNNING))
   {
      command_reply_error(cmd, "RESET", "no content is running");
      return false;
   }
   if (!(r = command_reply_new("RESET")))
   {
      command_reply_error(cmd, "RESET", "out of memory");
      return false;
   }
   r->pause = pause;
   r->reset = true;
   r->start = command_reset_start;
   return command_reply_push(cmd, r);
}

bool command_load_state_slot(command_t *cmd, const char *arg)
{
   return command_state_slot(cmd, arg, true);
}

bool command_save_state_slot(command_t *cmd, const char *arg)
{
   return command_state_slot(cmd, arg, false);
}

bool command_play_replay_slot(command_t *cmd, const char *arg)
{
#ifdef HAVE_BSV_MOVIE
   unsigned int slot            = 0;
   struct command_reply *r      = NULL;
   if (!command_arg_slot(arg, &slot))
   {
      command_reply_error(cmd, "PLAY_REPLAY_SLOT", "a slot number, not %s",
            (arg && *arg) ? arg : "nothing");
      return false;
   }
   if (     core_info_current_supports_savestate()
         && (r = command_reply_new("PLAY_REPLAY_SLOT")))
   {
      runloop_get_replay_path(r->path, sizeof(r->path), slot);
      r->state_loaded = true;
      /* answered from the movie task's callback, on a later frame */
      if (movie_start_playback_notify(input_state_get_ptr(), r->path,
               command_reply_done, r))
      {
         command_deferred_take(&r->deferred, cmd);
         return true;
      }
      free(r);
      command_reply_error(cmd, "PLAY_REPLAY_SLOT",
            "no replay in slot %u", slot);
      return false;
   }
   command_reply_error(cmd, "PLAY_REPLAY_SLOT",
         "this core cannot play a replay");
   return false;
#else
   command_reply_error(cmd, "PLAY_REPLAY_SLOT",
         "this build has no replay support");
   return false;
#endif
}

bool command_seek_replay(command_t *cmd, const char *arg)
{
#ifdef HAVE_BSV_MOVIE
   char reply[32];
   char *endptr  = NULL;
   size_t _len;
   int64_t frame = arg ? (int64_t)strtoll(arg, &endptr, 10) : 0;
   input_driver_state_t *input_st = input_state_get_ptr();
   struct command_reply *r;
   /* strtoll always writes a valid pointer, so an empty or non-numeric
    * argument shows up as no characters consumed; anything but spaces
    * after the number means it was not one. */
   if (arg && endptr != arg)
      while (*endptr == ' ')
         endptr++;
   if (!arg || endptr == arg || *endptr)
   {
      command_reply_error(cmd, "SEEK_REPLAY", "a frame number, not %s",
            (arg && *arg) ? arg : "nothing");
      return false;
   }
   if (!(input_st->bsv_movie_state.flags & (BSV_FLAG_MOVIE_PLAYBACK | BSV_FLAG_MOVIE_RECORDING)))
   {
      command_reply_error(cmd, "SEEK_REPLAY",
            "no replay is playing or recording");
      return false;
   }
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
   {
      command_reply_error(cmd, "SEEK_REPLAY",
            "achievements hardcore mode forbids seeking");
      return false;
   }
#endif
   if (!movie_seek_to_frame(input_st, frame))
   {
      command_reply_error(cmd, "SEEK_REPLAY",
            "the replay could not be seeked to frame %" PRId64, frame);
      return false;
   }
   /* A structured request is answered once the seek has run, on a
    * later frame; a line-based one at once, as it always was. */
   if (cmd->structured && (r = command_reply_new("SEEK_REPLAY")))
   {
      snprintf(r->ok, sizeof(r->ok), "OK %" PRId64,
            input_st->bsv_movie_state.seek_target_frame);
      task_notify_set(&input_st->bsv_movie_op, command_reply_done, r);
      command_deferred_take(&r->deferred, cmd);
      return true;
   }
   _len = (size_t)snprintf(reply, sizeof(reply), "OK %" PRId64 "\n",
         input_st->bsv_movie_state.seek_target_frame);
   cmd->replier(cmd, reply, _len);
   return true;
#else
   command_reply_error(cmd, "SEEK_REPLAY",
         "this build has no replay support");
   return false;
#endif
}

bool command_save_savefiles(command_t *cmd, const char* arg)
{
   /* In the future, this should probably send each saved file path
      to the replier. */
   if (!command_event(CMD_EVENT_SAVE_FILES, NULL))
   {
      command_reply_error(cmd, "SAVE_FILES",
            "nothing to save: no content is loaded, or the core has no "
            "save files");
      return false;
   }
   cmd->replier(cmd, "OK\n", 3);
   return true;
}

bool command_load_savefiles(command_t *cmd, const char* arg)
{
   if (!command_event(CMD_EVENT_LOAD_FILES, NULL))
   {
      command_reply_error(cmd, "LOAD_FILES",
            "nothing to load: no content is loaded, or the core has no "
            "save files");
      return false;
   }
   cmd->replier(cmd, "OK\n", 3);
   return true;
}

/* Largest byte count READ_CORE_RAM / READ_CORE_MEMORY will serve. The
 * reply carries 3 characters per byte and goes out as one UDP datagram,
 * so anything much bigger could not be delivered anyway; the cap also
 * keeps `nbytes * 3` far from wrapping in unsigned int, which a request
 * of ~1431655766 bytes did, allocating a few bytes and writing 4 GiB. */
#define COMMAND_READ_NBYTES_MAX 16384u

/* A system or achievement address in hexadecimal, range-checked before
 * it is narrowed, so 100001001 is refused rather than read as 1001. */
static bool command_parse_address(const char *s, unsigned *address,
      char **end)
{
   unsigned long num;
   while (s && *s == ' ')
      s++;
   if (!s || (unsigned char)*s <= ' ' || *s == '-' || *s == '+')
      return false;
   errno    = 0;
   num      = strtoul(s, end, 16);
   *address = (unsigned)num;
   return *end != s && errno != ERANGE && (unsigned long)*address == num;
}

/* The next of a run of hexadecimal bytes separated by spaces: 1 with
 * it in @out, 0 at the end, -1 at anything that is not a byte. A
 * write checks every byte before it makes the first. */
static int command_next_byte(const char **s, uint8_t *out)
{
   char         *end = NULL;
   unsigned long num;
   while (**s == ' ')
      (*s)++;
   if (!**s)
      return 0;
   if (**s == '-' || **s == '+')
      return -1;
   num = strtoul(*s, &end, 16);
   if (end == *s || num > 0xff || (*end && *end != ' '))
      return -1;
   *s   = end;
   *out = (uint8_t)num;
   return 1;
}

static bool command_bytes_valid(const char *s)
{
   uint8_t b;
   int     r;
   while ((r = command_next_byte(&s, &b)) > 0)
      ;
   return r == 0;
}

/* @n bytes of @data as " XX" apiece; gives back the end of what it
 * wrote. */
static char *command_hex_bytes(char *at, const uint8_t *data, size_t n)
{
   static const char hex[] = "0123456789ABCDEF";
   size_t i;
   for (i = 0; i < n; i++)
   {
      *at++ = ' ';
      *at++ = hex[data[i] >> 4];
      *at++ = hex[data[i] & 0x0f];
   }
   return at;
}

#if defined(HAVE_CHEEVOS)
bool command_read_ram(command_t *cmd, const char *arg)
{
   unsigned long num          = 0;
   unsigned int nbytes        = 0;
   unsigned int addr          = 0;
   char *end                  = NULL;

   if (command_parse_address(arg, &addr, &end) && *end == ' ')
      num             = strtoul(end + 1, NULL, 10);
   nbytes             = num <= COMMAND_READ_NBYTES_MAX ? (unsigned)num : 0;

   if (!nbytes)
   {
      command_reply_error(cmd, "READ_CORE_RAM",
            "an achievement address in hexadecimal, a space, and a byte "
            "count from 1 to %u", COMMAND_READ_NBYTES_MAX);
      return false;
   }
   {
      size_t _len             = 0;
      char *reply_at          = NULL;
      unsigned int avail      = 0;
      const uint8_t *data     = rcheevos_patch_address_avail(addr, &avail);
      unsigned int alloc_size;
      char *reply;

      /* Never read past the end of the region the address lives in. */
      if (data && nbytes > avail)
         nbytes = avail;

      /* We allocate more than needed, saving 20 bytes is not really relevant */
      alloc_size = 40 + nbytes * 3;
      reply      = (char*)malloc(alloc_size);
      
      if (!reply)
      {
         command_reply_error(cmd, "READ_CORE_RAM", "out of memory");
         return false;
      }
      
      reply[0]                = '\0';
      reply_at                = reply + snprintf(
            reply, alloc_size - 1, "READ_CORE_RAM" " %x", addr);

      if (data && nbytes > 0)
      {
         char *end = command_hex_bytes(reply_at, data, nbytes);
         *end++    = '\n';
         _len      = (size_t)(end - reply);
      }
      else
      {
         /* no achievement memory at this address; " -1" is what line
          * clients have always read */
         strlcpy_lit(reply_at, " -1\n", alloc_size - (size_t)(reply_at - reply));
         _len = reply_at + STRLEN_CONST(" -1\n") - reply;
         cmd->error = true;
      }
      cmd->replier(cmd, reply, _len);
      free(reply);
   }
   return !cmd->error;
}

bool command_write_ram(command_t *cmd, const char *arg)
{
   unsigned int addr    = 0;
   unsigned int avail   = 0;
   char *end            = NULL;
   uint8_t *data        = NULL;
   uint8_t more;
   const uint8_t *start;

   if (!command_parse_address(arg, &addr, &end) || !command_bytes_valid(end))
   {
      command_reply_error(cmd, "WRITE_CORE_RAM", "an achievement address "
            "in hexadecimal, then bytes from 00 to ff separated by "
            "spaces");
      return false;
   }
   arg   = end;
   data  = (uint8_t *)rcheevos_patch_address_avail(addr, &avail);
   start = data;

   if (!data)
   {
      command_reply_error(cmd, "WRITE_CORE_RAM",
            "no achievement memory at %x; a game with achievements must "
            "be running", addr);
      return false;
   }

   if (rcheevos_hardcore_active())
   {
      RARCH_LOG("[Command] Achievements hardcore mode disabled by WRITE_CORE_RAM.\n");
      rcheevos_pause_hardcore();
   }

   /* Stop at the end of the region: the payload length is whatever the
    * sender put in the datagram. */
   while (avail && command_next_byte(&arg, data) > 0)
   {
      data++;
      avail--;
   }
   /* read into a byte of its own: @data is past the region here */
   if (command_next_byte(&arg, &more) > 0)
      RARCH_WARN("[Command] WRITE_CORE_RAM at %x reached the end of the "
            "memory region; remainder of the payload ignored.\n", addr);
   {
      char   reply[64];
      size_t _len = (size_t)snprintf(reply, sizeof(reply),
            "WRITE_CORE_RAM %x %u\n", addr, (unsigned)(data - start));
      cmd->replier(cmd, reply, _len);
   }
   return true;
}
#endif

/* ---- Queries for clients that browse and launch content --------- */

/* A reply larger than one UDP datagram cannot go back over the network
 * command port; lists stop short of it and say where to go on. */
#define COMMAND_LIST_REPLY_MAX 60000
#define COMMAND_PLAYLIST_PAGE  200

/* ------------------------------------------------------------------ */
/* Options: what GET_OPTION reports and SET_OPTION writes              */

/* Which option a row of the table below is. Every one has a case in
 * command_option_read(), and no default, so that one added here without
 * a case is a warning rather than an option that reports nothing. */
enum cmd_option_id
{
   /* on or off */
   CMD_OPT_PAUSE = 0,
   CMD_OPT_FAST_FORWARD,
   CMD_OPT_SLOW_MOTION,
   CMD_OPT_MUTE,
   CMD_OPT_FPS,
   CMD_OPT_STATISTICS,
   CMD_OPT_FULLSCREEN,
   CMD_OPT_SHADER,
   CMD_OPT_VIDEO_FILTER,
   CMD_OPT_REWIND,
   CMD_OPT_RUNAHEAD,
   CMD_OPT_PREEMPT,
   CMD_OPT_VRR_RUNLOOP,
   CMD_OPT_TURBO_FIRE,
   CMD_OPT_GRAB_MOUSE,
   CMD_OPT_GAME_FOCUS,
   CMD_OPT_RECORDING,
   CMD_OPT_STREAMING,
   CMD_OPT_CHEEVOS_HARDCORE,
   CMD_OPT_CHEEVOS_ENABLE,
   CMD_OPT_LOADING,
   /* a value they report */
   CMD_OPT_FRAME_COUNT,
   CMD_OPT_STATE_SLOT,
   CMD_OPT_REPLAY_SLOT,
   CMD_OPT_ACTIVE_REPLAY,
   CMD_OPT_SYSTEM,
   CMD_OPT_CONTENT,
   CMD_OPT_DIR_SAVEFILE,
   CMD_OPT_DIR_SAVESTATE,
   CMD_OPT_DIR_RUNTIME_LOG,
   CMD_OPT_DIR_LOG,
   CMD_OPT_DIR_CACHE,
   CMD_OPT_DIR_SYSTEM,
   CMD_OPT_NICKNAME
};

/* An option GET_OPTION reports and SET_OPTION writes.
 *
 * @alias is the name GET_CONFIG_PARAM knew the option by, kept so that
 * interface answers what it always did; NULL where there was none.
 *
 * SET_OPTION is asked for a state, not a change, and writes only when
 * the option is not already in it, so sending the same value twice is
 * one change and then nothing. That is why @event, the single event the
 * hotkey toggles the option with, is enough for most of them; the few
 * the frontend does differently are @settable with no event, and
 * command_option_set() has them by @id. */
struct cmd_option_map
{
   const char        *str;
   const char        *alias;
   enum cmd_option_id id;
   bool               settable;
   enum event_command event;
   const char        *desc;
};

/* Whether @o is on, and its value into @s - @yes or @no for one that is
 * on or off, else what it reports - unless @s is NULL.
 *
 * Every option is read where its state lives rather than from the
 * setting behind it: a setting says what was configured, and this says
 * what is true now. An option a build does not have never reaches here,
 * having no row in the table, but its case is still compiled: what the
 * state would be read from may not exist. */
static bool command_option_read(const struct cmd_option_map *o,
      char *s, size_t len, const char *yes, const char *no)
{
   settings_t *settings = config_get_ptr();
   const char *text     = NULL;
   bool        on       = false;
   char        num[64];

   switch (o->id)
   {
      case CMD_OPT_PAUSE:
         on   = (runloop_get_flags() & RUNLOOP_FLAG_PAUSED) != 0;
         break;
      case CMD_OPT_FAST_FORWARD:
         on   = (runloop_get_flags() & RUNLOOP_FLAG_FASTMOTION) != 0;
         break;
      case CMD_OPT_SLOW_MOTION:
         on   = (runloop_get_flags() & RUNLOOP_FLAG_SLOWMOTION) != 0;
         break;
      case CMD_OPT_MUTE:
         on   = audio_state_get_ptr()->mute_enable;
         break;
      case CMD_OPT_FPS:
         on   = settings->bools.video_fps_show;
         break;
      case CMD_OPT_STATISTICS:
         on   = settings->bools.video_statistics_show;
         break;
      case CMD_OPT_FULLSCREEN:
         on   = settings->bools.video_fullscreen;
         break;
      case CMD_OPT_SHADER:
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
         on   = settings->bools.video_shader_enable;
#endif
         break;
      case CMD_OPT_VIDEO_FILTER:
#ifdef HAVE_VIDEO_FILTER
         on   = settings->bools.video_filter_enable;
#endif
         break;
      case CMD_OPT_REWIND:
#ifdef HAVE_REWIND
         on   = settings->bools.rewind_enable;
#endif
         break;
      case CMD_OPT_RUNAHEAD:
#ifdef HAVE_RUNAHEAD
         on   = settings->bools.run_ahead_enabled;
#endif
         break;
      case CMD_OPT_PREEMPT:
#ifdef HAVE_RUNAHEAD
         on   = settings->bools.preemptive_frames_enable;
#endif
         break;
      case CMD_OPT_VRR_RUNLOOP:
         on   = settings->bools.vrr_runloop_enable;
         break;
      case CMD_OPT_TURBO_FIRE:
         on   = settings->bools.input_turbo_enable;
         break;
      case CMD_OPT_GRAB_MOUSE:
         on   = input_driver_mouse_grabbed();
         break;
      case CMD_OPT_GAME_FOCUS:
         on   = input_driver_game_focus_enabled();
         break;
      /* Both are the recorder running; the stream is the one that has
       * somewhere to send it. */
      case CMD_OPT_RECORDING:
      case CMD_OPT_STREAMING:
         {
            const recording_state_t *rec_st = recording_state_get_ptr();
            on = rec_st && rec_st->enable
               && (rec_st->streaming_enable == (o->id == CMD_OPT_STREAMING));
         }
         break;
      case CMD_OPT_CHEEVOS_HARDCORE:
#ifdef HAVE_CHEEVOS
         on   = rcheevos_hardcore_active();
#endif
         break;
      case CMD_OPT_CHEEVOS_ENABLE:
#ifdef HAVE_CHEEVOS
         on   = settings->bools.cheevos_enable;
#endif
         break;
      case CMD_OPT_LOADING:
         on   = command_interfaces_held();
         break;

      case CMD_OPT_FRAME_COUNT:
         snprintf(num, sizeof(num), "%" PRIu64,
               video_driver_get_frame_count());
         text = num;
         break;
      case CMD_OPT_STATE_SLOT:
         snprintf(num, sizeof(num), "%d", settings->ints.state_slot);
         text = num;
         break;
      case CMD_OPT_REPLAY_SLOT:
         snprintf(num, sizeof(num), "%d", settings->ints.replay_slot);
         text = num;
         break;
      /* the replay's identifier, its state flags and the frame it is
       * on, as GET_CONFIG_PARAM has always given them */
      case CMD_OPT_ACTIVE_REPLAY:
         text = "0 0 0";
#ifdef HAVE_BSV_MOVIE
         {
            input_driver_state_t *input_st = input_state_get_ptr();
            if (input_st->bsv_movie_state_handle)
            {
               bsv_movie_t *movie = input_st->bsv_movie_state_handle;
               snprintf(num, sizeof(num), "%lld %u %lld",
                     (long long)movie->identifier,
                     input_st->bsv_movie_state.flags,
                     (long long)movie->frame_counter);
               text = num;
            }
         }
#endif
         break;
      case CMD_OPT_SYSTEM:
         {
            core_info_t     *core_info  = NULL;
            runloop_state_t *runloop_st = runloop_state_get_ptr();
            core_info_get_current_core(&core_info);
            if (core_info && core_info->system_id)
               text = core_info->system_id;
            else
               text = runloop_st->system.info.library_name;
         }
         break;
      case CMD_OPT_CONTENT:
         text = path_get(RARCH_PATH_BASENAME);
         break;
      case CMD_OPT_DIR_SAVEFILE:
         text = dir_get_ptr(RARCH_DIR_SAVEFILE);
         break;
      case CMD_OPT_DIR_SAVESTATE:
         text = dir_get_ptr(RARCH_DIR_SAVESTATE);
         break;
      case CMD_OPT_DIR_RUNTIME_LOG:
         text = settings->paths.directory_runtime_log;
         break;
      case CMD_OPT_DIR_LOG:
         text = settings->paths.log_dir;
         break;
      case CMD_OPT_DIR_CACHE:
         text = settings->paths.directory_cache;
         break;
      case CMD_OPT_DIR_SYSTEM:
         text = settings->paths.directory_system;
         break;
      case CMD_OPT_NICKNAME:
         text = settings->paths.username;
         break;
   }

   if (s)
      strlcpy(s, text ? text : (on ? yes : no), len);
   return on;
}

/* Puts @o in state @on, which it is not already in. */
static bool command_option_set(const struct cmd_option_map *o,
      command_t *cmd, bool on)
{
   switch (o->id)
   {
      case CMD_OPT_PAUSE:
         command_event(on ? CMD_EVENT_PAUSE : CMD_EVENT_UNPAUSE, NULL);
         break;
      case CMD_OPT_RECORDING:
      case CMD_OPT_STREAMING:
         if (on && recording_state_get_ptr()->enable)
         {
            command_reply_error(cmd, "SET_OPTION",
                  "stop the active recording or stream before starting %s",
                  o->str);
            return false;
         }
         if (o->id == CMD_OPT_STREAMING)
            command_event(CMD_EVENT_STREAMING_TOGGLE, NULL);
         else
            command_event(on ? CMD_EVENT_RECORD_INIT
                             : CMD_EVENT_RECORD_DEINIT, NULL);
         break;
      case CMD_OPT_GAME_FOCUS:
         {
            enum input_game_focus_cmd_type type = on
               ? GAME_FOCUS_CMD_ON : GAME_FOCUS_CMD_OFF;
            command_event(CMD_EVENT_GAME_FOCUS_TOGGLE, &type);
         }
         break;
      case CMD_OPT_FAST_FORWARD:
         return runloop_set_fastmotion(on);
      case CMD_OPT_SLOW_MOTION:
         return runloop_set_slowmotion(on);
      default:
         command_event(o->event, NULL);
         break;
   }
   /* An event that cannot act now - pausing with no core running, the
    * video filter likewise - does nothing and reports success all the
    * same, so what it reached is read back. */
   return command_option_read(o, NULL, 0, NULL, NULL) == on;
}

static const struct cmd_option_map option_map[] = {
   { "pause", NULL, CMD_OPT_PAUSE, true, CMD_EVENT_NONE,
      "The content is paused." },
   { "fast_forward", NULL, CMD_OPT_FAST_FORWARD, true, CMD_EVENT_NONE,
      "Fast-forward is running." },
   { "slow_motion", NULL, CMD_OPT_SLOW_MOTION, true, CMD_EVENT_NONE,
      "Slow motion is running." },
   { "mute", NULL, CMD_OPT_MUTE, true, CMD_EVENT_AUDIO_MUTE_TOGGLE,
      "Audio is muted." },
   { "fps", NULL, CMD_OPT_FPS, true, CMD_EVENT_FPS_TOGGLE,
      "The framerate is shown on screen." },
   { "statistics", NULL, CMD_OPT_STATISTICS, true,
      CMD_EVENT_STATISTICS_TOGGLE,
      "The technical statistics are shown on screen." },
   { "fullscreen", "video_fullscreen", CMD_OPT_FULLSCREEN, true,
      CMD_EVENT_FULLSCREEN_TOGGLE, "The window is fullscreen." },
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
   { "shader", NULL, CMD_OPT_SHADER, true, CMD_EVENT_SHADER_TOGGLE,
      "The shader preset is applied." },
#endif
#ifdef HAVE_VIDEO_FILTER
   { "video_filter", NULL, CMD_OPT_VIDEO_FILTER, true,
      CMD_VIDEO_FILTER_TOGGLE, "The video filter is applied." },
#endif
#ifdef HAVE_REWIND
   { "rewind", NULL, CMD_OPT_REWIND, true, CMD_EVENT_REWIND_TOGGLE,
      "Rewind is available." },
#endif
#ifdef HAVE_RUNAHEAD
   { "runahead", NULL, CMD_OPT_RUNAHEAD, true, CMD_EVENT_RUNAHEAD_TOGGLE,
      "Run-ahead is on." },
   { "preempt", NULL, CMD_OPT_PREEMPT, true, CMD_EVENT_PREEMPT_TOGGLE,
      "Preemptive frames are on." },
#endif
   { "vrr_runloop", NULL, CMD_OPT_VRR_RUNLOOP, true,
      CMD_EVENT_VRR_RUNLOOP_TOGGLE,
      "The runloop syncs to the exact content framerate." },
   { "turbo_fire", NULL, CMD_OPT_TURBO_FIRE, true,
      CMD_EVENT_TURBO_FIRE_TOGGLE, "Turbo fire is on." },
   { "grab_mouse", NULL, CMD_OPT_GRAB_MOUSE, true,
      CMD_EVENT_GRAB_MOUSE_TOGGLE, "The mouse is grabbed." },
   { "game_focus", NULL, CMD_OPT_GAME_FOCUS, true, CMD_EVENT_NONE,
      "The game has all keyboard input, rather than the hotkeys." },
   { "recording", NULL, CMD_OPT_RECORDING, true, CMD_EVENT_NONE,
      "Video is being recorded to a file." },
   { "streaming", NULL, CMD_OPT_STREAMING, true, CMD_EVENT_NONE,
      "The session is being streamed." },
#ifdef HAVE_CHEEVOS
   { "cheevos_hardcore", NULL, CMD_OPT_CHEEVOS_HARDCORE, true,
      CMD_EVENT_CHEEVOS_HARDCORE_MODE_TOGGLE,
      "Achievements hardcore mode is on: it forbids states, rewind and "
      "frame advance." },
   { "cheevos_enable", "cheevos_enable", CMD_OPT_CHEEVOS_ENABLE, false,
      CMD_EVENT_NONE, "Achievements are enabled." },
#endif
   /* Reported, never set. */
   { "loading", NULL, CMD_OPT_LOADING, false, CMD_EVENT_NONE,
      "Content is loading: a command that needs the core waits for it." },
   { "frame_count", NULL, CMD_OPT_FRAME_COUNT, false, CMD_EVENT_NONE,
      "Frames shown since the video driver started." },
   { "state_slot", NULL, CMD_OPT_STATE_SLOT, false, CMD_EVENT_NONE,
      "The save state slot LOAD_STATE and SAVE_STATE use." },
   { "replay_slot", NULL, CMD_OPT_REPLAY_SLOT, false, CMD_EVENT_NONE,
      "The replay slot PLAY_REPLAY and RECORD_REPLAY use." },
   { "active_replay", "active_replay", CMD_OPT_ACTIVE_REPLAY, false,
      CMD_EVENT_NONE,
      "The open replay: its identifier, state flags and frame, or zeroes." },
   { "system", NULL, CMD_OPT_SYSTEM, false, CMD_EVENT_NONE,
      "The running core's system, or empty when none is loaded." },
   { "content", NULL, CMD_OPT_CONTENT, false, CMD_EVENT_NONE,
      "The running content's path, or empty when none is loaded." },
   { "savefile_directory", "savefile_directory", CMD_OPT_DIR_SAVEFILE,
      false, CMD_EVENT_NONE, "Where save files are written." },
   { "savestate_directory", "savestate_directory", CMD_OPT_DIR_SAVESTATE,
      false, CMD_EVENT_NONE, "Where save states are written." },
   { "runtime_log_directory", "runtime_log_directory",
      CMD_OPT_DIR_RUNTIME_LOG, false, CMD_EVENT_NONE,
      "Where runtime logs are written." },
   { "log_dir", "log_dir", CMD_OPT_DIR_LOG, false, CMD_EVENT_NONE,
      "Where the log is written." },
   { "cache_directory", "cache_directory", CMD_OPT_DIR_CACHE, false,
      CMD_EVENT_NONE, "Where extracted content is cached." },
   { "system_directory", "system_directory", CMD_OPT_DIR_SYSTEM, false,
      CMD_EVENT_NONE, "Where cores look for system files." },
   { "netplay_nickname", "netplay_nickname", CMD_OPT_NICKNAME, false,
      CMD_EVENT_NONE, "The name shown to netplay peers." }
};

/* The option @name, by its own name or the one GET_CONFIG_PARAM knows
 * it by when @alias, or NULL. */
static const struct cmd_option_map *command_option_find(const char *name,
      bool alias)
{
   size_t i;
   for (i = 0; i < ARRAY_SIZE(option_map); i++)
   {
      if (string_is_equal(name, option_map[i].str))
         return &option_map[i];
      if (     alias && option_map[i].alias
            && string_is_equal(name, option_map[i].alias))
         return &option_map[i];
   }
   return NULL;
}

/* GET_OPTION [option]
 *
 * Every option and its value, name and value tab separated, one per
 * line; with a name, that option's line alone. */
bool command_get_option(command_t *cmd, const char *arg)
{
   char   value[PATH_MAX_LENGTH];
   size_t i;
   size_t _len  = 0;
   bool   found = false;
   bool   one;
   size_t cap;
   char  *reply;

   while (arg && *arg == ' ')
      arg++;
   one = arg && *arg;
   /* one line needs room for one; the whole table stops short of what a
    * reply can carry, as the other lists do */
   cap = one ? NAME_MAX_LENGTH + PATH_MAX_LENGTH + 2
             : COMMAND_LIST_REPLY_MAX;

   if (!(reply = (char*)malloc(cap + 1)))
   {
      command_reply_error(cmd, "GET_OPTION", "out of memory");
      return false;
   }
   reply[0] = '\0';

   for (i = 0; i < ARRAY_SIZE(option_map); i++)
   {
      int n;
      if (one && !string_is_equal(arg, option_map[i].str))
         continue;
      found = true;
      command_option_read(&option_map[i], value, sizeof(value), "on", "off");
      n = snprintf(reply + _len, cap - _len, "%s\t%s\n",
            option_map[i].str, value);
      /* Short of a reply holding every option, half the list would be
       * read as the whole of it, so say so instead. */
      if (n < 0 || (size_t)n >= cap - _len)
      {
         free(reply);
         command_reply_error(cmd, "GET_OPTION",
               "the options did not fit one reply, stopping at %s",
               option_map[i].str);
         return false;
      }
      _len += (size_t)n;
   }

   if (!found)
   {
      free(reply);
      command_reply_error(cmd, "GET_OPTION",
            "no such option %s; OPTION show lists them", arg);
      return false;
   }

   cmd->replier(cmd, reply, _len);
   free(reply);
   return true;
}

/* SET_OPTION <option> on|off
 *
 * Asking for the state the option is already in changes nothing and
 * succeeds, so the same request twice is one change. */
bool command_set_option(command_t *cmd, const char *arg)
{
   char   reply[NAME_MAX_LENGTH + 32];
   size_t _len;
   const struct cmd_option_map *o;
   const char *sp;
   char   name[NAME_MAX_LENGTH];
   bool   on;

   while (arg && *arg == ' ')
      arg++;
   if (!arg || !*arg || !(sp = strchr(arg, ' ')))
   {
      command_reply_error(cmd, "SET_OPTION",
            "an option and on or off, as in OPTION set pause on");
      return false;
   }
   if ((size_t)(sp - arg) >= sizeof(name))
   {
      command_reply_error(cmd, "SET_OPTION", "no such option");
      return false;
   }
   memcpy(name, arg, (size_t)(sp - arg));
   name[sp - arg] = '\0';
   while (*sp == ' ')
      sp++;

   if (string_is_equal(sp, "on"))
      on = true;
   else if (string_is_equal(sp, "off"))
      on = false;
   else
   {
      command_reply_error(cmd, "SET_OPTION",
            "%s takes on or off, not %s", name, sp);
      return false;
   }

   if (!(o = command_option_find(name, false)))
   {
      command_reply_error(cmd, "SET_OPTION",
            "no such option %s; OPTION show lists them",
            name);
      return false;
   }
   if (!o->settable)
   {
      command_reply_error(cmd, "SET_OPTION", "%s only reports", o->str);
      return false;
   }
   if (     command_option_read(o, NULL, 0, NULL, NULL) != on
         && !command_option_set(o, cmd, on))
   {
      if (!cmd->error)
         command_reply_error(cmd, "SET_OPTION", "%s could not be turned %s",
               o->str, on ? "on" : "off");
      return false;
   }

   /* the shape GET_OPTION gives, so one reading serves both */
   _len = (size_t)snprintf(reply, sizeof(reply), "%s\t%s\n", o->str,
         on ? "on" : "off");
   cmd->replier(cmd, reply, _len);
   return true;
}

#ifdef HAVE_MCP
/* GET_LOG [since]
 *
 * The lines logged since line @since (0 when left out), as many as one
 * reply holds, then NEXT and the number to ask from next time. Lines
 * logged before the first GET_LOG, or the MCP server started, are not
 * kept; SKIPPED and a count says lines were overwritten before they
 * were read. */
bool command_get_log(command_t *cmd, const char *arg)
{
   size_t first, next, _len;
   unsigned since = 0;
   char  *reply;

   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg && !command_arg_uint(arg, &since))
   {
      command_reply_error(cmd, "GET_LOG", "a line number, not %s", arg);
      return false;
   }
   verbosity_ring_arm();
   if (!(reply = (char*)malloc(COMMAND_LIST_REPLY_MAX + 1)))
   {
      command_reply_error(cmd, "GET_LOG", "out of memory");
      return false;
   }
   /* room kept for the SKIPPED and NEXT lines */
   _len = verbosity_ring_read(since, reply + 32, COMMAND_LIST_REPLY_MAX - 64,
         &first, &next);
   if (first > since)
   {
      int n = snprintf(reply, 32, "SKIPPED %u\n", (unsigned)(first - since));
      memmove(reply + n, reply + 32, _len);
      _len += (size_t)n;
   }
   else
      memmove(reply, reply + 32, _len);
   _len += (size_t)snprintf(reply + _len, 32, "NEXT %u\n", (unsigned)next);
   cmd->replier(cmd, reply, _len);
   free(reply);
   return true;
}
#endif

/* Where a system address lands, defined with the memory commands. */
static uint8_t *command_memory_get_pointer(
      const rarch_system_info_t* sys_info,
      unsigned address, unsigned int* max_bytes,
      int for_write, char *s, size_t len);

/* What RUN_UNTIL, a PRESS that waits after it and a STEPS list wait on:
 * the byte at @lo, or with @wide the value @hi * 256 + @lo, from two
 * bytes that need not be adjacent. */
struct command_cond
{
   unsigned hi;
   unsigned lo;
   unsigned mask;   /* "& <mask>": the bits compared; 0 for all */
   unsigned want;
   uint8_t  op;     /* enum cmd_until_op */
   bool     wide;
};

/* "<address>[:<address>]" into @c, @end after it: 0, or 1 where the
 * first address is not one and 2 where the second is not. */
static int command_cond_address(const char *s, struct command_cond *c,
      char **end)
{
   unsigned address = 0;
   if (!command_parse_address(s, &address, end))
      return 1;
   c->lo = address;
   if (**end != ':')
      return 0;
   if (     !command_parse_address(*end + 1, &address, end)
         || (**end && **end != ' '))
      return 2;
   c->hi   = c->lo;
   c->lo   = address;
   c->wide = true;
   return 0;
}

static bool command_cond_read(const struct command_cond *c,
      unsigned *out, char *why, size_t why_len)
{
   unsigned       avail = 0;
   const rarch_system_info_t *sys = &runloop_state_get_ptr()->system;
   const uint8_t *lo    = command_memory_get_pointer(sys, c->lo, &avail, 0,
         why, why_len);
   const uint8_t *hi    = NULL;
   if (!lo || (c->wide && !(hi = command_memory_get_pointer(sys, c->hi,
                  &avail, 0, why, why_len))))
      return false;
   *out = hi ? ((unsigned)*hi << 8) | *lo : *lo;
   if (c->mask)
      *out &= c->mask;
   return true;
}

/* The reason command_memory_get_pointer() wrote, as line clients read
 * it - " -1 ", why, a newline - trimmed to the why. */
static const char *command_memory_why(char *reason)
{
   char *why = !strncmp(reason, " -1 ", STRLEN_CONST(" -1 "))
      ? reason + STRLEN_CONST(" -1 ") : reason;
   char *nl  = strchr(why, '\n');
   if (nl)
      *nl = '\0';
   return *why ? why : "no memory at that address";
}

/* The bytes a client asked to be told about, by the labels it gave
 * them. A step is a request and a look - press, then read where the
 * player is, then read the enemies, then read the game mode - so the
 * look rides along with the step instead of being three more requests.
 *
 * Each is looked up afresh on every reply rather than kept as a
 * pointer: a core may move its memory without closing the content. */
#define COMMAND_WATCH_MAX 16
/* the most one watch's line takes: label, address and value */
#define COMMAND_WATCH_LINE 48

struct command_watch_entry
{
   struct command_cond where; /* its address or two, read as a condition is */
   char                label[16];
};
static struct command_watch_entry command_watches[COMMAND_WATCH_MAX];
static unsigned command_watch_count;

void command_watch_clear(void)
{
   command_watch_count = 0;
}

/* The watches as lines of label, address and value, which is what a
 * line client reads and what the rows of a structured reply are. */
static size_t command_watch_lines(char *s, size_t len)
{
   char      value[8];
   char      where[24];
   char      reason[128];
   size_t    _len = 0;
   unsigned  i;
   for (i = 0; i < command_watch_count && _len + COMMAND_WATCH_LINE < len;
         i++)
   {
      const struct command_watch_entry *e = &command_watches[i];
      unsigned now = 0;
      if (command_cond_read(&e->where, &now, reason, sizeof(reason)))
         snprintf(value, sizeof(value), "%u", now);
      else
         strlcpy(value, "none", sizeof(value));
      if (e->where.wide)
         snprintf(where, sizeof(where), "%x:%x", e->where.hi, e->where.lo);
      else
         snprintf(where, sizeof(where), "%x", e->where.lo);
      _len += (size_t)snprintf(s + _len, len - _len, "%s\t%s\t%s\n",
            e->label, where, value);
   }
   return _len;
}

/* How a condition compares, in the order the words below name them. */
enum cmd_until_op
{
   CMD_UNTIL_EQ = 0,
   CMD_UNTIL_NE,
   CMD_UNTIL_LT,
   CMD_UNTIL_GT,
   CMD_UNTIL_LE,
   CMD_UNTIL_GE
};
#define COMMAND_UNTIL_OPS "==, !=, <, >, <= or >="
static const char *const command_until_ops[] = {
   "==", "!=", "<", ">", "<=", ">="
};

/* A number in a condition: "0x" and hexadecimal digits, or decimal.
 * False where @s starts with neither; @end after it. */
static bool command_cond_number(const char *s, char **end,
      unsigned long *out)
{
   errno = 0;
   if (     s[0] == '0' && (s[1] == 'x' || s[1] == 'X')
         && ((s[2] >= '0' && s[2] <= '9') || (s[2] >= 'a' && s[2] <= 'f')
            || (s[2] >= 'A' && s[2] <= 'F')))
      *out = strtoul(s + 2, end, 16);
   else if (*s >= '0' && *s <= '9' && s[1] != 'x' && s[1] != 'X')
      *out = strtoul(s, end, 10);
   else
      return false;
   return errno != ERANGE;
}

/* "<address>[:<address>] <condition> <value>", @end after the value;
 * false with what was wrong in @why. */
static bool command_cond_parse(const char *s, struct command_cond *c,
      char **end, char *why, size_t why_len)
{
   unsigned      i;
   unsigned long num;
   const char   *sp;
   int           bad;

   memset(c, 0, sizeof(*c));
   if ((bad = command_cond_address(s, c, end)))
   {
      strlcpy(why, bad == 1
            ? "a hexadecimal address, or two as high:low, then a "
              "condition and a value"
            : "a second hexadecimal address after the \":\"", why_len);
      return false;
   }
   while (**end == ' ')
      (*end)++;
   /* "& 0x40" or "& 64": only those bits, as a game keeps its flags */
   if (**end == '&')
   {
      const char *m = *end + 1;
      while (*m == ' ')
         m++;
      if (     !command_cond_number(m, end, &num) || !num
            || num > (c->wide ? 65535UL : 255UL))
      {
         strlcpy(why, "a mask after \"&\", such as 0x40 or 64", why_len);
         return false;
      }
      c->mask = (unsigned)num;
      while (**end == ' ')
         (*end)++;
   }
   if (!**end)
   {
      strlcpy(why, "a condition and a value after the address", why_len);
      return false;
   }
   if (!(sp = strchr(*end, ' ')))
   {
      strlcpy(why, "a condition and a value after the address", why_len);
      return false;
   }
   for (i = 0; i < ARRAY_SIZE(command_until_ops); i++)
      if (     !strncmp(*end, command_until_ops[i], (size_t)(sp - *end))
            && !command_until_ops[i][sp - *end])
         break;
   if (i == ARRAY_SIZE(command_until_ops))
   {
      snprintf(why, why_len, "a condition of %s, not %.*s",
            COMMAND_UNTIL_OPS, (int)(sp - *end), *end);
      return false;
   }
   while (*sp == ' ')
      sp++;
   /* "== 112" or "== 0x70", as a mask is given */
   if (     !command_cond_number(sp, end, &num)
         || num > (c->wide ? 65535UL : 255UL))
   {
      strlcpy(why, c->wide
            ? "a value from 0 to 65535 (0xFFFF), which is what two bytes hold"
            : "a value from 0 to 255 (0xFF), which is what a byte holds",
            why_len);
      return false;
   }
   c->want = (unsigned)num;
   c->op   = (uint8_t)i;
   return true;
}

/* What @c's memory holds now, looked up afresh as WATCH's bytes are,
 * since a core may move its memory while the content runs; false where
 * nothing maps it, with the reason as line clients read it in @why. */
static bool command_cond_met(const struct command_cond *c, unsigned now)
{
   switch (c->op)
   {
      case CMD_UNTIL_EQ: return now == c->want;
      case CMD_UNTIL_NE: return now != c->want;
      case CMD_UNTIL_LT: return now <  c->want;
      case CMD_UNTIL_GT: return now >  c->want;
      case CMD_UNTIL_LE: return now <= c->want;
      case CMD_UNTIL_GE: return now >= c->want;
      default:           break;
   }
   return true;
}

/* Whether @c's memory is mapped now: answered to @cmd as @name's error
 * where it is not, so a wait that could not end is refused before any
 * frame runs. */
static bool command_cond_mapped(command_t *cmd, const char *name,
      const struct command_cond *c)
{
   char     reason[128];
   unsigned now = 0;
   if (command_cond_read(c, &now, reason, sizeof(reason)))
      return true;
   command_reply_error(cmd, name, "%s", command_memory_why(reason));
   return false;
}

static unsigned command_frames_default(void);

/* A frame job is a list of steps run in order, one frame at a time:
 * run some frames, press buttons for some, or run until a condition
 * holds. RUN_FRAMES and PRESS are one step, RUN_UNTIL is one, a PRESS
 * that waits after it is two, and STEPS is whatever the client lists -
 * approach, jump, land - so a stretch of play that took three requests
 * takes one. STOP and CHECKPOINT take no frame: a list's stops go
 * ahead of its steps, so a list queued behind another brings its own. */
enum cmd_step_kind
{
   CMD_STEP_RUN = 0,
   CMD_STEP_PRESS,
   CMD_STEP_UNTIL,
   CMD_STEP_STOP,
   CMD_STEP_CHECKPOINT
};

struct command_step
{
   struct command_cond cond;   /* UNTIL and STOP */
   unsigned            frames; /* RUN and PRESS */
   unsigned            port;   /* PRESS: the player, from 0 */
   uint16_t            mask;   /* PRESS: the buttons, by bit */
   uint8_t             kind;   /* enum cmd_step_kind */
   uint8_t             idx;    /* its number in its list, from 1; a
                                  STOP's among the stops */
};

#define COMMAND_STEPS_MAX 32
#define COMMAND_STOPS_MAX 4
/* steps queued and running, their stops among them; each queued list
 * also has a marker, which does not count */
#define COMMAND_QUEUE_MAX 64

/* How the job answers: the command's own line (RUN_FRAMES, PRESS), how
 * the wait ended and the value (RUN_UNTIL, a PRESS that waits), or how
 * the list ended and on which step (STEPS). */
enum cmd_job_answer
{
   CMD_ANSWER_LINE = 0,
   CMD_ANSWER_UNTIL,
   CMD_ANSWER_STEPS
};

/* The job in progress. One at a time: a second replaces the first,
 * which is answered with an error. A queued one has no request waiting
 * on it: how it stopped or failed is kept for the next queued STEPS. */
static struct
{
   command_deferred_t  deferred;
   struct command_step steps[2 * COMMAND_QUEUE_MAX];
   /* STEPS: end the list where any of them holds - a death, the level's
    * end */
   struct command_cond stops[COMMAND_STOPS_MAX];
   const char         *name;    /* whichever command owes the reply */
   unsigned            count;   /* steps; 0 when no job runs */
   unsigned            cur;     /* the step running */
   unsigned            left;    /* frames left in a RUN or PRESS step */
   unsigned            budget;  /* frames left for the whole job */
   unsigned            ran;     /* frames run so far */
   unsigned            value;   /* what the last condition read held */
   unsigned            port;    /* the player whose buttons are held */
   uint16_t            held;    /* the buttons the job let go of, by bit */
   uint8_t             answer;  /* enum cmd_job_answer */
   unsigned            nstops;
   unsigned            stopped; /* which stop held, from 1 */
   /* a frame with the buttons let go between two presses of the same
    * one, so the game sees two taps rather than one long press */
   bool                gap;
   /* what a press let go of on the frame boundary being crossed, and
    * whose: a press starting on the same boundary waits a frame, in
    * this job or the next request's, until a frame has run */
   uint16_t            let_go;
   unsigned            let_go_port;
   char                reply[256]; /* CMD_ANSWER_LINE: the line */
   bool                queued;
   /* how a queued list stopped, gave up or failed, as one PREVIOUS
    * line, until the next call that runs frames carries it */
   char                prev[192];
   /* the PREVIOUS line this job's answer carries */
   char                carry[192];
   /* queued: when it ran dry, and the content paused waiting for more */
   retro_time_t        dry_since;
} command_run_frames_st;

/* A PRESS step lets go of what it held, on its last frame or on
 * whatever ended it early; what SET_INPUT held stays held. */
static void command_run_frames_release(void)
{
   unsigned i;
   for (i = 0; i < 16; i++)
      if (command_run_frames_st.held & (1u << i))
         input_driver_command_hold(command_run_frames_st.port, i, 0);
   command_run_frames_st.held = 0;
}

/* Ends the job, answering no one. */
static void command_run_frames_finish(void)
{
   runloop_frame_work_set(RUNLOOP_WORK_RUN_FRAMES, false);
   command_run_frames_st.count = 0;
   command_run_frames_st.left  = 0;
   command_run_frames_release();
   /* a frame run without a job ends what the next one would carry */
   runloop_frame_work_set(RUNLOOP_WORK_FREE_FRAME,
         command_run_frames_st.let_go != 0);
}

/* Ends the job a request waits on: @first, the PREVIOUS line it
 * carries, the watches and @last, or where it failed @first, the
 * reason, and that line. */
static void command_run_frames_answer(const char *first, const char *last,
      bool is_error)
{
   /* the step's own line, then a line for each byte watched: room for
    * the longest reply and every watch */
   char   out[256 + sizeof(command_run_frames_st.carry)
      + COMMAND_WATCH_MAX * COMMAND_WATCH_LINE + 32];
   size_t _len = strlcpy(out, first, sizeof(out));

   if (_len >= sizeof(out))
      _len = sizeof(out) - 1;
   command_run_frames_finish();
   /* how the queued list before it ended, after its own first line */
   if (_len < sizeof(out))
      _len += strlcpy(out + _len, command_run_frames_st.carry,
            sizeof(out) - _len);
   command_run_frames_st.carry[0] = '\0';
   if (!is_error && _len < sizeof(out))
   {
      _len += command_watch_lines(out + _len, sizeof(out) - _len);
      if (last && _len < sizeof(out))
         _len += strlcpy(out + _len, last, sizeof(out) - _len);
   }
   if (_len >= sizeof(out))
      _len = sizeof(out) - 1;
   command_deferred_send(&command_run_frames_st.deferred, out, _len,
         is_error);
}

/* The step the job is on, from 1, as its list numbers it: the last
 * where all have run. */
static unsigned command_run_frames_step(void)
{
   return command_run_frames_st.steps[
      command_run_frames_st.cur < command_run_frames_st.count
      ? command_run_frames_st.cur : command_run_frames_st.count - 1].idx;
}

/* @how ("MET", "WAITING", "DONE", "STOPPED") and the frames run, as the
 * job's kind of answer gives it. */
static void command_run_frames_end(const char *how)
{
   char   first[48];
   char   last[48];
   size_t _len;
   /* a queue run dry pauses, with nothing to tell */
   if (command_run_frames_st.queued && string_is_equal(how, "DONE"))
   {
      command_run_frames_finish();
      command_run_frames_st.dry_since = cpu_features_get_time_usec();
      runloop_frame_work_set(RUNLOOP_WORK_FREE_FRAME, true);
      return;
   }
   /* nothing waits on a queued list: how it ended goes to the next call
    * that runs frames */
   if (command_run_frames_st.queued)
   {
      size_t n = (size_t)snprintf(command_run_frames_st.prev,
            sizeof(command_run_frames_st.prev), "PREVIOUS %s %u", how,
            command_run_frames_st.ran);
      if (string_is_equal(how, "STOPPED") && n < sizeof(command_run_frames_st.prev))
         n += (size_t)snprintf(command_run_frames_st.prev + n,
               sizeof(command_run_frames_st.prev) - n, " STOP %u",
               command_run_frames_st.stopped);
      if (n < sizeof(command_run_frames_st.prev))
         snprintf(command_run_frames_st.prev + n,
               sizeof(command_run_frames_st.prev) - n, " STEP %u\n",
               command_run_frames_step());
      command_run_frames_finish();
      return;
   }
   switch (command_run_frames_st.answer)
   {
      case CMD_ANSWER_UNTIL:
         snprintf(first, sizeof(first), "%s %u\n", how,
               command_run_frames_st.ran);
         snprintf(last, sizeof(last), "VALUE %u\n",
               command_run_frames_st.value);
         command_run_frames_answer(first, last, false);
         break;
      case CMD_ANSWER_STEPS:
         snprintf(first, sizeof(first), "%s %u\n", how,
               command_run_frames_st.ran);
         /* which stop held, where one did, then the step it ended on,
          * from 1: the last when all ran */
         _len = 0;
         if (string_is_equal(how, "STOPPED"))
            _len = (size_t)snprintf(last, sizeof(last), "STOP %u\n",
                  command_run_frames_st.stopped);
         snprintf(last + _len, sizeof(last) - _len, "STEP %u\n",
               command_run_frames_step());
         command_run_frames_answer(first, last, false);
         break;
      default:
         command_run_frames_answer(command_run_frames_st.reply, NULL,
               false);
         break;
   }
}

/* Ends the job on a failure, answered as the job answers; a queued
 * one's goes to the next call as a PREVIOUS ERROR line. */
void command_run_frames_cancel(const char *why)
{
   char msg[128];
   if (command_run_frames_st.queued)
   {
      snprintf(command_run_frames_st.prev,
            sizeof(command_run_frames_st.prev), "PREVIOUS ERROR %s\n", why);
      command_run_frames_finish();
      return;
   }
   snprintf(msg, sizeof(msg), "%s ERROR %s",
         command_run_frames_st.name ? command_run_frames_st.name
                                    : "RUN_FRAMES", why);
   command_run_frames_answer(msg, NULL, true);
}

/* A frame has run with no job: a press now is a fresh tap, and the
 * content is no longer sitting idle where a queue ran dry. */
void command_run_frames_free_frame(void)
{
   command_run_frames_st.let_go    = 0;
   command_run_frames_st.dry_since = 0;
   runloop_frame_work_set(RUNLOOP_WORK_FREE_FRAME, false);
}

const char *command_tools_refused(void)
{
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_in_game())
      return "achievements hardcore mode is on; the player can turn it off";
#endif
   return NULL;
}

#ifdef HAVE_THREADS
/* hardcore mode took effect on a task thread, as a game's achievements
 * finish loading: what it stops waits for the main thread's next frame */
static retro_atomic_int_t command_hardcore_due;
#endif

void command_hardcore_entered(void)
{
#ifdef HAVE_THREADS
   if (!task_is_on_main_thread())
   {
      retro_atomic_store_release_int(&command_hardcore_due, 1);
      return;
   }
#endif
   /* a queued job keeps why it ended, told once hardcore mode is off */
   if (runloop_state_get_ptr()->frame_work & RUNLOOP_WORK_RUN_FRAMES)
      command_run_frames_cancel("achievements hardcore mode is on");
   else
      command_run_frames_forget();
   input_driver_command_release(MAX_USERS);
}

void command_frame_start(void)
{
#ifdef HAVE_THREADS
   if (retro_atomic_exchange_int(&command_hardcore_due, 0))
      command_hardcore_entered();
#endif
#ifdef HAVE_MENU
   command_menu_closed();
#endif
}

void command_run_frames_forget(void)
{
   if (command_run_frames_st.prev[0])
      command_queue_ended = true;
   if (     command_run_frames_st.queued
         && (runloop_state_get_ptr()->frame_work & RUNLOOP_WORK_RUN_FRAMES))
   {
      command_run_frames_finish();
      command_queue_ended = true;
   }
   command_run_frames_st.prev[0] = '\0';
   command_run_frames_free_frame();
}

/* A PRESS step holds its buttons; what SET_INPUT already holds stays
 * held after it. */
static void command_run_frames_hold(const struct command_step *s)
{
   unsigned i;
   int16_t  analog[4];
   command_run_frames_st.port = s->port;
   command_run_frames_st.held = s->mask
      & (uint16_t)~input_driver_command_held(s->port, analog);
   for (i = 0; i < 16; i++)
      if (s->mask & (1u << i))
         input_driver_command_hold(s->port, i, 1);
}

/* Starts the step at cur and any after it that need no frame: a PRESS
 * holds its buttons, a condition that already holds is passed, stops
 * take over, and a checkpoint is kept where @safe says the core is off
 * the stack; otherwise it waits for command_run_frames_between().
 * Answers where that ends the job. */
static void command_run_frames_enter(bool safe)
{
   char     why[128];
   while (command_run_frames_st.cur < command_run_frames_st.count)
   {
      struct command_step *s =
         &command_run_frames_st.steps[command_run_frames_st.cur];
      if (s->kind == CMD_STEP_STOP)
      {
         /* stop 0 starts a queued list: none of the last one's stops,
          * and its own count of frames */
         if (!s->idx)
         {
            command_run_frames_st.nstops = 0;
            command_run_frames_st.ran    = 0;
         }
         else
         {
            command_run_frames_st.stops[s->idx - 1] = s->cond;
            command_run_frames_st.nstops            = s->idx;
         }
         command_run_frames_st.cur++;
         continue;
      }
      if (s->kind == CMD_STEP_CHECKPOINT)
      {
         if (!safe)
            return;
         if (!command_checkpoint_take())
         {
            command_run_frames_cancel("the core could not keep a "
                  "checkpoint");
            return;
         }
         command_run_frames_st.cur++;
         continue;
      }
      if (s->kind == CMD_STEP_UNTIL)
      {
         if (!command_cond_read(&s->cond, &command_run_frames_st.value,
                  why, sizeof(why)))
         {
            command_run_frames_cancel("nothing maps the address waited "
                  "on now");
            return;
         }
         if (!command_cond_met(&s->cond, command_run_frames_st.value))
         {
            /* a queued list has no request's limit, so each wait has
             * one of its own */
            command_run_frames_st.left = command_frames_default();
            return;
         }
         command_run_frames_st.cur++;
         continue;
      }
      command_run_frames_st.left = s->frames;
      if (s->kind == CMD_STEP_PRESS)
      {
         /* the same buttons let go on this boundary: a frame let go
          * first, whatever passed in between without one */
         if (     (s->mask & command_run_frames_st.let_go)
               && s->port == command_run_frames_st.let_go_port)
         {
            command_run_frames_st.gap = true;
            /* that frame is not the press's own */
            if (command_run_frames_st.budget)
               command_run_frames_st.budget++;
            return;
         }
         command_run_frames_hold(s);
      }
      return;
   }
   command_run_frames_end(command_run_frames_st.answer == CMD_ANSWER_STEPS
         ? "DONE" : "MET");
}

/* Replaces any job running with @steps, which @cmd asked for as @name,
 * and starts it: a condition that already holds is answered at once,
 * without a frame. @line is the answer of a CMD_ANSWER_LINE job. With
 * no @cmd it is queued: nothing waits on it. */
static void command_run_frames_start(command_t *cmd, const char *name,
      const struct command_step *steps, unsigned count, unsigned budget,
      uint8_t answer, const char *line)
{
   runloop_state_t *runloop_st = runloop_state_get_ptr();
   command_run_frames_st.carry[0] = '\0';
   if (     (runloop_st->frame_work & RUNLOOP_WORK_RUN_FRAMES)
         && command_run_frames_st.queued)
   {
      /* a queue still playing, which this request ends */
      snprintf(command_run_frames_st.carry,
            sizeof(command_run_frames_st.carry),
            "PREVIOUS REPLACED %u STEP %u\n", command_run_frames_st.ran,
            command_run_frames_step());
      command_run_frames_finish();
   }
   else if (runloop_st->frame_work & RUNLOOP_WORK_RUN_FRAMES)
   {
      char why[48];
      snprintf(why, sizeof(why), "replaced by %s%s",
            string_is_equal(name, "RUN_FRAMES") ? "another " : "", name);
      command_run_frames_cancel(why);
   }
   else if (cmd && command_run_frames_st.prev[0])
      /* how the last queued list ended, not yet told */
      strlcpy(command_run_frames_st.carry, command_run_frames_st.prev,
            sizeof(command_run_frames_st.carry));
   command_run_frames_st.prev[0] = '\0';
   memcpy(command_run_frames_st.steps, steps, count * sizeof(*steps));
   command_run_frames_st.nstops     = 0;
   command_run_frames_st.queued     = !cmd;
   command_run_frames_st.dry_since  = 0;
   strlcpy(command_run_frames_st.reply, line ? line : "",
         sizeof(command_run_frames_st.reply));
   command_run_frames_st.name   = name;
   command_run_frames_st.count  = count;
   command_run_frames_st.cur    = 0;
   command_run_frames_st.ran    = 0;
   command_run_frames_st.budget = budget;
   command_run_frames_st.answer = answer;
   command_run_frames_st.held   = 0;
   command_run_frames_st.gap    = false;
   if (cmd)
      command_deferred_take(&command_run_frames_st.deferred, cmd);
   runloop_frame_work_set(RUNLOOP_WORK_RUN_FRAMES, true);
   command_run_frames_enter(false);
}

/* Puts @steps behind those the queued job has left, or starts one with
 * them, which nothing waits on: the content plays on through them and
 * pauses once they have run. Room is the caller's to check. */
static void command_run_frames_queue(const struct command_step *steps,
      unsigned count)
{
   runloop_state_t *runloop_st = runloop_state_get_ptr();
   if (runloop_st->frame_work & RUNLOOP_WORK_RUN_FRAMES)
   {
      /* the steps already run make room */
      unsigned cur = command_run_frames_st.cur;
      memmove(command_run_frames_st.steps, command_run_frames_st.steps + cur,
            (command_run_frames_st.count - cur) * sizeof(*steps));
      command_run_frames_st.count -= cur;
      command_run_frames_st.cur    = 0;
      memcpy(command_run_frames_st.steps + command_run_frames_st.count,
            steps, count * sizeof(*steps));
      command_run_frames_st.count += count;
      return;
   }
   command_run_frames_start(NULL, "STEPS", steps, count, 0,
         CMD_ANSWER_STEPS, NULL);
}

void command_run_frames_between(void)
{
   if (     command_run_frames_st.cur < command_run_frames_st.count
         && command_run_frames_st.steps[command_run_frames_st.cur].kind
            == CMD_STEP_CHECKPOINT)
      command_run_frames_enter(true);
}

/* A frame has run: the step it belonged to goes on or ends, and the
 * reply goes once the last has, the list is stopped, or the frames
 * allowed have all run. */
void command_run_frames_tick(void)
{
   char                 why[128];
   unsigned             now = 0;
   unsigned             i;
   struct command_step *s;

   if (command_run_frames_st.cur >= command_run_frames_st.count)
      return;
   /* a frame has crossed the boundary a press let go on */
   command_run_frames_st.let_go = 0;
   command_run_frames_st.ran++;
   if (command_run_frames_st.budget)
      command_run_frames_st.budget--;
   for (i = 0; i < command_run_frames_st.nstops; i++)
   {
      if (!command_cond_read(&command_run_frames_st.stops[i], &now, why,
               sizeof(why)))
      {
         command_run_frames_cancel("nothing maps the stop address now");
         return;
      }
      if (command_cond_met(&command_run_frames_st.stops[i], now))
      {
         command_run_frames_st.stopped = i + 1;
         command_run_frames_end("STOPPED");
         return;
      }
   }
   s = &command_run_frames_st.steps[command_run_frames_st.cur];
   if (command_run_frames_st.gap)
   {
      /* that was the frame let go: the press starts now */
      command_run_frames_st.gap = false;
      command_run_frames_hold(s);
   }
   else if (s->kind == CMD_STEP_CHECKPOINT)
      /* a job started while that frame ran */
      command_run_frames_enter(true);
   else if (s->kind == CMD_STEP_UNTIL)
   {
      if (!command_cond_read(&s->cond, &command_run_frames_st.value, why,
               sizeof(why)))
      {
         command_run_frames_cancel("nothing maps the address waited on "
               "now");
         return;
      }
      if (command_cond_met(&s->cond, command_run_frames_st.value))
      {
         command_run_frames_st.cur++;
         command_run_frames_enter(true);
      }
      else if (command_run_frames_st.queued && !--command_run_frames_st.left)
      {
         command_run_frames_end("WAITING");
         return;
      }
   }
   else if (!--command_run_frames_st.left)
   {
      /* only what it let go: a button SET_INPUT holds stays down, and
       * a press of it needs no frame between */
      if (s->kind == CMD_STEP_PRESS)
      {
         command_run_frames_st.let_go      = command_run_frames_st.held;
         command_run_frames_st.let_go_port = s->port;
      }
      command_run_frames_release();
      command_run_frames_st.cur++;
      command_run_frames_enter(true);
   }
   /* the frames allowed have run with a step still going: how far it
    * got, so the next request carries on from there */
   if (     command_run_frames_st.count && !command_run_frames_st.budget
         && !command_run_frames_st.queued)
      command_run_frames_end("WAITING");
}

/* What a command needs before it can run a frame of content: content
 * to run, no menu over it, and achievements not in hardcore mode.
 * False with the reason answered to @cmd. */
static bool command_frames_ready(command_t *cmd, const char *name)
{
   runloop_state_t *runloop_st = runloop_state_get_ptr();
#ifdef HAVE_MENU
   struct menu_state *menu_st  = menu_state_get_ptr();
#endif

   if (!(runloop_st->flags & RUNLOOP_FLAG_CORE_RUNNING))
   {
      command_reply_error(cmd, name, "no content is running");
      return false;
   }
#ifdef HAVE_MENU
   if (menu_st && (menu_st->flags & MENU_ST_FLAG_ALIVE))
   {
      command_reply_error(cmd, name, "the menu is open");
      return false;
   }
#endif
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
   {
      command_reply_error(cmd, name,
            "achievements hardcore mode forbids frame advance");
      return false;
   }
#endif
   return true;
}

/* About nine seconds of the content's own frames, at most
 * COMMAND_FRAMES_REPLY_MAX: a structured reply comes inside its
 * ten-second deadline at any frame rate, and a wait runs this long when
 * not told. */
static unsigned command_frames_default(void)
{
   double fps = video_state_get_ptr()->av_info.timing.fps;
   if (fps > 0.0 && fps * 9.0 < (double)COMMAND_FRAMES_REPLY_MAX)
      return fps * 9.0 >= 1.0 ? (unsigned)(fps * 9.0) : 1;
   return COMMAND_FRAMES_REPLY_MAX;
}

/* The most frames one request runs for @cmd */
static unsigned command_frames_reply_max(const command_t *cmd)
{
   return cmd->structured ? command_frames_default()
                          : COMMAND_FRAMES_REPLY_MAX;
}

/* RUN_FRAMES <count>
 *
 * Pauses, if the content is running, and runs it @count frames,
 * answered once the last has run; it stays paused. Another RUN_FRAMES
 * replaces one still running, which is answered with an error. */
bool command_run_frames(command_t *cmd, const char *arg)
{
   char                line[48];
   struct command_step step;
   unsigned            n   = 0;
   /* over MCP no more than the reply is waited for, refused now rather
    * than failed with the frames already running */
   unsigned            max = cmd->structured
      ? command_frames_reply_max(cmd) : COMMAND_RUN_FRAMES_MAX;

   if (!command_arg_uint(arg, &n) || n < 1 || n > max)
   {
      command_reply_error(cmd, "RUN_FRAMES", "a frame count from 1 to %u%s",
            max, cmd->structured ? "; ask again to run more" : "");
      return false;
   }
   if (!command_frames_ready(cmd, "RUN_FRAMES"))
      return false;

   memset(&step, 0, sizeof(step));
   step.kind   = CMD_STEP_RUN;
   step.frames = n;
   snprintf(line, sizeof(line), "RUN_FRAMES %u\n", n);
   command_run_frames_start(cmd, "RUN_FRAMES", &step, 1, n,
         CMD_ANSWER_LINE, line);
   return true;
}

/* RetroPad controls by the names SET_INPUT takes them by: the sixteen
 * buttons in RETRO_DEVICE_ID_JOYPAD order, then the four stick axes. */
static const char *const command_input_names[] = {
   "b", "y", "select", "start", "up", "down", "left", "right",
   "a", "x", "l", "r", "l2", "r2", "l3", "r3",
   "left_x", "left_y", "right_x", "right_y"
};

/* @port's held controls, the shape SET_INPUT and RELEASE_INPUT answer
 * with: the player, then the buttons and the axes held, tab separated,
 * "none" for either when there are none. */
static size_t command_input_line(unsigned port, char *s, size_t len)
{
   unsigned i;
   int16_t  analog[4];
   uint16_t buttons = input_driver_command_held(port, analog);
   size_t   _len  = (size_t)snprintf(s, len, "%u\t", port + 1);
   bool     any   = false;

   for (i = 0; i < 16 && _len < len; i++)
      if (buttons & (1u << i))
      {
         _len += (size_t)snprintf(s + _len, len - _len, "%s%s",
               any ? " " : "", command_input_names[i]);
         any   = true;
      }
   if (!any && _len < len)
      _len += strlcpy(s + _len, "none", len - _len);
   if (_len < len)
      s[_len++] = '\t';
   any = false;
   for (i = 0; i < 4 && _len < len; i++)
      if (analog[i])
      {
         _len += (size_t)snprintf(s + _len, len - _len, "%s%s=%d",
               any ? " " : "", command_input_names[16 + i],
               (int)analog[i]);
         any   = true;
      }
   if (!any && _len < len)
      _len += strlcpy(s + _len, "none", len - _len);
   if (_len + 1 >= len)
      _len = len - 2;
   s[_len++] = '\n';
   s[_len]   = '\0';
   return _len;
}

/* SET_INPUT <player> <control> <value>
 *
 * Holds a RetroPad button (1, or 0 to let it go) or a stick axis
 * (-32768 to 32767, 0 to let it go) for the core, over the player's own
 * input, until it is set again or RELEASE_INPUT lets it go.
 *
 * Held as the game is to see it: SOCD cleaning and D-Pad rotation are
 * for a person's hands on a pad and are not applied. Under netplay the
 * player is this machine's local device, sampled with its input and
 * sent to the others, so every peer runs the same frames. */
/* "<player> <control>[+<control>...] <number>", the request SET_INPUT
 * and PRESS both take: the player in @player, the controls in @ids and
 * how many of them in @count, and the number in @number. False with the
 * reason answered to @cmd, naming @what - what that command's own
 * number is - and @name.
 *
 * Several controls at once, joined by "+", so a combination a game
 * wants together - right+a to run and jump - is one request and one
 * frame rather than two of each. Every one is resolved before the
 * caller acts on any, so a combination with something wrong in it does
 * nothing at all. */
static bool command_input_args(command_t *cmd, const char *name,
      const char *what, const char *arg, unsigned *player,
      unsigned *ids, unsigned *count, long *number)
{
   char   control[160];
   unsigned i;
   char  *end                     = NULL;
   char  *tok;
   const char *sp;
   unsigned long v                = 0;

   *count = 0;
   while (arg && *arg == ' ')
      arg++;
   /* range-checked before narrowing: 4294967297 is not player 1 */
   if (arg && *arg >= '0' && *arg <= '9')
      v = strtoul(arg, &end, 10);
   *player = v <= MAX_USERS ? (unsigned)v : 0;
   if (!end || end == arg || *end != ' ' || *player < 1)
   {
      command_reply_error(cmd, name,
            "a player from 1 to %u, a control and %s",
            (unsigned)MAX_USERS, what);
      return false;
   }
   while (*end == ' ')
      end++;
   if (!(sp = strchr(end, ' ')) || (size_t)(sp - end) >= sizeof(control))
   {
      command_reply_error(cmd, name, "a control and %s", what);
      return false;
   }
   memcpy(control, end, (size_t)(sp - end));
   control[sp - end] = '\0';
   *number = strtol(sp + 1, &end, 10);
   if (end == sp + 1 || *end)
   {
      command_reply_error(cmd, name, "%s after the control", what);
      return false;
   }
   for (tok = control; *tok; )
   {
      char *plus = strchr(tok, '+');
      if (plus)
         *plus = '\0';
      if (!*tok)
      {
         /* "a++b", and a "+" at either end: nothing between them */
         tok = plus + 1;
         continue;
      }
      for (i = 0; i < ARRAY_SIZE(command_input_names); i++)
         if (string_is_equal(tok, command_input_names[i]))
            break;
      if (i == ARRAY_SIZE(command_input_names))
      {
         command_reply_error(cmd, name, "no control named %s", tok);
         return false;
      }
      /* a control named over and over would run past the array */
      if (*count >= ARRAY_SIZE(command_input_names))
      {
         command_reply_error(cmd, name, "at most %u controls at once",
               (unsigned)ARRAY_SIZE(command_input_names));
         return false;
      }
      ids[(*count)++] = i;
      if (!plus)
         break;
      tok = plus + 1;
   }
   if (!*count)
   {
      command_reply_error(cmd, name, "a control, or several "
            "joined by \"+\"");
      return false;
   }
   return true;
}

bool command_set_input(command_t *cmd, const char *arg)
{
   char   reply[192];
   unsigned ids[ARRAY_SIZE(command_input_names)];
   unsigned count                 = 0;
   unsigned player;
   unsigned i;
   long   value;

   if (!command_input_args(cmd, "SET_INPUT", "a value", arg, &player,
            ids, &count, &value))
      return false;
   for (i = 0; i < count; i++)
   {
      unsigned id = ids[i];
      if (     (id <  16 && value != 0 && value != 1)
            || (id >= 16 && (value < -32768 || value > 32767)))
      {
         command_reply_error(cmd, "SET_INPUT", id < 16
               ? "%s takes 1 to hold it or 0 to let it go"
               : "%s takes -32768 to 32767", command_input_names[id]);
         return false;
      }
   }
#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
   {
      command_reply_error(cmd, "SET_INPUT",
            "achievements hardcore mode forbids input from a command");
      return false;
   }
#endif

   for (i = 0; i < count; i++)
      input_driver_command_hold(player - 1, ids[i], (int16_t)value);

   cmd->replier(cmd, reply,
         command_input_line(player - 1, reply, sizeof(reply)));
   return true;
}


/* WATCH [<label> <address|off>]...
 *
 * With nothing, what is watched now. Each label and address watches the
 * byte there under that label, carried by RUN_FRAMES, PRESS and
 * RUN_UNTIL; a label and "off" stops watching it. Every pair is taken
 * or none is, so a refusal leaves the list as it was.
 *
 * Answers with the list either way, so a client sees what it has. */
bool command_watch(command_t *cmd, const char *arg)
{
   struct command_watch_entry next[COMMAND_WATCH_MAX];
   char      reply[64 + COMMAND_WATCH_MAX * COMMAND_WATCH_LINE];
   char      label[sizeof(next[0].label)];
   char      reason[128];
   size_t    _len  = 0;
   size_t    n;
   unsigned  count = command_watch_count;
   unsigned  i;
   const char *sp;

   memcpy(next, command_watches, sizeof(next));
   while (arg && *arg)
   {
      while (*arg == ' ')
         arg++;
      if (!*arg)
         break;
      /* a tab or a newline would split the label's row */
      for (sp = arg; (unsigned char)*sp > ' '; sp++)
         ;
      if ((*sp && *sp != ' ') || (size_t)(sp - arg) >= sizeof(label))
      {
         command_reply_error(cmd, "WATCH", "a label of up to %u "
               "characters, then an address or \"off\"",
               (unsigned)(sizeof(label) - 1));
         return false;
      }
      memcpy(label, arg, (size_t)(sp - arg));
      label[sp - arg] = '\0';
      while (*sp == ' ')
         sp++;
      if (!*sp)
      {
         command_reply_error(cmd, "WATCH", "%s needs an address or "
               "\"off\" after it", label);
         return false;
      }
      for (arg = sp; (unsigned char)*arg > ' '; arg++)
         ;
      n = (size_t)(arg - sp);
      /* a label already watched keeps its place in the list, so the
       * rows a client reads stay where they were */
      for (i = 0; i < count; i++)
         if (string_is_equal(next[i].label, label))
            break;
      if (n == STRLEN_CONST("off") && !strncmp(sp, "off", n))
      {
         if (i < count)
         {
            memmove(&next[i], &next[i + 1],
                  (count - i - 1) * sizeof(*next));
            count--;
         }
      }
      else
      {
         struct command_cond where;
         unsigned  now = 0;
         char     *end = NULL;
         memset(&where, 0, sizeof(where));
         /* high:low, two bytes as one value, as conditions take them */
         if (     command_cond_address(sp, &where, &end) || end != arg
               || (*arg && *arg != ' '))
         {
            command_reply_error(cmd, "WATCH", "a hexadecimal address, or "
                  "\"off\" to stop watching %s", label);
            return false;
         }
         /* only a label that is not watched yet needs room */
         if (i == count && count >= COMMAND_WATCH_MAX)
         {
            command_reply_error(cmd, "WATCH", "at most %u bytes watched "
                  "at once", (unsigned)COMMAND_WATCH_MAX);
            return false;
         }
         /* found now, as RUN_UNTIL finds the byte it waits on, so an
          * address nothing maps is refused rather than read later */
         if (!command_cond_read(&where, &now, reason, sizeof(reason)))
         {
            command_reply_error(cmd, "WATCH", "%s: %s", label,
                  command_memory_why(reason));
            return false;
         }
         if (i == count)
            count++;
         next[i].where = where;
         strlcpy(next[i].label, label, sizeof(next[i].label));
      }
   }
   memcpy(command_watches, next, sizeof(next));
   command_watch_count = count;

   _len = command_watch_lines(reply, sizeof(reply));
   if (!_len)
      _len = strlcpy_lit(reply, "WATCH none\n", sizeof(reply));
   cmd->replier(cmd, reply, _len);
   return true;
}

/* RUN_UNTIL <address> <condition> <value> [max frames]
 *
 * Runs the content until the byte at a system address meets what was
 * asked, then answers with how many frames that took and the value it
 * found. Where a client would otherwise run a few frames, read the
 * byte, and go round again - which is where a field run spent most of
 * its calls - this is one request.
 *
 * It waits no longer than a reply is waited for. At the cap it answers
 * WAITING with the frames it ran, so the next request carries on from
 * there rather than the client being told it failed. */
bool command_run_until(command_t *cmd, const char *arg)
{
   char                why[160];
   struct command_step step;
   unsigned            frames = 0;
   char               *end    = NULL;
   unsigned long       num;

   memset(&step, 0, sizeof(step));
   if (!command_cond_parse(arg, &step.cond, &end, why, sizeof(why)))
   {
      command_reply_error(cmd, "RUN_UNTIL", "%s", why);
      return false;
   }
   if (*end == ' ')
   {
      while (*end == ' ')
         end++;
      if (*end)
      {
         num = strtoul(end, &end, 10);
         if (num < 1 || num > command_frames_reply_max(cmd))
         {
            command_reply_error(cmd, "RUN_UNTIL", "at most %u frames "
                  "to wait, which is as long as a reply is waited for",
                  command_frames_reply_max(cmd));
            return false;
         }
         frames = (unsigned)num;
      }
   }
   if (*end)
   {
      command_reply_error(cmd, "RUN_UNTIL", "nothing after the frames "
            "to wait");
      return false;
   }
   if (!command_frames_ready(cmd, "RUN_UNTIL"))
      return false;
   /* the memory is found before any frame runs, so an address nothing
    * maps is answered now rather than after a wait that could not have
    * ended */
   if (!command_cond_mapped(cmd, "RUN_UNTIL", &step.cond))
      return false;
   step.kind = CMD_STEP_UNTIL;
   command_run_frames_start(cmd, "RUN_UNTIL", &step, 1,
         frames ? frames : command_frames_default(), CMD_ANSWER_UNTIL,
         NULL);
   return true;
}

/* PRESS <player> <control>[+<control>...] <frames>
 *
 * Holds the buttons, runs that many frames and lets them go, answered
 * once the last of them has run. One request where a tap took four:
 * SET_INPUT, RUN_FRAMES, SET_INPUT to release and RUN_FRAMES again.
 * Axes are SET_INPUT's: they are held at a value, not pressed. */
bool command_press(command_t *cmd, const char *arg)
{
   char     line[256];
   char     reply[256];
   char     why[160];
   unsigned ids[ARRAY_SIZE(command_input_names)];
   unsigned count              = 0;
   unsigned player;
   unsigned i;
   unsigned budget;
   size_t   _len;
   long     frames;
   char    *until;
   struct command_step steps[2];

   if (strlcpy(line, arg ? arg : "", sizeof(line)) >= sizeof(line))
   {
      command_reply_error(cmd, "PRESS", "at most %u characters",
            (unsigned)sizeof(line) - 1);
      return false;
   }
   memset(steps, 0, sizeof(steps));
   /* "<frames> until <condition>": run on after the press until the
    * condition holds - jump, then land - in the same request */
   if ((until = strstr(line, " until ")))
   {
      char *end = NULL;
      *until    = '\0';
      until    += STRLEN_CONST(" until ");
      if (!command_cond_parse(until, &steps[1].cond, &end, why,
               sizeof(why)))
      {
         command_reply_error(cmd, "PRESS", "%s after until", why);
         return false;
      }
      while (*end == ' ')
         end++;
      if (*end)
      {
         command_reply_error(cmd, "PRESS", "nothing after the condition");
         return false;
      }
   }
   if (!command_input_args(cmd, "PRESS", "a frame count", line, &player,
            ids, &count, &frames))
      return false;
   if (frames < 1 || frames > (long)command_frames_reply_max(cmd))
   {
      command_reply_error(cmd, "PRESS", "a frame count from 1 to %u; a "
            "longer hold is INPUT set with RUN_FRAMES",
            command_frames_reply_max(cmd));
      return false;
   }
   for (i = 0; i < count; i++)
      if (ids[i] >= 16)
      {
         command_reply_error(cmd, "PRESS",
               "%s is an axis, which INPUT set holds at a value",
               command_input_names[ids[i]]);
         return false;
      }
   if (!command_frames_ready(cmd, "PRESS"))
      return false;
   if (until && !command_cond_mapped(cmd, "PRESS", &steps[1].cond))
      return false;

   steps[0].kind   = CMD_STEP_PRESS;
   steps[0].frames = (unsigned)frames;
   steps[0].port   = player - 1;
   for (i = 0; i < count; i++)
      steps[0].mask |= (uint16_t)(1u << ids[i]);
   steps[1].kind   = CMD_STEP_UNTIL;
   /* the controls as they were resolved, so "a++b" comes back "a+b" */
   _len = (size_t)snprintf(reply, sizeof(reply), "PRESS %u ", player);
   for (i = 0; i < count && _len < sizeof(reply); i++)
      _len += (size_t)snprintf(reply + _len, sizeof(reply) - _len, "%s%s",
            i ? "+" : "", command_input_names[ids[i]]);
   if (_len < sizeof(reply))
      snprintf(reply + _len, sizeof(reply) - _len, " %u\n",
            (unsigned)frames);
   /* the wait gets what a wait gets, and the press at least its own */
   budget = command_frames_default();
   if (budget < (unsigned)frames)
      budget = (unsigned)frames;
   command_run_frames_start(cmd, "PRESS", steps, until ? 2 : 1,
         until ? budget : (unsigned)frames,
         until ? CMD_ANSWER_UNTIL : CMD_ANSWER_LINE, reply);
   return true;
}

/* How long, in milliseconds, the content has sat paused since a queue
 * ran dry; -1 while it runs, or when it stopped for another reason. */
static long command_steps_idle(void)
{
   if (     !command_run_frames_st.dry_since
         || (runloop_state_get_ptr()->frame_work & RUNLOOP_WORK_RUN_FRAMES))
      return -1;
   return (long)((cpu_features_get_time_usec()
            - command_run_frames_st.dry_since) / 1000);
}

/* The answer of a queued STEPS: how many steps are left to run, or,
 * where the last queued list stopped, gave up or failed, how many of
 * this call's @discarded steps were dropped rather than played on from
 * that, and its PREVIOUS line; what WATCH watches; and how long the
 * content sat idle, run dry, before @idle says these came. */
static void command_steps_report(command_t *cmd, long idle,
      unsigned discarded)
{
   char     out[64 + sizeof(command_run_frames_st.prev)
      + COMMAND_WATCH_MAX * COMMAND_WATCH_LINE];
   size_t   _len;
   unsigned i;
   unsigned left = 0;
   if (command_run_frames_st.prev[0])
   {
      _len = discarded
         ? (size_t)snprintf(out, sizeof(out), "DISCARDED %u\n", discarded)
         : strlcpy(out, "QUEUED 0\n", sizeof(out));
      _len += strlcpy(out + _len, command_run_frames_st.prev,
            sizeof(out) - _len);
      command_run_frames_st.prev[0] = '\0';
      idle = -1;
   }
   else
   {
      for (i = command_run_frames_st.cur; i < command_run_frames_st.count;
            i++)
         if (command_run_frames_st.steps[i].kind != CMD_STEP_STOP)
            left++;
      _len = (size_t)snprintf(out, sizeof(out), "QUEUED %u\n", left);
   }
   if (_len < sizeof(out))
      _len += command_watch_lines(out + _len, sizeof(out) - _len);
   if (idle >= 0 && _len < sizeof(out))
      _len += (size_t)snprintf(out + _len, sizeof(out) - _len,
            "IDLE %ld\n", idle);
   if (_len >= sizeof(out))
      _len = sizeof(out) - 1;
   cmd->replier(cmd, out, _len);
}

/* STEPS <step>[; <step>...][|on]
 *
 * Runs a stretch of play as one request: "run <frames>", "press
 * <player> <controls> <frames>" and "until <condition>", in order, then
 * answers with how it ended and what WATCH watches. A "stop
 * <condition>" entry ends the list after any frame where it holds, so a
 * death does not play out the rest, and "checkpoint" keeps the state
 * STATE rollback returns to. The whole list runs no longer than a wait
 * does; past that it answers WAITING and the step it was on, and the
 * next request carries on from there.
 *
 * With on, it answers at once and the steps go behind those still
 * queued, so the content plays on while the next stretch is planned,
 * and pauses once they have all run. A stop or a failure since the last
 * queued STEPS is answered instead, and its steps are dropped; with no
 * steps it only asks. */
bool command_steps(command_t *cmd, const char *arg)
{
   char                list[1024];
   char                why[160];
   /* the stops go ahead of the steps, in the slots left before them,
    * and a queued list's marker ahead of those */
   struct command_step steps[1 + COMMAND_STOPS_MAX + COMMAND_STEPS_MAX];
   struct command_step *first = steps + 1 + COMMAND_STOPS_MAX;
   struct command_cond stops[COMMAND_STOPS_MAX];
   unsigned            ids[ARRAY_SIZE(command_input_names)];
   unsigned            count    = 0;
   unsigned            frames   = 0;
   unsigned            fixed    = 0;
   unsigned            budget;
   unsigned            i;
   unsigned            nstops   = 0;
   long                idle;
   bool                queue    = false;
   char               *entry;
   char               *next;
   char               *bar;

   if (!arg || strlcpy(list, arg, sizeof(list)) >= sizeof(list))
   {
      command_reply_error(cmd, "STEPS", "steps separated by \";\", in at "
            "most %u characters", (unsigned)sizeof(list) - 1);
      return false;
   }
   if ((bar = strrchr(list, '|')))
   {
      char *v = bar + 1;
      *bar    = '\0';
      while (*v == ' ')
         v++;
      if (string_is_equal(v, "on"))
         queue = true;
      else if (!string_is_equal(v, "off"))
      {
         command_reply_error(cmd, "STEPS", "on or off after the \"|\"");
         return false;
      }
   }
   memset(steps, 0, sizeof(steps));
   memset(stops, 0, sizeof(stops));
   budget = command_frames_default();
   for (entry = list; entry; entry = next)
   {
      struct command_step *s;
      struct command_cond *c   = NULL;
      char                *end = NULL;
      size_t               n;
      if ((next = strchr(entry, ';')))
         *next++ = '\0';
      while (*entry == ' ')
         entry++;
      for (n = strlen(entry); n && entry[n - 1] == ' '; n--)
         entry[n - 1] = '\0';
      if (!*entry)
         continue;
      /* a queued list is not one request's wait: only each step is */
      if (queue)
         fixed = 0;
      if (!strncmp(entry, "stop ", 5))
      {
         if (nstops >= COMMAND_STOPS_MAX)
         {
            command_reply_error(cmd, "STEPS", "at most %u stops",
                  (unsigned)COMMAND_STOPS_MAX);
            return false;
         }
         c      = &stops[nstops++];
         entry += 5;
      }
      else if (count >= COMMAND_STEPS_MAX)
      {
         command_reply_error(cmd, "STEPS", "at most %u steps",
               (unsigned)COMMAND_STEPS_MAX);
         return false;
      }
      else
      {
         s      = &first[count++];
         s->idx = (uint8_t)count;
         if (string_is_equal(entry, "checkpoint"))
         {
            if (!core_info_current_supports_savestate())
            {
               command_reply_error(cmd, "STEPS", "step %u: this core "
                     "cannot save a state", count);
               return false;
            }
            s->kind = CMD_STEP_CHECKPOINT;
         }
         else if (!strncmp(entry, "until ", 6))
         {
            s->kind = CMD_STEP_UNTIL;
            c       = &s->cond;
            entry  += 6;
            frames++;
         }
         else if (!strncmp(entry, "run ", 4))
         {
            s->kind = CMD_STEP_RUN;
            if (     !command_arg_uint(entry + 4, &s->frames)
                  || s->frames < 1 || s->frames > budget - fixed)
            {
               command_reply_error(cmd, "STEPS", "step %u: run a frame "
                     "count from 1, within the %u frames one request runs",
                     count, budget);
               return false;
            }
            fixed += s->frames;
            frames++;
         }
         else if (!strncmp(entry, "press ", 6))
         {
            const struct command_step *prev = s;
            unsigned player;
            unsigned nids;
            long     held;
            if (!command_input_args(cmd, "STEPS", "a frame count",
                     entry + 6, &player, ids, &nids, &held))
               return false;
            for (i = 0; i < nids; i++)
            {
               if (ids[i] >= 16)
               {
                  command_reply_error(cmd, "STEPS", "step %u: %s is an "
                        "axis, which INPUT set holds at a value", count,
                        command_input_names[ids[i]]);
                  return false;
               }
               s->mask |= (uint16_t)(1u << ids[i]);
            }
            /* a tap of what the press before it held runs a frame let go
             * first, as command_run_frames_tick does, a checkpoint
             * between them or not */
            while (prev > first && (prev - 1)->kind == CMD_STEP_CHECKPOINT)
               prev--;
            if (     prev > first && (prev - 1)->kind == CMD_STEP_PRESS
                  && (prev - 1)->port == player - 1
                  && ((prev - 1)->mask & s->mask))
               fixed++;
            if (     fixed > budget || held < 1
                  || (unsigned long)held > budget - fixed)
            {
               command_reply_error(cmd, "STEPS", "step %u: press for a "
                     "frame count from 1, within the %u frames one request "
                     "runs", count, budget);
               return false;
            }
            s->kind   = CMD_STEP_PRESS;
            s->port   = player - 1;
            s->frames = (unsigned)held;
            fixed    += s->frames;
            frames++;
         }
         else
         {
            command_reply_error(cmd, "STEPS", "step %u: run, press, until, "
                  "checkpoint or stop, not %s", count, entry);
            return false;
         }
      }
      if (c)
      {
         if (!command_cond_parse(entry, c, &end, why, sizeof(why)))
         {
            command_reply_error(cmd, "STEPS", "%s", why);
            return false;
         }
         while (*end == ' ')
            end++;
         if (*end)
         {
            command_reply_error(cmd, "STEPS", "nothing after a condition "
                  "but \";\"");
            return false;
         }
      }
   }
   /* the stops, numbered, just ahead of the steps */
   for (i = 0; i < nstops; i++)
   {
      struct command_step *s = first - nstops + i;
      s->cond = stops[i];
      s->kind = CMD_STEP_STOP;
      s->idx  = (uint8_t)(i + 1);
   }
   if (queue && !count && !nstops)
   {
      command_steps_report(cmd, command_steps_idle(), 0);
      return true;
   }
   if (!frames)
   {
      command_reply_error(cmd, "STEPS", "a step at least: run, press or "
            "until");
      return false;
   }
   if (!command_frames_ready(cmd, "STEPS"))
      return false;
   for (i = 0; i < count; i++)
      if (     first[i].kind == CMD_STEP_UNTIL
            && !command_cond_mapped(cmd, "STEPS", &first[i].cond))
         return false;
   for (i = 0; i < nstops; i++)
      if (!command_cond_mapped(cmd, "STEPS", &stops[i]))
         return false;
   if (!queue)
   {
      command_run_frames_start(cmd, "STEPS", first - nstops,
            nstops + count, budget, CMD_ANSWER_STEPS, NULL);
      return true;
   }
   if (runloop_state_get_ptr()->frame_work & RUNLOOP_WORK_RUN_FRAMES)
   {
      unsigned queued = nstops + count;
      if (!command_run_frames_st.queued)
      {
         command_reply_error(cmd, "STEPS", "a request waits on the steps "
               "running; queue once it is answered");
         return false;
      }
      for (i = command_run_frames_st.cur; i < command_run_frames_st.count; i++)
         if (     command_run_frames_st.steps[i].kind != CMD_STEP_STOP
               || command_run_frames_st.steps[i].idx)
            queued++;
      if (queued > COMMAND_QUEUE_MAX)
      {
         command_reply_error(cmd, "STEPS", "the queue is full: %u steps "
               "and stops at most, queued and running",
               (unsigned)COMMAND_QUEUE_MAX);
         return false;
      }
   }
   /* a stop the client has not heard about: told now, and these not
    * played on from a death */
   idle = command_steps_idle();
   /* stop 0 marks where the list starts, so it runs with its own stops
    * and counts its own frames (memset left its kind and idx) */
   first[-(int)nstops - 1].kind = CMD_STEP_STOP;
   if (!command_run_frames_st.prev[0])
      command_run_frames_queue(first - nstops - 1, 1 + nstops + count);
   command_steps_report(cmd, idle, count);
   return true;
}

/* GET_INPUT [player]
 *
 * What the player holds, without changing it. SET_INPUT answers in the
 * same shape but has to set something first, and RELEASE_INPUT lets go
 * before it answers, so neither can be used to look. */
bool command_get_input(command_t *cmd, const char *arg)
{
   char     reply[192];
   unsigned player = 1;

   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg && (!command_arg_uint(arg, &player)
            || player < 1 || player > MAX_USERS))
   {
      command_reply_error(cmd, "GET_INPUT",
            "a player from 1 to %u, or nothing for the first",
            (unsigned)MAX_USERS);
      return false;
   }
   cmd->replier(cmd, reply,
         command_input_line(player - 1, reply, sizeof(reply)));
   return true;
}

/* RELEASE_INPUT [player]
 *
 * Lets go of everything SET_INPUT holds for the player, or for every
 * player. */
bool command_release_input(command_t *cmd, const char *arg)
{
   char   reply[192];
   unsigned player                = 0;

   while (arg && *arg == ' ')
      arg++;
   if (arg && *arg)
   {
      if (!command_arg_uint(arg, &player) || player < 1 || player > MAX_USERS)
      {
         command_reply_error(cmd, "RELEASE_INPUT",
               "a player from 1 to %u, or nothing for every player",
               (unsigned)MAX_USERS);
         return false;
      }
   }
   input_driver_command_release(player ? player - 1 : MAX_USERS);

   cmd->replier(cmd, reply,
         command_input_line(player ? player - 1 : 0, reply, sizeof(reply)));
   return true;
}

/* The core option @key, or false with the reason replied. */
static bool command_core_option_find(command_t *cmd, const char *name,
      const char *key, core_option_manager_t **opt, size_t *idx)
{
   runloop_state_t *runloop_st = runloop_state_get_ptr();

   if (!(runloop_get_flags() & RUNLOOP_FLAG_CORE_RUNNING))
   {
      command_reply_error(cmd, name, "no core is running: LOAD_CONTENT or "
            "CORE start starts one");
      return false;
   }
   if (!(*opt = runloop_st ? runloop_st->core_options : NULL) || !(*opt)->size)
   {
      command_reply_error(cmd, name, "the running core has no options");
      return false;
   }
   if (key && !core_option_manager_get_idx(*opt, key, idx))
   {
      command_reply_error(cmd, name,
            "no such core option %s; CORE_OPTION show lists them", key);
      return false;
   }
   return true;
}

/* @opt's line: key, value and description, tab separated, and its
 * values after a tab when @values. Returns what it wrote, or 0 when
 * that did not fit @len. */
static size_t command_core_option_line(const struct core_option *opt,
      char *s, size_t len, bool values)
{
   size_t i;
   size_t _len;
   int    n = snprintf(s, len, "%s\t%s\t%s", opt->key,
         opt->vals && opt->index < opt->vals->size
         ? opt->vals->elems[opt->index].data : "",
         opt->desc ? opt->desc : "");

   if (n < 0 || (size_t)n >= len)
      return 0;
   _len = (size_t)n;
   if (values && opt->vals)
      for (i = 0; i < opt->vals->size; i++)
      {
         n = snprintf(s + _len, len - _len, "%s%s", i ? "|" : "\t",
               opt->vals->elems[i].data);
         if (n < 0 || (size_t)n >= len - _len)
            return 0;
         _len += (size_t)n;
      }
   if (_len + 1 >= len)
      return 0;
   s[_len++] = '\n';
   s[_len]   = '\0';
   return _len;
}

/* GET_CORE_OPTION [key]
 *
 * Every option of the running core, one per line: key, value and
 * description, tab separated. With a key, that option's line alone,
 * with the values it takes after a further tab, separated by |. */
bool command_get_core_option(command_t *cmd, const char *arg)
{
   core_option_manager_t *opt = NULL;
   size_t idx                 = 0;
   size_t _len                = 0;
   size_t i;
   char  *reply;

   while (arg && *arg == ' ')
      arg++;
   if (!command_core_option_find(cmd, "GET_CORE_OPTION",
            arg && *arg ? arg : NULL, &opt, &idx))
      return false;
   if (!(reply = (char*)malloc(COMMAND_LIST_REPLY_MAX + 1)))
   {
      command_reply_error(cmd, "GET_CORE_OPTION", "out of memory");
      return false;
   }

   for (i = (arg && *arg) ? idx : 0; i < opt->size; i++)
   {
      size_t n = command_core_option_line(&opt->opts[i], reply + _len,
            COMMAND_LIST_REPLY_MAX + 1 - _len, arg && *arg);
      if (!n)
      {
         free(reply);
         command_reply_error(cmd, "GET_CORE_OPTION",
               "the options did not fit one reply, stopping at %s",
               opt->opts[i].key);
         return false;
      }
      _len += n;
      if (arg && *arg)
         break;
   }

   cmd->replier(cmd, reply, _len);
   free(reply);
   return true;
}

/* SET_CORE_OPTION <key> <value>
 *
 * The value is one GET_CORE_OPTION <key> lists. Asking for the value
 * the option already has changes nothing and succeeds. */
bool command_set_core_option(command_t *cmd, const char *arg)
{
   char   key[NAME_MAX_LENGTH];
   char   reply[NAME_MAX_LENGTH + PATH_MAX_LENGTH];
   core_option_manager_t *opt = NULL;
   const char *sp;
   size_t idx                 = 0;
   size_t val_idx             = 0;
   size_t _len;

   while (arg && *arg == ' ')
      arg++;
   if (!arg || !*arg || !(sp = strchr(arg, ' ')))
   {
      command_reply_error(cmd, "SET_CORE_OPTION",
            "a core option key and a value");
      return false;
   }
   if ((size_t)(sp - arg) >= sizeof(key))
   {
      command_reply_error(cmd, "SET_CORE_OPTION", "no such core option");
      return false;
   }
   memcpy(key, arg, (size_t)(sp - arg));
   key[sp - arg] = '\0';
   while (*sp == ' ')
      sp++;

   if (!command_core_option_find(cmd, "SET_CORE_OPTION", key, &opt, &idx))
      return false;
   if (!core_option_manager_get_val_idx(opt, idx, sp, &val_idx))
   {
      command_reply_error(cmd, "SET_CORE_OPTION",
            "%s does not take %s; GET_CORE_OPTION %s lists what it takes",
            key, sp, key);
      return false;
   }
   if (opt->opts[idx].index != val_idx)
      core_option_manager_set_val(opt, idx, val_idx, true);

   /* the shape GET_CORE_OPTION gives, so one reading serves both */
   if (!(_len = command_core_option_line(&opt->opts[idx], reply,
               sizeof(reply), false)))
      _len = (size_t)snprintf(reply, sizeof(reply), "%s\t%s\n", key, sp);
   cmd->replier(cmd, reply, _len);
   return true;
}

/* GET_CONFIG_PARAM <param name>
 *
 * The option that goes by this name, which GET_OPTION also reports;
 * "unsupported" for one this build does not have, as it always was.
 * Booleans are true and false here, the words this interface has always
 * answered, where GET_OPTION says on and off. */
bool command_get_config_param(command_t *cmd, const char* arg)
{
   char   value[PATH_MAX_LENGTH];
   char   reply[PATH_MAX_LENGTH + NAME_MAX_LENGTH];
   size_t _len;
   const struct cmd_option_map *o;

   while (arg && *arg == ' ')
      arg++;
   if (!arg)
      arg = "";
   if ((o = command_option_find(arg, true)))
      command_option_read(o, value, sizeof(value), "true", "false");
   else
      strlcpy(value, "unsupported", sizeof(value));

   _len = (size_t)snprintf(reply, sizeof(reply), "GET_CONFIG_PARAM %s %s",
         arg, value);
   cmd->replier(cmd, reply, _len);
   return true;
}


/* LIST_CORES [content path]
 *
 * The installed cores, one per line: display name, a tab, the path
 * LOAD_CONTENT takes. With a content path, only the cores that support
 * it - the candidates LOAD_CONTENT names when it is handed content and
 * no core to load it with. Filtering sorts the shared list, as the
 * menu does, so the unfiltered order can change afterwards. */
bool command_list_cores(command_t *cmd, const char *arg)
{
   core_info_list_t  *list  = NULL;
   const core_info_t *infos = NULL;
   size_t             count = 0;
   size_t i, len = 0;
   char  *reply;

   while (arg && *arg == ' ')
      arg++;

   if (!(reply = (char*)malloc(COMMAND_LIST_REPLY_MAX + 64)))
      return false;
   reply[0] = '\0';
   if (core_info_get_list(&list) && list)
   {
      if (arg && *arg)
         core_info_list_get_supported_cores(list, arg, &infos, &count);
      else
      {
         infos = list->list;
         count = list->count;
      }
      for (i = 0; i < count; i++)
      {
         const core_info_t *ci = &infos[i];
         int n;
         if (!ci->path)
            continue;
         n = snprintf(reply + len, COMMAND_LIST_REPLY_MAX - len, "%s\t%s\n",
               ci->display_name ? ci->display_name : "", ci->path);
         if (n < 0 || (size_t)n >= COMMAND_LIST_REPLY_MAX - len)
         {
            len += (size_t)snprintf(reply + len, 64, "MORE\n");
            break;
         }
         len += (size_t)n;
      }
   }
   if (!len)
      len = strlcpy(reply, "LIST_CORES none\n", COMMAND_LIST_REPLY_MAX);
   cmd->replier(cmd, reply, len);
   free(reply);
   return true;
}

/* LIST_PLAYLISTS and GET_PLAYLIST read files, which may be slow, so
 * they answer from a task: the text is made on the task thread and sent
 * from the callback. */
struct command_query
{
   command_deferred_t deferred;
   size_t     first;           /* GET_PLAYLIST: first entry */
   char      *reply;           /* made by the handler */
   size_t     reply_len;
   char       dir[PATH_MAX_LENGTH];
   char       name[NAME_MAX_LENGTH];
   bool       list_playlists;
   /* the reply reports a failure: no such playlist */
   bool       error;
   /* the playlist format settings, taken on the main thread */
   bool       old_format;
   bool       compress;
   bool       fuzzy_archive_match;
   bool       portable_paths;
   char       content_dir[DIR_MAX_LENGTH];
};

static void command_query_append(struct command_query *q, size_t *cap,
      const char *s)
{
   size_t n = strlen(s);
   if (!q->reply || q->reply_len + n + 1 > *cap)
      return;
   memcpy(q->reply + q->reply_len, s, n + 1);
   q->reply_len += n;
}

static void command_query_handler(retro_task_t *task)
{
   struct command_query *q = (struct command_query*)task->state;
   size_t cap              = COMMAND_LIST_REPLY_MAX;

   if ((q->reply = (char*)malloc(cap + 1)))
      q->reply[0] = '\0';

   if (q->list_playlists)
   {
      struct string_list *files = dir_list_new(q->dir, "lpl",
            false, false, false, false);
      size_t i;
      for (i = 0; files && i < files->size; i++)
      {
         char line[NAME_MAX_LENGTH + 2];
         const char *base = path_basename(files->elems[i].data);
         snprintf(line, sizeof(line), "%s\n", base);
         if (q->reply_len + strlen(line) + 6 > cap)
         {
            command_query_append(q, &cap, "MORE\n");
            break;
         }
         command_query_append(q, &cap, line);
      }
      if (files)
         string_list_free(files);
      if (!q->reply_len)
         command_query_append(q, &cap, "LIST_PLAYLISTS none\n");
   }
   else
   {
      /* the config holds two paths: on the heap, as this runs on a task
       * thread when the queue is threaded */
      playlist_config_t *config = (playlist_config_t*)calloc(1,
            sizeof(*config));
      playlist_t *pl            = NULL;

      if (config)
      {
         fill_pathname_join_special(config->path, q->dir, q->name,
               sizeof(config->path));
         if (!string_ends_with_size(config->path, ".lpl",
                  strlen(config->path), 4))
            strlcat(config->path, ".lpl", sizeof(config->path));
         config->capacity            = COLLECTION_SIZE;
         config->old_format          = q->old_format;
         config->compress            = q->compress;
         config->fuzzy_archive_match = q->fuzzy_archive_match;
         playlist_config_set_base_content_directory(config,
               q->portable_paths ? q->content_dir : NULL);
      }

      if (     !config || !path_is_valid(config->path)
            || !(pl = playlist_init(config)))
      {
         q->error = true;
         command_query_append(q, &cap, "GET_PLAYLIST ERROR no such playlist\n");
      }
      else
      {
         size_t i, n = playlist_size(pl);
         for (i = q->first; q->reply && i < n; i++)
         {
            const struct playlist_entry *e = NULL;
            char   more[32];
            size_t room = cap - q->reply_len;
            int    len;
            if (i - q->first >= COMMAND_PLAYLIST_PAGE)
            {
               snprintf(more, sizeof(more), "MORE %u\n", (unsigned)i);
               command_query_append(q, &cap, more);
               break;
            }
            playlist_get_index(pl, i, &e);
            if (!e)
               continue;
            /* the row goes straight into the reply, room kept for the
             * MORE that says where to go on from */
            len = room > 16 ? snprintf(q->reply + q->reply_len, room - 16,
                  "%u\t%s\t%s\t%s\n", (unsigned)i,
                  e->label     ? e->label     : "",
                  e->path      ? e->path      : "",
                  e->core_path ? e->core_path : "") : -1;
            if (len < 0 || (size_t)len >= room - 16)
            {
               q->reply[q->reply_len] = '\0';
               snprintf(more, sizeof(more), "MORE %u\n", (unsigned)i);
               command_query_append(q, &cap, more);
               break;
            }
            q->reply_len += (size_t)len;
         }
         if (!q->reply_len)
            command_query_append(q, &cap, "GET_PLAYLIST empty\n");
         playlist_free(pl);
      }
      free(config);
   }
   task_set_progress(task, 100);
   task_set_flags(task, RETRO_TASK_FLG_FINISHED, true);
}

static void command_query_callback(retro_task_t *task, void *task_data,
      void *user_data, const char *error)
{
   struct command_query *q = (struct command_query*)task->state;
   if (q)
      command_deferred_send(&q->deferred, q->reply, q->reply_len, q->error);
}

static void command_query_cleanup(retro_task_t *task)
{
   struct command_query *q = (struct command_query*)task->state;
   if (!q)
      return;
   free(q->reply);
   free(q->deferred.dest);
   free(q);
   task->state = NULL;
}

static bool command_query_push(command_t *cmd, bool list_playlists,
      const char *arg)
{
   settings_t           *settings = config_get_ptr();
   struct command_query *q;
   retro_task_t         *task;

   if (!(q = (struct command_query*)calloc(1, sizeof(*q))))
      return false;
   q->list_playlists = list_playlists;
   strlcpy(q->dir, settings->paths.directory_playlist, sizeof(q->dir));
   q->old_format          = settings->bools.playlist_use_old_format;
   q->compress            = settings->bools.playlist_compression;
   q->fuzzy_archive_match = settings->bools.playlist_fuzzy_archive_match;
   q->portable_paths      = settings->bools.playlist_portable_paths;
   strlcpy(q->content_dir, settings->paths.directory_menu_content,
         sizeof(q->content_dir));
   if (!list_playlists)
   {
      /* "<name> [first]": the name may hold spaces, so a last word that
       * is a number and nothing else is the first entry wanted. It has
       * to be the whole word: a playlist whose name ends in one, as
       * "Atari - 2600" and "Sony - PlayStation 2" do, was read as a
       * name without it and an entry to start at. */
      const char *sp;
      while (*arg == ' ')
         arg++;
      strlcpy(q->name, arg, sizeof(q->name));
      if ((sp = strrchr(q->name, ' ')) && sp[1] >= '0' && sp[1] <= '9')
      {
         char         *end   = NULL;
         unsigned long first = strtoul(sp + 1, &end, 10);
         /* the whole word, or it belongs to the name */
         if (end && !*end)
         {
            q->first              = (size_t)first;
            q->name[sp - q->name] = '\0';
         }
      }
      if (!*q->name || strchr(q->name, '/') || strchr(q->name, '\\'))
      {
         command_reply_error(cmd, "GET_PLAYLIST",
               "a playlist name, as LIST_PLAYLISTS gives");
         free(q);
         return false;
      }
   }
   if (!(task = task_init()))
   {
      free(q);
      return false;
   }
   command_deferred_take(&q->deferred, cmd);
   task->state    = q;
   task->handler  = command_query_handler;
   task->callback = command_query_callback;
   task->cleanup  = command_query_cleanup;
   task->flags   |= RETRO_TASK_FLG_MUTE;
   task_queue_push(task);
   return true;
}

/* LIST_PLAYLISTS: the playlist files, one per line, as GET_PLAYLIST
 * takes them. */
bool command_list_playlists(command_t *cmd, const char *arg)
{
   return command_query_push(cmd, true, arg);
}

/* GET_PLAYLIST <playlist> [first]: a playlist's entries, one per line:
 * index, label, content path, core path, tab separated;
 * COMMAND_PLAYLIST_PAGE at a time, "MORE <next>" when there are more. */
bool command_get_playlist(command_t *cmd, const char *arg)
{
   return command_query_push(cmd, false, arg);
}

/* One HELP line: name, argument, description, and what it does to
 * RetroArch, appended to @s at *@len; false when it would not fit. */
static bool command_help_line(char *s, size_t size, size_t *len,
      const char *name, const char *arg_desc, const char *desc,
      unsigned flags)
{
   int n = snprintf(s + *len, size - *len, "%s%s%s\t%s%s\n",
         name,
         arg_desc ? " " : "", arg_desc ? arg_desc : "",
         desc ? desc : "",
           (flags & CMD_INFO_READ_ONLY)   ? " [read-only]"
         : (flags & CMD_INFO_DESTRUCTIVE) ? " [destructive]"
         : "");
   if (n < 0 || (size_t)n >= size - *len)
      return false;
   *len += (size_t)n;
   return true;
}

/* HELP [command]
 *
 * With no argument, every command, one per line: the name, its
 * argument, a tab, what it does, and [read-only] or [destructive].
 * Hotkey commands take no argument and press the hotkey for one
 * frame. With a command name, that command's line alone. */
bool command_help(command_t *cmd, const char* arg)
{
   size_t   i;
   size_t   _len  = 0;
   size_t   size  = 256
      + (ARRAY_SIZE(map) + ARRAY_SIZE(action_map)) * 160;
   bool     found = false;
   char    *reply;

   while (arg && *arg == ' ')
      arg++;
   if (!(reply = (char*)malloc(size)))
      return false;
   reply[0] = '\0';

   for (i = 0; i < ARRAY_SIZE(action_map); i++)
   {
      bool noarg = string_is_equal(action_map[i].arg_desc, "No argument");
      if (arg && *arg && !string_is_equal(arg, action_map[i].str))
         continue;
      found = true;
      if (!command_help_line(reply, size, &_len, action_map[i].str,
               noarg ? NULL : action_map[i].arg_desc,
               action_map[i].desc, action_map[i].flags))
         break;
   }
   for (i = 0; i < ARRAY_SIZE(map); i++)
   {
      size_t j;
      /* RESET is an action too, whose line says it */
      for (j = 0; j < ARRAY_SIZE(action_map); j++)
         if (string_is_equal(map[i].str, action_map[j].str))
            break;
      if (j < ARRAY_SIZE(action_map))
         continue;
      if (arg && *arg && !string_is_equal(arg, map[i].str))
         continue;
      found = true;
      if (!command_help_line(reply, size, &_len, map[i].str, NULL,
               map[i].desc, map[i].flags))
         break;
   }
   if (!found)
      _len = (size_t)snprintf(reply, size, "HELP ERROR unknown command %s\n",
            arg);

   cmd->replier(cmd, reply, _len);
   free(reply);
   return found;
}

bool command_version(command_t *cmd, const char* arg)
{
   char reply[256];
   size_t  _len  = strlcpy(reply, PACKAGE_VERSION, sizeof(reply));
   reply[  _len] = '\n';
   reply[++_len] = '\0';
   cmd->replier(cmd, reply, _len);
   return true;
}

/* Whether @path is a core that can be loaded, answered to @cmd with
 * why when it is not.
 *
 * Asked before anything is torn down for it: a path that exists and is
 * not a core - a stale library, something renamed - would otherwise
 * unload the running core and then fail, costing the game that was
 * running. libretro_get_system_info() is the probe core scanning
 * already uses. A built-in core is not a file on disk and has nothing
 * to probe. */
static bool command_core_at(command_t *cmd, const char *name,
      const char *path)
{
   struct retro_system_info info;

   if (string_ends_with_size(path, "builtin",
            strlen(path), STRLEN_CONST("builtin")))
      return true;
   if (!path_is_valid(path))
   {
      command_reply_error(cmd, name, "no core at %s", path);
      return false;
   }
   if (!libretro_get_system_info(path, &info, NULL))
   {
      command_reply_error(cmd, name, "%s is not a libretro core", path);
      return false;
   }
   return true;
}

/* LOAD_CORE <core path>
 *
 * Mirrors selecting a core in the menu's core list / file browser,
 * action_ok_load_core() -> generic_action_ok()'s ACTION_OK_LOAD_CORE
 * branch, with the same task_push_load_new_core() call. */
bool command_load_core(command_t *cmd, const char* arg)
{
   content_ctx_info_t content_info = {0};
   char path[PATH_MAX_LENGTH];

   while (arg && *arg == ' ')
      arg++;
   if (!arg || !*arg)
   {
      command_reply_error(cmd, "LOAD_CORE", "a core path");
      return false;
   }
#if TARGET_OS_IPHONE
   fill_pathname_expand_special(path, arg, sizeof(path));
#else
   strlcpy(path, arg, sizeof(path));
#endif
   if (!command_core_at(cmd, "LOAD_CORE", path))
      return false;
   if (!task_push_load_new_core(path, NULL,
            &content_info, CORE_TYPE_PLAIN, NULL, NULL))
   {
      command_reply_error(cmd, "LOAD_CORE", "could not load %s", path);
      return false;
   }
   return true;
}

/* START_CORE
 *
 * Mirrors the Main Menu "Start Core" entry, action_ok_start_core():
 * clears the content path and starts the currently loaded core without
 * content.  The list_cache() call that entry makes first is menu
 * animation bookkeeping and has no equivalent here. */
bool command_start_core(command_t *cmd, const char* arg)
{
   content_ctx_info_t content_info = {0};

   path_clear(RARCH_PATH_BASENAME);

   if (!task_push_start_current_core(&content_info))
      return false;
   return command_content_reply(cmd, "START_CORE", false, true, false);
}

/* LOAD_CONTENT <core path>|<content path>
 *
 * The separator is '|' rather than a space because both operands are
 * filesystem paths and may legitimately contain spaces.  Routed through
 * the companion UI entry point so that the command interface takes the
 * same content load path as any other frontend-external requester,
 * rather than duplicating the menu-only variant.
 *
 * Both paths are resolved and checked before that load is pushed: the
 * task unloads the running core first and only then finds out that a
 * path is unusable, so a typo would otherwise cost the caller the game
 * it was playing. */
bool command_load_content(command_t *cmd, const char* arg)
{
   char core_path[PATH_MAX_LENGTH];
#if TARGET_OS_IPHONE
   char expanded[PATH_MAX_LENGTH];
#endif
   content_ctx_info_t content_info = {0};
   const char *content_path        = NULL;
   const char *sep                 = NULL;
   const char *last;
   char       *trimmed             = NULL;
   size_t _len                     = 0;
   bool pause                      = false;
   bool ret                        = false;

   if (!arg || !*arg || !(sep = strchr(arg, '|')))
   {
      command_reply_error(cmd, "LOAD_CONTENT",
            "a core path, '|' and a content path");
      return false;
   }

   _len = (size_t)(sep - arg);
   if (_len >= sizeof(core_path))
   {
      command_reply_error(cmd, "LOAD_CONTENT", "core path is too long");
      return false;
   }
   if (!*(sep + 1))
   {
      command_reply_error(cmd, "LOAD_CONTENT", "no content path after '|'");
      return false;
   }

   memcpy(core_path, arg, _len);
   core_path[_len] = '\0';

   /* "|on" or "|off" after the content path: whether to pause once it
    * has loaded. Anything else after a "|" is the path's own. */
   content_path    = sep + 1;
   if (     (last = strrchr(content_path, '|'))
         && (string_is_equal(last + 1, "on")
            || string_is_equal(last + 1, "off")))
   {
      _len  = (size_t)(last - content_path);
      pause = string_is_equal(last + 1, "on");
      if (!(trimmed = (char*)malloc(_len + 1)))
         return false;
      memcpy(trimmed, content_path, _len);
      trimmed[_len] = '\0';
      content_path  = trimmed;
   }
#if TARGET_OS_IPHONE
   fill_pathname_expand_special(expanded, content_path, sizeof(expanded));
   content_path    = expanded;
#endif

   /* Content inside an archive is named as one path, which
    * path_is_valid() would reject */
   if (!playlist_content_path_is_valid(content_path))
   {
      command_reply_error(cmd, "LOAD_CONTENT", "no content at %s",
            content_path);
      goto end;
   }

   /* A playlist entry with no core of its own carries DETECT, so take
    * that, and nothing at all, as a request for a core that supports
    * the content.  The menu asks the user to pick one where the
    * playlist's default core does not settle it; nobody is here to
    * answer that, so an ambiguous one says so and leaves the choice;
    * LIST_CORES, given the same content path, lists the candidates. */
   if (!*core_path || string_is_equal(core_path, FILE_PATH_DETECT))
   {
      core_info_list_t *core_info_list = NULL;
      const core_info_t *supported     = NULL;
      size_t count                     = 0;

      if (core_info_get_list(&core_info_list))
         core_info_list_get_supported_cores(core_info_list, content_path,
               &supported, &count);

      if (count == 0)
      {
         command_reply_error(cmd, "LOAD_CONTENT",
               "no installed core supports %s", content_path);
         goto end;
      }
      if (count > 1)
      {
         command_reply_error(cmd, "LOAD_CONTENT",
               "%u cores support %s, name one of them; LIST_CORES with "
               "that content path lists them", (unsigned)count,
               content_path);
         goto end;
      }

      /* An entry whose core file is gone keeps its info and loses its
       * path; it supports the content and cannot be loaded. */
      if (!supported[0].path)
      {
         command_reply_error(cmd, "LOAD_CONTENT",
               "the only core that supports %s is not installed",
               content_path);
         goto end;
      }
      strlcpy(core_path, supported[0].path, sizeof(core_path));
   }
   else if (!command_core_at(cmd, "LOAD_CONTENT", core_path))
      goto end;

   if (!task_push_load_content_with_new_core_from_companion_ui(
         core_path, content_path, NULL, NULL, NULL, &content_info, NULL, NULL))
   {
      command_reply_error(cmd, "LOAD_CONTENT", "could not load %s with %s",
            content_path, core_path);
      goto end;
   }
   ret = command_content_reply(cmd, "LOAD_CONTENT", false, true, pause);
end:
   free(trimmed);
   return ret;
}

/* CLOSE_CONTENT
 *
 * On HAVE_MENU builds this is CMD_EVENT_CLOSE_CONTENT, the same event the
 * Quick Menu "Close Content" entry issues.
 *
 * On builds without a menu, CMD_EVENT_CLOSE_CONTENT is defined as
 * CMD_EVENT_QUIT -- reasonable for a hotkey on a frontend that has
 * nowhere to return to, but wrong here: a command interface consumer
 * asking to close content is not asking to terminate the process, and
 * has no way to discover that the two are the same on this build.  Use
 * CMD_EVENT_UNLOAD_CORE instead, which unloads the core and starts the
 * dummy core.  That is as close to "content closed" as a menuless build
 * gets, and it leaves the process alive to accept further commands.
 *
 * This was previously a map[] entry driving RARCH_CLOSE_CONTENT_KEY,
 * which is not what the menu entry does either: the hotkey path in
 * runloop_iterate() also applies the 'confirm_close' double press timer,
 * and nothing external can produce the second press inside the window,
 * so with that setting enabled the command was silently swallowed.  The
 * menu entry's confirmation is a dialog rather than a timer and is
 * equally unreachable over the command interface, so neither form of
 * confirmation applies on this path. */
bool command_close_content(command_t *cmd, const char* arg)
{
#ifdef HAVE_MENU
   /* this quits instead, and there is no unload to wait for */
   if (should_quit_on_close())
      return command_event(CMD_EVENT_CLOSE_CONTENT, NULL);
   /* the menu unloads the core on a later frame */
   if (!command_event(CMD_EVENT_CLOSE_CONTENT, NULL))
      return false;
   return command_content_reply(cmd, "CLOSE_CONTENT", true, false, false);
#else
   if (!command_event(CMD_EVENT_UNLOAD_CORE, NULL))
      return false;
   return command_content_reply(cmd, "CLOSE_CONTENT", false, false, false);
#endif
}

/* UNLOAD_CORE
 *
 * CMD_EVENT_UNLOAD_CORE releases the core and starts the dummy core, and
 * is not menu dependent.  The Main Menu "Unload Core" entry issues the
 * same event and then clears the last core path; that clear is a
 * frontend path operation rather than a menu one, so it belongs here
 * too.  Only the entry refresh afterwards is menu state. */
bool command_unload_core(command_t *cmd, const char* arg)
{
   if (!command_event(CMD_EVENT_UNLOAD_CORE, NULL))
      return false;

   command_content_reply(cmd, "UNLOAD_CORE", false, false, false);
   path_clear(RARCH_PATH_CORE_LAST);

#ifdef HAVE_MENU
   {
      struct menu_state *menu_st = menu_state_get_ptr();
      if (menu_st)
         menu_st->flags |=  MENU_ST_FLAG_ENTRIES_NEED_REFRESH
                         |  MENU_ST_FLAG_PREVENT_POPULATE;
   }
#endif

   return true;
}

/* VIDEO_REINIT / AUDIO_REINIT / DRIVERS_REINIT
 *
 * Driver reinit, split by scope.  None has a menu equivalent; they exist
 * so that a driver teardown and rebuild can be triggered on its own,
 * rather than only as a side effect of loading content.
 *
 * CMD_EVENT_REINIT takes an optional driver mask through its data
 * pointer and falls back to DRIVERS_CMD_ALL when passed NULL, so
 * VIDEO_REINIT passes DRIVER_VIDEO_MASK explicitly rather than relying on
 * the default -- otherwise it would tear down audio, input, MIDI and the
 * rest as well, and would not be a video reinit at all.  A video-only
 * mask through video_driver_reinit() is what the CRT switch path already
 * does.  DRIVERS_REINIT keeps the all-drivers behaviour under a name that
 * says so. */
bool command_video_reinit(command_t *cmd, const char* arg)
{
   int flags = DRIVER_VIDEO_MASK;
   command_event(CMD_EVENT_REINIT, &flags);
   return true;
}

bool command_audio_reinit(command_t *cmd, const char* arg)
{
   return command_event(CMD_EVENT_AUDIO_REINIT, NULL);
}

bool command_drivers_reinit(command_t *cmd, const char* arg)
{
   command_event(CMD_EVENT_REINIT, NULL);
   return true;
}

static const rarch_memory_descriptor_t* command_memory_get_descriptor(const rarch_memory_map_t* mmap, unsigned address, size_t* offset)
{
   const rarch_memory_descriptor_t* desc = mmap->descriptors;
   const rarch_memory_descriptor_t* end  = desc + mmap->num_descriptors;

   for (; desc < end; desc++)
   {
      if (desc->core.select == 0)
      {
         /* if select is 0, attempt to explicitly match the address */
         if (address >= desc->core.start && address < desc->core.start + desc->core.len)
         {
            *offset = address - desc->core.start;
            return desc;
         }
      }
      else
      {
         /* otherwise, attempt to match the address by matching the select bits */
         if (((desc->core.start ^ address) & desc->core.select) == 0)
         {
            /* adjust the address to the start of the descriptor */
            unsigned desc_offset = address - (unsigned)desc->core.start;

            /* address is unsigned. we only need that much of the disconnect mask */
            unsigned mask = (unsigned)desc->core.disconnect;

            /* this magic logic is copied from mmap_reduce. it removes any bits from
             * address that are non-zero in the disconnect field. bits above the
             * removed bits are shifted down to fill the gap. */
            while (mask)
            {
               const unsigned tmp = (mask - 1) & ~mask;
               desc_offset = (desc_offset & tmp) | ((desc_offset >> 1) & ~tmp);
               mask        = (mask & (mask - 1)) >> 1;
            }

            /* we've calculated the actual offset of the data within the descriptor */
            *offset = desc_offset;

            /* sanity check - make sure the descriptor is large enough to hold the target address */
            if (desc_offset < desc->core.len)
               return desc;
         }
      }
   }

   return NULL;
}

/* A core with no memory map still hands over its RAM as blocks, once a
 * game is loaded: system RAM from address 0 and save RAM straight after
 * it, as the achievements lay them out when they know no console - for
 * the SNES, the addresses RetroAchievements' notes give. Fills @blocks
 * (data, start, size) for the system and the save block, a NULL data
 * where the core has none; false where it has neither. */
struct command_ram_block
{
   uint8_t *data;
   size_t   start;
   size_t   size;
};

static bool command_memory_core_blocks(struct command_ram_block blocks[2])
{
   runloop_state_t        *runloop_st = runloop_state_get_ptr();
   retro_ctx_memory_info_t info;
   memset(blocks, 0, 2 * sizeof(*blocks));
   if (     !(runloop_st->current_core.flags & RETRO_CORE_FLAG_GAME_LOADED)
         || !runloop_st->current_core.retro_get_memory_data
         || !runloop_st->current_core.retro_get_memory_size)
      return false;
   info.id = RETRO_MEMORY_SYSTEM_RAM;
   core_get_memory(&info);
   if (info.data && info.size)
   {
      blocks[0].data = (uint8_t*)info.data;
      blocks[0].size = info.size;
   }
   info.id = RETRO_MEMORY_SAVE_RAM;
   core_get_memory(&info);
   if (info.data && info.size)
   {
      blocks[1].data  = (uint8_t*)info.data;
      blocks[1].start = blocks[0].size;
      blocks[1].size  = info.size;
   }
   return blocks[0].data || blocks[1].data;
}

static uint8_t *command_memory_get_pointer(
      const rarch_system_info_t* sys_info,
      unsigned address, unsigned int* max_bytes,
      int for_write, char *s, size_t len)
{
   if (!sys_info || sys_info->mmaps.num_descriptors == 0)
   {
      struct command_ram_block blocks[2];
      unsigned                 n;
      bool                     any = command_memory_core_blocks(blocks);
      for (n = 0; n < 2; n++)
         if (     blocks[n].data && address >= blocks[n].start
               && address < blocks[n].start + blocks[n].size)
         {
            *max_bytes = (unsigned int)(blocks[n].start + blocks[n].size
                  - address);
            return blocks[n].data + (address - blocks[n].start);
         }
      if (any)
         strlcpy_lit(s, " -1 no descriptor for address\n", len);
      else
         strlcpy_lit(s, " -1 no memory map defined\n", len);
   }
   else
   {
      size_t offset;
      const rarch_memory_descriptor_t* desc = command_memory_get_descriptor(&sys_info->mmaps, address, &offset);
      if (!desc)
         strlcpy_lit(s, " -1 no descriptor for address\n", len);
      else if (!desc->core.ptr)
         strlcpy_lit(s, " -1 no data for descriptor\n", len);
      else if (for_write && (desc->core.flags & RETRO_MEMDESC_CONST))
         strlcpy_lit(s, " -1 descriptor data is readonly\n", len);
      else
      {
         *max_bytes = (unsigned int)(desc->core.len - offset);
         return (uint8_t*)desc->core.ptr + desc->core.offset + offset;
      }
   }

   *max_bytes = 0;
   return NULL;
}

/* @v in lowercase hexadecimal, whatever the width of size_t */
static void command_hex(char *s, size_t v)
{
   char   tmp[24];
   size_t n = 0;
   do
   {
      tmp[n++] = "0123456789abcdef"[v & 15];
      v      >>= 4;
   } while (v);
   while (n)
      *s++ = tmp[--n];
   *s = '\0';
}

/* GET_MEMORY_MAP
 *
 * The running core's memory map, one region per line, tab separated:
 * the first system address READ_CORE_MEMORY takes in it, its length,
 * its select and disconnect masks (all hexadecimal), what it holds
 * (system, save, video or other), rw, ro, or none when nothing backs
 * it, its byte order, and its address space name. */
bool command_get_memory_map(command_t *cmd, const char *arg)
{
   unsigned i;
   size_t _len                     = 0;
   char *reply;
   runloop_state_t *runloop_st     = runloop_state_get_ptr();
   const rarch_memory_map_t *mmap  = runloop_st ? &runloop_st->system.mmaps
                                                : NULL;

   if (!(reply = (char*)malloc(COMMAND_LIST_REPLY_MAX + 1)))
   {
      command_reply_error(cmd, "GET_MEMORY_MAP", "out of memory");
      return false;
   }
   /* no map: the RAM the core hands over, where READ_CORE_MEMORY reads
    * it, in an address space named core */
   if (!mmap || !mmap->num_descriptors)
   {
      struct command_ram_block blocks[2];
      command_memory_core_blocks(blocks);
      for (i = 0; i < 2; i++)
      {
         char s_start[24], s_len[24];
         if (!blocks[i].data)
            continue;
         command_hex(s_start, blocks[i].start);
         command_hex(s_len,   blocks[i].size);
         _len += (size_t)snprintf(reply + _len,
               COMMAND_LIST_REPLY_MAX + 1 - _len,
               "%s\t%s\t0\t0\t%s\trw\tlittle\tcore\n", s_start, s_len,
               i ? "save" : "system");
      }
      if (!_len)
      {
         free(reply);
         command_reply_error(cmd, "GET_MEMORY_MAP",
               "the running core has no memory map, and hands over no RAM");
         return false;
      }
      cmd->replier(cmd, reply, _len);
      free(reply);
      return true;
   }

   for (i = 0; i < mmap->num_descriptors; i++)
   {
      const struct retro_memory_descriptor *d = &mmap->descriptors[i].core;
      const char *kind   = (d->flags & RETRO_MEMDESC_SYSTEM_RAM) ? "system"
                         : (d->flags & RETRO_MEMDESC_SAVE_RAM)   ? "save"
                         : (d->flags & RETRO_MEMDESC_VIDEO_RAM)  ? "video"
                         : "other";
      const char *access = !d->ptr ? "none"
                         : (d->flags & RETRO_MEMDESC_CONST) ? "ro" : "rw";
      char start[24], len[24], sel[24], disc[24];
      int n;
      command_hex(start,      d->start);
      command_hex(len,        d->len);
      command_hex(sel,        d->select);
      command_hex(disc,       d->disconnect);
      n = snprintf(reply + _len, COMMAND_LIST_REPLY_MAX + 1 - _len,
            "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
            start, len, sel, disc, kind, access,
            (d->flags & RETRO_MEMDESC_BIGENDIAN) ? "big" : "little",
            d->addrspace ? d->addrspace : "");
      if (n < 0 || (size_t)n >= COMMAND_LIST_REPLY_MAX + 1 - _len)
      {
         free(reply);
         command_reply_error(cmd, "GET_MEMORY_MAP",
               "the map did not fit one reply, stopping at region %u", i);
         return false;
      }
      _len += (size_t)n;
   }

   cmd->replier(cmd, reply, _len);
   free(reply);
   return true;
}

bool command_get_status(command_t *cmd, const char* arg)
{
   size_t _len;
   /* a status, a system name and a file name */
   char reply[1024];
   uint8_t flags;

   if (!cmd)
      return false;

   if (!cmd->replier)
      return false;

   flags = content_get_flags();

   if (flags & CONTENT_ST_FLAG_IS_INITED)
   {
      /* add some content info */
      core_info_t *core_info      = NULL;
      runloop_state_t *runloop_st = runloop_state_get_ptr();
      const char *basename_path   = NULL;

      if (!runloop_st)
      {
         _len = strlcpy_lit(reply, "GET_STATUS ERROR", sizeof(reply));
         cmd->replier(cmd, reply, _len);
         return false;
      }

      core_info_get_current_core(&core_info);

      _len = 0;
      strlcpy_append(reply, sizeof(reply), &_len, "GET_STATUS ");

      if (runloop_st->flags & RUNLOOP_FLAG_PAUSED)
         strlcpy_append(reply, sizeof(reply), &_len, "PAUSED");
      else
         strlcpy_append(reply, sizeof(reply), &_len, "PLAYING");

      strlcpy_append(reply, sizeof(reply), &_len, " ");

      if (core_info && core_info->system_id)
         strlcpy_append(reply, sizeof(reply), &_len, core_info->system_id);
      else if (runloop_st->system.info.library_name)
         strlcpy_append(reply, sizeof(reply), &_len,
               runloop_st->system.info.library_name);
      else
         strlcpy_append(reply, sizeof(reply), &_len, "UNKNOWN");

      strlcpy_append(reply, sizeof(reply), &_len, ",");

      basename_path = path_get(RARCH_PATH_BASENAME);
      if (basename_path)
      {
         const char *basename = path_basename(basename_path);
         if (basename)
            strlcpy_append(reply, sizeof(reply), &_len, basename);
         else
            strlcpy_append(reply, sizeof(reply), &_len, "UNKNOWN");
      }
      else
         strlcpy_append(reply, sizeof(reply), &_len, "UNKNOWN");

      strlcpy_append(reply, sizeof(reply), &_len, "\n");
   }
   else
      _len = strlcpy_lit(reply, "GET_STATUS CONTENTLESS", sizeof(reply));

   cmd->replier(cmd, reply, _len);
   return true;
}

bool command_read_memory(command_t *cmd, const char *arg)
{
   char* reply                        = NULL;
   char* reply_at                     = NULL;
   const uint8_t* data                = NULL;
   unsigned int nbytes                = 0;
   unsigned int alloc_size            = 0;
   unsigned int address               = -1;
   size_t _len                        = 0;
   unsigned int max_bytes             = 0;
   runloop_state_t *runloop_st        = runloop_state_get_ptr();
   const rarch_system_info_t* sys_info= &runloop_st->system;

   {
      char *end       = NULL;
      unsigned long num;
      if (!command_parse_address(arg, &address, &end) || *end != ' ')
      {
         command_reply_error(cmd, "READ_CORE_MEMORY",
               "a hexadecimal address, a space and a byte count");
         return false;
      }
      num             = strtoul(end + 1, NULL, 10);
      nbytes          = num <= COMMAND_READ_NBYTES_MAX ? (unsigned)num : 0;
      if (nbytes == 0)
      {
         command_reply_error(cmd, "READ_CORE_MEMORY",
               "a byte count from 1 to %u", COMMAND_READ_NBYTES_MAX);
         return false;
      }
   }

   /* Ensure large enough to return all requested bytes or an error message */
   alloc_size = 96 + nbytes * 3;
   reply      = (char*)malloc(alloc_size);
   
   if (!reply)
   {
      command_reply_error(cmd, "READ_CORE_MEMORY", "out of memory");
      return false;
   }
   
   reply_at   = reply + snprintf(reply, alloc_size - 1, "READ_CORE_MEMORY %x", address);

   if ((data = command_memory_get_pointer(
               sys_info, address, &max_bytes,
               0, reply_at, alloc_size - strlen(reply))))
   {
      char         why[128];
      char        *end  = reply_at;
      unsigned int read = 0;
      /* on into the region that follows, as a core that splits its RAM
       * maps it; where nothing maps the rest, how much was read */
      while (data)
      {
         unsigned int n = nbytes - read < max_bytes
            ? nbytes - read : max_bytes;
         if (!n)
            break;
         end   = command_hex_bytes(end, data, n);
         read += n;
         if (read >= nbytes)
            break;
         data  = command_memory_get_pointer(sys_info, address + read,
               &max_bytes, 0, why, sizeof(why));
      }
      *end++               = '\n';
      if (read < nbytes)
         end += snprintf(end, alloc_size - (size_t)(end - reply),
               "TRUNCATED %u\n", read);
      _len                 = (size_t)(end - reply);
   }
   else
   {
      /* command_memory_get_pointer() has put the reason in the reply,
       * in the form line clients have always read */
      _len                 = strlen(reply);
      cmd->error           = true;
   }

   cmd->replier(cmd, reply, _len);
   free(reply);
   return !cmd->error;
}

bool command_write_memory(command_t *cmd, const char *arg)
{
   unsigned int address         = 0;
   unsigned int max_bytes       = 0;
   char reply[128]              = "";
   char *end                    = NULL;
   runloop_state_t *runloop_st  = runloop_state_get_ptr();
   const rarch_system_info_t
      *sys_info                 = &runloop_st->system;
   char *reply_at;
   uint8_t *data;

   if (     !command_parse_address(arg, &address, &end)
         || !command_bytes_valid(end))
   {
      command_reply_error(cmd, "WRITE_CORE_MEMORY", "a hexadecimal "
            "address, then bytes from 00 to ff separated by spaces");
      return false;
   }
   arg      = end;
   reply_at = reply + snprintf(reply, sizeof(reply) - 1, "WRITE_CORE_MEMORY %x", address);
   data     = command_memory_get_pointer(sys_info, address, &max_bytes, 1,
         reply_at, sizeof(reply) - strlen(reply) - 1);

   if (data)
   {
      uint8_t* start = data;
      while (max_bytes > 0 && command_next_byte(&arg, data) > 0)
      {
         --max_bytes;
         data++;
      }

      snprintf(reply_at, sizeof(reply) - strlen(reply) - 1,
            " %u\n", (unsigned)(data - start));

#ifdef HAVE_CHEEVOS
      if (rcheevos_hardcore_active())
      {
         RARCH_LOG("[Command] Achievements hardcore mode disabled by WRITE_CORE_MEMORY.\n");
         rcheevos_pause_hardcore();
      }
#endif
   }
   else
      /* command_memory_get_pointer() has put the reason in the reply,
       * in the form line clients have always read; nothing was written */
      cmd->error = true;

   cmd->replier(cmd, reply, strlen(reply));
   return !cmd->error;
}
#endif

void command_event_set_volume(
      settings_t *settings,
      float gain,
      bool widgets_active,
      bool audio_driver_mute_enable)
{
   size_t _len;
   char msg[128];
   float new_volume = settings->floats.audio_volume + gain;
   new_volume       = MAX(new_volume, -80.0f);
   new_volume       = MIN(new_volume, 12.0f);
   configuration_set_float(settings, settings->floats.audio_volume, new_volume);
   _len             = strlcpy(msg, msg_hash_to_str(MSG_AUDIO_VOLUME),
         sizeof(msg));
   _len            += strlcpy_lit(msg + _len, ": ", sizeof(msg) - _len);
   _len            += snprintf(msg + _len, sizeof(msg) - _len, "%.1f",
         new_volume);
   _len            += strlcpy_lit(msg + _len, " dB", sizeof(msg) - _len);

#if defined(HAVE_GFX_WIDGETS)
   if (widgets_active)
      gfx_widget_volume_update_and_show(new_volume,
            audio_driver_mute_enable);
   else
#endif
      runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
            MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);

   RARCH_LOG("[Audio] %s.\n", msg);

   audio_set_float(AUDIO_ACTION_VOLUME_GAIN, new_volume);
}

/**
 * event_set_mixer_volume:
 * @gain      : amount of gain to be applied to current volume level.
 *
 * Adjusts the current audio volume level.
 *
 **/
void command_event_set_mixer_volume(
      settings_t *settings,
      float gain)
{
   size_t _len;
   char msg[128];
   float new_volume = settings->floats.audio_mixer_volume + gain;
   new_volume       = MAX(new_volume, -80.0f);
   new_volume       = MIN(new_volume, 12.0f);
   configuration_set_float(settings, settings->floats.audio_mixer_volume, new_volume);
   _len             = strlcpy(msg, msg_hash_to_str(MSG_AUDIO_VOLUME),
         sizeof(msg));
   _len            += strlcpy_lit(msg + _len, ": ", sizeof(msg) - _len);
   _len            += snprintf(msg + _len, sizeof(msg) - _len, "%.1f",
         new_volume);
   _len            += strlcpy_lit(msg + _len, " dB", sizeof(msg) - _len);
   runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
         MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);

   RARCH_LOG("[Audio] %s.\n", msg);

   audio_set_float(AUDIO_ACTION_VOLUME_GAIN, new_volume);
}

void command_event_init_controllers(rarch_system_info_t *sys_info,
      settings_t *settings, unsigned num_active_users)
{
   unsigned port;
   unsigned num_core_ports = sys_info->ports.size;

   for (port = 0; port < num_core_ports; port++)
   {
      size_t i;
      retro_ctx_controller_info_t pad;
      unsigned device                                 = RETRO_DEVICE_NONE;
      const struct retro_controller_description *desc = NULL;

      /* Check whether current core port is mapped
       * to an input device
       * > If is not, leave 'device' set to
       *   'RETRO_DEVICE_NONE'
       * > For example: if input ports 0 and 1 are
       *   mapped to core port 0, core port 1 will
       *   be unmapped and should be disabled */
      for (i = 0; i < num_active_users; i++)
      {
         if (i >= MAX_USERS)
            break;

         if (port == settings->uints.input_remap_ports[i])
         {
            device = input_config_get_device(port);
            break;
         }
      }

      desc = libretro_find_controller_description(
            &sys_info->ports.data[port], device);

      if (desc && !desc->desc)
      {
         /* If we're trying to connect a completely unknown device,
          * revert back to JOYPAD. */
         if (device != RETRO_DEVICE_JOYPAD && device != RETRO_DEVICE_NONE)
         {
            /* Do not fix device,
             * because any use of dummy core will reset this,
             * which is not a good idea. */
            RARCH_WARN("[Input] Input device ID %u is unknown to this "
                  "libretro implementation. Using RETRO_DEVICE_JOYPAD.\n",
                  device);
            device = RETRO_DEVICE_JOYPAD;
         }
      }

      pad.device     = device;
      pad.port       = port;
      core_set_controller_port_device(&pad);
   }
}

#ifdef HAVE_CONFIGFILE
static size_t command_event_save_config(const char *config_path,
   char *s, size_t len)
{
   size_t _len      = 0;
   bool path_exists = *config_path;
   const char *str  = path_exists ? config_path :
      path_get(RARCH_PATH_CONFIG);

   /* Workaround for libdecor 0.2.0 setting unwanted locale */
#if defined(HAVE_WAYLAND) && defined(HAVE_DYNAMIC)
   setlocale(LC_NUMERIC,"C");
#endif
   if (path_exists && config_save_file(config_path))
   {
#if TARGET_OS_IPHONE
      char tmp[PATH_MAX_LENGTH] = {0};
      fill_pathname_abbreviate_special(tmp, config_path, sizeof(tmp));
      _len = snprintf(s, len, "%s \"%s\".",
            msg_hash_to_str(MSG_SAVED_NEW_CONFIG_TO),
            tmp);
#else
      _len = snprintf(s, len, "%s \"%s\".",
            msg_hash_to_str(MSG_SAVED_NEW_CONFIG_TO),
            config_path);
#endif
      RARCH_LOG("[Config] %s\n", s);
      return _len;
   }

   if (str && *str)
   {
      _len = snprintf(s, len, "%s \"%s\".",
            msg_hash_to_str(MSG_FAILED_SAVING_CONFIG_TO),
            str);
      RARCH_ERR("[Config] %s\n", s);
   }

   return _len;
}
#endif

static size_t command_event_undo_save_state(char *s, size_t len)
{
   if (content_undo_save_buf_is_empty())
   {
      enum msg_hash_enums msg = content_undo_save_disabled()
         ? MSG_CORE_DOES_NOT_SUPPORT_SAVESTATE_UNDO
         : MSG_NO_SAVE_STATE_HAS_BEEN_OVERWRITTEN_YET;
      return strlcpy(s, msg_hash_to_str(msg), len);
   }
   if (!content_undo_save_state())
      return strlcpy(s,
         msg_hash_to_str(MSG_FAILED_TO_UNDO_SAVE_STATE), len);
   return strlcpy(s,
         msg_hash_to_str(MSG_UNDOING_SAVE_STATE), len);
}

static size_t command_event_undo_load_state(char *s, size_t len)
{
   if (content_undo_load_buf_is_empty())
   {
      enum msg_hash_enums msg = content_undo_save_disabled()
         ? MSG_CORE_DOES_NOT_SUPPORT_SAVESTATE_UNDO
         : MSG_NO_STATE_HAS_BEEN_LOADED_YET;
      return strlcpy(s, msg_hash_to_str(msg), len);
   }
   if (!content_undo_load_state())
      return snprintf(s, len, "%s \"%s\".",
            msg_hash_to_str(MSG_FAILED_TO_UNDO_LOAD_STATE),
            "RAM");
#ifdef HAVE_NETWORKING
   netplay_driver_ctl(RARCH_NETPLAY_CTL_LOAD_SAVESTATE, NULL);
#endif
   return strlcpy(s,
         msg_hash_to_str(MSG_UNDID_LOAD_STATE), len);
}

bool command_event_resize_windowed_scale(settings_t *settings,
      unsigned window_scale)
{
   unsigned idx = 0;
   bool video_fullscreen = settings->bools.video_fullscreen
         || (video_driver_get_disp_flags() & VIDEO_FLAG_FORCE_FULLSCREEN);

   if (window_scale == 0)
      return false;

   configuration_set_uint(settings, settings->uints.video_scale, window_scale);

   if (!video_fullscreen)
   {
      if (     !video_driver_test_all_flags(GFX_CTX_FLAGS_WINDOW_RESIZE_IN_PLACE)
            || !video_driver_set_video_mode(
                  video_driver_window_dims(false), false))
      {
         int reinit_flags = DRIVER_VIDEO_AND_INPUT_MASK;
         command_event(CMD_EVENT_REINIT, &reinit_flags);
      }
   }

   retroarch_ctl(RARCH_CTL_SET_WINDOWED_SCALE, &idx);

   return true;
}

size_t command_event_save_auto_state(void)
{
   size_t _len;
   runloop_state_t *runloop_st = runloop_state_get_ptr();
   const char *name_savestate  = runloop_st->name.savestate;
   char savestate_name_auto[PATH_MAX_LENGTH];
   const char *a = NULL;

   if (!core_info_current_supports_savestate())
      return 0;
   a = path_basename(path_get(RARCH_PATH_BASENAME));
   if (!a || !*a)
      return 0;
   _len = strlcpy(savestate_name_auto, name_savestate,
         sizeof(savestate_name_auto));
   _len += strlcpy_lit(savestate_name_auto + _len, ".auto",
           sizeof(savestate_name_auto) - _len);
   if (content_auto_save_state((const char*)savestate_name_auto))
	   RARCH_LOG("[State] %s \"%s\" %s.\n",
			   msg_hash_to_str(MSG_AUTO_SAVE_STATE_TO),
			   savestate_name_auto, "succeeded");
   else
	   RARCH_LOG("[State] %s \"%s\" %s.\n",
			   msg_hash_to_str(MSG_AUTO_SAVE_STATE_TO),
			   savestate_name_auto, "failed");
   return _len;
}

#ifdef HAVE_CHEATS
void command_event_init_cheats(
      bool apply_cheats_after_load,
      const char *path_cheat_db,
      void *bsv_movie_data)
{
#ifdef HAVE_NETWORKING
   bool allow_cheats             = !netplay_driver_ctl(
         RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL);
#else
   bool allow_cheats             = true;
#endif
#ifdef HAVE_BSV_MOVIE
   allow_cheats                 &= !(bsv_movie_data != NULL);
#endif

   if (!allow_cheats)
      return;

   cheat_manager_alloc_if_empty();
   cheat_manager_load_game_specific_cheats(path_cheat_db);

   if (apply_cheats_after_load)
      cheat_manager_apply_cheats(
            config_get_ptr()->bools.notification_show_cheats_applied);
}
#endif

bool command_event_load_entry_state(settings_t *settings)
{
   char entry_state_path[PATH_MAX_LENGTH] = "";
   runloop_state_t *runloop_st     = runloop_state_get_ptr();
   bool ret                        = false;

   /* No early save-capability gate here: content_load_state() decides,
    * and an existing entry-state file outranks stale metadata. */

#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
      return false;
#endif
#ifdef HAVE_NETWORKING
   if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_ENABLED, NULL))
      return false;
#endif

   if (!runloop_get_entry_state_path(
         entry_state_path, sizeof(entry_state_path),
         runloop_st->entry_state_slot))
      return false;

   if (!path_is_valid(entry_state_path))
   {
      if (!runloop_get_savestate_path(
            entry_state_path, sizeof(entry_state_path),
            runloop_st->entry_state_slot))
         return false;
   }

   if (!path_is_valid(entry_state_path))
      return false;

   ret = content_load_state(entry_state_path, false, true);

   RARCH_LOG("[State] %s \"%s\".\n",
         msg_hash_to_str(MSG_FOUND_ENTRY_STATE_IN),
         entry_state_path);
   RARCH_LOG("[State] %s \"%s\" %s.\n",
         msg_hash_to_str(MSG_LOADING_ENTRY_STATE_FROM),
         entry_state_path,
         ret ? "succeeded" : "failed");

   return ret;
}

bool command_event_load_auto_state(void)
{
   size_t _len;
   char savestate_name_auto[PATH_MAX_LENGTH];
   runloop_state_t *runloop_st     = runloop_state_get_ptr();
   const char *name_savestate      = runloop_st->name.savestate;
   bool ret                        = false;
   bool must_initialize            = (core_serialization_quirks()
         & RETRO_SERIALIZATION_QUIRK_MUST_INITIALIZE) != 0;

   /* No early save-capability gate here: content_load_state() decides,
    * and an existing .auto state file outranks stale metadata. */

#ifdef HAVE_CHEEVOS
   if (rcheevos_hardcore_active())
      return false;
#endif
#ifdef HAVE_NETWORKING
   if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_ENABLED, NULL))
      return false;
#endif

   if (must_initialize
         && runloop_st->auto_state_load_attempted
         && !runloop_st->auto_state_load_ready)
      return false;

   _len = strlcpy(savestate_name_auto, name_savestate,
         sizeof(savestate_name_auto));
   strlcpy_lit(savestate_name_auto + _len, ".auto",
         sizeof(savestate_name_auto) - _len);

   if (!path_is_valid(savestate_name_auto))
      return false;

   if (must_initialize && !runloop_st->auto_state_load_ready)
   {
      if (!runloop_st->auto_state_load_pending)
      {
         runloop_st->auto_state_load_pending = true;
         RARCH_LOG("[State] Auto-loading savestate \"%s\" deferred until core initialization completes.\n",
               savestate_name_auto);
      }
      return true;
   }

   if (must_initialize)
   {
      runloop_st->auto_state_load_pending  = false;
      runloop_st->auto_state_load_attempted = true;
   }

   ret = content_load_state(savestate_name_auto, false, true);

   RARCH_LOG("[State] %s \"%s\".\n",
         msg_hash_to_str(MSG_FOUND_AUTO_SAVESTATE_IN),
         savestate_name_auto);
   RARCH_LOG("[State] %s \"%s\" %s.\n",
         msg_hash_to_str(MSG_AUTOLOADING_SAVESTATE_FROM),
         savestate_name_auto,
         ret ? "succeeded" : "failed");

   return ret;
}

/**
 * Scans existing states to determine which one should be loaded
 * and which one can be deleted, using savestate wraparound if
 * enabled.
 *
 * @param settings The usual RetroArch settings ptr.
 * @param last_index Return value for load slot.
 * @param @s Return value for file name that should be removed.
 */
static void command_scan_states(
      bool show_hidden_files,
      unsigned savestate_max_keep,
      int curr_state_slot,
      unsigned *last_index, char *s)
{
   /* Base name of 128 may be too short for some (<<1%) of the
      tosec-based file names, but in practice truncating will not
      lead to mismatch */
   char state_base[128];
   char state_dir[DIR_MAX_LENGTH];
   runloop_state_t *runloop_st        = runloop_state_get_ptr();
   const char *name_savestate         = runloop_st->name.savestate;

   unsigned max_idx                   = 0;
   unsigned loa_idx                   = 0;
   unsigned gap_idx                   = UINT_MAX;
   unsigned del_idx                   = UINT_MAX;
   retro_bits_512_t slot_mapping_low  = {{0}};
   retro_bits_512_t slot_mapping_high = {{0}};

   struct string_list *dir_list       = NULL;
   const char *savefile_root          = NULL;
   size_t savefile_root_length        = 0;

   size_t i, cnt                      = 0;
   size_t cnt_in_range                = 0;

   fill_pathname_basedir(state_dir, name_savestate,
         sizeof(state_dir));

   if (!(dir_list = dir_list_new_special(state_dir,
               DIR_LIST_PLAIN, NULL, show_hidden_files)))
      return;

   fill_pathname_base(state_base, name_savestate, sizeof(state_base));

   for (i = 0; i < dir_list->size; i++)
   {
      unsigned idx;
      size_t _len;
      char elem_base[128];
      const char *ext      = NULL;
      const char *end      = NULL;
      const char *dir_elem = dir_list->elems[i].data;

      if (!dir_elem || !*dir_elem)
         continue;

      _len = strlen(dir_elem);
      fill_pathname_base(elem_base, dir_elem, sizeof(elem_base));

      /* Only consider files with a '.state' extension
       * > i.e. Ignore '.state.auto', '.state.bak', etc. */
      ext = path_get_extension(elem_base);
      if (    (!ext || !*ext)
          || !string_starts_with_size(ext, "state", STRLEN_CONST("state")))
         continue;

      /* Check whether this file is associated with
       * the current content */
      if (!string_starts_with(elem_base, state_base))
         continue;

      /* This looks like a valid savestate */
      /* Save filename root and length (once) */
      if (savefile_root_length == 0)
      {
         savefile_root        = dir_elem;
         savefile_root_length = _len;
      }

      /* Decode the savestate index */
      end = dir_elem + _len;
      while ((end > dir_elem) && ISDIGIT((int)end[-1]))
      {
         end--;
         if (savefile_root == dir_elem)
            savefile_root_length--;
      }
      idx = string_to_unsigned(end);

      /* Simple administration: max, total. */
      if (idx > max_idx)
         max_idx = idx;
      cnt++;
      if (idx <= savestate_max_keep)
         cnt_in_range++;

      /* Maintain a 2x512 bit map of occupied save states */
      if (idx < 512)
         BIT512_SET(slot_mapping_low,idx);
      else if (idx < 1024)
         BIT512_SET(slot_mapping_high, idx - 512);
   }

   /* Next loop on the bitmap, since the file system may have presented the files in any order above */
   for (i = 0; i <= savestate_max_keep; i++)
   {
      /* Unoccupied save slots */
      if (   (i < 512 && !BIT512_GET(slot_mapping_low,  i))
          || (i > 511 && !BIT512_GET(slot_mapping_high, i-512)))
      {
         /* Gap index: lowest free slot in the wraparound range */
         if (gap_idx == UINT_MAX)
            gap_idx = (unsigned)i;
      }
      else /* Occupied save slots */
      {
         /* Del index: first occupied slot in the wraparound range,
            after gap index */
         if (    gap_idx < UINT_MAX && del_idx == UINT_MAX)
            del_idx = (unsigned)i;
      }
   }

   /* Special cases of wraparound */

   /* No previous savestate - set to end, so that first save
      goes to 0 */
   if (cnt_in_range == 0)
   {
      if (cnt == 0)
         loa_idx = savestate_max_keep;
      /* Transient: nothing in current range, but something is present
       * higher up -> load that */
      else
         loa_idx = max_idx;
      gap_idx    = savestate_max_keep;
      del_idx    = savestate_max_keep;
   }
   /* No gap was found - deduct from current index or default
      and set (missing) gap index to be deleted */
   else if (gap_idx == UINT_MAX)
   {
      /* Transient: no gap, and max is higher than currently
       * allowed -> load that, but wrap around so that next
       * time gap will be present */
      if (max_idx > savestate_max_keep)
      {
         loa_idx = max_idx;
         gap_idx = 1;
      }
      /* Current index is in range, so let's assume it is correct */
      else if ( (unsigned)curr_state_slot < savestate_max_keep)
      {
         loa_idx = curr_state_slot;
         gap_idx = curr_state_slot + 1;
      }
      else
      {
         loa_idx = savestate_max_keep;
         gap_idx = 0;
      }
      del_idx    = gap_idx;
   }
   /* Gap was found */
   else
   {
      /* No candidate to delete */
      /* Either gap is at the end of the range: wraparound.
         or there is no better idea than the lowest index  */
      if (del_idx == UINT_MAX)
         del_idx = 0;
      /* Adjust load index */
      if (gap_idx == 0)
         loa_idx = savestate_max_keep;
      else
         loa_idx = gap_idx - 1;
   }

   RARCH_DBG("[State] Save state scanning finished, used slots (in range): "
             "%d (%d), max:%d, load index %d, gap index %d, delete index %d.\n",
             cnt, cnt_in_range, max_idx, loa_idx, gap_idx, del_idx);

   if (last_index)
         *last_index = loa_idx;

   if (     s
         && cnt_in_range >= savestate_max_keep)
   {
      strlcpy(s, savefile_root, savefile_root_length + 1);
      /* ".state0" is just ".state" instead, so don't print that. */
      if (del_idx > 0)
         snprintf(s + savefile_root_length, 5, "%d", del_idx);
   }

   dir_list_free(dir_list);
}

/**
 * Determines next savestate slot in case of auto-increment,
 * i.e. save state scanning was done already earlier.
 * Logic moved here so that all save state wraparound code is
 * in this file.
 *
 * @param settings The usual RetroArch settings ptr.
 * @return \c The next savestate slot.
 */
int command_event_get_next_savestate_auto_index(settings_t *settings)
{
   unsigned savestate_max_keep = settings->uints.savestate_max_keep;
   int new_state_slot          = settings->ints.state_slot + 1;
   /* If previous save was above the wraparound range, or it overflows,
      return to the start of the range. */
   if (     (savestate_max_keep > 0)
         && (unsigned)new_state_slot > savestate_max_keep)
      return 0;
   return new_state_slot;
}

/**
 * Determines most recent savestate slot in case of content load.
 *
 * @param settings The usual RetroArch settings ptr.
 * @return \c The most recent savestate slot.
 */
void command_event_set_savestate_auto_index(settings_t *settings)
{
   unsigned max_idx          = 0;
   bool savestate_auto_index = settings->bools.savestate_auto_index;
   if (savestate_auto_index)
   {
      int prev_slot          = settings->ints.state_slot;
      command_scan_states(
            settings->bools.show_hidden_files,
            settings->uints.savestate_max_keep,
            settings->ints.state_slot, &max_idx, NULL);
      configuration_set_int(settings, settings->ints.state_slot, max_idx);
      RARCH_LOG("[State] %s: #%d (slot reset %d -> %u from on-disk scan, "
            "max_keep %u). If the previous slot was higher, earlier saves "
            "may be missing on disk.\n",
            msg_hash_to_str(MSG_FOUND_LAST_STATE_SLOT),
            max_idx, prev_slot, max_idx,
            settings->uints.savestate_max_keep);
   }
   else
      /* Reset savestate index to 0 when loading content. */
      configuration_set_int(settings, settings->ints.state_slot, 0);
}

/**
 * Deletes the oldest save state and its thumbnail, if needed.
 *
 * @param settings The usual RetroArch settings ptr.
 */
static void command_event_set_savestate_garbage_collect(settings_t *settings)
{
   size_t i;
   char state_to_delete[PATH_MAX_LENGTH] = {0};
   command_scan_states(
         settings->bools.show_hidden_files,
         settings->uints.savestate_max_keep,
         settings->ints.state_slot, NULL, state_to_delete);
   /* Only delete one save state per save action
    * > Conservative behaviour, designed to minimise
    *   the risk of deleting multiple incorrect files
    *   in case of accident */
   if (*state_to_delete)
   {
      filestream_delete(state_to_delete);
      RARCH_DBG("[State] Garbage collect, deleting \"%s\".\n",state_to_delete);
      /* Construct the save state thumbnail name
       * and delete that one as well. */
      i = strlen(state_to_delete);
      strlcpy_lit(state_to_delete + i,".png",STRLEN_CONST(".png")+1);
      filestream_delete(state_to_delete);
      RARCH_DBG("[State] Garbage collect, deleting \"%s\".\n",state_to_delete);
   }
}

void command_event_set_replay_auto_index(settings_t *settings)
{
   size_t i;
   char elem_base[128];
   char state_base[128];
   char state_dir[DIR_MAX_LENGTH];

   struct string_list *dir_list      = NULL;
   unsigned max_idx                  = 0;
   runloop_state_t *runloop_st       = runloop_state_get_ptr();
   const char *name_replay           = runloop_st->name.replay;
   bool replay_auto_index            = settings->bools.replay_auto_index;
   bool show_hidden_files            = settings->bools.show_hidden_files;

   if (!replay_auto_index)
      return;
   /* Find the file in the same directory as runloop_st->name.replay
    * with the largest numeral suffix.
    *
    * E.g. /foo/path/content.replay will try to find
    * /foo/path/content.replay%d, where %d is the largest number available.
    */
   fill_pathname_basedir(state_dir, name_replay,
         sizeof(state_dir));

   if (!(dir_list = dir_list_new_special(state_dir,
               DIR_LIST_PLAIN, NULL, show_hidden_files)))
      return;

   fill_pathname_base(state_base, name_replay, sizeof(state_base));

   for (i = 0; i < dir_list->size; i++)
   {
      unsigned idx;
      const char *end                 = NULL;
      const char *dir_elem            = dir_list->elems[i].data;
      size_t _len = fill_pathname_base(elem_base, dir_elem, sizeof(elem_base));

      if (strstr(elem_base, state_base) != elem_base)
         continue;

      end = dir_elem + _len;

      while ((end > dir_elem) && ISDIGIT((int)end[-1]))
         end--;

      idx = (unsigned)strtoul(end, NULL, 0);
      if (idx > max_idx)
         max_idx = idx;
   }

   dir_list_free(dir_list);

   configuration_set_int(settings, settings->ints.replay_slot, max_idx);

   if (max_idx)
      RARCH_LOG("[Replay] %s: #%d\n",
            msg_hash_to_str(MSG_FOUND_LAST_REPLAY_SLOT),
            max_idx);
}

void command_event_set_replay_garbage_collect(
      unsigned max_to_keep,
      bool show_hidden_files
      )
{
  /* TODO: debugme */
   size_t i, cnt = 0;
   char tmp[DIR_MAX_LENGTH];
   runloop_state_t *runloop_st       = runloop_state_get_ptr();
   const char *name_replay           = runloop_st->name.replay;
   struct string_list *dir_list      = NULL;
   unsigned min_idx                  = UINT_MAX;
   const char *oldest_save           = NULL;

   /* Similar to command_event_set_replay_auto_index(),
    * this will find the lowest numbered replay */
   fill_pathname_basedir(tmp, name_replay, sizeof(tmp));

   if (!(dir_list = dir_list_new_special(tmp,
               DIR_LIST_PLAIN, NULL, show_hidden_files)))
      return;

   fill_pathname_base(tmp, name_replay, sizeof(tmp));

   for (i = 0; i < dir_list->size; i++)
   {
      unsigned idx;
      size_t _len;
      char elem_base[128];
      const char *ext                 = NULL;
      const char *end                 = NULL;
      const char *dir_elem            = dir_list->elems[i].data;

      if (!dir_elem || !*dir_elem)
         continue;

      _len = fill_pathname_base(elem_base, dir_elem, sizeof(elem_base));

      /* Only consider files with a '.replayXX' extension
       * > i.e. Ignore '.replay.auto', '.replay.bak', etc. */
      ext = path_get_extension(elem_base);
      if (    (!ext || !*ext)
          || !string_starts_with_size(ext, "replay", STRLEN_CONST("REPLAY")))
         continue;

      /* Check whether this file is associated with
       * the current content */
      if (!string_starts_with(elem_base, tmp))
         continue;

      /* This looks like a valid save */
      cnt++;

      /* > Get index */
      end = dir_elem + _len;

      while ((end > dir_elem) && ISDIGIT((int)end[-1]))
         end--;

      idx = string_to_unsigned(end);

      /* > Check if this is the lowest index so far */
      if (idx < min_idx)
      {
         min_idx     = idx;
         oldest_save = dir_elem;
      }
   }

   /* Only delete one save state per save action
    * > Conservative behaviour, designed to minimise
    *   the risk of deleting multiple incorrect files
    *   in case of accident */
   if (oldest_save && *oldest_save && (cnt > max_to_keep))
      filestream_delete(oldest_save);

   dir_list_free(dir_list);
}

#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
bool command_set_shader(command_t *cmd, const char *arg)
{
   enum  rarch_shader_type type = video_shader_parse_type(arg);
   settings_t  *settings        = config_get_ptr();
   bool apply_new_shader        = arg && *arg;
   char abs_arg[PATH_MAX_LENGTH];
#ifdef HAVE_COMMAND
   struct command_reply *r;
#endif

   if (apply_new_shader)
   {
      gfx_ctx_flags_t flags;
      flags.flags     = 0;
      video_context_driver_get_flags(&flags);

      if (!BIT32_GET(flags.flags, video_shader_type_to_flag(type)))
      {
         command_reply_error(cmd, "SET_SHADER",
               "the video driver cannot run this kind of shader");
         return false;
      }

      /* rebase on shader directory */
      if (!path_is_absolute(arg))
      {
         const char *ref_path = settings->paths.directory_video_shader;
         fill_pathname_join_special(abs_arg, ref_path, arg, sizeof(abs_arg));
         arg = abs_arg;
      }
      /* drivers fall back to the stock shader for a preset they
       * cannot read, and call that success */
      if (!path_is_valid(arg))
      {
         command_reply_error(cmd, "SET_SHADER", "no shader preset at %s",
               arg);
         return false;
      }
   }

   /* only once it is known what to apply: a refused preset leaves the
    * setting as it was */
   configuration_set_bool(settings, settings->bools.video_shader_enable, apply_new_shader);
   if (!video_shader_apply_shader(settings, type, arg, true))
   {
      command_reply_error(cmd, "SET_SHADER",
            apply_new_shader ? "the preset could not be applied"
                             : "the shader could not be turned off");
      return false;
   }

#ifdef HAVE_COMMAND
   /* A deferred load compiles over the next frames: answered once it
    * is through. */
   if (cmd && cmd->structured && (r = command_reply_new("SET_SHADER")))
   {
      if (video_shader_deferred_notify(command_reply_done, r))
      {
         command_deferred_take(&r->deferred, cmd);
         return true;
      }
      free(r);
   }
#endif
   return true;
}
#endif

#ifdef HAVE_CONFIGFILE
bool command_event_save_core_config(
      const char *dir_menu_config,
      const char *rarch_path_config)
{
   char msg[128];
   char config_dir[DIR_MAX_LENGTH];
   char config_path[PATH_MAX_LENGTH];
   char config_name[NAME_MAX_LENGTH];
   size_t _len                     = 0;
   bool new_path_available         = false;
   bool overrides_active           = false;
   const char *core_path           = NULL;
   runloop_state_t *runloop_st     = runloop_state_get_ptr();

   msg[0]                          = '\0';

   if (dir_menu_config && *dir_menu_config)
      _len = strlcpy(config_dir, dir_menu_config, sizeof(config_dir));
   else if (rarch_path_config && *rarch_path_config) /* Fallback */
      _len = fill_pathname_basedir(config_dir, rarch_path_config,
            sizeof(config_dir));

   if (_len == 0)
   {
      const char *_msg = msg_hash_to_str(MSG_CONFIG_DIRECTORY_NOT_SET);
      runloop_msg_queue_push(_msg, strlen(_msg), 1, 180, true, NULL,
            MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
      RARCH_ERR("[Config] %s\n", _msg);
      return false;
   }

   core_path                       = path_get(RARCH_PATH_CORE);

   /* Infer file name based on libretro core. */
   if (path_is_valid(core_path))
   {
      unsigned i;
      char tmp[PATH_MAX_LENGTH + 8];
      RARCH_LOG("[Config] %s\n", msg_hash_to_str(MSG_USING_CORE_NAME_FOR_NEW_CONFIG));

      fill_pathname(config_name, path_basename(core_path), "",
            sizeof(config_name));
      fill_pathname_join_special(config_path, config_dir, config_name,
            sizeof(config_path));

      /* In case of collision, find an alternative name. */
      for (i = 0; i < 16; i++)
      {
         size_t __len = strlcpy(tmp, config_path, sizeof(tmp));

         if (i)
            __len += snprintf(tmp + __len, sizeof(tmp) - __len, "-%u", i);
         strlcpy_lit(tmp + __len, ".cfg", sizeof(tmp) - __len);

         if (!path_is_valid(tmp))
         {
            strlcpy(config_path, tmp, sizeof(config_path));
            new_path_available = true;
            break;
         }
      }
   }

   if (!new_path_available)
   {
      /* Fallback to system time... */
      RARCH_WARN("[Config] %s\n",
            msg_hash_to_str(MSG_CANNOT_INFER_NEW_CONFIG_PATH));
      fill_dated_filename(config_name, ".cfg", sizeof(config_name));
      fill_pathname_join_special(config_path, config_dir, config_name,
            sizeof(config_path));
   }

   if (runloop_st->flags & RUNLOOP_FLAG_OVERRIDES_ACTIVE)
   {
      /* Overrides block config file saving,
       * make it appear as overrides weren't enabled
       * for a manual save. */
      runloop_st->flags &= ~RUNLOOP_FLAG_OVERRIDES_ACTIVE;
      overrides_active   = true;
   }

#ifdef HAVE_CONFIGFILE
   _len = command_event_save_config(config_path, msg, sizeof(msg));
#endif

   if (_len > 0)
      runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
            MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);

   if (overrides_active)
      runloop_st->flags |=  RUNLOOP_FLAG_OVERRIDES_ACTIVE;
   else
      runloop_st->flags &= ~RUNLOOP_FLAG_OVERRIDES_ACTIVE;

   return true;
}

void command_event_save_current_config(enum override_type type)
{
   runloop_state_t *runloop_st     = runloop_state_get_ptr();

   switch (type)
   {
      default:
      case OVERRIDE_NONE:
         {
            size_t _len;
            char msg[256];
            enum message_queue_category msg_cat = MESSAGE_QUEUE_CATEGORY_INFO;

            msg[0] = '\0';

            if (path_is_empty(RARCH_PATH_CONFIG))
            {
               msg_cat = MESSAGE_QUEUE_CATEGORY_ERROR;
               _len    = strlcpy_lit(msg, "Config directory not set, cannot save configuration.", sizeof(msg));
            }
            else
            {
               if (runloop_st->flags & RUNLOOP_FLAG_OVERRIDES_ACTIVE)
               {
                  msg_cat = MESSAGE_QUEUE_CATEGORY_ERROR;
                  _len    = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ACTIVE_NOT_SAVING), sizeof(msg));
               }
               else
               {
                  msg_cat = MESSAGE_QUEUE_CATEGORY_SUCCESS;
                  _len    = command_event_save_config(path_get(RARCH_PATH_CONFIG), msg, sizeof(msg));
               }
            }

            /* command_event_save_config() does its own logging */
            if (msg_cat == MESSAGE_QUEUE_CATEGORY_ERROR)
               RARCH_ERR("[Override] %s\n", msg);

            runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
                  MESSAGE_QUEUE_ICON_DEFAULT, msg_cat);
         }
         break;
      case OVERRIDE_GAME:
      case OVERRIDE_CORE:
      case OVERRIDE_CONTENT_DIR:
         {
            size_t _len;
            char msg[256];
            int8_t ret      = config_save_overrides(type, &runloop_st->system, false, NULL);
            enum message_queue_category msg_cat = MESSAGE_QUEUE_CATEGORY_INFO;

            switch (ret)
            {
               case 1:
                  msg_cat = MESSAGE_QUEUE_CATEGORY_SUCCESS;
                  _len    = strlcpy(msg,
                        msg_hash_to_str(MSG_OVERRIDES_SAVED_SUCCESSFULLY), sizeof(msg));
                  /* set overrides to active so the original config can be
                     restored after closing content */
                  runloop_st->flags |= RUNLOOP_FLAG_OVERRIDES_ACTIVE;
                  break;
               case -1:
                  msg_cat = MESSAGE_QUEUE_CATEGORY_WARNING;
                  _len    = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_NOT_SAVED), sizeof(msg));
                  break;
               default:
               case 0:
                  msg_cat = MESSAGE_QUEUE_CATEGORY_ERROR;
                  _len = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_SAVING), sizeof(msg));
                  break;
            }

            switch (msg_cat)
            {
               case MESSAGE_QUEUE_CATEGORY_ERROR:
                  RARCH_ERR("[Override] %s\n", msg);
                  break;
               case MESSAGE_QUEUE_CATEGORY_WARNING:
                  RARCH_WARN("[Override] %s\n", msg);
                  break;
               case MESSAGE_QUEUE_CATEGORY_SUCCESS:
               default:
                  RARCH_LOG("[Override] %s\n", msg);
                  break;
            }

            runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
                  MESSAGE_QUEUE_ICON_DEFAULT, msg_cat);

#ifdef HAVE_MENU
            {
               struct menu_state *menu_st      = menu_state_get_ptr();
               menu_st->flags                 |=  MENU_ST_FLAG_ENTRIES_NEED_REFRESH
                                               |  MENU_ST_FLAG_PREVENT_POPULATE;
            }
#endif
         }
         break;
   }
}

void command_event_remove_current_config(enum override_type type)
{
   runloop_state_t *runloop_st     = runloop_state_get_ptr();

   switch (type)
   {
      default:
      case OVERRIDE_NONE:
         break;
      case OVERRIDE_GAME:
      case OVERRIDE_CORE:
      case OVERRIDE_CONTENT_DIR:
         {
            size_t _len;
            char msg[256];
            enum message_queue_category msg_cat = MESSAGE_QUEUE_CATEGORY_INFO;

            if (config_save_overrides(type, &runloop_st->system, true, NULL))
            {
               msg_cat = MESSAGE_QUEUE_CATEGORY_SUCCESS;
               _len    = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_REMOVED_SUCCESSFULLY), sizeof(msg));
            }
            else
            {
               msg_cat = MESSAGE_QUEUE_CATEGORY_ERROR;
               _len    = strlcpy(msg, msg_hash_to_str(MSG_OVERRIDES_ERROR_REMOVING), sizeof(msg));
            }

            if (msg_cat == MESSAGE_QUEUE_CATEGORY_ERROR)
               RARCH_ERR("[Override] %s\n", msg);
            else
               RARCH_LOG("[Override] %s\n", msg);

            runloop_msg_queue_push(msg, _len, 1, 180, true, NULL,
                  MESSAGE_QUEUE_ICON_DEFAULT, msg_cat);
#ifdef HAVE_MENU
            {
               struct menu_state *menu_st      = menu_state_get_ptr();
               menu_st->flags                 |=  MENU_ST_FLAG_ENTRIES_NEED_REFRESH
                                               |  MENU_ST_FLAG_PREVENT_POPULATE;
            }
#endif
         }
         break;
   }
}
#endif

bool command_event_main_state(unsigned cmd)
{
   char msg[128]               = "";
   char state_path[PATH_MAX_LENGTH] = "";
   size_t _len                 = 0;
   settings_t *settings        = config_get_ptr();
   bool savestates_enabled     = core_info_current_supports_savestate();
   bool ret                    = false;

   if (savestates_enabled)
   {
      size_t info_size;
      runloop_get_current_savestate_path(state_path,
            sizeof(state_path));

      info_size          = core_serialize_size();
      savestates_enabled = (info_size > 0);
   }

  /* TODO: Load state should act in one of three ways:
     - [X] Not during recording or playback: normally
     - [-] During playback: If the state is part of this replay, go back to
           that state and rewind the replay (not yet implemented); otherwise
           halt playback and go to that state normally.
     - [-] During recording: If the state is part of this replay, go back to
           that state and rewind the replay, clobbering the stuff in between
           then and now (not yet implemented); if the state is not part of
           the replay, do nothing and log a warning.
   */
   if (savestates_enabled)
   {
      switch (cmd)
      {
         case CMD_EVENT_SAVE_STATE:
         case CMD_EVENT_SAVE_STATE_TO_RAM:
            {
               /* TODO: Saving state during recording should associate
                * the state with the replay. */
               video_driver_state_t *video_st                 =
                  video_state_get_ptr();
               bool savestate_auto_index                      =
                     settings->bools.savestate_auto_index;
               unsigned savestate_max_keep                    =
                     settings->uints.savestate_max_keep;
               bool frame_time_counter_auto_reset             =
                     settings->bools.frame_time_counter_auto_reset;
               bool queued                                    = true;

               if (cmd == CMD_EVENT_SAVE_STATE)
               {
                  queued = content_save_state(state_path, true);
                  RARCH_LOG("[State] Save dispatch for slot %d, path "
                        "\"%s\": content_save_state queued=%s "
                        "(auto_index=%s, max_keep=%u). NOTE: actual disk "
                        "write is asynchronous; success is only known when "
                        "the save task completes.\n",
                        settings->ints.state_slot, state_path,
                        queued ? "yes" : "NO",
                        savestate_auto_index ? "on" : "off",
                        savestate_max_keep);
                  /* Turned away - the saves and loads held behind the
                   * one in flight are already at their bound: said,
                   * rather than the hotkey doing nothing */
                  if (!queued)
                     _len = snprintf(msg, sizeof(msg), "%s \"%s\".",
                           msg_hash_to_str(MSG_FAILED_TO_SAVE_STATE_TO),
                           path_basename(state_path));
               }
               else
                  content_save_state_to_ram();

               /* Clean up excess savestates if necessary: not for a
                * save that was turned away, which wrote nothing */
               if (     queued
                     && savestate_auto_index && (savestate_max_keep > 0))
                  command_event_set_savestate_garbage_collect(settings);

               if (frame_time_counter_auto_reset)
                  video_st->frame_time_count = 0;

               /* false for a save turned away, so the caller can take
                * back the slot it advanced for it */
               ret      = queued;
            }
            break;
         case CMD_EVENT_LOAD_STATE:
         case CMD_EVENT_LOAD_STATE_FROM_RAM:
            {
               bool res = false;
               if (cmd == CMD_EVENT_LOAD_STATE)
                  res = content_load_state(state_path, false, false);
               else
                  res = content_load_state_from_ram();

               if (res)
               {
                  command_post_state_loaded();
                  ret = true;
               }
               /* Turned away (the hold behind the state task in flight
                * is full) or not begun: said, rather than nothing */
               else if (cmd == CMD_EVENT_LOAD_STATE)
                  _len = strlcpy(msg,
                        msg_hash_to_str(MSG_FAILED_TO_LOAD_STATE),
                        sizeof(msg));
            }
            break;
        case CMD_EVENT_UNDO_LOAD_STATE:
           {
              /* TODO: To support this through re-recording would take some
               * care around moving the replay recording forward to the time
               * when the undo happened, which would need undo support for
               * replays. For now, forbid it during recording and halt
               * playback. */
#ifdef HAVE_BSV_MOVIE
              input_driver_state_t *input_st   = input_state_get_ptr();
              if (input_st->bsv_movie_state.flags & BSV_FLAG_MOVIE_RECORDING)
              {
                 RARCH_ERR("[State] Can't undo load state during movie record.\n");
                 return false;
              }
              if (input_st->bsv_movie_state.flags & BSV_FLAG_MOVIE_PLAYBACK)
              {
                 RARCH_LOG("[State] Undo load state during movie playback, halting playback.\n");
                 movie_stop(input_st);
              }
#endif
              _len = command_event_undo_load_state(msg, sizeof(msg));
              ret = true;
              break;
            }
         case CMD_EVENT_UNDO_SAVE_STATE:
            _len = command_event_undo_save_state(msg, sizeof(msg));
            ret  = true;
            break;
      }
   }
   else
      _len = strlcpy(msg, msg_hash_to_str(
               MSG_CORE_DOES_NOT_SUPPORT_SAVESTATES), sizeof(msg));

   if (_len > 0)
   {
      runloop_msg_queue_push(msg, _len, 2, 180, true, NULL,
            MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
      RARCH_LOG("[State] %s\n", msg);
   }

   return ret;
}

bool command_event_disk_control_append_image(
      const char *path)
{
   runloop_state_t *runloop_st    = runloop_state_get_ptr();
   rarch_system_info_t *sys_info  = runloop_st ? (rarch_system_info_t*)&runloop_st->system : NULL;
   if (     !sys_info
         || !disk_control_append_image(&sys_info->disk_control, path))
      return false;

#ifdef HAVE_THREADS
   if (runloop_st->flags & RUNLOOP_FLAG_USE_SRAM)
      autosave_deinit();
#endif

   command_event(CMD_EVENT_AUTOSAVE_INIT, NULL);

   return true;
}

/* Read-side callback for the snapshot phase of command_event_reinit.
 * Receives the cached frame's pixels (or NULL if HW-render / no
 * cached frame), copies into the static reuse buffer, and reports
 * dims back to the caller via userdata.  Skips the work entirely
 * if data is NULL -- caller checks the reported size to know
 * whether a snapshot was actually taken. */
struct command_reinit_snapshot_ctx
{
   void   **buf_p;       /* static cached_snapshot in the caller */
   size_t  *cap_p;       /* static cached_snapshot_cap in the caller */
   unsigned dims;
   size_t   p, size;
};

static void command_reinit_snapshot_cb(void *userdata,
      const void *data,
      unsigned dims, size_t pitch)
{
   struct command_reinit_snapshot_ctx *ctx
      = (struct command_reinit_snapshot_ctx*)userdata;
   size_t want;

   if (!ctx || !data || !VIDEO_SCALE_W(dims) || !VIDEO_SCALE_H(dims) || !pitch)
      return;

   want = pitch * VIDEO_SCALE_H(dims);
   if (want > *ctx->cap_p)
   {
      void *tmp = realloc(*ctx->buf_p, want);
      if (!tmp)
         return;
      *ctx->buf_p = tmp;
      *ctx->cap_p = want;
   }
   if (!*ctx->buf_p)
      return;

   memcpy(*ctx->buf_p, data, want);
   ctx->dims = dims;
   ctx->p    = pitch;
   ctx->size = want;
}

bool command_event_reinit(const int flags)
{
   settings_t *settings           = config_get_ptr();
   video_driver_state_t *video_st = video_state_get_ptr();
#ifdef HAVE_MENU
   gfx_display_t *p_disp          = disp_get_ptr();
   struct menu_state *menu_st     = menu_state_get_ptr();
   bool video_fullscreen          = settings->bools.video_fullscreen;
   bool adaptive_vsync            = settings->bools.video_adaptive_vsync;
   unsigned swap_interval_config  = settings->uints.video_swap_interval;
#endif
   enum input_game_focus_cmd_type
      game_focus_cmd              = GAME_FOCUS_CMD_REAPPLY;

   /* Snapshot the last cached core frame before tearing the video
    * driver down.  video_driver_free() invalidates the cache as
    * part of the reinit cycle (the pointer was borrowed from the
    * core's own framebuffer and isn't guaranteed to stay live
    * across the driver swap), so without a snapshot the new
    * driver would come up with no core image to replay.  Restored
    * + replayed below so the paused-core background remains
    * visible when reinit is triggered from inside the menu (e.g.
    * HDR mode toggle).
    *
    * The snapshot buffer is static and reused across reinits — we
    * need it to outlive command_event_reinit because we publish
    * the pointer back through video_driver_cached_frame_publish
    * for the new driver to read via video_driver_cached_frame(),
    * and the core's next real frame will replace the pointer at
    * its leisure.  Resizing in place on each call keeps it
    * bounded at one buffer's worth.
    *
    * The actual copy happens inside the cached_frame_read
    * callback (which is what this function was hand-rolling
    * before the unified read API existed -- exactly the same
    * pattern, lifted into one place).  HW-render frames are
    * skipped: the callback receives data == NULL for those, so
    * we don't even allocate. */
   static void  *cached_snapshot      = NULL;
   static size_t cached_snapshot_cap  = 0;
   unsigned      cached_snapshot_dims = 0;
   size_t        cached_snapshot_p    = 0;
   size_t        cached_snapshot_size = 0;
   /* A reinit while the video driver is down must not create a
    * driver instance. It happens when content loads over running
    * content: core deinit tears the drivers down, then unloading
    * the old content's override fires CMD_EVENT_REINIT (the
    * override changed video_fullscreen, and CORE_RUNNING is still
    * set). An instance created here is replaced by
    * retroarch_main_init's drivers_init without being freed - an
    * orphaned window and device that widget fonts keep drawing
    * into - while the next drivers_init applies the restored mode
    * anyway. Guarded here, in the layer that owns reinit, so every
    * caller is covered and call sites stay bare command_events.
    *
    * The reasons the pointer is captured for are kept above the
    * drivers, so there is nothing to put right about the grab here:
    * the next video driver has them applied to it. */
   if (!video_st->data)
      return false;

   /* A staged content load ends in a reinit of every driver against
    * the new core: one asked for before then - the old override
    * unloading, the new core's SET_SYSTEM_AV_INFO - would rebuild
    * the drivers the stage is about to rebuild again. */
   if (runloop_is_content_switching())
      return false;

   if (recording_gpu_defer_reinit(flags))
      return true;



   {
      struct command_reinit_snapshot_ctx ctx;
      ctx.buf_p = &cached_snapshot;
      ctx.cap_p = &cached_snapshot_cap;
      ctx.dims  = 0;
      ctx.p     = 0;
      ctx.size  = 0;
      video_driver_cached_frame_read(&ctx, command_reinit_snapshot_cb);
      cached_snapshot_dims = ctx.dims;
      cached_snapshot_p    = ctx.p;
      cached_snapshot_size = ctx.size;
   }
   (void)cached_snapshot_size;

   video_driver_reinit(flags);

   /* The hotkey that asked for this may still be down, and is not to
    * ask again when the new window gets the focus. */
   input_driver_hold_over_window_change();

   /* Restore the snapshot and ask the new driver to replay it so the
    * paused-core background appears in the first post-reinit frame.
    * The buffer stays live across subsequent frame_cb calls from the
    * core (which overwrite the pointer) and is reused on the next
    * reinit.  The static cached_snapshot itself is not freed at
    * shutdown - it's a one-shot leak bounded at one framebuffer's
    * worth of memory, reclaimed by the OS on process exit.  Adding
    * a teardown hook would mean wiring command_event_reinit's
    * statics into retroarch_deinit_drivers; the size cap makes the
    * leak benign in practice, so we leave it. */
   if (cached_snapshot_p && VIDEO_SCALE_H(cached_snapshot_dims))
   {
      video_driver_cached_frame_publish(cached_snapshot,
            cached_snapshot_dims, cached_snapshot_p);

#ifdef HAVE_MENU
      /* If the menu is alive across the reinit, the runloop's
       * pre-frame menu work (driver_ctx->render +
       * set_texture_enable) doesn't get a chance to run before
       * the cached_frame() replay below.  Two consequences if we
       * don't reproduce that work here:
       *
       * 1. The new video driver instance starts with its
       *    menu-texture flag (D3D11_ST_FLAG_MENU_ENABLE,
       *    GL2_FLAG_MENU_TEXTURE_ENABLE, etc.) cleared, so the
       *    replay frame falls into the driver's "else if
       *    (statistics_show)" branch and draws OSD stats on the
       *    bare core framebuffer instead of the menu overlay.
       *
       * 2. Menu drivers like ozone cache layout/font dimensions
       *    keyed on the previous viewport size and only
       *    recompute them when their render() callback notices a
       *    width/height change.  If we replay before render()
       *    runs, the menu draws at the old (windowed) scale into
       *    the new (fullscreen) viewport, so fonts and widgets
       *    appear undersized for one frame until the next
       *    runloop iteration corrects them.
       *
       * Mirroring the runloop's pre-frame menu sequence here --
       * render with the new dimensions, then raise the
       * texture-enable flag -- keeps the snapshot replay
       * visually consistent with subsequent frames.
       *
       * Gated on a valid snapshot: without one we won't be
       * pushing a replay frame anyway, and calling render() on a
       * freshly-(re)initialised menu driver before the runloop
       * has had a chance to populate it can leave it in a
       * partially-computed state for the next real frame
       * (e.g. ozone clears OZONE_FLAG_NEED_COMPUTE after a
       * premature render). */
      if (menu_st->flags & MENU_ST_FLAG_ALIVE)
      {
         unsigned output_size = VIDEO_DRIVER_OUTPUT_DIMS(video_st);
         if (     menu_st->driver_ctx
               && menu_st->driver_ctx->render)
            menu_st->driver_ctx->render(
                  menu_st->userdata, output_size, false);

         if (     video_st->poke
               && video_st->poke->set_texture_enable)
            video_st->poke->set_texture_enable(video_st->data,
                  true, false);
      }
#endif

      video_driver_cached_frame();
   }

   /* Poll input to avoid possibly stale data to corrupt things. */
   input_driver_poll_devices();
   command_event(CMD_EVENT_GAME_FOCUS_TOGGLE, &game_focus_cmd);

#ifdef HAVE_MENU
   p_disp->flags |= GFX_DISP_FLAG_FB_DIRTY;
   if (video_fullscreen)
   {
      if (     video_st->poke
            && video_st->poke->show_mouse)
         video_st->poke->show_mouse(video_st->data, false);
   }
   /* The menu runs with vsync if vsync is on - the rule
    * menu_driver_toggle() applies when the menu comes up - and only
    * then. This used to switch it on whenever the menu was up, whatever
    * the setting: with vsync off, every reinit with the menu up (a
    * fullscreen toggle, say) started the new driver without vsync, as
    * configured, and a few frames later turned it on here, which
    * rebuilds the swapchain that had just been made. The menu ran with
    * a vsync the user had switched off, unlike at startup, and on at
    * least one Windows Vulkan setup the first present after that second
    * swapchain failed or left a dead picture. */
   if (     (menu_st->flags & MENU_ST_FLAG_ALIVE)
         &&  settings->bools.video_vsync
         && !settings->bools.video_scanline_sync
         && video_st->current_video->set_nonblock_state)
      video_st->current_video->set_nonblock_state(
            video_st->data, false,
               video_driver_test_all_flags(GFX_CTX_FLAGS_ADAPTIVE_VSYNC)
            && adaptive_vsync,
            runloop_get_video_swap_interval(swap_interval_config));
#endif
   return true;
}