445 lines
16 KiB
C++
445 lines
16 KiB
C++
/*
|
|
* main.cpp
|
|
* MontaukOS userspace print spooler daemon
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include <montauk/syscall.h>
|
|
#include <print/print.hpp>
|
|
#include "test_page_jpeg.hpp"
|
|
|
|
extern "C" {
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
}
|
|
|
|
using namespace print;
|
|
|
|
static constexpr bool ENABLE_BACKGROUND_PROBE = false;
|
|
static constexpr uint64_t DAEMON_STATE_HEARTBEAT_MS = 15000;
|
|
|
|
static char g_last_state_phase[32] = {};
|
|
static char g_last_state_subject[128] = {};
|
|
static char g_last_state_detail[256] = {};
|
|
static uint64_t g_last_state_write_ms = 0;
|
|
|
|
enum class ClaimResult {
|
|
None,
|
|
Claimed,
|
|
Failed,
|
|
};
|
|
|
|
static void write_daemon_state(const char* phase, const char* subject = nullptr,
|
|
const char* detail = nullptr) {
|
|
const char* safe_phase = phase ? phase : "";
|
|
const char* safe_subject = subject ? subject : "";
|
|
const char* safe_detail = detail ? detail : "";
|
|
uint64_t now_ms = montauk::get_milliseconds();
|
|
|
|
if (g_last_state_write_ms != 0
|
|
&& strcmp(g_last_state_phase, safe_phase) == 0
|
|
&& strcmp(g_last_state_subject, safe_subject) == 0
|
|
&& strcmp(g_last_state_detail, safe_detail) == 0
|
|
&& now_ms - g_last_state_write_ms < DAEMON_STATE_HEARTBEAT_MS)
|
|
return;
|
|
|
|
safe_copy(g_last_state_phase, sizeof(g_last_state_phase), safe_phase);
|
|
safe_copy(g_last_state_subject, sizeof(g_last_state_subject), safe_subject);
|
|
safe_copy(g_last_state_detail, sizeof(g_last_state_detail), safe_detail);
|
|
g_last_state_write_ms = now_ms;
|
|
|
|
char now[32] = {};
|
|
now_string(now, sizeof(now));
|
|
|
|
char buf[512];
|
|
int n = snprintf(buf, sizeof(buf),
|
|
"time=%s\npid=%d\nphase=%s\nsubject=%s\ndetail=%s\n",
|
|
now,
|
|
montauk::getpid(),
|
|
safe_phase,
|
|
safe_subject,
|
|
safe_detail);
|
|
if (n < 0) return;
|
|
write_text_file_atomic(SPOOL_DAEMON_STATE_PATH, buf);
|
|
}
|
|
|
|
static void log_msg(const char* fmt, ...) {
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
printf("[printd] ");
|
|
vprintf(fmt, ap);
|
|
printf("\n");
|
|
va_end(ap);
|
|
}
|
|
|
|
static void set_job_state(JobMeta* job, const char* state, const char* message) {
|
|
safe_copy(job->state, sizeof(job->state), state);
|
|
if (message && *message) safe_copy(job->status_message, sizeof(job->status_message), message);
|
|
now_string(job->updated_at, sizeof(job->updated_at));
|
|
}
|
|
|
|
static void set_job_debug(JobMeta* job, const char* detail) {
|
|
if (job == nullptr) return;
|
|
safe_copy(job->debug_info, sizeof(job->debug_info), detail ? detail : "");
|
|
}
|
|
|
|
static void set_job_debug_from_result(JobMeta* job, const IppPrintResult* result, const char* prefix) {
|
|
if (job == nullptr) return;
|
|
char detail[MAX_DEBUG_LEN] = {};
|
|
summarize_ipp_print_result(result, detail, sizeof(detail));
|
|
if (prefix && *prefix) {
|
|
if (detail[0]) {
|
|
char joined[MAX_DEBUG_LEN];
|
|
snprintf(joined, sizeof(joined), "%s; %s", prefix, detail);
|
|
safe_copy(job->debug_info, sizeof(job->debug_info), joined);
|
|
} else {
|
|
safe_copy(job->debug_info, sizeof(job->debug_info), prefix);
|
|
}
|
|
} else {
|
|
safe_copy(job->debug_info, sizeof(job->debug_info), detail);
|
|
}
|
|
}
|
|
|
|
static void persist_job_debug(const char* active_path, JobMeta* job, const char* detail) {
|
|
if (active_path == nullptr || *active_path == '\0' || job == nullptr) return;
|
|
set_job_debug(job, detail);
|
|
now_string(job->updated_at, sizeof(job->updated_at));
|
|
save_job_to_path_atomic(active_path, job);
|
|
}
|
|
|
|
static bool write_pid_file() {
|
|
char pid[32];
|
|
snprintf(pid, sizeof(pid), "%d\n", montauk::getpid());
|
|
return write_text_file_atomic(SPOOL_DAEMON_PID_PATH, pid);
|
|
}
|
|
|
|
static bool move_job_file(const char* src, const char* dst, char* err = nullptr, int err_len = 0) {
|
|
if (err && err_len > 0) err[0] = '\0';
|
|
if (src == nullptr || dst == nullptr || *src == '\0' || *dst == '\0') {
|
|
safe_copy(err, err_len, "invalid source or destination path");
|
|
return false;
|
|
}
|
|
if (rename(src, dst) == 0) return true;
|
|
|
|
uint8_t* data = nullptr;
|
|
int len = 0;
|
|
char io_err[128] = {};
|
|
if (!read_file_bytes(src, &data, &len, io_err, sizeof(io_err))) {
|
|
char detail[160];
|
|
snprintf(detail, sizeof(detail), "rename failed; could not read source (%s)", io_err);
|
|
safe_copy(err, err_len, detail);
|
|
return false;
|
|
}
|
|
|
|
bool ok = write_file_atomic(dst, data, len, io_err, sizeof(io_err));
|
|
free(data);
|
|
if (!ok) {
|
|
char detail[160];
|
|
snprintf(detail, sizeof(detail), "rename failed; could not write destination (%s)", io_err);
|
|
safe_copy(err, err_len, detail);
|
|
return false;
|
|
}
|
|
|
|
if (remove(src) != 0) {
|
|
remove(dst);
|
|
safe_copy(err, err_len, "rename failed; copied destination but could not delete source");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void auto_probe_configured_printer(char* last_uri, int last_uri_len,
|
|
uint64_t* last_probe_ms, bool* last_probe_ok,
|
|
bool force = false) {
|
|
if (last_uri == nullptr || last_probe_ms == nullptr || last_probe_ok == nullptr) return;
|
|
|
|
char current_uri[MAX_PATH_LEN] = {};
|
|
bool have_uri = read_default_printer_uri(current_uri, sizeof(current_uri));
|
|
uint64_t now = montauk::get_milliseconds();
|
|
|
|
if (!have_uri || current_uri[0] == '\0') {
|
|
bool had_cached_uri = last_uri[0] != '\0';
|
|
if (had_cached_uri || file_exists(SPOOL_PROBE_STATE_PATH)) {
|
|
clear_printer_probe_state();
|
|
if (had_cached_uri) log_msg("cleared printer probe state (no default printer configured)");
|
|
}
|
|
last_uri[0] = '\0';
|
|
*last_probe_ms = 0;
|
|
*last_probe_ok = false;
|
|
return;
|
|
}
|
|
|
|
bool uri_changed = strcmp(last_uri, current_uri) != 0;
|
|
if (!force && !uri_changed && *last_probe_ms != 0)
|
|
return;
|
|
|
|
ProbeState state = {};
|
|
char err[128] = {};
|
|
bool ok = probe_printer_uri(current_uri, &state, err, sizeof(err));
|
|
if (!save_printer_probe_state(&state))
|
|
log_msg("warning: failed to persist printer probe state for %s", current_uri);
|
|
|
|
if (ok) {
|
|
if (state.caps.printer_name[0])
|
|
log_msg("auto-probed printer %s (%s)", state.printer_uri, state.caps.printer_name);
|
|
else
|
|
log_msg("auto-probed printer %s", state.printer_uri);
|
|
if (state.detail[0]) log_msg("probe detail: %s", state.detail);
|
|
} else {
|
|
log_msg("auto-probe failed for %s: %s",
|
|
state.printer_uri[0] ? state.printer_uri : current_uri,
|
|
state.message[0] ? state.message : (err[0] ? err : "probe failed"));
|
|
if (state.detail[0]) log_msg("probe detail: %s", state.detail);
|
|
}
|
|
|
|
safe_copy(last_uri, last_uri_len, state.printer_uri[0] ? state.printer_uri : current_uri);
|
|
*last_probe_ms = now;
|
|
*last_probe_ok = ok;
|
|
}
|
|
|
|
static void requeue_stale_active_jobs() {
|
|
DIR* dir = opendir(SPOOL_ACTIVE_DIR);
|
|
if (!dir) return;
|
|
|
|
struct dirent* ent = nullptr;
|
|
while ((ent = readdir(dir)) != nullptr) {
|
|
if (ent->d_name[0] == '.') continue;
|
|
|
|
char src[MAX_PATH_LEN];
|
|
char dst[MAX_PATH_LEN];
|
|
path_join(src, sizeof(src), SPOOL_ACTIVE_DIR, ent->d_name);
|
|
path_join(dst, sizeof(dst), SPOOL_QUEUE_DIR, ent->d_name);
|
|
|
|
JobMeta job = {};
|
|
if (load_job_from_path(src, &job)) {
|
|
set_job_state(&job, "queued", "Re-queued after daemon restart");
|
|
save_job_to_path_atomic(src, &job);
|
|
}
|
|
char move_err[160] = {};
|
|
if (!move_job_file(src, dst, move_err, sizeof(move_err))) {
|
|
log_msg("warning: failed to requeue stale job %s: %s",
|
|
ent->d_name, move_err[0] ? move_err : "move failed");
|
|
}
|
|
}
|
|
closedir(dir);
|
|
}
|
|
|
|
static ClaimResult claim_next_job(char* out_active_path, int out_active_path_len) {
|
|
DIR* dir = opendir(SPOOL_QUEUE_DIR);
|
|
if (!dir) return ClaimResult::None;
|
|
|
|
char best_name[64] = {};
|
|
struct dirent* ent = nullptr;
|
|
while ((ent = readdir(dir)) != nullptr) {
|
|
if (ent->d_name[0] == '.') continue;
|
|
if (best_name[0] == '\0' || strcmp(ent->d_name, best_name) < 0)
|
|
safe_copy(best_name, sizeof(best_name), ent->d_name);
|
|
}
|
|
closedir(dir);
|
|
if (best_name[0] == '\0') return ClaimResult::None;
|
|
|
|
char queued[MAX_PATH_LEN];
|
|
char active[MAX_PATH_LEN];
|
|
path_join(queued, sizeof(queued), SPOOL_QUEUE_DIR, best_name);
|
|
path_join(active, sizeof(active), SPOOL_ACTIVE_DIR, best_name);
|
|
|
|
write_daemon_state("claiming", best_name, queued);
|
|
char move_err[160] = {};
|
|
if (!move_job_file(queued, active, move_err, sizeof(move_err))) {
|
|
char detail[256];
|
|
snprintf(detail, sizeof(detail), "%s -> %s (%s)",
|
|
queued, active,
|
|
move_err[0] ? move_err : "move failed");
|
|
write_daemon_state("claim-failed", best_name, detail);
|
|
log_msg("failed to claim job %s: %s", best_name, detail);
|
|
return ClaimResult::Failed;
|
|
}
|
|
write_daemon_state("claimed", best_name, active);
|
|
safe_copy(out_active_path, out_active_path_len, active);
|
|
return ClaimResult::Claimed;
|
|
}
|
|
|
|
static void finalize_job(const char* active_path, const char* target_dir, JobMeta* job) {
|
|
save_job_to_path_atomic(active_path, job);
|
|
char target[MAX_PATH_LEN];
|
|
make_job_file_path(target_dir, job->id, target, sizeof(target));
|
|
char move_err[160] = {};
|
|
if (!move_job_file(active_path, target, move_err, sizeof(move_err))) {
|
|
log_msg("warning: failed to move job %s to %s", job->id, target_dir);
|
|
write_daemon_state("finalize-failed", job->id,
|
|
move_err[0] ? move_err : target_dir);
|
|
}
|
|
}
|
|
|
|
static bool try_print_test_page(const char* active_path, JobMeta* job,
|
|
IppPrintResult* result, char* err, int err_len) {
|
|
persist_job_debug(active_path, job, "querying printer capabilities");
|
|
|
|
IppCapabilities caps = {};
|
|
bool have_caps = ipp_get_printer_capabilities(job->printer_uri, &caps, err, err_len);
|
|
if (have_caps) {
|
|
char detail[MAX_DEBUG_LEN] = {};
|
|
summarize_ipp_capabilities(&caps, detail, sizeof(detail));
|
|
persist_job_debug(active_path, job, detail);
|
|
} else if (err && err[0]) {
|
|
char detail[MAX_DEBUG_LEN];
|
|
snprintf(detail, sizeof(detail), "capability probe failed; attempting direct submit (%s)", err);
|
|
persist_job_debug(active_path, job, detail);
|
|
}
|
|
|
|
const struct {
|
|
const char* mime;
|
|
bool (*generate)(uint8_t**, int*);
|
|
bool allowed;
|
|
} attempts[] = {
|
|
{"application/pdf", generate_test_page_pdf, !have_caps || caps.supports_pdf},
|
|
{"image/jpeg", generate_test_page_jpeg, !have_caps || caps.supports_jpeg},
|
|
{"text/plain", generate_test_page_text, !have_caps || caps.supports_text},
|
|
};
|
|
|
|
if (have_caps && !caps.supports_pdf && !caps.supports_jpeg && !caps.supports_text) {
|
|
if (caps.supported_formats[0]) {
|
|
snprintf(err, (size_t)err_len,
|
|
"printer does not advertise a built-in test-page format (supports: %s)",
|
|
caps.supported_formats);
|
|
} else {
|
|
safe_copy(err, err_len, "printer does not advertise a built-in test-page format");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < sizeof(attempts) / sizeof(attempts[0]); i++) {
|
|
if (!attempts[i].allowed) continue;
|
|
|
|
uint8_t* data = nullptr;
|
|
int len = 0;
|
|
if (!attempts[i].generate(&data, &len)) {
|
|
safe_copy(err, err_len, "failed to generate test page");
|
|
return false;
|
|
}
|
|
|
|
char detail[MAX_DEBUG_LEN];
|
|
snprintf(detail, sizeof(detail), "submitting test page as %s (%d bytes, %d %s)",
|
|
attempts[i].mime, len,
|
|
job->copies > 0 ? job->copies : 1,
|
|
(job->copies > 1) ? "copies" : "copy");
|
|
persist_job_debug(active_path, job, detail);
|
|
|
|
bool ok = ipp_print_buffer(job->printer_uri, job->job_name, job->user_name,
|
|
job->copies, attempts[i].mime, data, len, result, err, err_len);
|
|
free(data);
|
|
if (ok) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool try_print_document(const char* active_path, JobMeta* job,
|
|
IppPrintResult* result, char* err, int err_len) {
|
|
persist_job_debug(active_path, job, "loading document bytes");
|
|
|
|
uint8_t* data = nullptr;
|
|
int len = 0;
|
|
if (!read_file_bytes(job->doc_path, &data, &len, err, err_len)) return false;
|
|
|
|
char detail[MAX_DEBUG_LEN];
|
|
snprintf(detail, sizeof(detail), "submitting %s document (%d bytes, %d %s)",
|
|
job->doc_format[0] ? job->doc_format : "application/octet-stream", len,
|
|
job->copies > 0 ? job->copies : 1,
|
|
(job->copies > 1) ? "copies" : "copy");
|
|
persist_job_debug(active_path, job, detail);
|
|
|
|
bool ok = ipp_print_buffer(job->printer_uri, job->job_name, job->user_name,
|
|
job->copies, job->doc_format, data, len, result, err, err_len);
|
|
free(data);
|
|
return ok;
|
|
}
|
|
|
|
static void process_job(const char* active_path) {
|
|
JobMeta job = {};
|
|
if (!load_job_from_path(active_path, &job)) {
|
|
log_msg("dropping unreadable job file: %s", active_path);
|
|
write_daemon_state("unreadable-job", active_path, nullptr);
|
|
remove(active_path);
|
|
return;
|
|
}
|
|
|
|
log_msg("processing job %s (%s)", job.id, job.job_name);
|
|
write_daemon_state("processing", job.id, job.job_name);
|
|
set_job_state(&job, "printing", "Sending to printer");
|
|
set_job_debug(&job, "dispatching queued job");
|
|
save_job_to_path_atomic(active_path, &job);
|
|
|
|
IppPrintResult result = {};
|
|
char err[128] = {};
|
|
bool ok = false;
|
|
|
|
if (strcmp(job.source_kind, "test-page") == 0)
|
|
ok = try_print_test_page(active_path, &job, &result, err, sizeof(err));
|
|
else
|
|
ok = try_print_document(active_path, &job, &result, err, sizeof(err));
|
|
|
|
if (ok) {
|
|
job.remote_job_id = result.job_id;
|
|
set_job_state(&job, "completed",
|
|
result.status_message[0] ? result.status_message : "Printed");
|
|
set_job_debug_from_result(&job, &result, nullptr);
|
|
finalize_job(active_path, SPOOL_DONE_DIR, &job);
|
|
log_msg("job %s completed (printer job id %d)", job.id, result.job_id);
|
|
write_daemon_state("completed", job.id, job.status_message);
|
|
} else {
|
|
set_job_state(&job, "failed", err[0] ? err : "Print failed");
|
|
set_job_debug_from_result(&job, &result, err[0] ? err : nullptr);
|
|
finalize_job(active_path, SPOOL_FAILED_DIR, &job);
|
|
log_msg("job %s failed: %s", job.id, job.status_message);
|
|
if (job.debug_info[0]) log_msg("job %s debug: %s", job.id, job.debug_info);
|
|
write_daemon_state("failed", job.id, job.status_message);
|
|
}
|
|
|
|
if (job.doc_path[0] != '\0') remove(job.doc_path);
|
|
}
|
|
|
|
extern "C" void _start() {
|
|
if (!ensure_spool_dirs()) {
|
|
log_msg("failed to initialize spool directories");
|
|
montauk::exit(1);
|
|
}
|
|
|
|
int running_pid = -1;
|
|
if (daemon_is_running(&running_pid) && running_pid != montauk::getpid()) {
|
|
log_msg("another print daemon is already running (pid %d)", running_pid);
|
|
montauk::exit(0);
|
|
}
|
|
|
|
if (!write_pid_file()) {
|
|
log_msg("failed to write daemon pid file");
|
|
montauk::exit(1);
|
|
}
|
|
|
|
requeue_stale_active_jobs();
|
|
char last_probed_uri[MAX_PATH_LEN] = {};
|
|
uint64_t last_probe_ms = 0;
|
|
bool last_probe_ok = false;
|
|
log_msg("ready");
|
|
write_daemon_state("ready", nullptr, nullptr);
|
|
|
|
for (;;) {
|
|
char active_path[MAX_PATH_LEN];
|
|
ClaimResult claim = claim_next_job(active_path, sizeof(active_path));
|
|
if (claim == ClaimResult::Claimed) {
|
|
process_job(active_path);
|
|
continue;
|
|
}
|
|
if (claim == ClaimResult::Failed) {
|
|
montauk::sleep_ms(1000);
|
|
continue;
|
|
}
|
|
write_daemon_state("idle", nullptr, nullptr);
|
|
if (ENABLE_BACKGROUND_PROBE) {
|
|
auto_probe_configured_printer(last_probed_uri, sizeof(last_probed_uri),
|
|
&last_probe_ms, &last_probe_ok);
|
|
}
|
|
montauk::sleep_ms(1000);
|
|
}
|
|
}
|