kirill-refactor

mine/lab_4/Makefile

@@ -0,0 +1,65 @@
+CC = gcc
+CFLAGS = -Wall -Wextra -std=c99 -g
+
+# Default target - build FIFO programs
+all: fifo
+
+# ===== FIFO targets =====
+fifo: fifo_server fifo_client
+
+fifo_server: fifo_server.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+fifo_client: fifo_client.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+# ===== Test files =====
+files:
+	@echo "Создание тестовых файлов..."
+	echo "abbaabbaabbaabbaabbaabbaabbaabba" > input1.txt
+	echo "xyzxyzxyzxyzxyzxyzxyzxyz" >> input1.txt
+	echo "hello world hello" >> input1.txt
+	echo "testtest" > input2.txt
+	echo "aaaaaaa" >> input2.txt
+	echo "programming" > input3.txt
+	echo "ppppython" >> input3.txt
+
+# ===== FIFO tests =====
+test_server: fifo files
+	@echo "=== Запуск FIFO сервера ==="
+	@echo "В другом терминале выполните: make test_fifo_client"
+	@echo "\n\n"
+	./fifo_server 10
+
+test_client: fifo files
+	@echo "=== Запуск FIFO клиента ===\n\n" & \
+    ./fifo_client input1.txt output1_fifo.txt; \
+	./fifo_client input2.txt output2_fifo.txt; \
+	./fifo_client input3.txt output3_fifo.txt;
+	@echo "\n=== Результаты FIFO ===\n"
+	@echo "--- output1_fifo.txt ---"
+	@cat output1_fifo.txt || true
+	@echo "\n--- output2_fifo.txt ---"
+	@cat output2_fifo.txt || true
+	@echo "\n--- output3_fifo.txt ---"
+	@cat output3_fifo.txt || true
+
+# Cleanup
+clean:
+	@echo "Очистка..."
+	rm -f fifo_server fifo_client
+	rm -f input1.txt input2.txt input3.txt
+	rm -f output*.txt
+	rm -f /tmp/fifo_request /tmp/fifo_response
+
+# Help
+help:
+	@echo "Available targets:"
+	@echo "  fifo        - Compile fifo_server and fifo_client"
+	@echo "  files       - Create test input files"
+	@echo "  test_server - Run FIFO server (use client in another terminal)"
+	@echo "  test_client - Run FIFO client and show results"
+	@echo "  clean       - Remove built files and test files"
+	@echo "  help        - Show this help"
+
+.PHONY: all fifo files test_server test_client clean help

mine/lab_4/fifo_client.c

@@ -0,0 +1,155 @@
+#include <stdio.h>      // printf, fprintf
+#include <stdlib.h>     // malloc, free, exit
+#include <string.h>     // strlen, strerror, strstr, sscanf
+#include <unistd.h>     // read, write, close, getpid
+#include <fcntl.h>      // open, O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC
+#include <sys/types.h>  // типы для системных вызовов
+#include <sys/stat.h>   // константы прав доступа (S_IRUSR и т.п.)
+#include <errno.h>      // errno и коды ошибок [web:17]
+
+#define FIFO_REQUEST "/tmp/fifo_request"   // путь к FIFO для запроса клиент→сервер
+#define FIFO_RESPONSE "/tmp/fifo_response" // путь к FIFO для ответа сервер→клиент
+#define BUFFER_SIZE 4096                   // размер буфера для обмена данными
+
+// Печать подсказки по использованию программы
+void print_usage(const char *progname) {
+    fprintf(stderr, "Usage: %s <input_file> <output_file>\n", progname);
+    fprintf(stderr, "Example: %s input.txt output.txt\n", progname);
+}
+
+int main(int argc, char *argv[]) {
+    // Проверка числа аргументов командной строки
+    if (argc != 3) {
+        fprintf(stderr, "ERROR: Неверное количество аргументов\n");
+        print_usage(argv[0]);
+        return 1;
+    }
+
+    // Имена входного и выходного файлов берём из аргументов
+    const char *input_file = argv[1];
+    const char *output_file = argv[2];
+
+    // Информационное сообщение о запуске клиента
+    printf("=== FIFO Client ===\n");
+    printf("Client PID: %d\n", getpid());
+    printf("Входной файл: %s\n", input_file);
+    printf("Выходной файл: %s\n", output_file);
+
+    // Открываем входной файл для чтения
+    int in_fd = open(input_file, O_RDONLY);
+    if (in_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть входной файл %s: %s\n",
+                input_file, strerror(errno));
+        return 1;
+    }
+
+    // Выделяем буфер под содержимое файла и обмен с сервером
+    char *buffer = malloc(BUFFER_SIZE);
+    if (!buffer) {
+        fprintf(stderr, "ERROR: Не удалось выделить память\n");
+        close(in_fd);
+        return 1;
+    }
+
+    // Читаем данные из входного файла (не более BUFFER_SIZE-1, оставляем место под '\0')
+    ssize_t bytes_read = read(in_fd, buffer, BUFFER_SIZE - 1);
+    close(in_fd);
+
+    if (bytes_read < 0) {
+        fprintf(stderr, "ERROR: Не удалось прочитать файл: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Делаем буфер временно C-строкой для отладочного вывода
+    buffer[bytes_read] = '\0';
+    printf("Прочитано байт из файла: %zd\n", bytes_read);
+
+    // Открываем FIFO запроса на запись (ожидается, что сервер уже создал FIFO и слушает)
+    printf("Отправка запроса серверу...\n");
+    int fd_req = open(FIFO_REQUEST, O_WRONLY);
+    if (fd_req == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO запроса: %s\n", strerror(errno));
+        fprintf(stderr, "Убедитесь, что сервер запущен!\n");
+        free(buffer);
+        return 1;
+    }
+
+    // Отправляем прочитанные из файла данные серверу по FIFO запроса
+    ssize_t bytes_written = write(fd_req, buffer, bytes_read);
+    close(fd_req);
+
+    if (bytes_written != bytes_read) {
+        fprintf(stderr, "ERROR: Ошибка отправки данных\n");
+        free(buffer);
+        return 1;
+    }
+
+    printf("Отправлено байт: %zd\n", bytes_written);
+
+    // Открываем FIFO ответа на чтение, чтобы получить обработанные данные от сервера
+    printf("Ожидание ответа от сервера...\n");
+    int fd_resp = open(FIFO_RESPONSE, O_RDONLY);
+    if (fd_resp == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO ответа: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Читаем ответ сервера в тот же буфер
+    ssize_t response_bytes = read(fd_resp, buffer, BUFFER_SIZE - 1);
+    close(fd_resp);
+
+    if (response_bytes < 0) {
+        fprintf(stderr, "ERROR: Ошибка чтения ответа\n");
+        free(buffer);
+        return 1;
+    }
+
+    // Делает ответ строкой для поиска служебной части с количеством замен
+    buffer[response_bytes] = '\0';
+    printf("Получено байт от сервера: %zd\n", response_bytes);
+
+    // В протоколе ответа сервер дописывает в конец строку вида "\nREPLACEMENTS:<число>"
+    // Ищем начало этой служебной информации
+    char *replacements_info = strstr(buffer, "\nREPLACEMENTS:");
+    long long replacements = 0;
+
+    if (replacements_info) {
+        // Считываем количество замен из служебной части
+        sscanf(replacements_info, "\nREPLACEMENTS:%lld", &replacements);
+        // Обрезаем строку в месте начала служебной части, оставляя только полезные данные
+        *replacements_info = '\0';
+        // Пересчитываем длину полезных данных как количество байт до служебного блока
+        response_bytes = replacements_info - buffer;
+    }
+
+    // Открываем (или создаём) выходной файл с правами rw-rw-rw-
+    int out_fd = open(output_file, O_CREAT | O_WRONLY | O_TRUNC,
+                      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    if (out_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть выходной файл %s: %s\n",
+                output_file, strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Записываем в выходной файл только содержимое (без служебной части REPLACEMENTS)
+    ssize_t written = write(out_fd, buffer, response_bytes);
+    close(out_fd);
+
+    if (written != response_bytes) {
+        fprintf(stderr, "ERROR: Ошибка записи в выходной файл\n");
+        free(buffer);
+        return 1;
+    }
+
+    // Информационные сообщения об успешной обработке
+    printf("Записано байт в выходной файл: %zd\n", written);
+    printf("Количество выполненных замен: %lld\n", replacements);
+    printf("\nОбработка завершена успешно!\n");
+
+    // Освобождение выделенной памяти и нормальное завершение
+    free(buffer);
+    return 0;
+}

mine/lab_4/fifo_server.c

@@ -0,0 +1,206 @@
+#include <stdio.h>      // printf, fprintf
+#include <stdlib.h>     // malloc, free, strtoll
+#include <string.h>     // strlen, strerror
+#include <unistd.h>     // read, write, close, unlink, getpid
+#include <fcntl.h>      // open, флаги O_RDONLY/O_WRONLY
+#include <sys/types.h>  // типы для системных вызовов
+#include <sys/stat.h>   // mkfifo, права доступа
+#include <errno.h>      // errno
+#include <signal.h>     // signal, SIGINT, SIGTERM
+
+#define FIFO_REQUEST "/tmp/fifo_request"   // путь к FIFO для запроса клиент→сервер
+#define FIFO_RESPONSE "/tmp/fifo_response" // путь к FIFO для ответа сервер→клиент
+#define BUFFER_SIZE 4096                   // размер буфера для обмена данными
+
+// Флаг для аккуратного завершения по сигналу
+volatile sig_atomic_t running = 1;
+
+// Обработчик сигналов завершения (Ctrl+C, SIGTERM)
+void signal_handler(int sig) {
+    (void) sig; // чтобы не ругался компилятор на неиспользуемый arg
+    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;
+}
+
+// Основная логика обработки текста:
+//   - input/input_len: входные данные
+//   - output/output_size: буфер для результата
+//   - max_replacements: глобальное ограничение по числу замен
+// Правило: в каждой строке первый символ принят как "ключ" строки,
+// все его повторения в этой строке заменяются на пробел (пока не кончится лимит).
+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[]) {
+    // Ожидаем один аргумент: max_replacements
+    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;
+    }
+
+    // Информационный вывод о запуске сервера
+    printf("=== FIFO Server запущен ===\n");
+    printf("Server PID: %d\n", getpid());
+    printf("Максимум замен: %lld\n", max_replacements);
+
+    // Устанавливаем обработчики сигналов для корректного завершения
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+    // Не умирать от SIGPIPE, когда клиент закрыл FIFO
+    signal(SIGPIPE, SIG_IGN);
+
+    // На всякий случай удаляем старые FIFO, если остались от предыдущего запуска
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    // Создаем именованный канал для запросов
+    if (mkfifo(FIFO_REQUEST, 0666) == -1) {
+        perror("mkfifo request");
+        return 1;
+    }
+    // Создаем именованный канал для ответов
+    if (mkfifo(FIFO_RESPONSE, 0666) == -1) {
+        perror("mkfifo response");
+        unlink(FIFO_REQUEST); // чистим первый, если второй mkfifo не удался
+        return 1;
+    }
+
+    printf("FIFO каналы созданы:\n");
+    printf("  Request: %s\n", FIFO_REQUEST);
+    printf("  Response: %s\n", FIFO_RESPONSE);
+    printf("Ожидание запросов от клиентов...\n\n");
+
+    // Главный цикл сервера: пока не пришёл сигнал завершения
+    while (running) {
+        // Открываем FIFO запроса для чтения (блокируется, пока клиент не откроет на запись)
+        int fd_req = open(FIFO_REQUEST, O_RDONLY);
+        if (fd_req == -1) {
+            // Если нас прервали сигналом, просто пробуем снова
+            if (errno == EINTR) continue;
+            perror("open request FIFO");
+            break;
+        }
+
+        // Выделяем буферы под входные и выходные данные для текущего запроса
+        char *input_buffer = malloc(BUFFER_SIZE);
+        char *output_buffer = malloc(BUFFER_SIZE);
+
+        if (!input_buffer || !output_buffer) {
+            fprintf(stderr, "ERROR: Memory allocation failed\n");
+            close(fd_req);
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        // Читаем данные от клиента
+        ssize_t bytes_read = read(fd_req, input_buffer, BUFFER_SIZE - 1);
+        close(fd_req);
+
+        // Если ничего не прочитали или ошибка — просто переходим к следующему циклу
+        if (bytes_read <= 0) {
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        // Делаем входной буфер C-строкой для удобства отладки
+        input_buffer[bytes_read] = '\0';
+        printf("Получен запрос: %zd байт\n", bytes_read);
+
+        // Обрабатываем данные по заданному правилу
+        long long replacements = process_data(input_buffer, bytes_read,
+                                              output_buffer, BUFFER_SIZE,
+                                              max_replacements);
+
+        printf("Выполнено замен: %lld\n", replacements);
+
+        // Открываем FIFO ответа для записи (ждём, пока клиент откроет на чтение)
+        int fd_resp = open(FIFO_RESPONSE, O_WRONLY);
+        if (fd_resp == -1) {
+            perror("open response FIFO");
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        // Отправляем клиенту обработанный текст
+        size_t output_len = strlen(output_buffer);
+        ssize_t bytes_written = write(fd_resp, output_buffer, output_len);
+
+        // Затем — служебную строку с количеством замен в формате "\nREPLACEMENTS:<n>\n"
+        char result[64];
+        snprintf(result, sizeof(result), "\nREPLACEMENTS:%lld\n", replacements);
+        write(fd_resp, result, strlen(result));
+
+        // Закрываем FIFO ответа — завершение "сессии" с клиентом
+        close(fd_resp);
+
+        printf("Отправлен ответ: %zd байт\n\n", bytes_written);
+
+        // Освобождаем буферы для этого запроса
+        free(input_buffer);
+        free(output_buffer);
+    }
+
+    // При завершении работы сервера удаляем FIFO
+    printf("\nЗавершение работы сервера...\n");
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    return 0;
+}

mine/lab_4/kirill's/Makefile

@@ -0,0 +1,99 @@
+# Makefile for lab 4 - FIFO (named pipes) only
+
+CC = gcc
+CFLAGS = -Wall -Wextra -std=c99 -g
+
+# Default target - build FIFO programs
+all: fifo
+
+# ===== FIFO targets =====
+fifo: fifo_server fifo_client
+
+fifo_server: fifo_server.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+fifo_client: fifo_client.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+# ===== Test files =====
+test_files:
+	@echo "Создание тестовых файлов..."
+	echo "abbaabbaabbaabbaabbaabbaabbaabba" > input1.txt
+	echo "xyzxyzxyzxyzxyzxyzxyzxyz" >> input1.txt
+	echo "hello world hello" >> input1.txt
+	echo "testtest" > input2.txt
+	echo "aaaaaaa" >> input2.txt
+	echo "programming" > input3.txt
+	echo "ppppython" >> input3.txt
+
+# ===== FIFO tests =====
+test_fifo_server: fifo test_files
+	@echo "=== Запуск FIFO сервера ==="
+	@echo "В другом терминале выполните: make test_fifo_client"
+	./fifo_server 10
+
+test_fifo_client: fifo test_files
+	@echo "=== Запуск FIFO клиента ===" & \
+    ./fifo_client input1.txt output1_fifo.txt; \
+	./fifo_client input2.txt output2_fifo.txt; \
+	./fifo_client input3.txt output3_fifo.txt;
+	@echo "\n=== Результаты FIFO ==="
+	@echo "--- output1_fifo.txt ---"
+	@cat output1_fifo.txt || true
+	@echo "\n--- output2_fifo.txt ---"
+	@cat output2_fifo.txt || true
+	@echo "\n--- output3_fifo.txt ---"
+	@cat output3_fifo.txt || true
+
+# Automatic FIFO test (server in background)
+test_all: fifo test_files
+	@echo "=== Автоматический тест FIFO ==="
+	@./fifo_server 10 & \
+	SERVER_PID=$$!; \
+	sleep 1; \
+	./fifo_client input1.txt output1_fifo.txt; \
+	./fifo_client input2.txt output2_fifo.txt; \
+	./fifo_client input3.txt output3_fifo.txt; \
+	kill $$SERVER_PID 2>/dev/null || true; \
+	wait $$SERVER_PID 2>/dev/null || true
+	@echo "\n=== Результаты FIFO ==="
+	@echo "--- output1_fifo.txt ---"
+	@cat output1_fifo.txt || true
+	@echo "\n--- output2_fifo.txt ---"
+	@cat output2_fifo.txt || true
+	@echo "\n--- output3_fifo.txt ---"
+	@cat output3_fifo.txt || true
+
+# Error handling test for FIFO
+test_error: fifo
+	@echo "\n=== Тест обработки ошибки (несуществующий файл) - FIFO ==="
+	@./fifo_server 5 & \
+	SERVER_PID=$$!; \
+	sleep 1; \
+	./fifo_client nonexistent.txt output_error.txt || true; \
+	kill $$SERVER_PID 2>/dev/null || true; \
+	wait $$SERVER_PID 2>/dev/null || true
+
+# Cleanup
+clean:
+	@echo "Очистка..."
+	rm -f fifo_server fifo_client
+	rm -f input1.txt input2.txt input3.txt
+	rm -f output*.txt
+	rm -f /tmp/fifo_request /tmp/fifo_response
+
+# Help
+help:
+	@echo "Доступные цели:"
+	@echo "  all              - Скомпилировать FIFO программы"
+	@echo "  fifo             - Скомпилировать fifo_server и fifo_client"
+	@echo "  test_files       - Создать тестовые входные файлы"
+	@echo "  test_fifo_server - Запустить FIFO сервер (использовать с клиентом в другом терминале)"
+	@echo "  test_fifo_client - Запустить FIFO клиент и показать результат"
+	@echo "  test_fifo_auto   - Автоматический тест FIFO (сервер в фоне)"
+	@echo "  test_all         - Запустить все тесты (FIFO)"
+	@echo "  test_error_fifo  - Тест обработки ошибок (несуществующий файл)"
+	@echo "  clean            - Удалить скомпилированные файлы и тесты"
+
+.PHONY: all fifo test_files test_fifo_server test_fifo_client test_all \
+        test_error clean help

mine/lab_4/kirill's/fifo_client.c

@@ -0,0 +1,144 @@
+// fifo_client.c - Клиентская программа с использованием именованных каналов (FIFO)
+
+#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>
+
+#define FIFO_REQUEST "/tmp/fifo_request"
+#define FIFO_RESPONSE "/tmp/fifo_response"
+#define BUFFER_SIZE 4096
+
+void print_usage(const char *progname) {
+    fprintf(stderr, "Usage: %s <input_file> <output_file>\n", progname);
+    fprintf(stderr, "Example: %s input.txt output.txt\n", progname);
+}
+
+int main(int argc, char *argv[]) {
+    if (argc != 3) {
+        fprintf(stderr, "ERROR: Неверное количество аргументов\n");
+        print_usage(argv[0]);
+        return 1;
+    }
+
+    const char *input_file = argv[1];
+    const char *output_file = argv[2];
+
+    printf("=== FIFO Client ===\n");
+    printf("Client PID: %d\n", getpid());
+    printf("Входной файл: %s\n", input_file);
+    printf("Выходной файл: %s\n", output_file);
+
+    // Открываем входной файл
+    int in_fd = open(input_file, O_RDONLY);
+    if (in_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть входной файл %s: %s\n",
+                input_file, strerror(errno));
+        return 1;
+    }
+
+    // Читаем данные из файла
+    char *buffer = malloc(BUFFER_SIZE);
+    if (!buffer) {
+        fprintf(stderr, "ERROR: Не удалось выделить память\n");
+        close(in_fd);
+        return 1;
+    }
+
+    ssize_t bytes_read = read(in_fd, buffer, BUFFER_SIZE - 1);
+    close(in_fd);
+
+    if (bytes_read < 0) {
+        fprintf(stderr, "ERROR: Не удалось прочитать файл: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    buffer[bytes_read] = '\0';
+    printf("Прочитано байт из файла: %zd\n", bytes_read);
+
+    // Открываем FIFO для отправки запроса
+    printf("Отправка запроса серверу...\n");
+    int fd_req = open(FIFO_REQUEST, O_WRONLY);
+    if (fd_req == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO запроса: %s\n", strerror(errno));
+        fprintf(stderr, "Убедитесь, что сервер запущен!\n");
+        free(buffer);
+        return 1;
+    }
+
+    // Отправляем данные серверу
+    ssize_t bytes_written = write(fd_req, buffer, bytes_read);
+    close(fd_req);
+
+    if (bytes_written != bytes_read) {
+        fprintf(stderr, "ERROR: Ошибка отправки данных\n");
+        free(buffer);
+        return 1;
+    }
+
+    printf("Отправлено байт: %zd\n", bytes_written);
+
+    // Открываем FIFO для получения ответа
+    printf("Ожидание ответа от сервера...\n");
+    int fd_resp = open(FIFO_RESPONSE, O_RDONLY);
+    if (fd_resp == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO ответа: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Читаем обработанные данные
+    ssize_t response_bytes = read(fd_resp, buffer, BUFFER_SIZE - 1);
+    close(fd_resp);
+
+    if (response_bytes < 0) {
+        fprintf(stderr, "ERROR: Ошибка чтения ответа\n");
+        free(buffer);
+        return 1;
+    }
+
+    buffer[response_bytes] = '\0';
+    printf("Получено байт от сервера: %zd\n", response_bytes);
+
+    // Ищем информацию о количестве замен
+    char *replacements_info = strstr(buffer, "\nREPLACEMENTS:");
+    long long replacements = 0;
+
+    if (replacements_info) {
+        sscanf(replacements_info, "\nREPLACEMENTS:%lld", &replacements);
+        *replacements_info = '\0'; // Обрезаем служебную информацию
+        response_bytes = replacements_info - buffer;
+    }
+
+    // Открываем выходной файл
+    int out_fd = open(output_file, O_CREAT | O_WRONLY | O_TRUNC, 
+                      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    if (out_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть выходной файл %s: %s\n",
+                output_file, strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Записываем обработанные данные
+    ssize_t written = write(out_fd, buffer, response_bytes);
+    close(out_fd);
+
+    if (written != response_bytes) {
+        fprintf(stderr, "ERROR: Ошибка записи в выходной файл\n");
+        free(buffer);
+        return 1;
+    }
+
+    printf("Записано байт в выходной файл: %zd\n", written);
+    printf("Количество выполненных замен: %lld\n", replacements);
+    printf("\nОбработка завершена успешно!\n");
+
+    free(buffer);
+    return 0;
+}

mine/lab_4/kirill's/fifo_server.c

@@ -0,0 +1,183 @@
+// fifo_server.c - Серверная программа с использованием именованных каналов (FIFO)
+// Вариант повышенной сложности для Lab 4
+
+#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>
+
+#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;
+}
+
+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;
+    long long col = 0; /* position in current line (counts non-newline bytes) */
+    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 (c == '\n') {
+            /* write newline, reset column counter */
+            output[out_pos++] = '\n';
+            col = 0;
+            continue;
+        }
+
+        col++;
+        unsigned char outc = c;
+
+        if ((col % 3) == 0 && total_replacements < max_replacements) {
+            outc = ' ';
+            total_replacements++;
+        }
+
+        output[out_pos++] = (char)outc;
+    }
+
+    /* If there is space, terminate string */
+    if (out_pos < output_size)
+        output[out_pos] = '\0';
+    else if (output_size > 0)
+        output[output_size - 1] = '\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;
+    }
+
+    printf("=== FIFO Server запущен ===\n");
+    printf("Server PID: %d\n", getpid());
+    printf("Максимум замен: %lld\n", max_replacements);
+
+    // Устанавливаем обработчик сигналов
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+
+    // Удаляем старые FIFO, если существуют
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    // Создаем именованные каналы
+    if (mkfifo(FIFO_REQUEST, 0666) == -1) {
+        perror("mkfifo request");
+        return 1;
+    }
+    if (mkfifo(FIFO_RESPONSE, 0666) == -1) {
+        perror("mkfifo response");
+        unlink(FIFO_REQUEST);
+        return 1;
+    }
+
+    printf("FIFO каналы созданы:\n");
+    printf("  Request: %s\n", FIFO_REQUEST);
+    printf("  Response: %s\n", FIFO_RESPONSE);
+    printf("Ожидание запросов от клиентов...\n\n");
+
+    while (running) {
+        // Открываем FIFO для чтения запроса
+        int fd_req = open(FIFO_REQUEST, O_RDONLY);
+        if (fd_req == -1) {
+            if (errno == EINTR) continue;
+            perror("open request FIFO");
+            break;
+        }
+
+        // Читаем данные от клиента
+        char *input_buffer = malloc(BUFFER_SIZE);
+        char *output_buffer = malloc(BUFFER_SIZE);
+
+        if (!input_buffer || !output_buffer) {
+            fprintf(stderr, "ERROR: Memory allocation failed\n");
+            close(fd_req);
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        ssize_t bytes_read = read(fd_req, input_buffer, BUFFER_SIZE - 1);
+        close(fd_req);
+
+        if (bytes_read <= 0) {
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        input_buffer[bytes_read] = '\0';
+        printf("Получен запрос: %zd байт\n", bytes_read);
+
+        // Обрабатываем данные
+        long long replacements = process_data(input_buffer, bytes_read, 
+                                             output_buffer, BUFFER_SIZE, 
+                                             max_replacements);
+
+        printf("Выполнено замен: %lld\n", replacements);
+
+        // Открываем FIFO для отправки ответа
+        int fd_resp = open(FIFO_RESPONSE, O_WRONLY);
+        if (fd_resp == -1) {
+            perror("open response FIFO");
+            free(input_buffer);
+            free(output_buffer);
+            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);
+
+        printf("Отправлен ответ: %zd байт\n\n", bytes_written);
+
+        free(input_buffer);
+        free(output_buffer);
+    }
+
+    // Очистка
+    printf("\nЗавершение работы сервера...\n");
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    return 0;
+}

mine/lab_4/vlad's/Makefile

@@ -0,0 +1,99 @@
+# Makefile for lab 4 - FIFO (named pipes) only
+
+CC = gcc
+CFLAGS = -Wall -Wextra -std=c99 -g
+
+# Default target - build FIFO programs
+all: fifo
+
+# ===== FIFO targets =====
+fifo: fifo_server fifo_client
+
+fifo_server: fifo_server.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+fifo_client: fifo_client.c
+	$(CC) $(CFLAGS) -o $@ $<
+
+# ===== Test files =====
+test_files:
+	@echo "Создание тестовых файлов..."
+	echo "abbaabbaabbaabbaabbaabbaabbaabba" > input1.txt
+	echo "xyzxyzxyzxyzxyzxyzxyzxyz" >> input1.txt
+	echo "hello world hello" >> input1.txt
+	echo "testtest" > input2.txt
+	echo "aaaaaaa" >> input2.txt
+	echo "programming" > input3.txt
+	echo "ppppython" >> input3.txt
+
+# ===== FIFO tests =====
+test_fifo_server: fifo test_files
+	@echo "=== Запуск FIFO сервера ==="
+	@echo "В другом терминале выполните: make test_fifo_client"
+	./fifo_server 10
+
+test_fifo_client: fifo test_files
+	@echo "=== Запуск FIFO клиента ===" & \
+    ./fifo_client input1.txt output1_fifo.txt; \
+	./fifo_client input2.txt output2_fifo.txt; \
+	./fifo_client input3.txt output3_fifo.txt;
+	@echo "\n=== Результаты FIFO ==="
+	@echo "--- output1_fifo.txt ---"
+	@cat output1_fifo.txt || true
+	@echo "\n--- output2_fifo.txt ---"
+	@cat output2_fifo.txt || true
+	@echo "\n--- output3_fifo.txt ---"
+	@cat output3_fifo.txt || true
+
+# Automatic FIFO test (server in background)
+test_all: fifo test_files
+	@echo "=== Автоматический тест FIFO ==="
+	@./fifo_server 10 & \
+	SERVER_PID=$$!; \
+	sleep 1; \
+	./fifo_client input1.txt output1_fifo.txt; \
+	./fifo_client input2.txt output2_fifo.txt; \
+	./fifo_client input3.txt output3_fifo.txt; \
+	kill $$SERVER_PID 2>/dev/null || true; \
+	wait $$SERVER_PID 2>/dev/null || true
+	@echo "\n=== Результаты FIFO ==="
+	@echo "--- output1_fifo.txt ---"
+	@cat output1_fifo.txt || true
+	@echo "\n--- output2_fifo.txt ---"
+	@cat output2_fifo.txt || true
+	@echo "\n--- output3_fifo.txt ---"
+	@cat output3_fifo.txt || true
+
+# Error handling test for FIFO
+test_error: fifo
+	@echo "\n=== Тест обработки ошибки (несуществующий файл) - FIFO ==="
+	@./fifo_server 5 & \
+	SERVER_PID=$$!; \
+	sleep 1; \
+	./fifo_client nonexistent.txt output_error.txt || true; \
+	kill $$SERVER_PID 2>/dev/null || true; \
+	wait $$SERVER_PID 2>/dev/null || true
+
+# Cleanup
+clean:
+	@echo "Очистка..."
+	rm -f fifo_server fifo_client
+	rm -f input1.txt input2.txt input3.txt
+	rm -f output*.txt
+	rm -f /tmp/fifo_request /tmp/fifo_response
+
+# Help
+help:
+	@echo "Доступные цели:"
+	@echo "  all              - Скомпилировать FIFO программы"
+	@echo "  fifo             - Скомпилировать fifo_server и fifo_client"
+	@echo "  test_files       - Создать тестовые входные файлы"
+	@echo "  test_fifo_server - Запустить FIFO сервер (использовать с клиентом в другом терминале)"
+	@echo "  test_fifo_client - Запустить FIFO клиент и показать результат"
+	@echo "  test_fifo_auto   - Автоматический тест FIFO (сервер в фоне)"
+	@echo "  test_all         - Запустить все тесты (FIFO)"
+	@echo "  test_error_fifo  - Тест обработки ошибок (несуществующий файл)"
+	@echo "  clean            - Удалить скомпилированные файлы и тесты"
+
+.PHONY: all fifo test_files test_fifo_server test_fifo_client test_all \
+        test_error clean help

mine/lab_4/vlad's/fifo_client.c

@@ -0,0 +1,144 @@
+// fifo_client.c - Клиентская программа с использованием именованных каналов (FIFO)
+
+#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>
+
+#define FIFO_REQUEST "/tmp/fifo_request"
+#define FIFO_RESPONSE "/tmp/fifo_response"
+#define BUFFER_SIZE 4096
+
+void print_usage(const char *progname) {
+    fprintf(stderr, "Usage: %s <input_file> <output_file>\n", progname);
+    fprintf(stderr, "Example: %s input.txt output.txt\n", progname);
+}
+
+int main(int argc, char *argv[]) {
+    if (argc != 3) {
+        fprintf(stderr, "ERROR: Неверное количество аргументов\n");
+        print_usage(argv[0]);
+        return 1;
+    }
+
+    const char *input_file = argv[1];
+    const char *output_file = argv[2];
+
+    printf("=== FIFO Client ===\n");
+    printf("Client PID: %d\n", getpid());
+    printf("Входной файл: %s\n", input_file);
+    printf("Выходной файл: %s\n", output_file);
+
+    // Открываем входной файл
+    int in_fd = open(input_file, O_RDONLY);
+    if (in_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть входной файл %s: %s\n",
+                input_file, strerror(errno));
+        return 1;
+    }
+
+    // Читаем данные из файла
+    char *buffer = malloc(BUFFER_SIZE);
+    if (!buffer) {
+        fprintf(stderr, "ERROR: Не удалось выделить память\n");
+        close(in_fd);
+        return 1;
+    }
+
+    ssize_t bytes_read = read(in_fd, buffer, BUFFER_SIZE - 1);
+    close(in_fd);
+
+    if (bytes_read < 0) {
+        fprintf(stderr, "ERROR: Не удалось прочитать файл: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    buffer[bytes_read] = '\0';
+    printf("Прочитано байт из файла: %zd\n", bytes_read);
+
+    // Открываем FIFO для отправки запроса
+    printf("Отправка запроса серверу...\n");
+    int fd_req = open(FIFO_REQUEST, O_WRONLY);
+    if (fd_req == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO запроса: %s\n", strerror(errno));
+        fprintf(stderr, "Убедитесь, что сервер запущен!\n");
+        free(buffer);
+        return 1;
+    }
+
+    // Отправляем данные серверу
+    ssize_t bytes_written = write(fd_req, buffer, bytes_read);
+    close(fd_req);
+
+    if (bytes_written != bytes_read) {
+        fprintf(stderr, "ERROR: Ошибка отправки данных\n");
+        free(buffer);
+        return 1;
+    }
+
+    printf("Отправлено байт: %zd\n", bytes_written);
+
+    // Открываем FIFO для получения ответа
+    printf("Ожидание ответа от сервера...\n");
+    int fd_resp = open(FIFO_RESPONSE, O_RDONLY);
+    if (fd_resp == -1) {
+        fprintf(stderr, "ERROR: Не удалось открыть FIFO ответа: %s\n", strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Читаем обработанные данные
+    ssize_t response_bytes = read(fd_resp, buffer, BUFFER_SIZE - 1);
+    close(fd_resp);
+
+    if (response_bytes < 0) {
+        fprintf(stderr, "ERROR: Ошибка чтения ответа\n");
+        free(buffer);
+        return 1;
+    }
+
+    buffer[response_bytes] = '\0';
+    printf("Получено байт от сервера: %zd\n", response_bytes);
+
+    // Ищем информацию о количестве замен
+    char *replacements_info = strstr(buffer, "\nREPLACEMENTS:");
+    long long replacements = 0;
+
+    if (replacements_info) {
+        sscanf(replacements_info, "\nREPLACEMENTS:%lld", &replacements);
+        *replacements_info = '\0'; // Обрезаем служебную информацию
+        response_bytes = replacements_info - buffer;
+    }
+
+    // Открываем выходной файл
+    int out_fd = open(output_file, O_CREAT | O_WRONLY | O_TRUNC, 
+                      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+    if (out_fd < 0) {
+        fprintf(stderr, "ERROR: Не удалось открыть выходной файл %s: %s\n",
+                output_file, strerror(errno));
+        free(buffer);
+        return 1;
+    }
+
+    // Записываем обработанные данные
+    ssize_t written = write(out_fd, buffer, response_bytes);
+    close(out_fd);
+
+    if (written != response_bytes) {
+        fprintf(stderr, "ERROR: Ошибка записи в выходной файл\n");
+        free(buffer);
+        return 1;
+    }
+
+    printf("Записано байт в выходной файл: %zd\n", written);
+    printf("Количество выполненных замен: %lld\n", replacements);
+    printf("\nОбработка завершена успешно!\n");
+
+    free(buffer);
+    return 0;
+}

mine/lab_4/vlad's/fifo_server.c

@@ -0,0 +1,187 @@
+// fifo_server.c - Серверная программа с использованием именованных каналов (FIFO)
+// Вариант повышенной сложности для Lab 4
+
+#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>
+
+#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;
+}
+
+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;
+    size_t out_pos = 0;
+    size_t i = 0;
+
+    while (i < input_len && out_pos < output_size - 1) {
+        unsigned char c = (unsigned char)input[i];
+
+        /* Try to form a non-overlapping pair with the next character.
+           Do not treat newline as part of a pair (preserve line structure). */
+        if (i + 1 < input_len) {
+            unsigned char next = (unsigned char)input[i + 1];
+            if (c != '\n' && next != '\n' && c == next && total_replacements < max_replacements) {
+                /* write first char of pair */
+                output[out_pos++] = (char)c;
+                if (out_pos >= output_size - 1) break;
+                /* write space instead of second char */
+                output[out_pos++] = ' ';
+                total_replacements++;
+                i += 2; /* skip both chars (non-overlapping) */
+                continue;
+            }
+        }
+
+        /* No valid pair -> write current char */
+        output[out_pos++] = (char)c;
+        i++;
+    }
+
+    /* If we stopped early but still have room, copy remaining bytes (without forming pairs)
+       until output buffer full or input ends. This preserves trailing data. */
+    while (i < input_len && out_pos < output_size - 1) {
+        output[out_pos++] = input[i++];
+    }
+
+    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;
+    }
+
+    printf("=== FIFO Server запущен ===\n");
+    printf("Server PID: %d\n", getpid());
+    printf("Максимум замен: %lld\n", max_replacements);
+
+    // Устанавливаем обработчик сигналов
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+
+    // Удаляем старые FIFO, если существуют
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    // Создаем именованные каналы
+    if (mkfifo(FIFO_REQUEST, 0666) == -1) {
+        perror("mkfifo request");
+        return 1;
+    }
+    if (mkfifo(FIFO_RESPONSE, 0666) == -1) {
+        perror("mkfifo response");
+        unlink(FIFO_REQUEST);
+        return 1;
+    }
+
+    printf("FIFO каналы созданы:\n");
+    printf("  Request: %s\n", FIFO_REQUEST);
+    printf("  Response: %s\n", FIFO_RESPONSE);
+    printf("Ожидание запросов от клиентов...\n\n");
+
+    while (running) {
+        // Открываем FIFO для чтения запроса
+        int fd_req = open(FIFO_REQUEST, O_RDONLY);
+        if (fd_req == -1) {
+            if (errno == EINTR) continue;
+            perror("open request FIFO");
+            break;
+        }
+
+        // Читаем данные от клиента
+        char *input_buffer = malloc(BUFFER_SIZE);
+        char *output_buffer = malloc(BUFFER_SIZE);
+
+        if (!input_buffer || !output_buffer) {
+            fprintf(stderr, "ERROR: Memory allocation failed\n");
+            close(fd_req);
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        ssize_t bytes_read = read(fd_req, input_buffer, BUFFER_SIZE - 1);
+        close(fd_req);
+
+        if (bytes_read <= 0) {
+            free(input_buffer);
+            free(output_buffer);
+            continue;
+        }
+
+        input_buffer[bytes_read] = '\0';
+        printf("Получен запрос: %zd байт\n", bytes_read);
+
+        // Обрабатываем данные
+        long long replacements = process_data(input_buffer, bytes_read, 
+                                             output_buffer, BUFFER_SIZE, 
+                                             max_replacements);
+
+        printf("Выполнено замен: %lld\n", replacements);
+
+        // Открываем FIFO для отправки ответа
+        int fd_resp = open(FIFO_RESPONSE, O_WRONLY);
+        if (fd_resp == -1) {
+            perror("open response FIFO");
+            free(input_buffer);
+            free(output_buffer);
+            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);
+
+        printf("Отправлен ответ: %zd байт\n\n", bytes_written);
+
+        free(input_buffer);
+        free(output_buffer);
+    }
+
+    // Очистка
+    printf("\nЗавершение работы сервера...\n");
+    unlink(FIFO_REQUEST);
+    unlink(FIFO_RESPONSE);
+
+    return 0;
+}