sfp_monitor.c

/*
 * sfp_monitor.c - Ultra-lean SFP+ DDM monitor daemon
 *
 * Polls ethtool -m for standard SFP+ DDM (Digital Diagnostics Monitoring)
 * data and writes module temperature and supply voltage to hwmon-format
 * files for CoolerControl to read as a custom file sensor.
 *
 * Works with any SFP+ transceiver that supports DDM — copper RJ45
 * (RealHD, MikroTik S+RJ10, etc.), SR/LR optical, DAC, AOC.
 * Parses only standard DDM fields; ignores spoofed optical data
 * from copper transceivers that fake laser/optical identity.
 *
 * Compile: gcc -O2 -Wall -o sfp_monitor sfp_monitor.c
 * Install: sudo cp sfp_monitor /usr/local/bin/
 * Run:     sudo sfp_monitor <interface> [output_dir] [poll_interval] [-v]
 *
 * hwmon output files created:
 *   <output_dir>/name          - device name string
 *   <output_dir>/temp1_input   - module temperature (millidegrees C)
 *   <output_dir>/temp1_label   - "SFP+ Module"
 *   <output_dir>/temp1_max     - high warning threshold (millidegrees C)
 *   <output_dir>/temp1_crit    - high alarm threshold (millidegrees C)
 *   <output_dir>/in1_input     - supply voltage (millivolts)
 *   <output_dir>/in1_label     - "SFP+ Voltage"
 *   <output_dir>/in1_max       - voltage high alarm (millivolts)
 *   <output_dir>/in1_min       - voltage low alarm (millivolts)
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <sys/stat.h>
#include <time.h>

#define MAX_LINE 256
#define MAX_PATH 512
#define MAX_FILEPATH (MAX_PATH + 32) /* dir + "/temp1_input.tmp" etc. */

/* Configuration */
typedef struct {
    char interface[64];
    char output_dir[MAX_PATH];
    int poll_interval;
    int verbose;
} config_t;

/* Sensor data */
typedef struct {
    int temp_millidegrees;      /* Module temperature in millidegrees C */
    int voltage_millivolts;     /* Supply voltage in millivolts */
    int temp_warn_high;         /* High warning threshold (millidegrees) */
    int temp_alarm_high;        /* High alarm threshold (millidegrees) */
    int volt_alarm_high;        /* Voltage high alarm (millivolts) */
    int volt_alarm_low;         /* Voltage low alarm (millivolts) */
    int valid;                  /* Data valid flag */
    int thresholds_valid;       /* Thresholds parsed flag */
} sensor_data_t;

/* Global for signal handling */
static volatile int keep_running = 1;

static void signal_handler(int signum) {
    (void)signum;
    keep_running = 0;
}

/* Atomic write integer to file (write tmp, rename) */
static int write_sensor_file(const char *path, int value) {
    char tmp_path[MAX_FILEPATH];
    FILE *fp;

    snprintf(tmp_path, sizeof(tmp_path), "%s.tmp", path);
    fp = fopen(tmp_path, "w");
    if (!fp) {
        perror("fopen");
        return -1;
    }

    fprintf(fp, "%d\n", value);
    fclose(fp);

    if (rename(tmp_path, path) == -1) {
        perror("rename");
        unlink(tmp_path);
        return -1;
    }

    chmod(path, 0444);
    return 0;
}

/* Write string to file (for labels, name) */
static int write_string_file(const char *path, const char *value) {
    FILE *fp = fopen(path, "w");
    if (!fp) {
        perror("fopen");
        return -1;
    }
    fprintf(fp, "%s\n", value);
    fclose(fp);
    chmod(path, 0444);
    return 0;
}

/* Recursive mkdir — create all path components (like mkdir -p) */
static int mkdir_p(const char *dir, mode_t mode) {
    char tmp[MAX_PATH];
    char *p;

    snprintf(tmp, sizeof(tmp), "%s", dir);
    for (p = tmp + 1; *p; p++) {
        if (*p == '/') {
            *p = '\0';
            if (mkdir(tmp, mode) == -1 && errno != EEXIST)
                return -1;
            *p = '/';
        }
    }
    if (mkdir(tmp, mode) == -1 && errno != EEXIST)
        return -1;
    return 0;
}

/* Create output directory and static files */
static int create_output_structure(const char *dir, const char *iface) {
    char path[MAX_FILEPATH];
    char device_name[128];

    /* Create directory tree (works for both systemd and manual invocation) */
    if (mkdir_p(dir, 0755) == -1) {
        perror("mkdir_p");
        return -1;
    }

    /* name file */
    snprintf(device_name, sizeof(device_name), "sfp_%s", iface);
    snprintf(path, sizeof(path), "%s/name", dir);
    write_string_file(path, device_name);

    /* Labels */
    snprintf(path, sizeof(path), "%s/temp1_label", dir);
    write_string_file(path, "SFP+ Module");

    snprintf(path, sizeof(path), "%s/in1_label", dir);
    write_string_file(path, "SFP+ Voltage");

    return 0;
}

/* Convert float to milliunit int with proper rounding (not truncation) */
static inline int to_milli(float val) {
    return (int)(val * 1000.0f + 0.5f);
}

/* Parse ethtool -m output for DDM values */
static int parse_ethtool_output(const char *output, sensor_data_t *data) {
    char line[MAX_LINE];
    const char *ptr = output;
    const char *end;
    float fval;

    data->valid = 0;
    data->thresholds_valid = 0;

    while (*ptr) {
        end = strchr(ptr, '\n');
        if (!end) end = ptr + strlen(ptr);

        int len = end - ptr;
        if (len >= MAX_LINE - 1) len = MAX_LINE - 2;

        strncpy(line, ptr, len);
        line[len] = '\0';

        /* Current readings — reject threshold/alarm/warning variants */
        if (strstr(line, "Module temperature") && !strstr(line, "threshold") &&
            !strstr(line, "alarm") && !strstr(line, "warning")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                /* Sanity: reject readings outside -20°C to 120°C */
                if (fval >= -20.0f && fval <= 120.0f) {
                    data->temp_millidegrees = to_milli(fval);
                    data->valid = 1;
                }
            }
        }

        if (strstr(line, "Module voltage") && !strstr(line, "threshold") &&
            !strstr(line, "alarm") && !strstr(line, "warning")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                /* Sanity: reject readings outside 0V to 5V */
                if (fval >= 0.0f && fval <= 5.0f) {
                    data->voltage_millivolts = to_milli(fval);
                }
            }
        }

        /* Thresholds (written once, used by CoolerControl for limit display) */
        if (strstr(line, "temperature high alarm threshold")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                data->temp_alarm_high = to_milli(fval);
                data->thresholds_valid = 1;
            }
        }

        if (strstr(line, "temperature high warning threshold")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                data->temp_warn_high = to_milli(fval);
            }
        }

        if (strstr(line, "voltage high alarm threshold")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                data->volt_alarm_high = to_milli(fval);
            }
        }

        if (strstr(line, "voltage low alarm threshold")) {
            if (sscanf(line, "%*[^:]: %f", &fval) == 1) {
                data->volt_alarm_low = to_milli(fval);
            }
        }

        ptr = (*end) ? end + 1 : end;
    }

    return data->valid ? 0 : -1;
}

/* Execute ethtool and read output */
static int read_sfp_data(const char *interface, sensor_data_t *data) {
    char cmd[MAX_LINE];
    char output[8192];
    FILE *fp;
    size_t bytes_read;

    snprintf(cmd, sizeof(cmd), "ethtool -m %s 2>/dev/null", interface);

    fp = popen(cmd, "r");
    if (!fp) {
        perror("popen");
        return -1;
    }

    bytes_read = fread(output, 1, sizeof(output) - 1, fp);
    output[bytes_read] = '\0';

    pclose(fp);

    return parse_ethtool_output(output, data);
}

/* Update all sensor files */
static int update_sensor_files(const char *dir, const sensor_data_t *data) {
    char path[MAX_FILEPATH];

    snprintf(path, sizeof(path), "%s/temp1_input", dir);
    if (write_sensor_file(path, data->temp_millidegrees) == -1)
        return -1;

    snprintf(path, sizeof(path), "%s/in1_input", dir);
    if (write_sensor_file(path, data->voltage_millivolts) == -1)
        return -1;

    return 0;
}

/* Write threshold files (only once, they don't change) */
static int write_threshold_files(const char *dir, const sensor_data_t *data) {
    char path[MAX_FILEPATH];

    if (!data->thresholds_valid)
        return 0;

    snprintf(path, sizeof(path), "%s/temp1_max", dir);
    write_sensor_file(path, data->temp_warn_high);

    snprintf(path, sizeof(path), "%s/temp1_crit", dir);
    write_sensor_file(path, data->temp_alarm_high);

    snprintf(path, sizeof(path), "%s/in1_max", dir);
    write_sensor_file(path, data->volt_alarm_high);

    snprintf(path, sizeof(path), "%s/in1_min", dir);
    write_sensor_file(path, data->volt_alarm_low);

    return 0;
}

static void get_timestamp(char *buf, size_t len) {
    time_t now = time(NULL);
    struct tm *tm = localtime(&now);
    strftime(buf, len, "%H:%M:%S", tm);
}

/* Main monitoring loop */
static int monitor_loop(const config_t *config) {
    sensor_data_t data;
    char timestamp[32];
    int errors = 0;
    int thresholds_written = 0;
    const int max_errors = 10;

    fprintf(stderr, "sfp_monitor: interface=%s dir=%s poll=%ds\n",
            config->interface, config->output_dir, config->poll_interval);

    while (keep_running) {
        if (read_sfp_data(config->interface, &data) == 0) {
            if (update_sensor_files(config->output_dir, &data) == 0) {
                errors = 0;

                /* Write thresholds once on first successful read */
                if (!thresholds_written && data.thresholds_valid) {
                    write_threshold_files(config->output_dir, &data);
                    thresholds_written = 1;
                }

                if (config->verbose) {
                    get_timestamp(timestamp, sizeof(timestamp));
                    fprintf(stderr, "[%s] Temp: %.2f°C  Voltage: %.3fV\n",
                            timestamp,
                            data.temp_millidegrees / 1000.0,
                            data.voltage_millivolts / 1000.0);
                }
            } else {
                fprintf(stderr, "sfp_monitor: error updating sensor files\n");
                errors++;
            }
        } else {
            fprintf(stderr, "sfp_monitor: error reading SFP+ DDM from %s\n",
                    config->interface);
            errors++;
        }

        if (errors >= max_errors) {
            fprintf(stderr, "sfp_monitor: too many consecutive errors, exiting\n");
            return 1;
        }

        sleep(config->poll_interval);
    }

    fprintf(stderr, "sfp_monitor: shutting down\n");
    return 0;
}

static void print_usage(const char *prog) {
    fprintf(stderr,
        "Usage: %s <interface> [output_dir] [poll_interval] [-v]\n"
        "\n"
        "Arguments:\n"
        "  interface      Network interface with SFP+ module (required)\n"
        "  output_dir     Directory for sensor files (default: /run/sfp-monitor/<interface>)\n"
        "  poll_interval  Seconds between polls (default: 5)\n"
        "\n"
        "Options:\n"
        "  -v             Verbose: log every poll to stderr\n"
        "  -h             Show this help\n"
        "\n"
        "Example:\n"
        "  %s enp3s0f0 /run/sfp-monitor/enp3s0f0 5 -v\n"
        "\n", prog, prog);
}

int main(int argc, char *argv[]) {
    config_t config = {
        .interface = "",
        .output_dir = "",
        .poll_interval = 5,
        .verbose = 0
    };

    /* Parse arguments */
    if (argc < 2 || strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
        print_usage(argv[0]);
        return (argc < 2) ? 1 : 0;
    }

    if (argv[1][0] != '-') {
        strncpy(config.interface, argv[1], sizeof(config.interface) - 1);
        config.interface[sizeof(config.interface) - 1] = '\0';
    }

    if (config.interface[0] == '\0') {
        fprintf(stderr, "sfp_monitor: interface name is required\n");
        print_usage(argv[0]);
        return 1;
    }

    if (argc >= 3 && argv[2][0] != '-') {
        strncpy(config.output_dir, argv[2], sizeof(config.output_dir) - 1);
        config.output_dir[sizeof(config.output_dir) - 1] = '\0';
    }

    if (argc >= 4 && argv[3][0] != '-') {
        config.poll_interval = atoi(argv[3]);
        if (config.poll_interval < 1) config.poll_interval = 5;
    }

    /* Scan for flags */
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0) config.verbose = 1;
    }

    /* Default output dir: /run/sfp-monitor/<interface> */
    if (config.output_dir[0] == '\0') {
        snprintf(config.output_dir, sizeof(config.output_dir),
                 "/run/sfp-monitor/%s", config.interface);
    }

    /* Signal handlers */
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);

    /* Create output structure */
    if (create_output_structure(config.output_dir, config.interface) == -1) {
        fprintf(stderr, "sfp_monitor: failed to create %s\n", config.output_dir);
        return 1;
    }

    return monitor_loop(&config);
}