pajjilykk/CS-LABS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

5-vlad

Browse Source
This commit is contained in:
pajjilykk
2025-12-11 08:08:53 +07:00
parent f3a5c1f658
commit ff6e412049
5 changed files with 327 additions and 378 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
vlad/lab_5/server.c
View File

@@ -1,230 +1,157 @@
#define _GNU_SOURCE // для определения расширенных возможностей glibc
// mq_server.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 <mqueue.h> // POSIX очереди сообщений: mq_open, mq_send, mq_receive, mq_timedreceive
#include <signal.h> // sig_atomic_t, signal, SIGINT
#include <stdbool.h> // bool, true/false
#include <stdint.h>
#include <stdio.h> // printf, fprintf, perror
#include <stdlib.h> // atoi, malloc/free при желании
#include <string.h> // memset, strncpy, strncmp
#include <sys/stat.h> // константы прав доступа к объектам ФС
#include <time.h> // clock_gettime, nanosleep, struct timespec
#include <signal.h>
#include "common.h" // описания REQ_QUEUE, NAME_MAXLEN, req_msg_t, rep_msg_t и т.п.
#include <mqueue.h> // POSIX message queues
#ifndef MAX_CLIENTS
#define MAX_CLIENTS 128 // максимальное число клиентов, чьи очереди мы запомним
#endif
#define MQ_REQUEST "/mq_request"
#define MQ_RESPONSE "/mq_response"
#define MQ_MAXMSG 10
#define BUFFER_SIZE 4096 // msgsize очереди и размер буферов
// Глобальный флаг остановки сервера по сигналу
static volatile sig_atomic_t stop_flag = 0;
// Обработчик SIGINT: просто выставляет флаг
static void on_sigint(int) { stop_flag = 1; }
volatile sig_atomic_t running = 1;
// Удобная функция "уснуть" на ms миллисекунд
static void msleep(int ms) {
struct timespec ts = {
.tv_sec = ms / 1000,
.tv_nsec = (ms % 1000) * 1000000L
};
nanosleep(&ts, NULL);
void signal_handler(int sig) {
(void)sig;
running = 0;
}
/* Простейший реестр клиентов: массив имён их ответных очередей */
static char clients[MAX_CLIENTS][NAME_MAXLEN];
static int client_count = 0;
// во всех парах одинаковых подряд символов второй -> пробел
long long process_text(const char *input, size_t len,
char *output, size_t out_size) {
if (out_size == 0) return -1;
// Добавляет имя очереди клиента в список, если его там ещё нет
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';
client_count++;
}
}
long long replacements = 0;
size_t out_pos = 0;
/* Рассылает всем запомненным клиентам сообщение 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 (size_t i = 0; i < len && out_pos < out_size - 1; i++) {
char c = input[i];
output[out_pos++] = c;
for (int i = 0; i < client_count; ++i) {
// Открываем очередь ответа клиента только на запись
mqd_t q = mq_open(clients[i], O_WRONLY);
if (q == -1) {
// Лучшая попытка: если открыть не удалось — просто пропускаем
continue;
if (i + 1 < len && input[i] == input[i + 1]) {
// вторая буква пары
if (out_pos < out_size - 1) {
output[out_pos++] = ' ';
replacements++;
}
i++; // пропускаем второй символ исходного текста
}
// Отправляем структуру-ответ без приоритета (0)
mq_send(q, (const char *) &stoprep, sizeof(stoprep), 0);
mq_close(q);
}
output[out_pos] = '\0';
return replacements;
}
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 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);
// Настроиваем атрибуты очереди запросов
int main(void) {
struct mq_attr attr;
memset(&attr, 0, sizeof(attr));
attr.mq_maxmsg = 10; // максимум 10 сообщений в очереди
attr.mq_msgsize = sizeof(req_msg_t); // размер одного сообщения = размер структуры запроса
mqd_t mq_req = (mqd_t)-1;
mqd_t mq_resp = (mqd_t)-1;
// Открываем общую очередь запросов: создаём и даём читать/писать
// (читаем заявки и также сможем через неё послать STOP при желании)
mqd_t qreq = mq_open(REQ_QUEUE, O_CREAT | O_RDWR, 0666, &attr);
if (qreq == (mqd_t) -1) {
perror("mq_open qreq");
fprintf(stderr, "Hint: ensure msg_max>=10 and msgsize_max>=%zu\n", sizeof(req_msg_t));
memset(&attr, 0, sizeof(attr));
attr.mq_flags = 0;
attr.mq_maxmsg = MQ_MAXMSG;
attr.mq_msgsize = BUFFER_SIZE;
attr.mq_curmsgs = 0;
mq_unlink(MQ_REQUEST);
mq_unlink(MQ_RESPONSE);
mq_req = mq_open(MQ_REQUEST, O_CREAT | O_RDONLY, 0666, &attr);
if (mq_req == (mqd_t)-1) {
fprintf(stderr, "ERROR: mq_open(%s) failed: %s\n",
MQ_REQUEST, strerror(errno));
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);
mq_resp = mq_open(MQ_RESPONSE, O_CREAT | O_WRONLY, 0666, &attr);
if (mq_resp == (mqd_t)-1) {
fprintf(stderr, "ERROR: mq_open(%s) failed: %s\n",
MQ_RESPONSE, strerror(errno));
mq_close(mq_req);
mq_unlink(MQ_REQUEST);
return 1;
}
// Обработчик Ctrl+C: аккуратное завершение
signal(SIGINT, on_sigint);
printf("=== MQ Server started ===\n");
printf("Request queue : %s\n", MQ_REQUEST);
printf("Response queue: %s\n", MQ_RESPONSE);
fprintf(stderr, "Server: started remain=%d portion=%d period=%dms starve=%dms\n",
remain, portion, period_ms, starvation_ms);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
// Инициализируем "текущее время" и моменты следующего приёма пищи / последней еды
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long long now_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; // когда он ел в последний раз
char in_buf[BUFFER_SIZE];
char out_buf[BUFFER_SIZE];
req_msg_t req; // буфер для входящего запроса
bool need_stop_broadcast = false; // флаг: нужно ли разослать клиентам STOP
// Главный цикл сервера: обрабатываем запросы и "еду" до сигнала или окончания мёда
while (!stop_flag) {
// Обновляем текущее время
clock_gettime(CLOCK_MONOTONIC, &now);
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
};
if (deadline.tv_nsec >= 1000000000L) {
deadline.tv_sec++;
deadline.tv_nsec -= 1000000000L;
}
// Пытаемся принять запрос до наступления дедлайна
ssize_t rd = mq_timedreceive(qreq, (char *) &req, sizeof(req), NULL, &deadline);
if (rd >= 0) {
// Успешно прочитали структуру запроса
if (req.want != 0) {
// Регистрируем очередь ответа клиента, чтобы уметь послать ему STOP
add_client(req.replyq);
rep_msg_t rep;
if (remain > 0) {
int grant = req.want;
if (grant > remain) grant = remain;
remain -= grant;
rep.granted = grant; // сколько реально дали
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);
mq_close(qrep);
}
}
} 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 {
// Мёда нет: проверяем, не умер ли Винни с голоду (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;
while (running) {
unsigned int prio = 0;
ssize_t bytes_read = mq_receive(mq_req, in_buf,
sizeof(in_buf), &prio);
if (bytes_read < 0) {
if (errno == EINTR && !running)
break;
if (errno == EINTR)
continue;
fprintf(stderr, "ERROR: mq_receive failed: %s\n",
strerror(errno));
break;
}
if (bytes_read >= (ssize_t)sizeof(in_buf))
bytes_read = sizeof(in_buf) - 1;
in_buf[bytes_read] = '\0';
printf("Received request: %zd bytes\n", bytes_read);
long long repl = process_text(in_buf, (size_t)bytes_read,
out_buf, sizeof(out_buf));
if (repl < 0) {
const char *err_msg = "ERROR: processing failed\n";
mq_send(mq_resp, err_msg, strlen(err_msg), 0);
continue;
}
printf("Replacements done: %lld\n", repl);
char resp_buf[BUFFER_SIZE];
size_t processed_len = strlen(out_buf);
if (processed_len + 64 >= sizeof(resp_buf)) {
const char *err_msg = "ERROR: response too long\n";
mq_send(mq_resp, err_msg, strlen(err_msg), 0);
continue;
}
memcpy(resp_buf, out_buf, processed_len);
int n = snprintf(resp_buf + processed_len,
sizeof(resp_buf) - processed_len,
"\nREPLACEMENTS:%lld\n", repl);
if (n < 0) {
const char *err_msg = "ERROR: snprintf failed\n";
mq_send(mq_resp, err_msg, strlen(err_msg), 0);
continue;
}
size_t resp_len = processed_len + (size_t)n;
if (mq_send(mq_resp, resp_buf, resp_len, 0) == -1) {
fprintf(stderr, "ERROR: mq_send failed: %s\n",
strerror(errno));
continue;
}
printf("Response sent: %zu bytes\n\n", resp_len);
}
// При нормальном окончании (мёд закончился или Винни умер с голоду)
// посылаем всем клиентам STOP
if (need_stop_broadcast) {
fprintf(stderr, "Server: broadcasting STOP to clients\n");
send_stop_to_clients();
msleep(100); // даём клиентам время получить сообщение
}
// Закрываем и удаляем очередь запросов
mq_close(qreq);
mq_unlink(REQ_QUEUE);
fprintf(stderr, "Server: finished\n");
printf("Server shutting down...\n");
mq_close(mq_req);
mq_close(mq_resp);
mq_unlink(MQ_REQUEST);
mq_unlink(MQ_RESPONSE);
return 0;
}