Merge remote-tracking branch 'origin/main'

lab_4/Makefile

@@ -1,5 +1,3 @@
-# Makefile for lab 4 - FIFO (named pipes) only
-
 CC = gcc
 CFLAGS = -Wall -Wextra -std=c99 -g
 
@@ -60,7 +58,7 @@ help:
 	@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 "  test_client - Run FIFO client and show results"
 	@echo "  clean       - Remove built files and test files"
 	@echo "  help        - Show this help"
 

lab_4/fifo_client.c

@@ -1,37 +1,41 @@
-#include <stdio.h>
+#include <stdio.h>      // printf, fprintf
-#include <stdlib.h>
+#include <stdlib.h>     // malloc, free, exit
-#include <string.h>
+#include <string.h>     // strlen, strerror, strstr, sscanf
-#include <unistd.h>
+#include <unistd.h>     // read, write, close, getpid
-#include <fcntl.h>
+#include <fcntl.h>      // open, O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC
-#include <sys/types.h>
+#include <sys/types.h>  // типы для системных вызовов
-#include <sys/stat.h>
+#include <sys/stat.h>   // константы прав доступа (S_IRUSR и т.п.)
-#include <errno.h>
+#include <errno.h>      // errno и коды ошибок [web:17]
 
-#define FIFO_REQUEST "/tmp/fifo_request"
+#define FIFO_REQUEST "/tmp/fifo_request"   // путь к FIFO для запроса клиент→сервер
-#define FIFO_RESPONSE "/tmp/fifo_response"
+#define FIFO_RESPONSE "/tmp/fifo_response" // путь к FIFO для ответа сервер→клиент
-#define BUFFER_SIZE 4096
+#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,121 @@
-#include <stdio.h>
+#include <stdio.h>      // printf, fprintf
-#include <stdlib.h>
+#include <stdlib.h>     // malloc, free, strtoll
-#include <string.h>
+#include <string.h>     // strlen, strerror
-#include <unistd.h>
+#include <unistd.h>     // read, write, close, unlink, getpid
-#include <fcntl.h>
+#include <fcntl.h>      // open, флаги O_RDONLY/O_WRONLY
-#include <sys/types.h>
+#include <sys/types.h>  // типы для системных вызовов
-#include <sys/stat.h>
+#include <sys/stat.h>   // mkfifo, права доступа
-#include <errno.h>
+#include <errno.h>      // errno
-#include <signal.h>
+#include <signal.h>     // signal, SIGINT, SIGTERM
 
-#define FIFO_REQUEST "/tmp/fifo_request"
+#define FIFO_REQUEST "/tmp/fifo_request"   // путь к FIFO для запроса клиент→сервер
-#define FIFO_RESPONSE "/tmp/fifo_response"
+#define FIFO_RESPONSE "/tmp/fifo_response" // путь к FIFO для ответа сервер→клиент
-#define BUFFER_SIZE 4096
+#define BUFFER_SIZE 4096                   // размер буфера для обмена данными
 
+// Флаг для аккуратного завершения по сигналу
 volatile sig_atomic_t running = 1;
 
+// Обработчик сигналов завершения (Ctrl+C, SIGTERM)
 void signal_handler(int sig) {
-    (void)sig;
+    (void) sig; // чтобы не ругался компилятор на неиспользуемый arg
-    running = 0;
+    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;
+    long long total_replacements = 0; // сколько замен уже сделано
-    int at_line_start = 1;
+    int at_line_start = 1; // находимся ли в начале строки
-    unsigned char line_key = 0;
+    unsigned char line_key = 0; // символ-ключ для текущей строки
-    size_t out_pos = 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);
+    // Не умирать от SIGPIPE, когда клиент закрыл FIFO
+    signal(SIGPIPE, SIG_IGN);
 
-    // Удаляем старые 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 +124,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 +147,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, 
+                                              output_buffer, BUFFER_SIZE,
-                                             max_replacements);
+                                              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 +178,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);

lab_5/server.c

@@ -1,38 +1,47 @@
-#define _GNU_SOURCE
+#define _GNU_SOURCE    // для определения расширенных возможностей glibc
 #include <errno.h>
-#include <mqueue.h>
+#include <mqueue.h>    // POSIX очереди сообщений: mq_open, mq_send, mq_receive, mq_timedreceive
-#include <signal.h>
+#include <signal.h>    // sig_atomic_t, signal, SIGINT
-#include <stdbool.h>
+#include <stdbool.h>   // bool, true/false
 #include <stdint.h>
-#include <stdio.h>
+#include <stdio.h>     // printf, fprintf, perror
-#include <stdlib.h>
+#include <stdlib.h>    // atoi, malloc/free при желании
-#include <string.h>
+#include <string.h>    // memset, strncpy, strncmp
-#include <sys/stat.h>
+#include <sys/stat.h>  // константы прав доступа к объектам ФС
-#include <time.h>
+#include <time.h>      // clock_gettime, nanosleep, struct timespec
 
-#include "common.h"
+#include "common.h"    // описания REQ_QUEUE, NAME_MAXLEN, req_msg_t, rep_msg_t и т.п.
 
 #ifndef MAX_CLIENTS
-#define MAX_CLIENTS 128
+#define MAX_CLIENTS 128          // максимальное число клиентов, чьи очереди мы запомним
 #endif
 
+// Глобальный флаг остановки сервера по сигналу
 static volatile sig_atomic_t stop_flag = 0;
+// Обработчик SIGINT: просто выставляет флаг
 static void on_sigint(int) { stop_flag = 1; }
 
+// Удобная функция "уснуть" на ms миллисекунд
 static void msleep(int ms) {
-    struct timespec ts = {.tv_sec = ms / 1000, .tv_nsec = (ms % 1000) * 1000000L};
+    struct timespec ts = {
+        .tv_sec = ms / 1000,
+        .tv_nsec = (ms % 1000) * 1000000L
+    };
     nanosleep(&ts, NULL);
 }
 
-/* Simple client registry (stores unique reply queue names) */
+/* Простейший реестр клиентов: массив имён их ответных очередей */
 static char clients[MAX_CLIENTS][NAME_MAXLEN];
 static int client_count = 0;
 
+// Добавляет имя очереди клиента в список, если его там ещё нет
 static void add_client(const char *name) {
     if (!name || name[0] == '\0') return;
+    // Проверка на дубликат
     for (int i = 0; i < client_count; ++i) {
         if (strncmp(clients[i], name, NAME_MAXLEN) == 0) return;
     }
+    // Если есть место — копируем имя в массив
     if (client_count < MAX_CLIENTS) {
         strncpy(clients[client_count], name, NAME_MAXLEN - 1);
         clients[client_count][NAME_MAXLEN - 1] = '\0';
@@ -40,44 +49,55 @@ static void add_client(const char *name) {
     }
 }
 
-/* Send a STOP reply (granted=0) to all recorded clients */
+/* Рассылает всем запомненным клиентам сообщение STOP (granted=0, remain=0) */
 static void send_stop_to_clients(void) {
     rep_msg_t stoprep;
     memset(&stoprep, 0, sizeof(stoprep));
     stoprep.granted = 0;
     stoprep.remain = 0;
+
     for (int i = 0; i < client_count; ++i) {
+        // Открываем очередь ответа клиента только на запись
         mqd_t q = mq_open(clients[i], O_WRONLY);
-        if (q == (mqd_t) -1) {
+        if (q == -1) {
-            // best-effort: skip if cannot open
+            // Лучшая попытка: если открыть не удалось — просто пропускаем
             continue;
         }
+        // Отправляем структуру-ответ без приоритета (0)
         mq_send(q, (const char *) &stoprep, sizeof(stoprep), 0);
         mq_close(q);
     }
 }
 
 int main(int argc, char **argv) {
+    // Ожидается: total_honey, portion, period_ms, starvation_ms
     if (argc != 5) {
         fprintf(stderr, "Usage: %s <total_honey> <portion> <period_ms> <starvation_ms>\n", argv[0]);
         return 2;
     }
-    int remain = atoi(argv[1]);
+
-    int portion = atoi(argv[2]);
+    // Разбираем параметры симуляции
-    int period_ms = atoi(argv[3]);
+    int remain = atoi(argv[1]); // сколько "мёда" всего
-    int starvation_ms = atoi(argv[4]);
+    int portion = atoi(argv[2]); // сколько Винни ест за один подход
+    int period_ms = atoi(argv[3]); // период "еды" в миллисекундах
+    int starvation_ms = atoi(argv[4]); // через сколько мс без еды считаем, что Винни умер с голоду
+
     if (remain < 0 || portion <= 0 || period_ms <= 0 || starvation_ms < 0) {
         fprintf(stderr, "Bad args\n");
         return 2;
     }
 
+    // На всякий случай удаляем старую очередь запросов, если осталась
     mq_unlink(REQ_QUEUE);
+
+    // Настроиваем атрибуты очереди запросов
     struct mq_attr attr;
     memset(&attr, 0, sizeof(attr));
-    attr.mq_maxmsg = 10; // ваш системный максимум = 10
+    attr.mq_maxmsg = 10; // максимум 10 сообщений в очереди
-    attr.mq_msgsize = sizeof(req_msg_t);
+    attr.mq_msgsize = sizeof(req_msg_t); // размер одного сообщения = размер структуры запроса
 
-    // Открываем общую очередь на O_RDWR: читаем заявки и посылаем STOP
+    // Открываем общую очередь запросов: создаём и даём читать/писать
+    // (читаем заявки и также сможем через неё послать STOP при желании)
     mqd_t qreq = mq_open(REQ_QUEUE, O_CREAT | O_RDWR, 0666, &attr);
     if (qreq == (mqd_t) -1) {
         perror("mq_open qreq");
@@ -85,30 +105,40 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    // Для отладки выводим реальные атрибуты очереди
     struct mq_attr got;
     if (mq_getattr(qreq, &got) == 0) {
         fprintf(stderr, "Server: q=%s maxmsg=%ld msgsize=%ld cur=%ld\n",
                 REQ_QUEUE, got.mq_maxmsg, got.mq_msgsize, got.mq_curmsgs);
     }
 
+    // Обработчик Ctrl+C: аккуратное завершение
     signal(SIGINT, on_sigint);
+
     fprintf(stderr, "Server: started remain=%d portion=%d period=%dms starve=%dms\n",
             remain, portion, period_ms, starvation_ms);
 
+    // Инициализируем "текущее время" и моменты следующего приёма пищи / последней еды
     struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
-    long long next_eat_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec + (long long) period_ms * 1000000LL;
+    long long now_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec;
-    long long last_feed_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec;
+    long long next_eat_ns = now_ns + (long long) period_ms * 1000000LL; // когда Винни в следующий раз ест
+    long long last_feed_ns = now_ns; // когда он ел в последний раз
 
-    req_msg_t req;
+    req_msg_t req; // буфер для входящего запроса
-    bool need_stop_broadcast = false;
+    bool need_stop_broadcast = false; // флаг: нужно ли разослать клиентам STOP
 
+    // Главный цикл сервера: обрабатываем запросы и "еду" до сигнала или окончания мёда
     while (!stop_flag) {
+        // Обновляем текущее время
         clock_gettime(CLOCK_MONOTONIC, &now);
-        long long now_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec;
+        now_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec;
+
+        // Сколько мс до следующего приёма пищи
         int sleep_ms = (int) ((next_eat_ns - now_ns) / 1000000LL);
         if (sleep_ms < 0) sleep_ms = 0;
 
+        // Дедлайн для mq_timedreceive: ждём сообщение не дольше sleep_ms
         struct timespec deadline = {
             .tv_sec = now.tv_sec + sleep_ms / 1000,
             .tv_nsec = now.tv_nsec + (sleep_ms % 1000) * 1000000L
@@ -118,10 +148,12 @@ int main(int argc, char **argv) {
             deadline.tv_nsec -= 1000000000L;
         }
 
+        // Пытаемся принять запрос до наступления дедлайна
         ssize_t rd = mq_timedreceive(qreq, (char *) &req, sizeof(req), NULL, &deadline);
         if (rd >= 0) {
+            // Успешно прочитали структуру запроса
             if (req.want != 0) {
-                /* record client's reply queue so we can notify it on shutdown */
+                // Регистрируем очередь ответа клиента, чтобы уметь послать ему STOP
                 add_client(req.replyq);
 
                 rep_msg_t rep;
@@ -129,12 +161,15 @@ int main(int argc, char **argv) {
                     int grant = req.want;
                     if (grant > remain) grant = remain;
                     remain -= grant;
-                    rep.granted = grant;
+                    rep.granted = grant; // сколько реально дали
-                    rep.remain = remain;
+                    rep.remain = remain; // сколько осталось
                 } else {
+                    // Мёд закончился — ничего не даём
                     rep.granted = 0;
                     rep.remain = 0;
                 }
+
+                // Открываем очередь ответа клиента и отправляем ему ответ
                 mqd_t qrep = mq_open(req.replyq, O_WRONLY);
                 if (qrep != (mqd_t) -1) {
                     mq_send(qrep, (const char *) &rep, sizeof(rep), 0);
@@ -142,42 +177,54 @@ int main(int argc, char **argv) {
                 }
             }
         } else if (errno != ETIMEDOUT && errno != EAGAIN) {
+            // Любая ошибка, кроме "таймаут" или "временно нет сообщений", логируется
             perror("mq_timedreceive");
         }
 
+        // После приёма (или таймаута) обновляем текущее время и проверяем, пора ли Винни есть
         clock_gettime(CLOCK_MONOTONIC, &now);
         now_ns = (long long) now.tv_sec * 1000000000LL + now.tv_nsec;
+
         if (now_ns >= next_eat_ns) {
             if (remain > 0) {
+                // Винни ест свою порцию (или остаток, если мёда меньше порции)
                 int eat = portion;
                 if (eat > remain) eat = remain;
                 remain -= eat;
                 last_feed_ns = now_ns;
                 fprintf(stderr, "Winnie eats %d, remain=%d\n", eat, remain);
             } else {
-                if (starvation_ms > 0 && (now_ns - last_feed_ns) / 1000000LL >= starvation_ms) {
+                // Мёда нет: проверяем, не умер ли Винни с голоду (starvation_ms)
+                if (starvation_ms > 0 &&
+                    (now_ns - last_feed_ns) / 1000000LL >= starvation_ms) {
                     fprintf(stderr, "Winnie starved, stopping\n");
                     need_stop_broadcast = true;
                     break;
                 }
             }
+            // Планируем следующий приём пищи через period_ms
             next_eat_ns = now_ns + (long long) period_ms * 1000000LL;
         }
 
+        // Если мёд закончился, надо будет всем сообщить STOP и завершаться
         if (remain <= 0) {
             need_stop_broadcast = true;
             break;
         }
     }
 
+    // При нормальном окончании (мёд закончился или Винни умер с голоду)
+    // посылаем всем клиентам STOP
     if (need_stop_broadcast) {
         fprintf(stderr, "Server: broadcasting STOP to clients\n");
         send_stop_to_clients();
-        msleep(100);
+        msleep(100); // даём клиентам время получить сообщение
     }
 
+    // Закрываем и удаляем очередь запросов
     mq_close(qreq);
     mq_unlink(REQ_QUEUE);
+
     fprintf(stderr, "Server: finished\n");
     return 0;
 }

lab_5/worker.c

@@ -1,25 +1,28 @@
-// worker.c
+#define _GNU_SOURCE    // для определения расширенных возможностей glibc
-#define _GNU_SOURCE
 #include <errno.h>
-#include <mqueue.h>
+#include <mqueue.h>    // POSIX очереди сообщений: mq_open, mq_send, mq_receive
 #include <signal.h>
-#include <stdbool.h>
 #include <stdint.h>
-#include <stdio.h>
+#include <stdio.h>     // fprintf, perror, dprintf
-#include <stdlib.h>
+#include <stdlib.h>    // atoi, rand_r
-#include <string.h>
+#include <string.h>    // memset, strncpy, snprintf
-#include <sys/stat.h>
+#include <sys/stat.h>  // права для mq_open (0666)
-#include <time.h>
+#include <time.h>      // time(), nanosleep, struct timespec
-#include <unistd.h>
+#include <unistd.h>    // getpid, STDOUT_FILENO
 
-#include "common.h"
+#include "common.h"    // REQ_QUEUE, NAME_MAXLEN, req_msg_t, rep_msg_t
 
+// Пауза на заданное количество миллисекунд
 static void msleep(int ms) {
-    struct timespec ts = {.tv_sec = ms / 1000, .tv_nsec = (ms % 1000) * 1000000L};
+    struct timespec ts = {
+        .tv_sec = ms / 1000,
+        .tv_nsec = (ms % 1000) * 1000000L
+    };
     nanosleep(&ts, NULL);
 }
 
 int main(int argc, char **argv) {
+    // Ожидается один аргумент: сколько мёда пчела просит за раз
     if (argc != 2) {
         fprintf(stderr, "Usage: %s <bee_portion>\n", argv[0]);
         return 2;
@@ -30,67 +33,89 @@ int main(int argc, char **argv) {
         return 2;
     }
 
+    // PID пчелы и имя её личной очереди ответов
     pid_t me = getpid();
     char replyq[NAME_MAXLEN];
     snprintf(replyq, sizeof(replyq), "/bee_%d", (int) me);
 
+    // На всякий случай удаляем старую очередь с таким именем
     mq_unlink(replyq);
+
+    // Атрибуты очереди ответов (куда сервер будет слать rep_msg_t)
     struct mq_attr attr;
     memset(&attr, 0, sizeof(attr));
     attr.mq_maxmsg = 10;
     attr.mq_msgsize = sizeof(rep_msg_t);
+
+    // Создаём очередь ответов пчелы, только для чтения
     mqd_t qrep = mq_open(replyq, O_CREAT | O_RDONLY, 0666, &attr);
     if (qrep == (mqd_t) -1) {
         perror("mq_open reply");
         return 1;
     }
 
-    mqd_t qreq = (mqd_t) -1;
+    // Открываем очередь запросов к серверу (общая очередь REQ_QUEUE)
+    mqd_t qreq = -1;
     for (int i = 0; i < 50; i++) {
         qreq = mq_open(REQ_QUEUE, O_WRONLY);
-        if (qreq != (mqd_t) -1) break;
+        if (qreq != -1) break; // удалось открыть — выходим из цикла
         if (errno != ENOENT) {
+            // другая ошибка, не "очередь ещё не создана"
             perror("mq_open req");
             break;
         }
+        // Если сервер ещё не создал очередь (ENOENT) — подождать и попробовать снова
         msleep(100);
     }
-    if (qreq == (mqd_t) -1) {
+    if (qreq == -1) {
+        // Не смогли открыть очередь запросов — выходим
         perror("mq_open req");
         mq_close(qrep);
         mq_unlink(replyq);
         return 1;
     }
 
+    // Инициализация отдельного генератора случайных чисел для этой пчелы
     unsigned seed = (unsigned) (time(NULL) ^ (uintptr_t) me);
 
+    // Основной рабочий цикл пчелы
     while (1) {
+        // Ждём случайное время 100–699 мс перед очередным запросом
         int ms = 100 + (rand_r(&seed) % 600);
         msleep(ms);
 
+        // Формируем запрос к серверу
         req_msg_t req;
         memset(&req, 0, sizeof(req));
         req.pid = me;
-        req.want = portion;
+        req.want = portion; // сколько мёда хотим получить
-        strncpy(req.replyq, replyq, sizeof(req.replyq) - 1);
+        strncpy(req.replyq, replyq, sizeof(req.replyq) - 1); // куда слать ответ
 
+        // Отправляем запрос в очередь REQ_QUEUE
         if (mq_send(qreq, (const char *) &req, sizeof(req), 0) == -1) {
             perror("mq_send");
             break;
         }
 
+        // Ждём ответ от сервера в своей очереди
         rep_msg_t rep;
         ssize_t rd = mq_receive(qrep, (char *) &rep, sizeof(rep), NULL);
         if (rd == -1) {
             perror("mq_receive");
             break;
         }
+
+        // Если нам больше ничего не дают (granted <= 0) — выходим
         if (rep.granted <= 0) {
             break;
         }
-        dprintf(STDOUT_FILENO, "Bee %d got %d, remain %d\n", (int) me, rep.granted, rep.remain);
+
+        // Иначе логируем, сколько мёда получили и сколько осталось у сервера
+        dprintf(STDOUT_FILENO, "Bee %d got %d, remain %d\n",
+                (int) me, rep.granted, rep.remain);
     }
 
+    // Очистка ресурсов: закрываем очереди и удаляем личную очередь ответов
     mq_close(qreq);
     mq_close(qrep);
     mq_unlink(replyq);