rgz-vlad works no count

vlad/rgz/daemon.c

@@ -0,0 +1,194 @@
+// fifo_server_daemon.c
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <signal.h>
+#include <syslog.h>
+
+#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;
+    running = 0;
+}
+
+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;
+}
+
+// для каждой пары одинаковых подряд символов второй -> ' ', до max_replacements
+long long process_data(const char *input, size_t input_len,
+                       char *output, size_t output_size,
+                       long long max_replacements)
+{
+    if (input_len == 0 || output_size == 0) {
+        return 0;
+    }
+
+    long long total_replacements = 0;
+    size_t out_pos = 0;
+
+    unsigned char prev = (unsigned char)input[0];
+    output[out_pos++] = (char)prev;
+
+    for (size_t i = 1; i < input_len && out_pos < output_size - 1; i++) {
+        unsigned char c = (unsigned char)input[i];
+        unsigned char outc = c;
+
+        if (c == prev && total_replacements < max_replacements) {
+            outc = ' ';
+            total_replacements++;
+        }
+
+        output[out_pos++] = (char)outc;
+        prev = c;
+    }
+
+    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 (must be non-negative integer)\n");
+        return 1;
+    }
+
+    openlog("fifo_server_daemon", LOG_PID | LOG_NDELAY, LOG_DAEMON);
+    syslog(LOG_INFO, "Server started (systemd), max_replacements=%lld", max_replacements);
+
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = signal_handler;
+    sigemptyset(&sa.sa_mask);
+    sigaction(SIGINT,  &sa, NULL);
+    sigaction(SIGTERM, &sa, NULL);
+    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) {
+            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);
+        if (bytes_read < 0 && errno == EINTR && !running) {
+            close(fd_req);
+            free(input_buffer);
+            free(output_buffer);
+            break;
+        }
+        close(fd_req);
+
+        if (!running) {
+            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);
+
+        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; replacements=%lld",
+               bytes_written, replacements);
+
+        free(input_buffer);
+        free(output_buffer);
+    }
+
+    syslog(LOG_INFO, "Server stopping, cleaning up");
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+    closelog();
+    return 0;
+}