slocker-lite/src/daemonize.cpp

// Copyright (C) 2026 Viorel Munteanu
//
// This program 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 Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

#include "daemonize.h"

#include <fcntl.h>
#include <unistd.h>

#include <cerrno>
#include <csignal>
#include <cstdlib>
#include <cstring>
#include <filesystem>
#include <system_error>

#include <fmt/core.h>
#include <spdlog/spdlog.h>

#include "pid_file.h"

namespace {

// Only ever one daemonize() call per process, same "singleton runtime state"
// pattern as process.cpp's own g_foreground_child_pid.
int g_report_fd = -1;
std::filesystem::path g_log_path;

// Reads whatever the child reports over the pipe until EOF, extracting the
// "LOG <path>" and (if present) "PID <pid>" lines. Parent-side only.
DaemonizeResult read_daemonize_report(int fd) {
    std::string buffer;
    char chunk[256];
    ssize_t n;
    while ((n = read(fd, chunk, sizeof(chunk))) > 0) {
        buffer.append(chunk, static_cast<size_t>(n));
    }

    DaemonizeResult result;
    size_t pos = 0;
    while (pos < buffer.size()) {
        size_t eol = buffer.find('\n', pos);
        if (eol == std::string::npos) {
            break;
        }
        std::string line = buffer.substr(pos, eol - pos);
        pos = eol + 1;

        if (line.rfind("LOG ", 0) == 0) {
            result.log_path = line.substr(4);
        } else if (line.rfind("PID ", 0) == 0) {
            result.pid = static_cast<pid_t>(std::atoi(line.c_str() + 4));
        }
    }
    return result;
}

void report_line(const std::string& line) {
    if (g_report_fd >= 0) {
        write(g_report_fd, line.data(), line.size());
    }
}

}  // namespace

std::optional<DaemonizeResult> daemonize(const std::string& container_name) {
    int fds[2];
    if (pipe2(fds, O_CLOEXEC) != 0) {
        spdlog::error("failed to set up daemonize pipe: {}", strerror(errno));
        return DaemonizeResult{std::nullopt, ""};
    }

    pid_t pid = fork();
    if (pid < 0) {
        spdlog::error("failed to fork for --daemonize: {}", strerror(errno));
        close(fds[0]);
        close(fds[1]);
        return DaemonizeResult{std::nullopt, ""};
    }

    if (pid > 0) {
        // Parent: block until the child either reports the real pid or exits
        // without ever doing so (a hard failure before bwrap ever started).
        close(fds[1]);
        auto result = read_daemonize_report(fds[0]);
        close(fds[0]);
        return result;
    }

    // Child: detach from the controlling terminal and everything it implies
    // (see daemonize.h for why this, not bwrap's own --new-session).
    close(fds[0]);
    g_report_fd = fds[1];

    setsid();

    struct sigaction ignore_sighup = {};
    ignore_sighup.sa_handler = SIG_IGN;
    sigemptyset(&ignore_sighup.sa_mask);
    sigaction(SIGHUP, &ignore_sighup, nullptr);

    g_log_path = session_log_file_path(container_name, getpid());

    std::error_code ec;
    std::filesystem::create_directories(g_log_path.parent_path(), ec);
    if (ec) {
        spdlog::error("failed to create log directory {}: {}", g_log_path.parent_path().string(), ec.message());
        _exit(1);
    }

    int log_fd = open(g_log_path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (log_fd < 0) {
        spdlog::error("failed to open log file {}: {}", g_log_path.string(), strerror(errno));
        _exit(1);
    }

    int null_fd = open("/dev/null", O_RDONLY);
    if (null_fd >= 0) {
        dup2(null_fd, STDIN_FILENO);
        close(null_fd);
    }
    dup2(log_fd, STDOUT_FILENO);
    dup2(log_fd, STDERR_FILENO);
    close(log_fd);

    report_line(fmt::format("LOG {}\n", g_log_path.string()));

    return std::nullopt;
}

void report_daemon_started(const std::string& container_name, pid_t pid) {
    if (g_report_fd < 0) {
        return;
    }

    auto new_path = session_log_file_path(container_name, pid);
    if (new_path != g_log_path) {
        std::error_code ec;
        std::filesystem::rename(g_log_path, new_path, ec);
        if (ec) {
            spdlog::warn("failed to rename log file {} to {}: {}", g_log_path.string(), new_path.string(),
                         ec.message());
        } else {
            g_log_path = new_path;
            // The parent already got an earlier "LOG" line naming the pre-rename
            // path (sent before the real pid was known) -- report the updated one
            // so it prints the path the file actually ends up at, not a stale one.
            report_line(fmt::format("LOG {}\n", g_log_path.string()));
        }
    }

    report_line(fmt::format("PID {}\n", pid));
    close(g_report_fd);
    g_report_fd = -1;
}