System Services and Process Management

#ifndef SENSOR_PROTOCOL_H
#define SENSOR_PROTOCOL_H

#define SENSOR_SOCK_PATH    "/run/sensor-monitor.sock"
#define SHM_NAME            "/sensor-ringbuf"
#define RING_CAPACITY       1000
#define MAX_CMD_LEN         64
#define MAX_RESPONSE_LEN    4096

/* Commands the client can send */
#define CMD_LATEST          "latest"
#define CMD_HISTORY         "history"
#define CMD_INTERVAL        "interval"

/* One sensor reading */
struct sensor_reading {
    double temperature;     /* Celsius */
    double pressure;        /* hPa */
    double humidity;        /* %RH */
    uint64_t timestamp_ms;  /* milliseconds since epoch */
};

/* Shared memory ring buffer layout */
struct sensor_ring {
    _Atomic uint32_t write_index;   /* next write position */
    _Atomic uint32_t count;         /* total readings stored (capped at RING_CAPACITY) */
    struct sensor_reading readings[RING_CAPACITY];
};

#endif /* SENSOR_PROTOCOL_H */

/*
 * sensor-monitord.c - Systemd-managed BME280 sensor daemon
 *
 * Reads BME280 via /dev/i2c-1, stores readings in shared memory,
 * serves clients over a Unix domain socket, and feeds the hardware
 * watchdog. Designed for the Raspberry Pi Zero 2 W.
 *
 * Build: aarch64-linux-gnu-gcc -o sensor-monitord sensor-monitord.c \
 *        -lrt -lpthread -lsystemd -lm
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdatomic.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <time.h>
#include <sched.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <linux/i2c-dev.h>
#include <systemd/sd-daemon.h>
#include <systemd/sd-journal.h>

#include "sensor-protocol.h"

/* BME280 I2C address and key registers */
#define BME280_ADDR         0x76
#define BME280_REG_ID       0xD0
#define BME280_REG_CTRL_HUM 0xF2
#define BME280_REG_CTRL_MEAS 0xF4
#define BME280_REG_CONFIG   0xF5
#define BME280_REG_DATA     0xF7
#define BME280_CHIP_ID      0x60

/* Calibration data storage */
struct bme280_calib {
    uint16_t dig_T1;
    int16_t  dig_T2, dig_T3;
    uint16_t dig_P1;
    int16_t  dig_P2, dig_P3, dig_P4, dig_P5;
    int16_t  dig_P6, dig_P7, dig_P8, dig_P9;
    uint8_t  dig_H1, dig_H3;
    int16_t  dig_H2, dig_H4, dig_H5;
    int8_t   dig_H6;
};

/* Global state */
static volatile sig_atomic_t running = 1;
static int i2c_fd = -1;
static int watchdog_fd = -1;
static int listen_fd = -1;
static struct sensor_ring *ring = NULL;
static struct bme280_calib calib;
static int sample_interval_ms = 1000;

/* ----------------------------------------------------------------
 * Signal handling
 * ---------------------------------------------------------------- */
static void signal_handler(int sig)
{
    (void)sig;
    running = 0;
}

static void install_signal_handlers(void)
{
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);

    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGHUP, &sa, NULL);

    /* Ignore SIGPIPE so writing to a disconnected socket returns EPIPE */
    signal(SIGPIPE, SIG_IGN);
}

/* ----------------------------------------------------------------
 * I2C helpers
 * ---------------------------------------------------------------- */
static int i2c_write_byte(int fd, uint8_t reg, uint8_t val)
{
    uint8_t buf[2] = { reg, val };
    if (write(fd, buf, 2) != 2)
        return -1;
    return 0;
}

static int i2c_read_bytes(int fd, uint8_t reg, uint8_t *buf, int len)
{
    if (write(fd, &reg, 1) != 1)
        return -1;
    if (read(fd, buf, len) != len)
        return -1;
    return 0;
}

/* ----------------------------------------------------------------
 * BME280 initialization and reading
 * ---------------------------------------------------------------- */
static int bme280_init(const char *i2c_dev)
{
    uint8_t id;
    uint8_t cal1[26], cal2[7];

    i2c_fd = open(i2c_dev, O_RDWR);
    if (i2c_fd < 0) {
        sd_journal_print(LOG_ERR, "Failed to open %s: %s",
                         i2c_dev, strerror(errno));
        return -1;
    }

    if (ioctl(i2c_fd, I2C_SLAVE, BME280_ADDR) < 0) {
        sd_journal_print(LOG_ERR, "I2C_SLAVE ioctl failed: %s",
                         strerror(errno));
        close(i2c_fd);
        i2c_fd = -1;
        return -1;
    }

    /* Verify chip ID */
    if (i2c_read_bytes(i2c_fd, BME280_REG_ID, &id, 1) < 0 ||
        id != BME280_CHIP_ID) {
        sd_journal_print(LOG_ERR, "BME280 not found (id=0x%02x)", id);
        close(i2c_fd);
        i2c_fd = -1;
        return -1;
    }

    /* Read temperature and pressure calibration (0x88..0xA1) */
    if (i2c_read_bytes(i2c_fd, 0x88, cal1, 26) < 0)
        return -1;

    calib.dig_T1 = (uint16_t)(cal1[1] << 8 | cal1[0]);
    calib.dig_T2 = (int16_t)(cal1[3] << 8 | cal1[2]);
    calib.dig_T3 = (int16_t)(cal1[5] << 8 | cal1[4]);
    calib.dig_P1 = (uint16_t)(cal1[7] << 8 | cal1[6]);
    calib.dig_P2 = (int16_t)(cal1[9] << 8 | cal1[8]);
    calib.dig_P3 = (int16_t)(cal1[11] << 8 | cal1[10]);
    calib.dig_P4 = (int16_t)(cal1[13] << 8 | cal1[12]);
    calib.dig_P5 = (int16_t)(cal1[15] << 8 | cal1[14]);
    calib.dig_P6 = (int16_t)(cal1[17] << 8 | cal1[16]);
    calib.dig_P7 = (int16_t)(cal1[19] << 8 | cal1[18]);
    calib.dig_P8 = (int16_t)(cal1[21] << 8 | cal1[20]);
    calib.dig_P9 = (int16_t)(cal1[23] << 8 | cal1[22]);

    /* Humidity calibration byte at 0xA1 */
    calib.dig_H1 = cal1[25];

    /* Read humidity calibration (0xE1..0xE7) */
    if (i2c_read_bytes(i2c_fd, 0xE1, cal2, 7) < 0)
        return -1;

    calib.dig_H2 = (int16_t)(cal2[1] << 8 | cal2[0]);
    calib.dig_H3 = cal2[2];
    calib.dig_H4 = (int16_t)((cal2[3] << 4) | (cal2[4] & 0x0F));
    calib.dig_H5 = (int16_t)((cal2[5] << 4) | (cal2[4] >> 4));
    calib.dig_H6 = (int8_t)cal2[6];

    /* Configure: humidity oversampling x1 */
    i2c_write_byte(i2c_fd, BME280_REG_CTRL_HUM, 0x01);
    /* Configure: standby 1000ms, filter off */
    i2c_write_byte(i2c_fd, BME280_REG_CONFIG, 0xA0);
    /* Configure: temp oversampling x1, pressure oversampling x1, normal mode */
    i2c_write_byte(i2c_fd, BME280_REG_CTRL_MEAS, 0x27);

    sd_journal_print(LOG_INFO, "BME280 initialized on %s", i2c_dev);
    return 0;
}

static int bme280_read(struct sensor_reading *out)
{
    uint8_t data[8];
    int32_t adc_T, adc_P, adc_H;
    int32_t t_fine;
    double var1, var2, T, P, H;
    struct timespec ts;

    if (i2c_read_bytes(i2c_fd, BME280_REG_DATA, data, 8) < 0)
        return -1;

    adc_P = (int32_t)((data[0] << 12) | (data[1] << 4) | (data[2] >> 4));
    adc_T = (int32_t)((data[3] << 12) | (data[4] << 4) | (data[5] >> 4));
    adc_H = (int32_t)((data[6] << 8) | data[7]);

    /* Temperature compensation (from BME280 datasheet) */
    var1 = ((double)adc_T / 16384.0 - (double)calib.dig_T1 / 1024.0)
           * (double)calib.dig_T2;
    var2 = (((double)adc_T / 131072.0 - (double)calib.dig_T1 / 8192.0)
           * ((double)adc_T / 131072.0 - (double)calib.dig_T1 / 8192.0))
           * (double)calib.dig_T3;
    t_fine = (int32_t)(var1 + var2);
    T = (var1 + var2) / 5120.0;

    /* Pressure compensation */
    var1 = ((double)t_fine / 2.0) - 64000.0;
    var2 = var1 * var1 * (double)calib.dig_P6 / 32768.0;
    var2 = var2 + var1 * (double)calib.dig_P5 * 2.0;
    var2 = (var2 / 4.0) + ((double)calib.dig_P4 * 65536.0);
    var1 = ((double)calib.dig_P3 * var1 * var1 / 524288.0
           + (double)calib.dig_P2 * var1) / 524288.0;
    var1 = (1.0 + var1 / 32768.0) * (double)calib.dig_P1;
    if (var1 == 0.0) {
        P = 0.0;
    } else {
        P = 1048576.0 - (double)adc_P;
        P = (P - (var2 / 4096.0)) * 6250.0 / var1;
        var1 = (double)calib.dig_P9 * P * P / 2147483648.0;
        var2 = P * (double)calib.dig_P8 / 32768.0;
        P = P + (var1 + var2 + (double)calib.dig_P7) / 16.0;
        P = P / 100.0;  /* Convert Pa to hPa */
    }

    /* Humidity compensation */
    H = (double)t_fine - 76800.0;
    if (H == 0.0) {
        H = 0.0;
    } else {
        H = (adc_H - (calib.dig_H4 * 64.0 + calib.dig_H5 / 16384.0 * H))
            * (calib.dig_H2 / 65536.0
               * (1.0 + calib.dig_H6 / 67108864.0 * H
                  * (1.0 + calib.dig_H3 / 67108864.0 * H)));
        H = H * (1.0 - calib.dig_H1 * H / 524288.0);
        if (H > 100.0) H = 100.0;
        if (H < 0.0)   H = 0.0;
    }

    clock_gettime(CLOCK_REALTIME, &ts);

    out->temperature = T;
    out->pressure = P;
    out->humidity = H;
    out->timestamp_ms = (uint64_t)ts.tv_sec * 1000
                      + (uint64_t)ts.tv_nsec / 1000000;
    return 0;
}

/* ----------------------------------------------------------------
 * Shared memory ring buffer
 * ---------------------------------------------------------------- */
static int ring_init(void)
{
    int shm_fd;

    shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0644);
    if (shm_fd < 0) {
        sd_journal_print(LOG_ERR, "shm_open failed: %s", strerror(errno));
        return -1;
    }

    if (ftruncate(shm_fd, sizeof(struct sensor_ring)) < 0) {
        sd_journal_print(LOG_ERR, "ftruncate failed: %s", strerror(errno));
        close(shm_fd);
        return -1;
    }

    ring = mmap(NULL, sizeof(struct sensor_ring),
                PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    close(shm_fd);

    if (ring == MAP_FAILED) {
        sd_journal_print(LOG_ERR, "mmap failed: %s", strerror(errno));
        ring = NULL;
        return -1;
    }

    /* Zero the ring on startup */
    memset(ring, 0, sizeof(struct sensor_ring));
    sd_journal_print(LOG_INFO, "Shared memory ring buffer initialized "
                     "(%zu bytes)", sizeof(struct sensor_ring));
    return 0;
}

static void ring_push(const struct sensor_reading *r)
{
    uint32_t idx = atomic_load(&ring->write_index);
    ring->readings[idx % RING_CAPACITY] = *r;
    atomic_store(&ring->write_index, idx + 1);

    uint32_t cnt = atomic_load(&ring->count);
    if (cnt < RING_CAPACITY)
        atomic_store(&ring->count, cnt + 1);
}

static void ring_cleanup(void)
{
    if (ring) {
        munmap(ring, sizeof(struct sensor_ring));
        ring = NULL;
    }
    shm_unlink(SHM_NAME);
}

/* ----------------------------------------------------------------
 * Hardware watchdog
 * ---------------------------------------------------------------- */
static int watchdog_init(void)
{
    watchdog_fd = open("/dev/watchdog", O_WRONLY);
    if (watchdog_fd < 0) {
        sd_journal_print(LOG_WARNING,
                         "Cannot open /dev/watchdog: %s (continuing without "
                         "hardware watchdog)", strerror(errno));
        return 0;  /* Non-fatal: continue without hardware watchdog */
    }
    sd_journal_print(LOG_INFO, "Hardware watchdog opened");
    return 0;
}

static void watchdog_kick(void)
{
    if (watchdog_fd >= 0) {
        if (write(watchdog_fd, "k", 1) != 1)
            sd_journal_print(LOG_ERR, "Watchdog kick failed");
    }
}

static void watchdog_close(void)
{
    if (watchdog_fd >= 0) {
        /* Write 'V' (magic close) to disable watchdog on clean shutdown */
        write(watchdog_fd, "V", 1);
        close(watchdog_fd);
        watchdog_fd = -1;
    }
}

/* ----------------------------------------------------------------
 * Unix domain socket server
 * ---------------------------------------------------------------- */
static int socket_init(void)
{
    struct sockaddr_un addr;

    listen_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
    if (listen_fd < 0) {
        sd_journal_print(LOG_ERR, "socket() failed: %s", strerror(errno));
        return -1;
    }

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SENSOR_SOCK_PATH, sizeof(addr.sun_path) - 1);

    unlink(SENSOR_SOCK_PATH);

    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        sd_journal_print(LOG_ERR, "bind(%s) failed: %s",
                         SENSOR_SOCK_PATH, strerror(errno));
        close(listen_fd);
        listen_fd = -1;
        return -1;
    }

    chmod(SENSOR_SOCK_PATH, 0666);

    if (listen(listen_fd, 5) < 0) {
        sd_journal_print(LOG_ERR, "listen() failed: %s", strerror(errno));
        close(listen_fd);
        listen_fd = -1;
        return -1;
    }

    sd_journal_print(LOG_INFO, "Listening on %s", SENSOR_SOCK_PATH);
    return 0;
}

static void handle_client(int client_fd)
{
    char cmd[MAX_CMD_LEN];
    char response[MAX_RESPONSE_LEN];
    ssize_t n;
    int len;

    n = recv(client_fd, cmd, sizeof(cmd) - 1, 0);
    if (n <= 0) {
        close(client_fd);
        return;
    }
    cmd[n] = '\0';

    /* Strip trailing newline */
    if (n > 0 && cmd[n - 1] == '\n')
        cmd[n - 1] = '\0';

    if (strcmp(cmd, CMD_LATEST) == 0) {
        uint32_t widx = atomic_load(&ring->write_index);
        if (widx == 0) {
            len = snprintf(response, sizeof(response),
                           "ERROR: no readings yet\n");
        } else {
            struct sensor_reading *r =
                &ring->readings[(widx - 1) % RING_CAPACITY];
            len = snprintf(response, sizeof(response),
                           "temperature=%.2f C\n"
                           "pressure=%.2f hPa\n"
                           "humidity=%.2f %%RH\n"
                           "timestamp=%lu\n",
                           r->temperature, r->pressure,
                           r->humidity, (unsigned long)r->timestamp_ms);
        }
    } else if (strcmp(cmd, CMD_HISTORY) == 0) {
        uint32_t widx = atomic_load(&ring->write_index);
        uint32_t cnt = atomic_load(&ring->count);
        int offset = 0;

        /* Limit history output to last 10 readings */
        uint32_t show = (cnt > 10) ? 10 : cnt;
        uint32_t begin = (widx >= show) ? widx - show : 0;

        offset += snprintf(response + offset, sizeof(response) - offset,
                           "count=%u\n", show);

        for (uint32_t i = begin; i < widx && offset < (int)sizeof(response) - 128; i++) {
            struct sensor_reading *r = &ring->readings[i % RING_CAPACITY];
            offset += snprintf(response + offset, sizeof(response) - offset,
                               "%.2f,%.2f,%.2f,%lu\n",
                               r->temperature, r->pressure,
                               r->humidity, (unsigned long)r->timestamp_ms);
        }
        len = offset;
    } else if (strncmp(cmd, CMD_INTERVAL, strlen(CMD_INTERVAL)) == 0) {
        /* "interval 2000" sets sample interval to 2000ms */
        const char *val = cmd + strlen(CMD_INTERVAL);
        while (*val == ' ') val++;
        int new_interval = atoi(val);
        if (new_interval >= 100 && new_interval <= 60000) {
            sample_interval_ms = new_interval;
            len = snprintf(response, sizeof(response),
                           "OK: interval=%d ms\n", sample_interval_ms);
            sd_journal_send("MESSAGE=Sample interval changed to %d ms",
                            sample_interval_ms,
                            "PRIORITY=%d", LOG_NOTICE,
                            "SENSOR_EVENT=interval_change",
                            NULL);
        } else {
            len = snprintf(response, sizeof(response),
                           "ERROR: interval must be 100..60000 ms\n");
        }
    } else {
        len = snprintf(response, sizeof(response),
                       "ERROR: unknown command '%s'\n"
                       "Commands: latest, history, interval <ms>\n", cmd);
    }

    send(client_fd, response, len, 0);
    close(client_fd);
}

/* ----------------------------------------------------------------
 * Main event loop
 * ---------------------------------------------------------------- */
int main(int argc, char *argv[])
{
    uint64_t watchdog_usec = 0;
    int wd_enabled;
    struct timespec last_sample, now;

    install_signal_handlers();

    /* Parse optional command-line interval */
    if (argc > 1)
        sample_interval_ms = atoi(argv[1]);
    if (sample_interval_ms < 100)
        sample_interval_ms = 1000;

    /* Initialize subsystems */
    if (bme280_init("/dev/i2c-1") < 0)
        return EXIT_FAILURE;

    if (ring_init() < 0)
        return EXIT_FAILURE;

    if (watchdog_init() < 0)
        return EXIT_FAILURE;

    if (socket_init() < 0)
        return EXIT_FAILURE;

    /* Check if systemd watchdog is enabled */
    wd_enabled = sd_watchdog_enabled(0, &watchdog_usec);
    if (wd_enabled > 0) {
        sd_journal_print(LOG_INFO,
                         "systemd watchdog enabled, interval=%lu us",
                         (unsigned long)watchdog_usec);
    }

    /* Notify systemd that startup is complete */
    sd_notify(0, "READY=1\nSTATUS=Monitoring BME280 sensor");

    clock_gettime(CLOCK_MONOTONIC, &last_sample);

    sd_journal_send("MESSAGE=sensor-monitord started, interval=%d ms",
                    sample_interval_ms,
                    "PRIORITY=%d", LOG_INFO,
                    "SENSOR_TYPE=bme280",
                    "SAMPLE_INTERVAL_MS=%d", sample_interval_ms,
                    NULL);

    while (running) {
        fd_set readfds;
        struct timeval tv;

        /* Accept client connections with a short timeout */
        FD_ZERO(&readfds);
        if (listen_fd >= 0)
            FD_SET(listen_fd, &readfds);

        tv.tv_sec = 0;
        tv.tv_usec = 50000;  /* 50ms poll */

        int sel = select(listen_fd + 1, &readfds, NULL, NULL, &tv);
        if (sel > 0 && FD_ISSET(listen_fd, &readfds)) {
            int client_fd = accept(listen_fd, NULL, NULL);
            if (client_fd >= 0)
                handle_client(client_fd);
        }

        /* Check if it is time to sample */
        clock_gettime(CLOCK_MONOTONIC, &now);
        long elapsed_ms = (now.tv_sec - last_sample.tv_sec) * 1000
                        + (now.tv_nsec - last_sample.tv_nsec) / 1000000;

        if (elapsed_ms >= sample_interval_ms) {
            struct sensor_reading reading;
            if (bme280_read(&reading) == 0) {
                ring_push(&reading);

                /* Log every 60th reading with structured fields */
                static int log_counter = 0;
                if (++log_counter >= 60) {
                    sd_journal_send(
                        "MESSAGE=T=%.2f C, P=%.2f hPa, H=%.2f %%RH",
                        reading.temperature, reading.pressure,
                        reading.humidity,
                        "PRIORITY=%d", LOG_INFO,
                        "SENSOR_TYPE=temperature",
                        "TEMPERATURE=%.2f", reading.temperature,
                        "PRESSURE=%.2f", reading.pressure,
                        "HUMIDITY=%.2f", reading.humidity,
                        NULL);
                    log_counter = 0;
                }
            } else {
                sd_journal_print(LOG_WARNING, "BME280 read failed");
            }

            /* Kick hardware watchdog */
            watchdog_kick();

            /* Notify systemd watchdog */
            if (wd_enabled > 0)
                sd_notify(0, "WATCHDOG=1");

            last_sample = now;
        }
    }

    /* Clean shutdown */
    sd_notify(0, "STOPPING=1\nSTATUS=Shutting down");
    sd_journal_print(LOG_INFO, "sensor-monitord shutting down");

    if (listen_fd >= 0) {
        close(listen_fd);
        unlink(SENSOR_SOCK_PATH);
    }
    watchdog_close();
    ring_cleanup();
    if (i2c_fd >= 0)
        close(i2c_fd);

    return EXIT_SUCCESS;
}

CC = aarch64-linux-gnu-gcc
CFLAGS = -Wall -Wextra -O2 -std=gnu11
LDFLAGS_DAEMON = -lrt -lpthread -lsystemd -lm
LDFLAGS_CLIENT = -lrt

all: sensor-monitord sensor-query

sensor-monitord: sensor-monitord.c sensor-protocol.h
  $(CC) $(CFLAGS) -o $@ sensor-monitord.c $(LDFLAGS_DAEMON)

sensor-query: sensor-query.c sensor-protocol.h
  $(CC) $(CFLAGS) -o $@ sensor-query.c $(LDFLAGS_CLIENT)

clean:
  rm -f sensor-monitord sensor-query

.PHONY: all clean

/*
 * sensor-query.c - Client tool for sensor-monitord
 *
 * Connects to the daemon's Unix domain socket, sends a command,
 * and prints the response.
 *
 * Build: aarch64-linux-gnu-gcc -o sensor-query sensor-query.c -lrt
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "sensor-protocol.h"

static void usage(const char *progname)
{
    fprintf(stderr,
            "Usage: %s <command>\n"
            "\n"
            "Commands:\n"
            "  latest            Show the most recent sensor reading\n"
            "  history           Show the last 10 readings\n"
            "  interval <ms>    Set the sampling interval (100..60000 ms)\n",
            progname);
}

int main(int argc, char *argv[])
{
    int sock_fd;
    struct sockaddr_un addr;
    char cmd[MAX_CMD_LEN];
    char response[MAX_RESPONSE_LEN];
    ssize_t n;

    if (argc < 2) {
        usage(argv[0]);
        return EXIT_FAILURE;
    }

    /* Build the command string from arguments */
    int offset = 0;
    for (int i = 1; i < argc && offset < (int)sizeof(cmd) - 2; i++) {
        if (i > 1)
            cmd[offset++] = ' ';
        int len = snprintf(cmd + offset, sizeof(cmd) - offset,
                           "%s", argv[i]);
        offset += len;
    }
    cmd[offset++] = '\n';
    cmd[offset] = '\0';

    /* Connect to the daemon */
    sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock_fd < 0) {
        perror("socket");
        return EXIT_FAILURE;
    }

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SENSOR_SOCK_PATH, sizeof(addr.sun_path) - 1);

    if (connect(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        fprintf(stderr, "Cannot connect to %s: is sensor-monitord running?\n",
                SENSOR_SOCK_PATH);
        close(sock_fd);
        return EXIT_FAILURE;
    }

    /* Send the command */
    if (send(sock_fd, cmd, offset, 0) < 0) {
        perror("send");
        close(sock_fd);
        return EXIT_FAILURE;
    }

    /* Read and print the response */
    while ((n = recv(sock_fd, response, sizeof(response) - 1, 0)) > 0) {
        response[n] = '\0';
        fputs(response, stdout);
    }

    close(sock_fd);
    return EXIT_SUCCESS;
}

[Unit]
Description=BME280 Sensor Monitor Daemon
Documentation=man:sensor-monitord(1)
After=local-fs.target
After=sysinit.target
Wants=dev-i2c\x2d1.device
After=dev-i2c\x2d1.device

[Service]
Type=notify
ExecStart=/usr/local/bin/sensor-monitord 1000
NotifyAccess=main

# Watchdog: daemon must call sd_notify("WATCHDOG=1") within this interval
WatchdogSec=15

# Restart policy
Restart=on-failure
RestartSec=3
StartLimitIntervalSec=60
StartLimitBurst=5

# Resource limits (cgroup-based)
MemoryMax=32M
MemorySwapMax=0
CPUQuota=25%

# Security hardening
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
ReadWritePaths=/run /dev/i2c-1 /dev/watchdog
NoNewPrivileges=yes

# Runtime directory for the socket
RuntimeDirectory=sensor-monitor
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

#include <stdio.h>
#include <stdint.h>
#include <stdatomic.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

#include "sensor-protocol.h"

int main(void)
{
    int shm_fd = shm_open(SHM_NAME, O_RDONLY, 0);
    if (shm_fd < 0) {
        perror("shm_open");
        return 1;
    }

    struct sensor_ring *ring = mmap(NULL, sizeof(struct sensor_ring),
                                    PROT_READ, MAP_SHARED, shm_fd, 0);
    close(shm_fd);

    if (ring == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    uint32_t widx = atomic_load(&ring->write_index);
    if (widx == 0) {
        printf("No readings available yet.\n");
    } else {
        struct sensor_reading *r = &ring->readings[(widx - 1) % RING_CAPACITY];
        printf("Latest reading (from shared memory):\n");
        printf("  Temperature: %.2f C\n", r->temperature);
        printf("  Pressure:    %.2f hPa\n", r->pressure);
        printf("  Humidity:    %.2f %%RH\n", r->humidity);
    }

    munmap(ring, sizeof(struct sensor_ring));
    return 0;
}

[Unit]
Description=Sensor Monitor Socket

[Socket]
ListenStream=/run/sensor-monitor.sock
SocketMode=0666

[Install]
WantedBy=sockets.target

[Unit]
Description=BME280 Sensor Monitor Daemon
After=local-fs.target

[Service]
Type=notify
ExecStart=/usr/local/bin/sensor-monitord 1000
NotifyAccess=main
WatchdogSec=15
Restart=on-failure
RestartSec=3
MemoryMax=32M
CPUQuota=25%

# No [Install] section: the socket unit handles activation