TCP 소켓 프로그래밍

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

static int send_all(int fd, const char *buf, ssize_t len) {
    ssize_t sent = 0;

    while (sent < len) {
        ssize_t n = send(fd, buf + sent, len - sent, 0);
        if (n < 0 && errno == EINTR) {
            continue;
        }
        if (n <= 0) {
            perror("send failed");
            return -1;
        }
        sent += n;
    }
    return 0;
}

void handle_client(int client_fd) {
    char buffer[1024];
    ssize_t bytes_read;
    while ((bytes_read = recv(client_fd, buffer, sizeof(buffer) - 1, 0)) > 0) {
        buffer[bytes_read] = '\0';
        if (send_all(client_fd, buffer, bytes_read) < 0) {
            break;
        }
    }
    close(client_fd);
    exit(0);
}

int main() {
    int server_fd;
    struct sockaddr_in addr;

    signal(SIGCHLD, SIG_IGN); // 좀비 프로세스 방지

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8080);

    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(server_fd, 128);
    printf("Server listening on port 8080\n");

    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        if (client_fd < 0) continue;

        pid_t pid = fork();
        if (pid == 0) {
            close(server_fd);  // 자식은 서버 소켓 불필요
            handle_client(client_fd);
        } else {
            close(client_fd);  // 부모는 클라이언트 소켓 불필요
        }
    }
}

import socket
import threading

def handle_client(client, addr):
    print(f"Connected: {addr}")
    while True:
        data = client.recv(1024)
        if not data:
            break
        client.sendall(data)
    client.close()
    print(f"Disconnected: {addr}")

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("0.0.0.0", 8080))
server.listen(128)
print("Server listening on port 8080")

while True:
    client, addr = server.accept()
    t = threading.Thread(target=handle_client, args=(client, addr))
    t.daemon = True
    t.start()

import struct

def send_msg(sock, msg):
    data = msg.encode()
    length = struct.pack("!I", len(data))  # 4바이트 빅엔디언
    sock.sendall(length + data)

def recv_msg(sock):
    raw_length = recv_exact(sock, 4)
    if not raw_length:
        return None
    length = struct.unpack("!I", raw_length)[0]
    data = recv_exact(sock, length)
    return None if data is None else data.decode()

def recv_exact(sock, n):
    data = b""
    while len(data) < n:
        chunk = sock.recv(n - len(data))
        if not chunk:
            return None
        data += chunk
    return data

import socket

from length_prefix import recv_msg, send_msg

HOST = "127.0.0.1"
PORT = 18080

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind((HOST, PORT))
    server.listen(1)
    print(f"Framed echo ready: {HOST}:{PORT}", flush=True)
    client, _ = server.accept()
    with client:
        while True:
            message = recv_msg(client)
            if message is None:
                break
            print(f"Message: {message!r}", flush=True)
            send_msg(client, message)
print("Receive EOF; server stopped", flush=True)

import socket
import struct

from length_prefix import recv_msg, send_msg

with socket.create_connection(("127.0.0.1", 18080), timeout=5) as client:
    for index, message in enumerate(["Hello, Socket!", "", "한글🙂"]):
        if index == 2:
            payload = message.encode("utf-8")
            frame = struct.pack("!I", len(payload)) + payload
            parts = (frame[:2], frame[2:5], frame[5:])
            for part in parts:
                client.sendall(part)
            print("Split writes:", [len(part) for part in parts])
        else:
            send_msg(client, message)
        echoed = recv_msg(client)
        if echoed != message:
            raise RuntimeError(f"Echo mismatch: expected {message!r}, got {echoed!r}")
        print(f"Verified: {echoed!r}")
    client.shutdown(socket.SHUT_WR)
    if recv_msg(client) is not None:
        raise RuntimeError("Unexpected response after the final message")
print("Receive EOF; client stopped")

python -X utf8 framed_echo_server.py

python -X utf8 framed_echo_client.py

Verified: 'Hello, Socket!'
Verified: ''
Split writes: [2, 3, 9]
Verified: '한글🙂'
Receive EOF; client stopped

Framed echo ready: 127.0.0.1:18080
Message: 'Hello, Socket!'
Message: ''
Message: '한글🙂'
Receive EOF; server stopped

import socket
import struct
import threading

clients = []
lock = threading.Lock()

def send_msg(sock, msg):
    data = msg.encode()
    header = struct.pack("!I", len(data))
    sock.sendall(header + data)

def recv_exact(sock, n):
    data = b""
    while len(data) < n:
        chunk = sock.recv(n - len(data))
        if not chunk:
            return None
        data += chunk
    return data

def recv_msg(sock):
    raw_length = recv_exact(sock, 4)
    if raw_length is None:
        return None
    length = struct.unpack("!I", raw_length)[0]
    data = recv_exact(sock, length)
    return None if data is None else data.decode()

def broadcast(message, sender):
    with lock:
        targets = [client for client in clients if client != sender]

    dead = []
    for client in targets:
        try:
            send_msg(client, message)
        except OSError:
            dead.append(client)

    if dead:
        with lock:
            for client in dead:
                if client in clients:
                    clients.remove(client)

def handle_client(client, addr):
    with lock:
        clients.append(client)
    print(f"Connected: {addr}")
    try:
        while True:
            message = recv_msg(client)
            if message is None:
                break
            broadcast(message, client)
    finally:
        with lock:
            if client in clients:
                clients.remove(client)
        client.close()
        print(f"Disconnected: {addr}")

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("0.0.0.0", 8080))
server.listen(128)
print("Chat server on port 8080")

while True:
    client, addr = server.accept()
    threading.Thread(target=handle_client, args=(client, addr), daemon=True).start()