UDP 소켓 프로그래밍

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

int main(void) {
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) { perror("socket"); return 1; }

    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(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind"); return 1; }

    char buf[2048];
    for (;;) {
        struct sockaddr_in peer;
        socklen_t peer_len = sizeof(peer);              /* 부를 때마다 버퍼 크기로 다시 맞춘다 */
        ssize_t n = recvfrom(fd, buf, sizeof(buf), MSG_TRUNC,
                             (struct sockaddr *)&peer, &peer_len);
        if (n < 0) {
            if (errno == EINTR) continue;
            perror("recvfrom");
            continue;
        }
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip));
        if ((size_t)n > sizeof(buf)) {                  /* MSG_TRUNC: 원래 길이가 버퍼보다 컸다 */
            fprintf(stderr, "%s:%u sent %zd bytes, dropped\n", ip, (unsigned)ntohs(peer.sin_port), n);
            continue;
        }
        if (sendto(fd, buf, (size_t)n, 0, (struct sockaddr *)&peer, peer_len) < 0) {
            perror("sendto");
        }
    }
}

import socket
import threading

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(("127.0.0.1", 0))

def serve():
    seen = 0
    while True:
        data, addr = server.recvfrom(2048)
        seen += 1
        if seen == 1:
            continue                                     # 첫 데이터그램은 사라진 것으로 친다
        server.sendto(b"ECHO " + data, addr)

threading.Thread(target=serve, daemon=True).start()

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.settimeout(0.2)                                   # 응답을 기다릴 최대 시간
for attempt in range(1, 4):                              # 최대 세 번까지 보낸다
    client.sendto(b"hello", server.getsockname())
    try:
        data, _ = client.recvfrom(2048)
        print(f"{attempt}번째 시도: {data}")
        break
    except socket.timeout:
        print(f"{attempt}번째 시도: 응답 없음")
client.close()

1번째 시도: 응답 없음
2번째 시도: b'ECHO hello'

import struct

def build_query(domain, qid):
    qname = b"".join(bytes([len(label)]) + label.encode("ascii") for label in domain.split(".")) + b"\x00"
    question = qname + struct.pack("!HH", 1, 1)                    # 타입 A, 클래스 IN
    return struct.pack("!HHHHHH", qid, 0x0100, 1, 0, 0, 0) + question, question

query, question = build_query("example.com", 0x1234)
response = (
    struct.pack("!HHHHHH", 0x1234, 0x8180, 1, 1, 0, 0)           # 응답, 재귀 가능, 오류 없음, 답 1개
    + question                                                   # 질문을 그대로 되풀이한다
    + struct.pack("!HHHIH", 0xC00C, 1, 1, 300, 4)                # 이름은 오프셋 12(헤더 바로 뒤)를 가리키는 압축 포인터
    + bytes([192, 0, 2, 44])
)
cases = [("정상", response),
         ("RDATA 두 바이트 누락", response[:-2]),
         ("ID가 다른 응답", b"\x99\x99" + response[2:]),
         ("TC가 켜진 응답", response[:2] + struct.pack("!H", 0x8380) + response[4:])]

def parse_first_a(data):
    def skip_name(offset):
        while True:
            length = data[offset]
            if length & 0xC0 == 0xC0:
                return offset + 2                                # 압축 포인터는 2바이트
            if length == 0:
                return offset + 1
            offset += 1 + length

    _, _, qdcount, ancount, _, _ = struct.unpack("!HHHHHH", data[:12])
    offset = 12
    for _ in range(qdcount):
        offset = skip_name(offset) + 4                           # QTYPE, QCLASS
    for _ in range(ancount):
        offset = skip_name(offset)
        rtype, rclass, _, rdlength = struct.unpack("!HHIH", data[offset:offset + 10])
        offset += 10
        rdata = data[offset:offset + rdlength]
        offset += rdlength
        if rtype == 1 and rclass == 1 and rdlength == 4:
            return ".".join(str(b) for b in rdata)
    raise ValueError("A 레코드가 없다")

print(f"{len(query)}바이트 질의, {len(response)}바이트 응답")
for name, data in cases:
    print(f"{name}: {parse_first_a(data)}")

29바이트 질의, 45바이트 응답
정상: 192.0.2.44
RDATA 두 바이트 누락: 192.0
ID가 다른 응답: 192.0.2.44
TC가 켜진 응답: 192.0.2.44

def parse_a(query, data):
    (qid,) = struct.unpack("!H", query[:2])
    rid, flags, _, ancount, _, _ = struct.unpack("!HHHHHH", data[:12])
    if rid != qid:
        raise ValueError("ID가 다르다")
    if not flags & 0x8000:
        raise ValueError("응답이 아니다")
    if flags & 0x0200:
        raise ValueError("잘린 응답이다: TCP로 다시 물어야 한다")
    if flags & 0x000F:
        raise ValueError(f"RCODE {flags & 0x000F}")
    q = query[12:]
    if data[12:12 + len(q)] != q:
        raise ValueError("질문이 다르다")
    offset = 12 + len(q)
    for _ in range(ancount):
        if data[offset] & 0xC0 != 0xC0:
            raise ValueError("이 예제는 압축된 이름만 다룬다")
        offset += 2
        if offset + 10 > len(data):
            raise ValueError("레코드 헤더가 잘렸다")
        rtype, rclass, ttl, rdlength = struct.unpack("!HHIH", data[offset:offset + 10])
        offset += 10
        if offset + rdlength > len(data):
            raise ValueError("RDATA가 잘렸다")
        rdata = data[offset:offset + rdlength]
        offset += rdlength
        if rtype == 1 and rclass == 1 and rdlength == 4:
            return ".".join(str(b) for b in rdata), ttl
    raise ValueError("A 레코드가 없다")

for name, data in cases:
    try:
        ip, ttl = parse_a(query, data)
        print(f"{name}: {ip}, TTL {ttl}초")
    except ValueError as e:
        print(f"{name}: 거부({e})")

정상: 192.0.2.44, TTL 300초
RDATA 두 바이트 누락: 거부(RDATA가 잘렸다)
ID가 다른 응답: 거부(ID가 다르다)
TC가 켜진 응답: 거부(잘린 응답이다: TCP로 다시 물어야 한다)