5-kirill

kirill/lab_5/Makefile

@@ -0,0 +1,61 @@
+CC          = gcc
+CFLAGS      = -Wall -Wextra -std=c99 -g
+LDFLAGS_MQ  = -lrt      # POSIX message queues on Linux
+
+TEST_INPUT  = test_input.txt
+TEST_OUTPUT = test_output.txt
+
+all: msg
+
+# ===== POSIX MQ targets =====
+msg: mq_server mq_client
+
+mq_server: server.c
+	$(CC) $(CFLAGS) -o $@ $< $(LDFLAGS_MQ)
+
+mq_client: client.c
+	$(CC) $(CFLAGS) -o $@ $< $(LDFLAGS_MQ)
+
+# ===== Ручные тесты =====
+
+test_server: msg
+	@echo "=== Запуск MQ сервера ==="
+	@echo "В другом терминале выполните: make test_client_manual"
+	./mq_server
+
+test_client_manual: msg
+	@echo "=== Запуск MQ клиента (ручной тест) ==="
+	./mq_client $(TEST_INPUT) $(TEST_OUTPUT)
+
+# ===== Автотест: сервер в фоне + клиент =====
+
+test_all: msg
+	@echo "=== Автотест MQ (server + client) ==="
+	@echo "Создание тестового входного файла..."
+	echo "aabbccddeeff" > $(TEST_INPUT)
+	@echo "Старт сервера в фоне..."
+	./mq_server & \
+	SRV=$$!; \
+	sleep 1; \
+	echo "Запуск клиента..."; \
+	./mq_client $(TEST_INPUT) $(TEST_OUTPUT); \
+	echo "Остановка сервера..."; \
+	kill $$SRV || true; \
+	wait $$SRV 2>/dev/null || true; \
+	echo "=== Содержимое $(TEST_OUTPUT) ==="; \
+	cat $(TEST_OUTPUT)
+
+clean:
+	@echo "Очистка..."
+	rm -f mq_server mq_client *.o $(TEST_INPUT) $(TEST_OUTPUT)
+
+help:
+	@echo "Available targets:"
+	@echo "  msg               - Build POSIX MQ programs"
+	@echo "  test_server       - Run MQ server (headline only)"
+	@echo "  test_client_manual- Run client (server must be running)"
+	@echo "  test_all          - Automatic end-to-end test (server+client)"
+	@echo "  clean             - Remove built and test files"
+	@echo "  help              - Show this help"
+
+.PHONY: all msg test_server test_client_manual test_all clean help

kirill/lab_5/client.c

@@ -0,0 +1,160 @@
+// mq_client.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>
+
+#define MQ_REQUEST  "/mq_request"
+#define MQ_RESPONSE "/mq_response"
+#define MQ_MAXMSG   10
+#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("=== MQ Client ===\n");
+    printf("Input file : %s\n", input_file);
+    printf("Output file: %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);
+
+    struct mq_attr attr;
+    memset(&attr, 0, sizeof(attr));
+    attr.mq_flags = 0;
+    attr.mq_maxmsg = MQ_MAXMSG;
+    attr.mq_msgsize = BUFFER_SIZE;
+    attr.mq_curmsgs = 0;
+
+    mqd_t mq_req = mq_open(MQ_REQUEST, O_WRONLY);
+    if (mq_req == (mqd_t) -1) {
+        fprintf(stderr,
+                "ERROR: Не удалось открыть очередь запросов %s: %s\n",
+                MQ_REQUEST, strerror(errno));
+        fprintf(stderr, "Убедитесь, что сервер запущен!\n");
+        free(buffer);
+        return 1;
+    }
+
+    mqd_t mq_resp = mq_open(MQ_RESPONSE, O_RDONLY);
+    if (mq_resp == (mqd_t) -1) {
+        fprintf(stderr,
+                "ERROR: Не удалось открыть очередь ответов %s: %s\n",
+                MQ_RESPONSE, strerror(errno));
+        mq_close(mq_req);
+        free(buffer);
+        return 1;
+    }
+
+    if (mq_send(mq_req, buffer, (size_t) bytes_read, 0) == -1) {
+        fprintf(stderr, "ERROR: mq_send failed: %s\n", strerror(errno));
+        mq_close(mq_req);
+        mq_close(mq_resp);
+        free(buffer);
+        return 1;
+    }
+
+    printf("Отправлено байт: %zd\n", bytes_read);
+
+    // размер буфера >= mq_msgsize
+    ssize_t resp_bytes = mq_receive(mq_resp, buffer, BUFFER_SIZE, NULL);
+    if (resp_bytes < 0) {
+        fprintf(stderr, "ERROR: mq_receive failed: %s\n", strerror(errno));
+        mq_close(mq_req);
+        mq_close(mq_resp);
+        free(buffer);
+        return 1;
+    }
+
+    if (resp_bytes >= BUFFER_SIZE)
+        resp_bytes = BUFFER_SIZE - 1;
+    buffer[resp_bytes] = '\0';
+
+    printf("Получено байт от сервера: %zd\n", resp_bytes);
+
+    char *repl_info = strstr(buffer, "\nREPLACEMENTS:");
+    long long replacements = 0;
+
+    if (repl_info) {
+        sscanf(repl_info, "\nREPLACEMENTS:%lld", &replacements);
+        *repl_info = '\0';
+        resp_bytes = repl_info - buffer;
+    } else {
+        fprintf(stderr,
+                "WARNING: Не найдена служебная строка REPLACEMENTS, "
+                "запишем весь ответ как есть\n");
+    }
+
+    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));
+        mq_close(mq_req);
+        mq_close(mq_resp);
+        free(buffer);
+        return 1;
+    }
+
+    ssize_t written = write(out_fd, buffer, resp_bytes);
+    close(out_fd);
+    if (written != resp_bytes) {
+        fprintf(stderr, "ERROR: Ошибка записи в выходной файл\n");
+        mq_close(mq_req);
+        mq_close(mq_resp);
+        free(buffer);
+        return 1;
+    }
+
+    printf("Записано байт в выходной файл: %zd\n", written);
+    printf("Количество выполненных замен: %lld\n", replacements);
+    printf("\nОбработка завершена успешно!\n");
+
+    mq_close(mq_req);
+    mq_close(mq_resp);
+    free(buffer);
+    return 0;
+}

kirill/lab_5/server.c

@@ -0,0 +1,157 @@
+// 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 <signal.h>
+
+#include <mqueue.h>  // POSIX message queues
+
+#define MQ_REQUEST  "/mq_request"
+#define MQ_RESPONSE "/mq_response"
+#define MQ_MAXMSG   10
+#define BUFFER_SIZE 4096   // msgsize очереди и размер буферов
+
+volatile sig_atomic_t running = 1;
+
+void signal_handler(int sig) {
+    (void) sig;
+    running = 0;
+}
+
+// Заменить каждый третий символ на пробел
+// (позиции 3, 6, 9, ... в исходном тексте)
+long long process_text(const char *input, size_t len,
+                       char *output, size_t out_size) {
+    if (out_size == 0) return -1;
+
+    long long replacements = 0;
+    size_t out_pos = 0;
+
+    for (size_t i = 0; i < len && out_pos < out_size - 1; i++) {
+        char c = input[i];
+
+        // считаем позиции с 1
+        size_t pos = i + 1;
+        if (pos % 3 == 0) {
+            output[out_pos++] = ' ';
+            replacements++;
+        } else {
+            output[out_pos++] = c;
+        }
+    }
+
+    output[out_pos] = '\0';
+    return replacements;
+}
+
+int main(void) {
+    struct mq_attr attr;
+    mqd_t mq_req = (mqd_t) -1;
+    mqd_t mq_resp = (mqd_t) -1;
+
+    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;
+    }
+
+    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;
+    }
+
+    printf("=== MQ Server started ===\n");
+    printf("Request queue : %s\n", MQ_REQUEST);
+    printf("Response queue: %s\n", MQ_RESPONSE);
+
+    signal(SIGINT, signal_handler);
+    signal(SIGTERM, signal_handler);
+
+    char in_buf[BUFFER_SIZE];
+    char out_buf[BUFFER_SIZE];
+
+    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);
+    }
+
+    printf("Server shutting down...\n");
+    mq_close(mq_req);
+    mq_close(mq_resp);
+    mq_unlink(MQ_REQUEST);
+    mq_unlink(MQ_RESPONSE);
+    return 0;
+}