DragonSpirit/NXST
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

arch codereview

Browse Source
This commit is contained in:
Nikolai Fedorov
2026-04-25 09:55:34 +03:00
parent 3e19149cb4
commit 7515e0334b
12 changed files with 579 additions and 487 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/server.cpp
+232 -270
View File
@@ -1,18 +1,16 @@
#include <arpa/inet.h>
#include <atomic>
#include <cstring>
#include <fcntl.h>
#include <iomanip>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <netinet/in.h>
#include <ostream>
#include <pthread.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <vector>
#ifdef __SWITCH__
#include <server.hpp>
@@ -20,312 +18,276 @@
#include <main.hpp>
#endif
#define PORT 8080
#define BUFFER_SIZE 65536
#define MULTICAST_PORT 8081
#define MULTICAST_GROUP "239.0.0.1" // Multicast group IP
#include <protocol.hpp>
#include <TransferState.hpp>
#include <net/Socket.hpp>
namespace fs = std::filesystem;
static TransferState g_server_state;
static std::atomic<int> g_server_client_sock{-1};
static std::atomic<int> g_broadcast_sock{-1};
bool isServerTransferDone() { return g_server_state.done.load(); }
bool isServerTransferCancelled() { return g_server_state.cancelled.load(); }
double getServerProgress() { return g_server_state.progress(); }
std::string getServerStatusText() { return g_server_state.getStatus(); }
void cancelServerTransfer() {
g_server_state.cancelled.store(true);
int sock = g_server_client_sock.load();
if (sock >= 0) shutdown(sock, SHUT_RDWR);
int bsock = g_broadcast_sock.load();
if (bsock >= 0) shutdown(bsock, SHUT_RDWR);
}
#ifdef __SWITCH__
std::string replaceUsername(const std::string &path) {
std::string replacedString = StringUtils::removeNotAscii(
StringUtils::removeAccents(Account::username(g_currentUId)));
// Найдём позицию последнего символа '/'
size_t lastSlashPos = path.rfind('/');
// Если нет '/', возвращаем исходный путь
if (lastSlashPos == std::string::npos) {
return path;
}
// Найдём позицию предыдущего символа '/' (начало последней папки)
size_t prevSlashPos = path.rfind('/', lastSlashPos - 1);
// Если предыдущий '/' не найден, значит путь состоит из одной папки и файла
// Заменим последнюю папку и вернём полный путь
if (prevSlashPos == std::string::npos) {
return replacedString + path.substr(lastSlashPos);
}
// Собираем путь, заменяя последнюю папку на "name"
return path.substr(0, prevSlashPos + 1) + replacedString +
path.substr(lastSlashPos);
static std::string replaceUsername(const std::string& path) {
std::string username = StringUtils::removeNotAscii(
StringUtils::removeAccents(Account::username(g_currentUId)));
size_t lastSlash = path.rfind('/');
if (lastSlash == std::string::npos) return path;
size_t prevSlash = path.rfind('/', lastSlash - 1);
if (prevSlash == std::string::npos)
return username + path.substr(lastSlash);
return path.substr(0, prevSlash + 1) + username + path.substr(lastSlash);
}
#endif
// Читает ровно len байт из сокета, повторяя read при частичном получении.
static bool recv_all(int sock, void *buf, size_t len) {
size_t received = 0;
while (received < len) {
ssize_t n = read(sock, static_cast<char *>(buf) + received, len - received);
if (n <= 0) return false;
received += n;
}
return true;
static bool recv_all(int sock, void* buf, size_t len) {
size_t received = 0;
while (received < len) {
ssize_t n = read(sock, static_cast<char*>(buf) + received, len - received);
if (n <= 0) return false;
received += n;
}
return true;
}
// Создаёт все компоненты пути через POSIX mkdir.
// std::filesystem::create_directories не работает с devkitPro-путями sdmc:/.
static void mkdirs(const std::string &path) {
for (size_t i = 1; i < path.size(); i++) {
if (path[i] == '/') {
std::string component = path.substr(0, i);
int rc = mkdir(component.c_str(), 0777);
std::cout << "mkdirs: mkdir [" << component << "] rc=" << rc << " errno=" << errno << std::endl;
static void mkdirs(const std::string& path) {
for (size_t i = 1; i < path.size(); i++) {
if (path[i] == '/') {
std::string component = path.substr(0, i);
mkdir(component.c_str(), 0777);
}
}
}
int rc = mkdir(path.c_str(), 0777);
std::cout << "mkdirs: mkdir [" << path << "] rc=" << rc << " errno=" << errno << std::endl;
mkdir(path.c_str(), 0777);
}
// Функция для получения файла
void receive_file(int sock, const std::string &relative_path,
size_t file_size) {
std::cout << "relative_path is: " << relative_path << std::endl;
static void receive_file(int sock, const std::string& relative_path, uint64_t file_size) {
std::cout << "Receiving: " << relative_path << " (" << file_size << " bytes)" << std::endl;
// Печатаем путь побайтово — ловим невидимые символы
std::cout << "receive_file len=" << relative_path.size() << " path=[";
for (unsigned char c : relative_path) {
if (c >= 0x20 && c <= 0x7e) std::cout << c;
else std::cout << "\\x" << std::hex << std::setw(2) << std::setfill('0') << (int)c << std::dec;
}
std::cout << "]" << std::endl;
size_t last_slash = relative_path.rfind('/');
std::string dir = (last_slash != std::string::npos)
? relative_path.substr(0, last_slash)
: "";
std::cout << "receive_file dir=[" << dir << "]" << std::endl;
if (!dir.empty()) mkdirs(dir);
// Проверяем stat на папке перед fopen
struct stat st;
int statrc = stat(dir.c_str(), &st);
std::cout << "stat(dir) rc=" << statrc << " is_dir="
<< (statrc == 0 && S_ISDIR(st.st_mode)) << std::endl;
FILE *outfile = fopen(relative_path.c_str(), "wb");
if (!outfile) {
int saved_errno = errno;
std::cerr << "Failed to open for writing: " << relative_path
<< " dir=[" << dir << "] fopen_errno=" << saved_errno << std::endl;
// Дренируем байты, чтобы отправитель не завис
char* drain_buf = new char[BUFFER_SIZE];
size_t remaining = file_size;
while (remaining > 0) {
ssize_t n = read(sock, drain_buf, remaining < (size_t)BUFFER_SIZE ? remaining : (size_t)BUFFER_SIZE);
if (n <= 0) break;
remaining -= n;
size_t last_slash = relative_path.rfind('/');
if (last_slash != std::string::npos) {
std::string dir = relative_path.substr(0, last_slash);
if (!dir.empty()) mkdirs(dir);
}
delete[] drain_buf;
return;
}
char* buffer = new char[BUFFER_SIZE]();
size_t total_bytes_received = 0;
while (total_bytes_received < file_size) {
size_t to_read = std::min((size_t)BUFFER_SIZE, file_size - total_bytes_received);
ssize_t bytes_received = read(sock, buffer, to_read);
std::cout << "Bytes received: " << bytes_received << std::endl;
if (bytes_received <= 0) {
std::cerr << "Error reading file data from socket." << std::endl;
break;
FILE* outfile = fopen(relative_path.c_str(), "wb");
if (!outfile) {
std::cerr << "Failed to open for writing: " << relative_path
<< " errno=" << errno << std::endl;
// Drain so sender doesn't hang
std::vector<char> drain(proto::BUF_SIZE);
uint64_t remaining = file_size;
while (remaining > 0) {
size_t to_read = (size_t)std::min(remaining, (uint64_t)proto::BUF_SIZE);
ssize_t n = read(sock, drain.data(), to_read);
if (n <= 0) break;
remaining -= (uint64_t)n;
}
return;
}
fwrite(buffer, 1, bytes_received, outfile);
total_bytes_received += bytes_received;
}
std::cout << "File received successfully: " << relative_path << std::endl;
delete[] buffer;
fclose(outfile);
g_server_state.bytes_total.store(file_size);
g_server_state.bytes_done.store(0);
std::vector<char> buffer(proto::BUF_SIZE);
uint64_t total_received = 0;
while (total_received < file_size) {
size_t to_read = (size_t)std::min(file_size - total_received, (uint64_t)proto::BUF_SIZE);
ssize_t n = read(sock, buffer.data(), to_read);
if (n <= 0) {
std::cerr << "Read error receiving: " << relative_path << std::endl;
break;
}
fwrite(buffer.data(), 1, (size_t)n, outfile);
total_received += (uint64_t)n;
g_server_state.bytes_done.store(total_received);
}
fclose(outfile);
std::cout << "Received: " << relative_path << std::endl;
}
void *handle_client(void *socket_desc) {
int client_socket = *(int *)socket_desc;
free(socket_desc);
static void* handle_client(void* socket_desc) {
int client_socket = *(int*)socket_desc;
free(socket_desc);
std::cout << "Обработка нового клиента в потоке " << pthread_self() << "\n";
while (true) {
uint32_t filename_len = 0;
if (!recv_all(client_socket, &filename_len, sizeof(filename_len)))
break;
while (true) {
if (filename_len == proto::EOF_SENTINEL) {
std::cout << "End of transfer." << std::endl;
break;
}
uint32_t filename_len;
ssize_t bytes_read =
read(client_socket, &filename_len, sizeof(filename_len));
if (filename_len > proto::MAX_FILENAME) {
std::cerr << "filename_len=" << filename_len << " exceeds MAX_FILENAME, aborting." << std::endl;
break;
}
// Check for end-of-transmission signal
if (bytes_read <= 0 || filename_len == 0) {
std::cout << "End of transmission detected." << std::endl;
break;
pthread_exit(nullptr);
std::vector<char> filename(filename_len + 1, '\0');
if (!recv_all(client_socket, filename.data(), filename_len)) {
std::cerr << "Short read on filename, aborting." << std::endl;
break;
}
std::string filename_str(filename.data(), filename_len);
#ifdef __SWITCH__
filename_str = replaceUsername(filename_str);
#endif
{
size_t sl = filename_str.rfind('/');
g_server_state.setStatus(
sl != std::string::npos ? filename_str.substr(sl + 1) : filename_str);
}
uint64_t file_size = 0;
if (!recv_all(client_socket, &file_size, sizeof(file_size))) {
std::cerr << "Short read on file_size, aborting." << std::endl;
break;
}
receive_file(client_socket, filename_str, file_size);
}
// Receive filename
char *filename = new char[filename_len + 1]();
if (!recv_all(client_socket, filename, filename_len)) {
std::cerr << "Short read on filename, aborting." << std::endl;
delete[] filename;
break;
}
filename[filename_len] = '\0';
std::string filename_str(filename);
delete[] filename;
std::cout << "Received filename_str is " << filename_str << std::endl;
#ifdef __SWITCH__
std::cout << "Replaced filename from " << filename_str << std::endl;
filename_str = replaceUsername(filename_str);
std::cout << "to " << filename_str << std::endl;
#endif
size_t file_size;
if (!recv_all(client_socket, &file_size, sizeof(file_size))) {
std::cerr << "Short read on file_size, aborting." << std::endl;
break;
}
std::cout << "file size is: " << file_size << std::endl;
receive_file(client_socket, filename_str, file_size);
}
close(client_socket);
pthread_exit(nullptr);
close(client_socket);
return nullptr;
}
void *broadcast_listener(void *) {
int sockfd;
struct sockaddr_in servaddr;
char buffer[BUFFER_SIZE + 1];
struct ip_mreq group;
struct AcceptArgs { int server_fd; };
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket creation failed");
pthread_exit(nullptr);
}
static void* accept_and_handle(void* arg) {
int server_fd = static_cast<AcceptArgs*>(arg)->server_fd;
delete static_cast<AcceptArgs*>(arg);
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(MULTICAST_PORT);
sockaddr_in client_addr{};
socklen_t client_len = sizeof(client_addr);
int client_socket = accept(server_fd, (sockaddr*)&client_addr, &client_len);
close(server_fd);
if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) {
perror("binding datagram socket");
close(sockfd);
pthread_exit(nullptr);
}
group.imr_multiaddr.s_addr = inet_addr(MULTICAST_GROUP);
group.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&group,
sizeof(group)) < 0) {
perror("setsockopt failed");
close(sockfd);
pthread_exit(nullptr);
}
std::cout << "Broadcast listener started" << std::endl;
struct sockaddr_in client_addr;
socklen_t addr_len = sizeof(client_addr);
while (true) {
int n = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&client_addr, &addr_len);
if (n < 0) {
perror("recvfrom failed");
continue;
if (client_socket >= 0) {
g_server_client_sock.store(client_socket);
int* pclient = new (std::nothrow) int(client_socket);
if (pclient) handle_client(pclient);
g_server_client_sock.store(-1);
}
std::cout << buffer << std::endl;
buffer[n] = '\0';
if (strcmp(buffer, "DISCOVER_SERVER") == 0) {
const char *message = "SERVER_HERE";
sendto(sockfd, message, strlen(message), 0,
(const struct sockaddr *)&client_addr, addr_len);
std::cout << "Server discovery response sent to multicast group"
<< std::endl;
pthread_exit(0);
}
}
close(sockfd);
pthread_exit(nullptr);
g_server_state.done.store(true);
return nullptr;
}
static void* broadcast_listener(void* arg) {
Socket udp(socket(AF_INET, SOCK_DGRAM, 0));
if (!udp.valid()) {
perror("broadcast_listener: socket");
return nullptr;
}
g_broadcast_sock.store(udp.fd);
sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(proto::MULTICAST_PORT);
if (bind(udp, (sockaddr*)&addr, sizeof(addr)) < 0) {
perror("broadcast_listener: bind");
g_broadcast_sock.store(-1);
return nullptr;
}
ip_mreq group{};
group.imr_multiaddr.s_addr = inet_addr(proto::MULTICAST_GROUP);
group.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(udp, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group)) < 0) {
perror("broadcast_listener: setsockopt");
g_broadcast_sock.store(-1);
return nullptr;
}
std::cout << "Broadcast listener started" << std::endl;
char buf[256];
sockaddr_in from{};
socklen_t fromlen = sizeof(from);
while (true) {
ssize_t n = recvfrom(udp, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen);
if (n < 0) {
if (g_server_state.cancelled.load()) break;
continue;
}
buf[n] = '\0';
if (strcmp(buf, "DISCOVER_SERVER") == 0) {
const char* reply = "SERVER_HERE";
sendto(udp, reply, strlen(reply), 0, (sockaddr*)&from, fromlen);
std::cout << "Discovery replied." << std::endl;
break;
}
}
g_broadcast_sock.store(-1);
return nullptr;
}
int startSendingThread() {
pthread_t broadcast_thread;
if (pthread_create(&broadcast_thread, nullptr, broadcast_listener, nullptr) <
0) {
perror("Thread creation failed");
return 1;
}
pthread_t broadcast_thread;
if (pthread_create(&broadcast_thread, nullptr, broadcast_listener, nullptr) != 0) {
perror("startSendingThread: broadcast thread");
return 1;
}
pthread_detach(broadcast_thread);
int server_fd, new_socket;
struct sockaddr_in address;
socklen_t addrlen = sizeof(address);
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("Socket creation failed");
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("Bind failed");
close(server_fd);
exit(EXIT_FAILURE);
}
if (listen(server_fd, 3) < 0) {
perror("Listen failed");
close(server_fd);
exit(EXIT_FAILURE);
}
std::cout << "Wait for broadcast thread done " << std::endl;
pthread_join(broadcast_thread, NULL);
std::cout << "Broadcast thread done " << std::endl;
std::cout << "Server listening on port " << PORT << std::endl;
while (true) {
sockaddr_in client_address;
socklen_t client_len = sizeof(client_address);
int client_socket =
accept(server_fd, (sockaddr *)&client_address, &client_len);
if (client_socket < 0) {
std::cerr << "Ошибка принятия подключения\n";
continue;
Socket server(socket(AF_INET, SOCK_STREAM, 0));
if (!server.valid()) {
perror("startSendingThread: socket");
return 1;
}
// Создаем новый поток для обработки клиента
pthread_t thread_id;
int *pclient = new (std::nothrow) int(client_socket);
if (!pclient) {
std::cerr << "Ошибка выделения памяти\n";
close(client_socket);
continue;
}
if (pthread_create(&thread_id, nullptr, handle_client, pclient) != 0) {
std::cerr << "Ошибка создания потока\n";
delete pclient; // Освобождаем память при ошибке
} else {
pthread_join(thread_id, NULL);
break;
}
}
sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(proto::TCP_PORT);
close(server_fd);
return 0;
if (bind(server, (sockaddr*)&addr, sizeof(addr)) < 0) {
perror("startSendingThread: bind");
return 1;
}
if (listen(server, 3) < 0) {
perror("startSendingThread: listen");
return 1;
}
g_server_state.reset();
g_server_state.setStatus("Waiting for connection...");
AcceptArgs* acc_args = new AcceptArgs{server.fd};
pthread_t accept_thread;
if (pthread_create(&accept_thread, nullptr, accept_and_handle, acc_args) != 0) {
delete acc_args;
return 1;
}
pthread_detach(accept_thread);
server.release(); // accepted by accept_and_handle
return 0;
}
#ifndef __SWITCH__ // for desktop
#ifndef __SWITCH__
int main() {
return startSendingThread();
if (startSendingThread() != 0) return 1;
while (!isServerTransferDone()) usleep(16000);
return 0;
}
#endif