TCP 소켓 프로그래밍

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>

static int send_all(int fd, const char *buf, size_t len) {
    size_t sent = 0;
    while (sent < len) {
        ssize_t n = send(fd, buf + sent, len - sent, MSG_NOSIGNAL);
        if (n < 0) {
            if (errno == EINTR) continue;
            return -1;
        }
        sent += (size_t)n;
    }
    return 0;
}

static void serve_client(int fd) {
    char buf[4096];
    for (;;) {
        ssize_t n = recv(fd, buf, sizeof(buf), 0);
        if (n < 0 && errno == EINTR) continue;
        if (n <= 0) break;                          /* EOF나 오류 */
        if (send_all(fd, buf, (size_t)n) < 0) break;
    }
}

int main(void) {
    signal(SIGCHLD, SIG_IGN);                       /* 끝난 자식이 좀비로 남지 않게 한다 */

    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) { perror("socket"); return 1; }
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(8080);
    if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind"); return 1; }
    if (listen(server_fd, 128) < 0) { perror("listen"); return 1; }

    for (;;) {
        int client_fd = accept(server_fd, NULL, NULL);
        if (client_fd < 0) {
            if (errno == EINTR) continue;
            perror("accept");
            continue;
        }
        pid_t pid = fork();
        if (pid < 0) {                              /* 자식을 만들지 못했다 */
            perror("fork");
            close(client_fd);
        } else if (pid == 0) {                      /* 자식 */
            close(server_fd);                       /* 자식에게 리스닝 소켓은 필요 없다 */
            serve_client(client_fd);
            close(client_fd);
            _exit(0);
        } else {                                    /* 부모 */
            close(client_fd);                       /* 부모에게 이 연결은 필요 없다 */
        }
    }
}

import socket
import socketserver
import threading

class UpperHandler(socketserver.StreamRequestHandler):
    def handle(self):
        for line in self.rfile:                              # 한 줄씩 읽어
            self.wfile.write(line.upper())                   # 대문자로 돌려준다

server = socketserver.ThreadingTCPServer(("127.0.0.1", 0), UpperHandler)   # 연결마다 스레드 하나
threading.Thread(target=server.serve_forever, daemon=True).start()

clients = [socket.create_connection(server.server_address) for _ in range(3)]  # 세 연결을 함께 열어 둔다
for i, c in enumerate(clients):
    c.sendall(f"client {i}\n".encode())
for c in clients:
    with c, c.makefile("rb") as reader:
        print(reader.readline())
server.shutdown()
server.server_close()

b'CLIENT 0\n'
b'CLIENT 1\n'
b'CLIENT 2\n'

import socket
import struct
import threading

def send_msg(sock, text):
    data = text.encode("utf-8")
    sock.sendall(struct.pack("!I", len(data)) + data)          # 4바이트 길이(빅 엔디언) + 본문

def recv_exact(sock, n):
    data = b""
    while len(data) < n:
        chunk = sock.recv(n - len(data))                       # 아직 모자란 만큼만 요청한다
        if not chunk:
            return None                                        # 다 모으기 전에 EOF
        data += chunk
    return data

def recv_msg(sock):
    header = recv_exact(sock, 4)
    if header is None:
        return None
    (length,) = struct.unpack("!I", header)
    body = recv_exact(sock, length)
    return None if body is None else body.decode("utf-8")

def serve(listener):
    conn, _ = listener.accept()
    with conn:
        while (message := recv_msg(conn)) is not None:
            send_msg(conn, message)

listener = socket.create_server(("127.0.0.1", 0))
threading.Thread(target=serve, args=(listener,), daemon=True).start()

with socket.create_connection(listener.getsockname(), timeout=5) as client:
    for text in ["Hello, Socket!", "", "한글🙂"]:
        if text == "한글🙂":
            payload = text.encode("utf-8")
            frame = struct.pack("!I", len(payload)) + payload
            for part in (frame[:2], frame[2:5], frame[5:]):     # 일부러 세 번에 나누어 쓴다
                client.sendall(part)
        else:
            send_msg(client, text)
        print(f"{recv_msg(client)!r}, 본문 {len(text.encode('utf-8'))}바이트")
    client.shutdown(socket.SHUT_WR)
    print("서버가 닫은 뒤:", recv_msg(client))
listener.close()

'Hello, Socket!', 본문 14바이트
'', 본문 0바이트
'한글🙂', 본문 10바이트
서버가 닫은 뒤: None

import threading

clients, lock = [], threading.Lock()

class FakeSocket:
    def __init__(self, name, broken=False):
        self.name, self.broken, self.received = name, broken, []

    def sendall(self, data):
        if self.broken:
            raise BrokenPipeError                            # 이미 끊긴 연결
        self.received.append(data)

def broadcast(message, sender):
    with lock:
        targets = [c for c in clients if c is not sender]    # 잠금 안에서는 목록만 복사한다
    dead = []
    for c in targets:                                        # 보내기는 잠금 밖에서 한다
        try:
            c.sendall(message)
        except OSError:
            dead.append(c)
    with lock:
        for c in dead:
            if c in clients:
                clients.remove(c)

a, b, gone = FakeSocket("a"), FakeSocket("b"), FakeSocket("gone", broken=True)
clients.extend([a, b, gone])
broadcast(b"hi", sender=a)
print(a.received, b.received, [c.name for c in clients])

[] [b'hi'] ['a', 'b']