CS-LABS/mine/rgz/fifo_server_daemon.c

// fifo_server_daemon.c
#include <stdio.h>       // fprintf (для ошибок до старта)
#include <stdlib.h>      // malloc, free, exit, strtoll
#include <string.h>      // strlen, strerror
#include <unistd.h>      // read, write, close, unlink
#include <fcntl.h>       // open, O_RDONLY, O_WRONLY
#include <sys/types.h>   // типы для системных вызовов
#include <sys/stat.h>    // mkfifo, права доступа, umask
#include <errno.h>       // errno
#include <signal.h>      // signal, SIGINT, SIGTERM, SIGPIPE
#include <syslog.h>      // syslog, openlog, closelog

#define FIFO_REQUEST  "/tmp/fifo_request"
#define FIFO_RESPONSE "/tmp/fifo_response"
#define BUFFER_SIZE   4096

volatile sig_atomic_t running = 1;

void signal_handler(int sig) {
    (void)sig;
    syslog(LOG_INFO, "Signal %d received, stopping...", sig);
    running = 0;
}

// разбор неотрицательного long long
static long long parse_ll(const char *s) {
    char *end = NULL;
    errno = 0;
    long long v = strtoll(s, &end, 10);
    if (errno != 0 || end == s || *end != '\0' || v < 0) {
        return -1;
    }
    return v;
}

// логика обработки текста (как в исходном сервере)
long long process_data(const char *input, size_t input_len,
                       char *output, size_t output_size,
                       long long max_replacements) {
    long long total_replacements = 0;
    int at_line_start = 1;
    unsigned char line_key = 0;
    size_t out_pos = 0;

    for (size_t i = 0; i < input_len && out_pos < output_size - 1; i++) {
        unsigned char c = (unsigned char)input[i];

        if (at_line_start) {
            line_key = c;
            at_line_start = 0;
        }

        unsigned char outc = c;

        if (c == '\n') {
            at_line_start = 1;
        } else if (c == line_key && total_replacements < max_replacements) {
            outc = ' ';
            total_replacements++;
        }

        output[out_pos++] = (char)outc;
    }

    output[out_pos] = '\0';
    return total_replacements;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <max_replacements>\n", argv[0]);
        return 1;
    }

    long long max_replacements = parse_ll(argv[1]);
    if (max_replacements < 0) {
        fprintf(stderr, "ERROR: Invalid max_replacements\n");
        return 1;
    }

    /* работаем в foreground, демонизацию делает systemd (Type=simple) */

    openlog("fifo_server_daemon", LOG_PID | LOG_NDELAY, LOG_DAEMON);
    syslog(LOG_INFO, "Server started (systemd), max_replacements=%lld",
           max_replacements);

    signal(SIGINT,  signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN);

    unlink(FIFO_REQUEST);
    unlink(FIFO_RESPONSE);

    if (mkfifo(FIFO_REQUEST, 0666) == -1) {
        syslog(LOG_ERR, "mkfifo request failed: %s", strerror(errno));
        closelog();
        return 1;
    }

    if (mkfifo(FIFO_RESPONSE, 0666) == -1) {
        syslog(LOG_ERR, "mkfifo response failed: %s", strerror(errno));
        unlink(FIFO_REQUEST);
        closelog();
        return 1;
    }

    syslog(LOG_INFO, "FIFO created: request=%s, response=%s",
           FIFO_REQUEST, FIFO_RESPONSE);

    while (running) {
        int fd_req = open(FIFO_REQUEST, O_RDONLY);
        if (!running) {                // сигнал пришёл во время open
            if (fd_req != -1)
                close(fd_req);
            break;
        }
        if (fd_req == -1) {
            if (errno == EINTR)
                continue;
            syslog(LOG_ERR, "open request FIFO failed: %s", strerror(errno));
            break;
        }

        char *input_buffer  = malloc(BUFFER_SIZE);
        char *output_buffer = malloc(BUFFER_SIZE);
        if (!input_buffer || !output_buffer) {
            syslog(LOG_ERR, "Memory allocation failed");
            close(fd_req);
            free(input_buffer);
            free(output_buffer);
            break;                     // выходим, не крутимся дальше
        }

        ssize_t bytes_read = read(fd_req, input_buffer, BUFFER_SIZE - 1);
        close(fd_req);

        if (!running) {                // сигнал во время read
            free(input_buffer);
            free(output_buffer);
            break;
        }

        if (bytes_read <= 0) {
            free(input_buffer);
            free(output_buffer);
            if (!running)
                break;
            continue;
        }

        input_buffer[bytes_read] = '\0';
        syslog(LOG_INFO, "Request received: %zd bytes", bytes_read);

        long long replacements =
            process_data(input_buffer, (size_t)bytes_read,
                         output_buffer, BUFFER_SIZE,
                         max_replacements);

        syslog(LOG_INFO, "Replacements done: %lld", replacements);

        int fd_resp = open(FIFO_RESPONSE, O_WRONLY);
        if (fd_resp == -1) {
            syslog(LOG_ERR, "open response FIFO failed: %s", strerror(errno));
            free(input_buffer);
            free(output_buffer);
            if (!running)
                break;
            continue;
        }

        size_t output_len = strlen(output_buffer);
        ssize_t bytes_written = write(fd_resp, output_buffer, output_len);

        char result[64];
        snprintf(result, sizeof(result), "\nREPLACEMENTS:%lld\n", replacements);
        write(fd_resp, result, strlen(result));

        close(fd_resp);

        syslog(LOG_INFO, "Response sent: %zd bytes", bytes_written);

        free(input_buffer);
        free(output_buffer);
    }

    syslog(LOG_INFO, "Server stopping, cleaning up");
    unlink(FIFO_REQUEST);
    unlink(FIFO_RESPONSE);
    closelog();
    return 0;
}