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

final 4

Browse Source
This commit is contained in:
pajjilykk
2025-11-27 10:23:49 +07:00
parent 2b488e06eb
commit ca46482150
5 changed files with 101 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
lab_3/kirill/Makefile
View File

@@ -1,55 +0,0 @@
# Компилятор и флаги
CC = gcc
CFLAGS = -Wall -Wextra -std=c99 -pedantic
# Целевые файлы
TARGET_PARENT = parent
TARGET_LAB1 = task18
# Исходные файлы
SRC_PARENT = parent.c
SRC_LAB1 = task18.c
# Объектные файлы
OBJ_PARENT = $(SRC_PARENT:.c=.o)
OBJ_LAB1 = $(SRC_LAB1:.c=.o)
.PHONY: all clean help test
all: $(TARGET_PARENT) $(TARGET_LAB1)
$(TARGET_PARENT): $(OBJ_PARENT)
$(CC) $(CFLAGS) -o $@ $^
@echo "Родительская программа собрана: $@"
$(TARGET_LAB1): $(OBJ_LAB1)
$(CC) $(CFLAGS) -o $@ $^
@echo "Программа лаб. работы №1 собрана: $@"
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(TARGET_PARENT) $(TARGET_LAB1) $(OBJ_PARENT) $(OBJ_LAB1) *.txt
@echo "Очистка завершена"
help:
@echo "Доступные цели:"
@echo " all - собрать все"
@echo " clean - удалить все скомпилированные файлы"
@echo " test - запустить тестирование программы"
test: all
@echo "Создаем тестовые файлы..."
@echo "22222222222222222222" > input1.txt
@echo "2222222222222222222" >> input1.txt
@echo "22222222222222222222" >> input1.txt
@echo "Test line one in second file" > input2.txt
@echo "Second line in second file" >> input2.txt
@echo "Third line in second file" >> input2.txt
@echo "Запуск parent..."
@./$(TARGET_PARENT) 5 input1.txt output1.txt input2.txt output2.txt
@echo "Содержимое output1.txt:"
@cat output1.txt || echo "Файл output1.txt не найден"
@echo "Содержимое output2.txt:"
@cat output2.txt || echo "Файл output2.txt не найден"

117
lab_3/kirill/parent.c
View File

@@ -1,117 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>
int main(int argc, char *argv[]) {
// Проверка аргументов командной строки
if (argc < 4) {
const char *usage =
"Usage: parent <max_replacements> <input1.txt> <output1.txt> "
"[<input2.txt> <output2.txt> ...]\n"
" max_replacements: максимальное количество замен\n"
" input/output: пары входных и выходных файлов\n";
fprintf(stderr, "%s", usage);
return -1;
}
// Проверка четности количества файлов (пары input/output)
if ((argc - 2) % 2 != 0) {
fprintf(stderr, "Error: количество файлов должно быть четным (пары input/output)\n");
return -1;
}
const char *max_replacements_arg = argv[1];
int num_files = (argc - 2) / 2; // количество пар файлов
printf("Родительский процесс: PID=%d\n", getpid());
printf("Будет запущено %d дочерних процессов\n", num_files);
printf("Максимальное количество замен: %s\n\n", max_replacements_arg);
// Массив для хранения PID дочерних процессов
pid_t *child_pids = malloc(num_files * sizeof(pid_t));
if (child_pids == NULL) {
perror("malloc failed");
return -1;
}
// Запуск дочерних процессов
for (int i = 0; i < num_files; i++) {
const char *input_file = argv[2 + i * 2];
const char *output_file = argv[2 + i * 2 + 1];
pid_t pid = fork();
if (pid < 0) {
// Ошибка при создании процесса
perror("fork failed");
// Ждем завершения уже запущенных процессов
for (int j = 0; j < i; j++) {
int status;
waitpid(child_pids[j], &status, 0);
}
free(child_pids);
return -1;
} else if (pid == 0) {
// Код дочернего процесса
printf("Дочерний процесс %d: PID=%d, обработка %s -> %s\n",
i + 1, getpid(), input_file, output_file);
// Запуск программы из лабораторной работы №1
execl("./task18", "task18", input_file, output_file, max_replacements_arg, (char *)NULL);
// Если execl вернул управление, произошла ошибка
fprintf(stderr, "Дочерний процесс %d: execl failed для %s: %s\n",
i + 1, input_file, strerror(errno));
_exit(-1);
} else {
// Код родительского процесса
child_pids[i] = pid;
}
}
// Ожидание завершения всех дочерних процессов
printf("\nРодительский процесс ожидает завершения дочерних процессов...\n\n");
for (int i = 0; i < num_files; i++) {
int status;
pid_t terminated_pid = waitpid(child_pids[i], &status, 0);
if (terminated_pid < 0) {
perror("waitpid failed");
continue;
}
// Проверка статуса завершения
if (WIFEXITED(status)) {
int exit_code = WEXITSTATUS(status);
printf("Процесс %d (PID=%d) завершился нормально\n",
i + 1, terminated_pid);
if (exit_code == 0) {
printf(" Код завершения: %d (успех)\n", exit_code);
} else {
printf(" Код завершения: %d (ошибка)\n", exit_code);
}
} else if (WIFSIGNALED(status)) {
int signal = WTERMSIG(status);
printf("Процесс %d (PID=%d) был прерван сигналом %d\n",
i + 1, terminated_pid, signal);
} else {
printf("Процесс %d (PID=%d) завершился с неизвестным статусом\n",
i + 1, terminated_pid);
}
}
printf("\nВсе дочерние процессы завершены\n");
free(child_pids);
return 0;
}

129
lab_3/kirill/task18.c
View File

@@ -1,129 +0,0 @@
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define RBUFSZ 4096
#define WBUFSZ 4096
static void die_perror(const char *what, const char *path, int exit_code) {
int saved = errno;
char msg[512];
int n;
if (path) {
n = snprintf(msg, sizeof(msg), "%s: %s: %s\n", what, path, strerror(saved));
} else {
n = snprintf(msg, sizeof(msg), "%s: %s\n", what, strerror(saved));
}
if (n > 0) (void) write(STDERR_FILENO, msg, (size_t) n);
_exit(exit_code);
}
static void xwrite_all(int fd, const char *buf, size_t len, const char *path) {
size_t off = 0;
while (off < len) {
ssize_t n = write(fd, buf + off, len - off);
if (n < 0) {
if (errno == EINTR) continue;
die_perror("write failed", path, -1);
}
off += (size_t) n;
}
}
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) {
errno = EINVAL;
return -1;
}
return v;
}
int main(int argc, char *argv[]) {
if (argc != 4) {
const char *usage =
"Usage: lab1_var_thirds_line <input.txt> <output.txt> <max_replacements>\n"
"Replace every third non-newline byte in each line with a space; counter resets after LF.\n";
(void) write(STDERR_FILENO, usage, strlen(usage));
return -1;
}
const char *in_path = argv[1];
const char *out_path = argv[2];
long long cap = parse_ll(argv[3]);
if (cap < 0) die_perror("invalid max_replacements", argv[3], -1);
int in_fd = open(in_path, O_RDONLY);
if (in_fd < 0) die_perror("open input failed", in_path, -1);
mode_t perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
int out_fd = open(out_path, O_CREAT | O_WRONLY | O_TRUNC, perms);
if (out_fd < 0) die_perror("open output failed", out_path, -1);
char rbuf[RBUFSZ];
char wbuf[WBUFSZ];
size_t wlen = 0;
long long total = 0;
long long col = 0;
int replacing_enabled = 1;
for (;;) {
ssize_t n = read(in_fd, rbuf, sizeof(rbuf));
if (n > 0) {
for (ssize_t i = 0; i < n; i++) {
unsigned char c = (unsigned char) rbuf[i];
if (c == '\n') {
if (wlen == sizeof(wbuf)) {
xwrite_all(out_fd, wbuf, wlen, out_path);
wlen = 0;
}
wbuf[wlen++] = '\n';
col = 0;
continue;
}
unsigned char outc = c;
col++;
if (replacing_enabled && (col % 3 == 0) && total < cap) {
outc = ' ';
total++;
if (total == cap) replacing_enabled = 0;
}
if (wlen == sizeof(wbuf)) {
xwrite_all(out_fd, wbuf, wlen, out_path);
wlen = 0;
}
wbuf[wlen++] = (char) outc;
}
} else if (n == 0) {
if (wlen > 0) {
xwrite_all(out_fd, wbuf, wlen, out_path);
wlen = 0;
}
break;
} else {
if (errno == EINTR) continue;
die_perror("read failed", in_path, -1);
}
}
if (close(in_fd) < 0) die_perror("close input failed", in_path, -1);
if (close(out_fd) < 0) die_perror("close output failed", out_path, -1);
char res[64];
int m = snprintf(res, sizeof(res), "%lld\n", total);
if (m > 0) (void) write(STDOUT_FILENO, res, (size_t) m);
return 0;
}

57
lab_4/fifo_client.c
View File

@@ -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,21 +106,26 @@ 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;
}
// Открываем выходной файл
int out_fd = open(output_file, O_CREAT | O_WRONLY | O_TRUNC,
// Открываем (или создаём) выходной файл с правами 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",
@@ -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;
}

102
lab_4/fifo_server.c
View File

@@ -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;
}
long long process_data(const char *input, size_t input_len, char *output,
// Основная логика обработки текста:
// - 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);
// Обрабатываем данные по заданному правилу
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);