sapi_posix_backend_reboot.c

Go to the documentation of this file.

/* _XOPEN_SOURCE 700 (implies _POSIX_C_SOURCE 200809L) rather than
 * _POSIX_C_SOURCE alone: setenv()/putenv() below are XSI extensions, not
 * base POSIX. */
#define _XOPEN_SOURCE 700

#include "safeapi/posix_backend/sapi_posix_backend.h"
 
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#if defined(__APPLE__)
#include <mach-o/dyld.h>
#endif
 
extern char **environ;

/* No dynamic allocation (REQ-OAL-REBOOT-001's fixed-storage convention,
 * project-wide "no malloc/free/realloc" rule) - a fixed-capacity static
 * array of pointers, not copies of the strings themselves (see
 * sapi_posix_backend_reboot_set_argv()'s own doc for why storing the
 * pointers is sufficient). +1 slot for the NULL terminator execv()
 * requires. */
#define SAPI_POSIX_REBOOT_MAX_ARGV 8U


static bool resolve_self_exe_path(char *out_path, size_t out_path_size, const char *argv0);
static sapi_status_t backend_request(uint16_t reason_code);

static char *s_registered_argv[SAPI_POSIX_REBOOT_MAX_ARGV + 1U];
static bool s_argv_registered = false;
static const sapi_reboot_backend_t s_posix_reboot_backend = { backend_request };

 

void sapi_posix_backend_reboot_set_argv(int argc, char *const argv[])
{
    int count = (argc < 0) ? 0 : argc;
    int i;
 
    if (count > (int)SAPI_POSIX_REBOOT_MAX_ARGV)
    {
        count = (int)SAPI_POSIX_REBOOT_MAX_ARGV;
    }
    for (i = 0; i < count; i++)
    {
        s_registered_argv[i] = argv[i];
    }
    s_registered_argv[count] = NULL;
    s_argv_registered = true;
}
 
const sapi_reboot_backend_t *sapi_posix_backend_reboot(void)
{
    return &s_posix_reboot_backend;
}
 
 
/****Local functions ****/
 
static bool resolve_self_exe_path(char *out_path, size_t out_path_size, const char *argv0)
{
#if defined(__APPLE__)
    uint32_t size = (uint32_t)out_path_size;
 
    if (_NSGetExecutablePath(out_path, &size) == 0)
    {
        return true;
    }
    /* size now holds the required buffer length, but out_path_size is a
     * fixed compile-time buffer here (PATH_MAX) - if that was not enough,
     * there is nothing more this stand-in backend can do. */
    (void)argv0;
    return false;
#elif defined(__linux__)
    ssize_t written = readlink("/proc/self/exe", out_path, out_path_size - 1U);
 
    if ((written <= 0) || ((size_t)written >= out_path_size))
    {
        (void)argv0;
        return false;
    }
    out_path[written] = '\0';
    return true;
#else
    /* Unknown UNIX: best effort only - argv0 may not be a resolvable path
     * (e.g. found via $PATH), which is an honest, documented limitation of
     * this fallback branch, not silently hidden. */
    if ((argv0 == NULL) || (out_path_size == 0U))
    {
        return false;
    }
    (void)snprintf(out_path, out_path_size, "%s", argv0);
    return true;
#endif
}
 
static sapi_status_t backend_request(uint16_t reason_code)
{
    char reason_env[32];
    int written;
    char self_path[PATH_MAX];
 
    written = snprintf(reason_env, sizeof(reason_env), "SAPI_REBOOT_REASON_CODE=%u", (unsigned int)reason_code);
    if ((written > 0) && ((size_t)written < sizeof(reason_env)))
    {
        (void)putenv(reason_env);
    }
 
    /* No argv0 threaded through to this backend (see file header) - the
     * unknown-UNIX fallback branch of resolve_self_exe_path() simply will
     * not have one to fall back to and returns false, same as any other
     * unresolvable-path case. */
    if (!resolve_self_exe_path(self_path, sizeof(self_path), NULL))
    {
        return SAPI_STATUS_NOT_SUPPORTED;
    }
 
    /* Prefer the caller's own original argv (sapi_posix_backend_
     * reboot_set_argv()) if registered, so a re-exec resumes with
     * whatever command-line arguments the caller's own main() depends on
     * - see this file's own header and sapi_posix_backend.h's doc.
     * Otherwise fall back to a self-contained placeholder argv[0]; the
     * kernel/loader resolves the actual executable from self_path either
     * way, not from argv[0]'s string content. */
    if (s_argv_registered)
    {
        (void)execv(self_path, s_registered_argv);
    }
    else
    {
        char *const argv_stub[] = { (char *)"sapi-reboot", NULL };
 
        (void)execv(self_path, argv_stub);
    }
 
    /* Reached only if execv() failed. */
    return SAPI_STATUS_NOT_SUPPORTED;
}