accidental rollback

lab_4/fifo_client.c

@@ -1,37 +1,41 @@
-#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 <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"
-#define FIFO_RESPONSE "/tmp/fifo_response"
-#define BUFFER_SIZE 4096
+#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",
@@ -39,7 +43,7 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    // Читаем данные из файла
+    // Выделяем буфер под содержимое файла и обмен с сервером
     char *buffer = malloc(BUFFER_SIZE);
     if (!buffer) {
         fprintf(stderr, "ERROR: Не удалось выделить память\n");
@@ -47,6 +51,7 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
+    // Читаем данные из входного файла (не более BUFFER_SIZE-1, оставляем место под '\0')
     ssize_t bytes_read = read(in_fd, buffer, BUFFER_SIZE - 1);
     close(in_fd);
 
@@ -56,10 +61,11 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
+    // Делаем буфер временно C-строкой для отладочного вывода
     buffer[bytes_read] = '\0';
     printf("Прочитано байт из файла: %zd\n", bytes_read);
 
-    // Открываем FIFO для отправки запроса
+    // Открываем FIFO запроса на запись (ожидается, что сервер уже создал FIFO и слушает)
     printf("Отправка запроса серверу...\n");
     int fd_req = open(FIFO_REQUEST, O_WRONLY);
     if (fd_req == -1) {
@@ -69,7 +75,7 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    // Отправляем данные серверу
+    // Отправляем прочитанные из файла данные серверу по FIFO запроса
     ssize_t bytes_written = write(fd_req, buffer, bytes_read);
     close(fd_req);
 
@@ -81,7 +87,7 @@ int main(int argc, char *argv[]) {
 
     printf("Отправлено байт: %zd\n", bytes_written);
 
-    // Открываем FIFO для получения ответа
+    // Открываем FIFO ответа на чтение, чтобы получить обработанные данные от сервера
     printf("Ожидание ответа от сервера...\n");
     int fd_resp = open(FIFO_RESPONSE, O_RDONLY);
     if (fd_resp == -1) {
@@ -90,7 +96,7 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    // Читаем обработанные данные
+    // Читаем ответ сервера в тот же буфер
     ssize_t response_bytes = read(fd_resp, buffer, BUFFER_SIZE - 1);
     close(fd_resp);
 
@@ -100,20 +106,25 @@ int main(int argc, char *argv[]) {
         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'; // Обрезаем служебную информацию
+        // Обрезаем строку в месте начала служебной части, оставляя только полезные данные
+        *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) {
@@ -123,7 +134,7 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    // Записываем обработанные данные
+    // Записываем в выходной файл только содержимое (без служебной части REPLACEMENTS)
     ssize_t written = write(out_fd, buffer, response_bytes);
     close(out_fd);
 
@@ -133,10 +144,12 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
+    // Информационные сообщения об успешной обработке
     printf("Записано байт в выходной файл: %zd\n", written);
     printf("Количество выполненных замен: %lld\n", replacements);
     printf("\nОбработка завершена успешно!\n");
 
+    // Освобождение выделенной памяти и нормальное завершение
     free(buffer);
     return 0;
 }

lab_4/fifo_server.c

@@ -1,96 +1,119 @@
-#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 <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"
-#define FIFO_RESPONSE "/tmp/fifo_response"
-#define BUFFER_SIZE 4096
+#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;
-    running = 0;
+    (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;
+    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];
+        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) {
+        }
+        // Если символ равен ключу строки и лимит замен ещё не исчерпан —
+        // заменяем его на пробел и увеличиваем счётчик
+        else if (c == line_key && total_replacements < max_replacements) {
             outc = ' ';
             total_replacements++;
         }
 
-        output[out_pos++] = (char)outc;
+        // Записываем преобразованный символ в выходной буфер
+        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);
 
-    // Удаляем старые FIFO, если существуют
+    // На всякий случай удаляем старые 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);
+        unlink(FIFO_REQUEST); // чистим первый, если второй mkfifo не удался
         return 1;
     }
 
@@ -99,16 +122,18 @@ int main(int argc, char *argv[]) {
     printf("  Response: %s\n", FIFO_RESPONSE);
     printf("Ожидание запросов от клиентов...\n\n");
 
+    // Главный цикл сервера: пока не пришёл сигнал завершения
     while (running) {
-        // Открываем FIFO для чтения запроса
+        // Открываем 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);
 
@@ -120,26 +145,29 @@ int main(int argc, char *argv[]) {
             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 для отправки ответа
+        // Открываем FIFO ответа для записи (ждём, пока клиент откроет на чтение)
         int fd_resp = open(FIFO_RESPONSE, O_WRONLY);
         if (fd_resp == -1) {
             perror("open response FIFO");
@@ -148,24 +176,26 @@ int main(int argc, char *argv[]) {
             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);