Я хотел бы реализовать архитектуру клиент-сервер, работающую в Linux, используя сокеты и язык C/С++, способный отправлять и получать файлы. Есть ли библиотека, облегчающая эту задачу? Может ли кто-нибудь указать пример?
Отправить и получить файл в сокетном программировании в Linux с помощью C/С++ (GCC/g++)
Ответ 1
Самое портативное решение - просто прочитать файл в кусках, а затем записать данные в сокет, в цикле (а также наоборот, когда вы получаете файл). Вы выделяете в этот буфер буфер read
и write
из этого буфера в ваш сокет (вы также можете использовать send
и recv
, которые предназначены для записи и чтения данных сокета). Схема будет выглядеть примерно так:
while (1) {
// Read data into buffer. We may not have enough to fill up buffer, so we
// store how many bytes were actually read in bytes_read.
int bytes_read = read(input_file, buffer, sizeof(buffer));
if (bytes_read == 0) // We're done reading from the file
break;
if (bytes_read < 0) {
// handle errors
}
// You need a loop for the write, because not all of the data may be written
// in one call; write will return how many bytes were written. p keeps
// track of where in the buffer we are, while we decrement bytes_read
// to keep track of how many bytes are left to write.
void *p = buffer;
while (bytes_read > 0) {
int bytes_written = write(output_socket, p, bytes_read);
if (bytes_written <= 0) {
// handle errors
}
bytes_read -= bytes_written;
p += bytes_written;
}
}
Обязательно внимательно прочитайте документацию для read
и write
, особенно при обработке ошибок. Некоторые из кодов ошибок означают, что вы должны просто повторить попытку, например, просто повторить цикл с помощью оператора continue
, в то время как другие означают, что что-то сломано, и вам нужно остановиться.
Для отправки файла в сокет есть системный вызов sendfile
, который делает именно то, что вы хотите. Он сообщает ядру отправить файл из одного дескриптора файла в другой, а затем ядро может позаботиться об остальном. Существует предостережение о том, что дескриптор исходного файла должен поддерживать mmap
(как, например, фактический файл, а не сокет), а получатель должен быть сокетом (поэтому вы не можете использовать его для копирования файлов или отправки данных непосредственно из одного сокета в другой); он предназначен для поддержки описанного вами использования, отправки файла в сокет. Однако это не помогает при получении файла; вам нужно будет сделать цикл для этого. Я не могу сказать вам, почему существует вызов sendfile
, но нет аналогичного recvfile
.
Остерегайтесь, что sendfile
является специфичным для Linux; он не переносится в другие системы. Другие системы часто имеют собственную версию sendfile
, но точный интерфейс может меняться (FreeBSD, Mac OS X, Solaris).
В Linux 2.6.17 системный вызов splice
был введенный, а по состоянию на 2.6.23 используется внутренне для реализации sendfile
. splice
- API более общего назначения, чем sendfile
. Для хорошего описания splice
и tee
см. Довольно хорошее объяснение от самого Линуса. Он указывает, как использование splice
в основном аналогично циклу выше, используя read
и write
, за исключением того, что буфер находится в ядре, поэтому данные не должны переноситься между ядром и пользовательским пространством, или даже не может проходить через процессор (известный как "ввод-вывод с нулевой копией" ).
Ответ 2
Сделайте man 2 sendfile
. Вам нужно только открыть исходный файл на клиентском и целевом файлах на сервере, а затем вызвать sendfile, и ядро будет рубить и перемещать данные.
Ответ 3
Этот файл послужит вам хорошим примером sendfile
: http://tldp.org/LDP/LGNET/91/misc/tranter/server.c.txt
Ответ 4
Минимально допустимый пример POSIX
Использование:
-
получить два компьютера в локальной сети
-
На компьютере сервера:
-
Найдите локальный IP-адрес сервера с помощью
ifconfig
, например.192.168.0.10
-
Run:
./server output.tmp 12345
-
-
На клиентском компьютере:
printf 'ab\ncd\n' > input.tmp ./client input.tmp 192.168.0.10 12345
-
Итог: файл
output.tmp
создается на компьютере-терминале, содержащем'ab\ncd\n'
.
server.c
/*
Receive a file over a socket.
Saves it to output.tmp by default.
Interface:
./executable [<output_file> [<port>]]
Defaults:
- output_file: output.tmp
- port: 12345
*/
#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h> /* getprotobyname */
#include <netinet/in.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <unistd.h>
int main(int argc, char **argv) {
char *file_path = "output.tmp";
char buffer[BUFSIZ];
char protoname[] = "tcp";
int client_sockfd;
int enable = 1;
int filefd;
int i;
int server_sockfd;
socklen_t client_len;
ssize_t read_return;
struct protoent *protoent;
struct sockaddr_in client_address, server_address;
unsigned short server_port = 12345u;
if (argc > 1) {
file_path = argv[1];
if (argc > 2) {
server_port = strtol(argv[2], NULL, 10);
}
}
/* Create a socket and listen to it.. */
protoent = getprotobyname(protoname);
if (protoent == NULL) {
perror("getprotobyname");
exit(EXIT_FAILURE);
}
server_sockfd = socket(
AF_INET,
SOCK_STREAM,
protoent->p_proto
);
if (server_sockfd == -1) {
perror("socket");
exit(EXIT_FAILURE);
}
if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)) < 0) {
perror("setsockopt(SO_REUSEADDR) failed");
exit(EXIT_FAILURE);
}
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(server_port);
if (bind(
server_sockfd,
(struct sockaddr*)&server_address,
sizeof(server_address)
) == -1
) {
perror("bind");
exit(EXIT_FAILURE);
}
if (listen(server_sockfd, 5) == -1) {
perror("listen");
exit(EXIT_FAILURE);
}
fprintf(stderr, "listening on port %d\n", server_port);
while (1) {
client_len = sizeof(client_address);
puts("waiting for client");
client_sockfd = accept(
server_sockfd,
(struct sockaddr*)&client_address,
&client_len
);
filefd = open(file_path,
O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR);
if (filefd == -1) {
perror("open");
exit(EXIT_FAILURE);
}
do {
read_return = read(client_sockfd, buffer, BUFSIZ);
if (read_return == -1) {
perror("read");
exit(EXIT_FAILURE);
}
if (write(filefd, buffer, read_return) == -1) {
perror("write");
exit(EXIT_FAILURE);
}
} while (read_return > 0);
close(filefd);
close(client_sockfd);
}
return EXIT_SUCCESS;
}
client.c
/*
Send a file over a socket.
Interface:
./executable [<input_path> [<sever_hostname> [<port>]]]
Defaults:
- input_path: input.tmp
- server_hostname: 127.0.0.1
- port: 12345
*/
#define _XOPEN_SOURCE 700
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h> /* getprotobyname */
#include <netinet/in.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <unistd.h>
int main(int argc, char **argv) {
char protoname[] = "tcp";
struct protoent *protoent;
char *file_path = "input.tmp";
char *server_hostname = "127.0.0.1";
char *server_reply = NULL;
char *user_input = NULL;
char buffer[BUFSIZ];
in_addr_t in_addr;
in_addr_t server_addr;
int filefd;
int sockfd;
ssize_t i;
ssize_t read_return;
struct hostent *hostent;
struct sockaddr_in sockaddr_in;
unsigned short server_port = 12345;
if (argc > 1) {
file_path = argv[1];
if (argc > 2) {
server_hostname = argv[2];
if (argc > 3) {
server_port = strtol(argv[3], NULL, 10);
}
}
}
filefd = open(file_path, O_RDONLY);
if (filefd == -1) {
perror("open");
exit(EXIT_FAILURE);
}
/* Get socket. */
protoent = getprotobyname(protoname);
if (protoent == NULL) {
perror("getprotobyname");
exit(EXIT_FAILURE);
}
sockfd = socket(AF_INET, SOCK_STREAM, protoent->p_proto);
if (sockfd == -1) {
perror("socket");
exit(EXIT_FAILURE);
}
/* Prepare sockaddr_in. */
hostent = gethostbyname(server_hostname);
if (hostent == NULL) {
fprintf(stderr, "error: gethostbyname(\"%s\")\n", server_hostname);
exit(EXIT_FAILURE);
}
in_addr = inet_addr(inet_ntoa(*(struct in_addr*)*(hostent->h_addr_list)));
if (in_addr == (in_addr_t)-1) {
fprintf(stderr, "error: inet_addr(\"%s\")\n", *(hostent->h_addr_list));
exit(EXIT_FAILURE);
}
sockaddr_in.sin_addr.s_addr = in_addr;
sockaddr_in.sin_family = AF_INET;
sockaddr_in.sin_port = htons(server_port);
/* Do the actual connection. */
if (connect(sockfd, (struct sockaddr*)&sockaddr_in, sizeof(sockaddr_in)) == -1) {
perror("connect");
return EXIT_FAILURE;
}
while (1) {
read_return = read(filefd, buffer, BUFSIZ);
if (read_return == 0)
break;
if (read_return == -1) {
perror("read");
exit(EXIT_FAILURE);
}
if (write(sockfd, buffer, read_return) == -1) {
perror("write");
exit(EXIT_FAILURE);
}
}
free(user_input);
free(server_reply);
close(filefd);
exit(EXIT_SUCCESS);
}
Дополнительные комментарии
Возможные улучшения:
-
В настоящее время
output.tmp
получает перезапись при каждом отправке.Это требует создания простого протокола, который позволяет передавать имя файла, чтобы можно было загрузить несколько файлов, например: имя файла до первого символа новой строки, максимальное имя файла 256 символов, а остальное до закрытия сокета - это содержимое, Конечно, это потребует санитарии, чтобы избежать поперечной уязвимости пути.
В качестве альтернативы мы могли бы создать сервер, который хэширует файлы для поиска имен файлов и сохраняет карту с исходных путей на хэши на диске (в базе данных).
-
Только один клиент может подключаться одновременно.
Это особенно вредно, если есть медленные клиенты, чьи подключения долго продолжаются: медленное соединение останавливает всех.
Один из способов обойти это - развить процесс/поток для каждого
accept
, немедленно начать прослушивание и использовать синхронизацию блокировки файлов в файлах. -
Добавьте таймауты и закрывайте клиентов, если они занимают слишком много времени. Или иначе было бы легко сделать DoS.
poll
илиselect
есть некоторые опции: Как реализовать тайм-аут при вызове функции чтения?
В этом примере на GitHub.
Протестировано на Ubuntu 15.10.