Раздел 19 — Сеть и сокеты

Каналы из раздела 17 связывают процессы одного компьютера. Сокет — такой же конец соединения, но между компьютерами сети. Чтобы данные дошли до нужной программы на нужном компьютере, нужны два числа:

Сервер — программа, которая заранее занимает порт и ждёт. Клиент знает адрес и порт сервера и подключается сам. Это та же схема, что с именованным каналом: имя канала там — адрес и порт здесь.

В курсе — TCP: он даёт надёжную доставку, а программе остаётся договориться о границах сообщений (пункт 06).

Сокеты в Windows — библиотека Winsock 2, функции живут в ws2_32.dll (раздел 18). Три обязательных вещи:

• заголовки <winsock2.h> и <ws2tcpip.h> — до <windows.h>, если он нужен (иначе конфликт со старым winsock.h); winsock2.h сам подключает windows.h;
• библиотека импорта -lws2_32 при сборке — иначе компоновщик выдаст undefined reference to `__imp_socket';
• WSAStartup(MAKEWORD(2, 2), &wsa) в начале и WSACleanup() в конце. Без WSAStartup все функции сокетов вернут ошибку 10093.

// Фрагмент tcpserver.cpp. Полностью — в примерах раздела
    WSADATA wsa;
    const int started = WSAStartup(MAKEWORD(2, 2), &wsa);   // подключить Winsock версии 2.2
    if (started != 0) {
        std::cout << "WSAStartup failed, error " << started << '\n';
        return 2;
    }
    SOCKET listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listener == INVALID_SOCKET) {
        printSocketError("socket");
        WSACleanup();
        return 2;
    }
    sockaddr_in address = {};
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_ANY);            // принимать на всех сетевых интерфейсах
    address.sin_port = htons(static_cast<u_short>(port));   // номер порта — в сетевом порядке байтов
    if (bind(listener, reinterpret_cast<sockaddr*>(&address), sizeof(address)) == SOCKET_ERROR
        || listen(listener, SOMAXCONN) == SOCKET_ERROR) {
        printSocketError("bind/listen");                    // 10048 — порт уже занят
        closesocket(listener);
        WSACleanup();
        return 2;
    }
    std::cout << "listening on port " << port << '\n';

    bool running = true;
    while (running) {
        sockaddr_in clientAddress = {};
        int addressLength = sizeof(clientAddress);
        SOCKET client = accept(listener, reinterpret_cast<sockaddr*>(&clientAddress), &addressLength);
        if (client == INVALID_SOCKET) {
            printSocketError("accept");
        } else {
            char ip[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &clientAddress.sin_addr, ip, sizeof(ip));
            std::cout << "client " << ip << ':' << ntohs(clientAddress.sin_port) << " connected\n";
            running = serveClient(client);
            closesocket(client);
            std::cout << "client disconnected\n";
        }
    }
    closesocket(listener);
    WSACleanup();

• Порядок байтов. Процессор x86 хранит младший байт числа первым, а сеть передаёт старший первым. htons (host to network short) и htonl переставляют байты порта и адреса; ntohs — обратно. Забытый htons — сервер слушает не тот порт: 5000 превращается в 34835.
• sockaddr_in — адрес IPv4; функции принимают указатель на общий тип sockaddr, отсюда reinterpret_cast — тот же приём «смотри на эти байты как на…», что в разделе 11. inet_ntop переводит адрес в текст "127.0.0.1".

// Фрагмент tcpclient.cpp. Полностью — в примерах раздела
    addrinfo hints = {};
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    addrinfo* found = nullptr;
    const int resolved = getaddrinfo(argv[1], argv[2], &hints, &found);    // имя или IP и порт → адрес
    if (resolved != 0) {
        std::cout << "Cannot resolve " << argv[1] << ", error " << resolved << '\n';   // 11001 — нет такого узла
        WSACleanup();
        return 2;
    }
    SOCKET s = socket(found->ai_family, found->ai_socktype, found->ai_protocol);
    if (s == INVALID_SOCKET || connect(s, found->ai_addr, static_cast<int>(found->ai_addrlen)) == SOCKET_ERROR) {
        printSocketError("connect");                        // 10061 — порт никто не слушает
        ...
    }
    freeaddrinfo(found);

getaddrinfo принимает имя узла (localhost, nevabit.ru) или IP-адрес текстом и номер порта текстом — прямо из argv — и возвращает список готовых адресов. Список выделен в куче (раздел 18): его освобождают freeaddrinfo. connect устанавливает соединение: после него send и recv работают с тем же сокетом. Порт клиента система выбирает сама — его видно в журнале сервера.

send(s, данные, сколько, 0) и recv(s, буфер, размер, 0) работают как WriteFile и ReadFile на байтовом канале: send может отправить не всё, recv возвращает сколько пришло — от 1 байта до размера буфера — или 0, если собеседник закрыл соединение. Границ между send не существует: два send по 3 байта могут прийти одним recv на 6 байт или тремя по 2.

Поэтому о границах договаривается протокол. В курсе — самый простой: каждое сообщение — строка, заканчивается '\n'. Получатель копит байты и отдаёт строку, когда встретил перевод строки; лишние байты ждут следующего вызова:

struct LineReader {
    char data[LINE_BUFFER];                     // принятые, но ещё не разобранные байты
    int length;
};

// Следующая строка из потока TCP (без '\r' и '\n') в line; байты после неё остаются в reader.
// false — соединение закрыто, ошибка или строка длиннее буфера
bool readLine(SOCKET s, LineReader& reader, char line[], int size)
{
    while (true) {
        for (int i = 0; i < reader.length; ++i) {
            if (reader.data[i] == '\n') {
                int k = 0;
                for (int j = 0; j < i && k < size - 1; ++j) {
                    if (reader.data[j] != '\r') {
                        line[k] = reader.data[j];
                        ++k;
                    }
                }
                line[k] = '\0';
                for (int j = i + 1; j < reader.length; ++j) {       // остаток — в начало буфера
                    reader.data[j - i - 1] = reader.data[j];
                }
                reader.length -= i + 1;
                return true;
            }
        }
        if (reader.length == LINE_BUFFER) {
            return false;                                           // строка не поместилась
        }
        const int received = recv(s, reader.data + reader.length, LINE_BUFFER - reader.length, 0);
        if (received <= 0) {
            return false;                                           // 0 — собеседник закрыл соединение
        }
        reader.length += received;
    }
}

Отправка — sendAll, такая же, как writeAll в разделе 17. Сервер и клиент в двух окнах:

> tcpserver 5000                        > tcpclient localhost 5000
listening on port 5000                  connected to localhost:5000
client 127.0.0.1:53712 connected        hello, socket
request: hello, socket                  HELLO, SOCKET
request: shutdown                       shutdown
client disconnected                     bye
server stopped                          quit

Проверить сервер можно и стандартным клиентом Windows — telnet localhost 5000 (включается в «Компонентах Windows»): он отправляет то, что вы печатаете. Протокол строк текстовый, поэтому его видно и отлаживать просто. Двоичные данные (числа, структуры) передают с заголовком длины: сначала 4 байта размера, потом ровно столько байт.

• Два компьютера. Сервер запускают на одном, узнают его адрес ipconfig (строка «IPv4-адрес»), клиент на другом подключается к этому адресу: tcpclient 192.168.1.15 5000. Компьютеры должны быть в одной сети или сеть должна пропускать порт.
• Брандмауэр Windows при первом listen спросит, разрешить ли программе принимать подключения. Без разрешения подключения с других компьютеров будут отвергаться — клиент получит тайм-аут 10060. В компьютерных классах разрешение может требовать прав администратора — тогда опыты ведут через localhost.
• Несколько клиентов. Сервер из пункта 04 обслуживает клиентов по очереди: остальные подключения ждут в очереди listen. Как в разделе 17, решение — поток на клиента (раздел 16): главный поток только принимает accept и передаёт сокет новому потоку. Общие данные потоков защищают критической секцией.
• Тайм-ауты. recv ждёт данных сколько угодно. Ограничить ожидание: setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, …) с числом миллисекунд — по истечении recv вернёт ошибку 10060.
• Безопасность. Сервер принимает данные от кого угодно в сети. Каждый запрос проверяется так же строго, как ввод с клавиатуры: длина строки ограничена буфером, числа — разбираются с проверкой. Переполнение буфера в сетевом сервере — самая опасная уязвимость из возможных: её может использовать любой, кто достучался до порта.