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

8-vlad

Browse Source
This commit is contained in:
pajjilykk
2025-12-10 15:14:24 +07:00
parent 47812b3900
commit baa8b5be9b
3 changed files with 379 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
lab_8/vlad/Makefile Normal file
View File

@@ -0,0 +1,51 @@
CC = gcc
CFLAGS = -Wall -Wextra -std=c11 -g
all: server_tcp_pairs client_tcp_pairs
server_tcp_pairs: server.c
$(CC) $(CFLAGS) -o $@ $<
client_tcp_pairs: client.c
$(CC) $(CFLAGS) -o $@ $<
test_server: server_tcp_pairs
@echo "=== Запуск TCP-сервера (пары одинаковых символов) ==="
@echo "Выходной файл: out.txt"
./server_tcp_pairs 5000 out.txt
test_client: client_tcp_pairs
@echo "=== Запуск TCP-клиента ==="
@echo "Создаём input.txt"
@printf "aabbccddeeff\nabba\nxxxxx\n" > input.txt
./client_tcp_pairs 127.0.0.1 5000 input.txt
test_all: all
@echo "=== Автотест TCP (пары одинаковых символов) ==="
@printf "aabbccddeeff\nabba\nxxxxx\n" > input.txt
./server_tcp_pairs 5000 out.txt & \
SRV=$$!; \
sleep 1; \
./client_tcp_pairs 127.0.0.1 5000 input.txt; \
wait $$SRV; \
echo "--- input.txt ---"; \
cat input.txt; \
echo "--- out.txt ---"; \
cat out.txt
clean:
@echo "Очистка..."
rm -f server_tcp_pairs client_tcp_pairs
rm -f input.txt out.txt
help:
@echo "Targets:"
@echo " all - build server_tcp_pairs and client_tcp_pairs"
@echo " test_server - run server (port 5000, out.txt)"
@echo " test_client - run client to send input.txt"
@echo " test_all - end-to-end TCP test"
@echo " clean - remove binaries and test files"
@echo " help - show this help"
.PHONY: all test_server test_client test_all clean help

139
lab_8/vlad/client.c Normal file
View File

@@ -0,0 +1,139 @@
// client_tcp_pairs.c
// TCP-клиент для лабораторной №8, вариант "во всех парах одинаковых символов
// второй символ заменить на пробел".
// Клиент читает входной файл и передаёт его содержимое серверу по TCP.
#include <stdio.h> // printf, fprintf, perror, FILE, fopen, fclose, fread
#include <stdlib.h> // exit, EXIT_FAILURE, strtol
#include <string.h> // memset, strlen
#include <errno.h> // errno
#include <unistd.h> // close, write
#include <arpa/inet.h> // sockaddr_in, inet_pton, htons
#include <sys/socket.h> // socket, connect
#include <sys/types.h> // типы сокетов
#include <netinet/in.h> // sockaddr_in
#define BUF_SIZE 4096
int main(int argc, char *argv[])
{
// Ожидаемые аргументы:
// argv[1] - IP-адрес сервера (например, 127.0.0.1).
// argv[2] - порт сервера.
// argv[3] - путь к входному файлу.
if (argc < 4) {
fprintf(stderr,
"Usage: %s <server_ip> <server_port> <input_file>\n",
argv[0]);
fprintf(stderr,
"Example: %s 127.0.0.1 5000 input.txt\n",
argv[0]);
return -1;
}
const char *server_ip = argv[1];
const char *server_port = argv[2];
const char *input_path = argv[3];
// Разбор порта.
char *endptr = NULL;
errno = 0;
long port_long = strtol(server_port, &endptr, 10);
if (errno != 0 || endptr == server_port || *endptr != '\0' ||
port_long <= 0 || port_long > 65535) {
fprintf(stderr, "ERROR: invalid port '%s'\n", server_port);
return -1;
}
int port = (int)port_long;
// Открываем входной файл.
FILE *fin = fopen(input_path, "r");
if (!fin) {
perror("fopen(input_file)");
return -1;
}
// Создаём TCP-сокет.
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket");
fclose(fin);
return -1;
}
// Заполняем структуру адреса сервера.
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
// Переводим строковый IP в бинарную форму.
if (inet_pton(AF_INET, server_ip, &servaddr.sin_addr) != 1) {
fprintf(stderr, "ERROR: invalid IP address '%s'\n", server_ip);
close(sockfd);
fclose(fin);
return -1;
}
// Устанавливаем TCP-соединение.
if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("connect");
close(sockfd);
fclose(fin);
return -1;
}
printf("Connected to %s:%d, sending file '%s'\n",
server_ip, port, input_path);
char buf[BUF_SIZE];
for (;;) {
// Читаем блок из файла.
size_t n = fread(buf, 1, sizeof(buf), fin);
if (n > 0) {
// Отправляем блок по TCP.
size_t sent_total = 0;
while (sent_total < n) {
ssize_t sent = write(sockfd,
buf + sent_total,
n - sent_total);
if (sent < 0) {
perror("write");
close(sockfd);
fclose(fin);
return -1;
}
sent_total += (size_t)sent;
}
}
// Если прочитали меньше, чем BUF_SIZE, либо EOF, либо ошибка.
if (n < sizeof(buf)) {
if (ferror(fin)) {
perror("fread");
close(sockfd);
fclose(fin);
return -1;
}
break; // EOF, передачу завершаем.
}
}
// Закрываем файл.
if (fclose(fin) == EOF) {
perror("fclose(input_file)");
}
// Корректно закрываем соединение, чтобы сервер получил EOF.
if (shutdown(sockfd, SHUT_WR) < 0) {
perror("shutdown");
}
close(sockfd);
printf("File '%s' sent to %s:%d, connection closed.\n",
input_path, server_ip, port);
return 0;
}

189
lab_8/vlad/server.c Normal file
View File

@@ -0,0 +1,189 @@
// server_tcp_pairs.c
// Лабораторная №8, протокол TCP (нечётные варианты, но здесь по заданию TCP).
// Задача: во всех парах одинаковых символов второй символ заменить на пробел,
// считать количество замен и сохранить обработанный текст в выходной файл.
#include <stdio.h> // printf, fprintf, perror, FILE, fopen, fclose, fwrite
#include <stdlib.h> // exit, EXIT_FAILURE, strtol
#include <string.h> // memset, strlen
#include <errno.h> // errno
#include <unistd.h> // close, read, write
#include <arpa/inet.h> // sockaddr_in, inet_ntoa, htons, htonl, ntohs, ntohl
#include <sys/socket.h> // socket, bind, listen, accept
#include <sys/types.h> // типы сокетов
#include <netinet/in.h> // структура sockaddr_in
#define BUF_SIZE 4096 // Размер буфера приёма из TCP-сокета.
// Функция обрабатывает блок данных, заменяя во всех парах одинаковых подряд
// идущих символов второй символ пары на пробел. Пары могут пересекать границу
// буферов, поэтому учитывается последний символ предыдущего блока.
static void process_block_pairs(char *buf,
ssize_t len,
int *has_prev,
unsigned char *prev_char,
long long *repl_counter) {
if (!buf || !has_prev || !prev_char || !repl_counter) {
return; // Проверка входных указателей.
}
for (ssize_t i = 0; i < len; i++) {
unsigned char c = (unsigned char) buf[i];
if (*has_prev) {
// Есть предыдущий символ из этого же потока.
if (c == *prev_char) {
// Найдена пара одинаковых подряд символов.
buf[i] = ' '; // Заменяем второй символ пары на пробел.
(*repl_counter)++; // Увеличиваем счётчик замен.
}
*has_prev = 0; // Сбрасываем флаг: пара уже обработана.
} else {
// Текущий символ станет предыдущим для возможной пары в следующем байте.
*prev_char = c;
*has_prev = 1;
}
}
}
int main(int argc, char *argv[]) {
// Ожидаемые аргументы:
// argv[1] - порт TCP сервера (например, 5000).
// argv[2] - имя выходного файла.
if (argc < 3) {
fprintf(stderr,
"Usage: %s <port> <output_file>\n",
argv[0]);
fprintf(stderr,
"Example: %s 5000 out.txt\n",
argv[0]);
return -1;
}
// Разбор номера порта.
char *endptr = NULL;
errno = 0;
long port_long = strtol(argv[1], &endptr, 10);
if (errno != 0 || endptr == argv[1] || *endptr != '\0' ||
port_long <= 0 || port_long > 65535) {
fprintf(stderr, "ERROR: invalid port '%s'\n", argv[1]);
return -1;
}
int port = (int) port_long;
const char *out_path = argv[2];
// Открываем выходной файл для записи (перезаписываем).
FILE *fout = fopen(out_path, "w");
if (!fout) {
perror("fopen(output_file)");
return -1;
}
// Создаём TCP-сокет.
int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0) {
perror("socket");
fclose(fout);
return -1;
}
// Включаем SO_REUSEADDR, чтобы можно было быстро перезапускать сервер.
int optval = 1;
if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,
&optval, sizeof(optval)) < 0) {
perror("setsockopt(SO_REUSEADDR)");
close(listen_fd);
fclose(fout);
return -1;
}
// Заполняем структуру адреса сервера.
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // Принимать на всех интерфейсах.
servaddr.sin_port = htons(port);
// Привязываем сокет к адресу и порту.
if (bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
perror("bind");
close(listen_fd);
fclose(fout);
return -1;
}
// Переводим сокет в режим прослушивания.
if (listen(listen_fd, 1) < 0) {
perror("listen");
close(listen_fd);
fclose(fout);
return -1;
}
printf("TCP server (pairs) listening on port %d, output file: %s\n",
port, out_path);
// Принимаем одно соединение от клиента.
struct sockaddr_in cliaddr;
socklen_t cli_len = sizeof(cliaddr);
int conn_fd = accept(listen_fd, (struct sockaddr *) &cliaddr, &cli_len);
if (conn_fd < 0) {
perror("accept");
close(listen_fd);
fclose(fout);
return -1;
}
printf("Client connected from %s:%d\n",
inet_ntoa(cliaddr.sin_addr),
ntohs(cliaddr.sin_port));
close(listen_fd); // Больше новых клиентов не принимаем.
char buf[BUF_SIZE];
long long repl_counter = 0; // Общее количество замен.
int has_prev = 0; // Был ли предыдущий символ для пары.
unsigned char prev_char = 0; // Предыдущий символ, если has_prev == 1.
for (;;) {
// Считываем данные из TCP-сокета.
ssize_t n = read(conn_fd, buf, sizeof(buf));
if (n > 0) {
// Обрабатываем блок на предмет пар одинаковых символов.
process_block_pairs(buf, n, &has_prev, &prev_char, &repl_counter);
// Пишем обработанный блок в выходной файл.
if (fwrite(buf, 1, (size_t) n, fout) != (size_t) n) {
perror("fwrite");
repl_counter = -1;
break;
}
} else if (n == 0) {
// Клиент корректно закрыл соединение.
printf("Client disconnected.\n");
break;
} else {
// Ошибка при чтении.
perror("read");
repl_counter = -1;
break;
}
}
// Закрываем соединение.
close(conn_fd);
// Закрываем файл.
if (fclose(fout) == EOF) {
perror("fclose(output_file)");
repl_counter = -1;
}
printf("Total replacements (pairs): %lld\n", repl_counter);
if (repl_counter < 0) {
return -1;
}
return 0;
}