소켓 뒷조사좀 해봤습니다

: 개발자가 네트워크 통신을 할 수 있도록 추상화된, 파일 유사 API를 제공하는 커널의 통신 채널 객체
(포스팅 내 대부분의 커널 코드는 Darwin XNU API로 기술했습니다.)

왜 필요한가?

• 프로세스는 직접 네트워크 장치에 접근할 수 없음. 커널만이 장치와 통신할 수 있음
• 따라서, 사용자 프로세스는 네트워크를 통해 다른 컴퓨터와 통신하려면 커널에게 요청할 수 있는 API가 필요.
  이때 커널과 소통하는 창구가 소켓

즉, 소켓은 “사용자 프로세스와 커널 네트워크 스택 사이의 계약된 인터페이스”

소켓은 네트워크를 추상적으로 이용할 수 있게 만들어주는 객체이며, 실질적인 노드 안의 종단점이다.
위 그림의 예시처럼, 클라이언트와 서버는 소켓을 통해 마치 직접 연결된 것 처럼 데이터를 주고 받을 수 있다.
즉, 양 종단의 소켓은 “통신 채널“이기도 하다.

객체로써의 소켓

소켓은 커널에 존재하는 객체, 커널 리소스이다.
소켓 조작은 대부분의 커널에서 파일 조작API와 유사한 API를 제공한다.
그러나 소켓은 객체이며, 커널은 FileDiscriptor를 제공해 소켓을 사용할 수 있게끔 할 뿐이다.
(이를 두고 가상 파일이라고도 한다.)

도구로써의 Socket

그러나 어플리케이션의 입장에서도, 운영체제의 입장에서도 소켓은 파일이다.

OS는 어플리케이션에게 파일 조작을 위한 디스크립터를 제공한다.
그리고 파일 디스크립터와 소켓 디스크립터는 같은 디스크립터 테이블 내에 존재한다.
소켓 생성 시스템 콜은 이 디스크립터 테이블 내의 특정한 인덱스를 반환한다.
그리고 어플리케이션인 해당 인덱스로 소켓API를 사용한다.
그래서 소켓은 파일이 아니지만, 운영체제는 소켓을 특수한 파일로써 취급한다.

HTTP의 수행비서

어플리케이션은 네트워크 통신 시 복수개의 HTTP 메세지를 병렬적으로 송수신한다.
이때, 병렬적인 네트워크 통신을 위해서 여러개의 소켓을 사용한다.
그리고 이러한 많은 양의 소켓은 OS의 입장에서 개별적이다.

HTTP는 어플리케이션 레벨의 프로토콜이다. 따라서 실질적인 전송을 위해 더 하위 레이어가 필요하다.
HTTP 메세징의 일꾼이 꼭 소켓일 필요는 없다. 소켓은 단지 전송 계층에 일을 시키기 위한 창구이기 때문이다.
HTTP는 전송계층으로 메세지를 보내야 할 뿐이고, 이는 소켓을 이용하는 방법이 가장 보편적일 뿐이다.
즉, 전송 계층에 일을 시킬 수 있다면 소켓이 아니더라도 상관 없다.

분류와 구성요소

(알고 계셨나요? TCP/UDP는 소켓보다 먼저 고안되었답니다!)

분류

같은 소켓일지라도 두 분류로 나눌 수 있다.

• 어떤 도메인을 사용하는가
• 어떤 타입인가
  실질적으로 우리가 말하는 소켓의 구분(스트림, 데이터그램 소켓)은 타입으로써의 구분을 이야기한다.

도메인 기준

도메인; 커널 내부에서 주소 체계를 관리하는 단위

• 커널 네트워크 스택에서는 주소 체계(AF_INET, AF_INET6, AF_UNIX, etc) 별로 각기 다른 프로토콜 집합(TCP, UDP, etc) 을 사용한다.
• 이 주소 체계 하나하나를 "도메인(domain)" 이라고 부른다.

도메인 (Domain)	설명
AF_INET	IPv4 인터넷 프로토콜
AF_INET6	IPv6 인터넷 프로토콜
AF_UNIX 또는 AF_LOCAL	로컬 IPC (파일 기반 통신)
AF_PACKET	리눅스 전용. 이더넷 프레임 직접 송수신 (RAW 레벨)
AF_NETLINK	커널과 유저스페이스 간 메시지 통신 (리눅스)
AF_BLUETOOTH	블루투스 통신
AF_CAN	Controller Area Network (자동차)
AF_X25, AF_DECnet, ...	오래된 또는 특수한 네트워크 프로토콜

타입 기준

타입 (Type)	설명
SOCK_STREAM	연결지향 스트림 소켓 (TCP와 매칭됨)
SOCK_DGRAM	비연결형 데이터그램 소켓 (UDP와 매칭됨)
SOCK_RAW	IP 패킷을 직접 다룸 (ICMP, 사용자 지정 프로토콜 등)
SOCK_SEQPACKET	연결지향 + 메시지 경계 보존 (ex. SCTP, UNIX 도메인)
SOCK_RDM	순서 보장 비연결형 소켓 (거의 안 쓰임)

 

소켓 5-튜플; 

• 프로토콜; 소켓 타입
• 로컬 IP 주소
• 로컬 포트 번호
• 원격 IP주소
• 원격 포트 번호

다음은 Darwin XNU(커널)에서 소켓의 구현체와 대략적인 계층 구조 및 생성 시나리오 샘플 코드이다.

// XNU: bsd/sys/socketvar.h
struct socket {
    short       so_type;      // SOCK_STREAM, SOCK_DGRAM 등
    int         so_options;
    short       so_state;
    void       *so_pcb;       // 프로토콜 제어 블록 (e.g., TCP/UDP 상태)
    struct protosw *so_proto; // 사용 중인 프로토콜 함수 테이블
    ...
};

// 소켓이 연결될 원격지 주소
struct sockaddr {
    __uint8_t   sa_len;       // 구조체 길이
    sa_family_t sa_family;    // AF_INET, AF_INET6, AF_UNIX 등
    char        sa_data[14];  // 주소와 포트를 담는 데이터
};
// IPv4인 경우
struct sockaddr_in {
    __uint8_t       sin_len;      // 구조체 길이
    sa_family_t     sin_family;   // AF_INET
    in_port_t       sin_port;     // 포트 번호 (network byte order)
    struct in_addr  sin_addr;     // IPv4 주소
    char            sin_zero[8];  // 패딩
};

User space: 
// sockfd == 디스크립터 테이블 내의 File 구조체의 인덱스
int sockfd = socket(AF_INET, SOCK_STREAM, 0);  ← 소켓 생성 시스템 콜, 
{   // socket를 생성하면...
    // 대략적인 흐름 (XNU 기준)
    // 파일 구조체 생성
    fd = alloc_fd();  // 사용자에게 줄 int sockfd, 파일디스크립터 테이블 내 인덱스
    file = file_alloc();
    file->f_ops = &socketops;
    file->f_data = struct socket * so;
    so = socket_create();  // 실제로 struct socket을 생성
    ──────────────────────────────────────────────
    user: int sockfd (이 값이 3이면)
    ↓
    커널: file descriptor table[3] → struct file
                             ↘︎
                             f_data → struct socket
}

struct sockaddr_in addr = { ... };

connect(sockfd, (struct sockaddr *)&addr, sizeof(addr));

  struct sockaddr_in (IPv4 주소)
       ↓ (캐스팅)
  struct sockaddr     (인터페이스 용도)
       ↓
  bind(), connect(), sendto() 등 시스템 콜 호출
       ↓
──────────────────────────────────────────────
Kernel space:

  struct socket      ←  시스템 콜을 통해 커널에서 생성됨
   └─→ 내부적으로 struct sockaddr를 통해 주소 정보를 다룸
            └─→ struct sockaddr_in (IPv4)
       ↓
  so_pcb → struct inpcb (IPv4 상태 관리)
       ↘︎
     주소 정보는 내부적으로 sockaddr_in을 기반으로 처리

아래는 TCP를 사용하는 스트림 소켓의 생성부터 사용 시나리오의 샘플 코드이다.

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    const char *message = "hello, world";

    // 1. 소켓 생성 (TCP)
    // tcp에 대응하는 Stream 소켓임을 명시
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in my_addr;
    my_addr.sin_family = AF_INET;
    // 원격지로부터 송신받는 데이터의 IP주소를 제한하지 않겠다고 설정
    my_addr.sin_addr.s_addr = INADDR_ANY;
    // 5000번 포트로 도착하는 데이터를 송신받겠다고 설정
    my_addr.sin_port = htons(5000);
    bind(sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr));

    // 2. 서버 주소 설정
    memset(&server_addr, 0, sizeof(server_addr));
    // IPv4를 사용하겠다고 설정
    server_addr.sin_family = AF_INET;
    // 원격지 송신 포트를 12345로 설정
    server_addr.sin_port = htons(12345);  // 서버 포트
    // 원격지 IP주소를 192...100으로 설정
    inet_pton(AF_INET, "192.168.1.100", &server_addr.sin_addr);

    // 3. 서버에 연결
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect");
        close(sockfd);
        exit(1);
    }

    // 4. 데이터 전송
    ssize_t sent = send(sockfd, message, strlen(message), 0);
    if (sent < 0) {
        perror("send");
        close(sockfd);
        exit(1);
    }

    printf("메시지 전송 완료 (%zd bytes)\n", sent);

    close(sockfd);
    return 0;
}

여기까지만 알면 소켓이 무엇인지는 충분히 알았으리라 생각한다.
이제 Swift의 Network 프레임워크 코드가 뭘 하는지 보이는가? 소켓 API와 매우 닮았다.

import Foundation
import Network

let host = NWEndpoint.Host("example.com")  // 연결할 원격지 호스트
let port = NWEndpoint.Port(integerLiteral: 12345) //연결할 원격지 포트
// 수신할 포트와 IP는 자동 지정
let connection = NWConnection(host: host, port: port, using: .tcp)
let queue = DispatchQueue(label: "TCPConnectionQueue")

connection.stateUpdateHandler = { state in
    switch state {
    case .ready:
        print("연결 완료")

        let message = "Hello from main.swift"
        let data = message.data(using: .utf8)!

        connection.send(content: data, completion: .contentProcessed({ sendError in
            if let error = sendError {
                print("전송 실패: \(error)")
                connection.cancel()
                return
            }
            print("전송 완료")

            // 응답 수신 시도
            connection.receive(minimumIncompleteLength: 1, maximumLength: 1024) { receivedData, _, isComplete, receiveError in
                if let data = receivedData, !data.isEmpty {
                    let text = String(decoding: data, as: UTF8.self)
                    print("수신: \(text)")
                } else if let error = receiveError {
                    print("수신 오류: \(error)")
                } else {
                    print("데이터 없음 or 연결 종료")
                }

                connection.cancel()
            }
        }))

    case .failed(let error):
        print("연결 실패: \(error)")
    case .waiting(let error):
        print("연결 대기 중: \(error)")
    case .cancelled:
        print("연결 취소됨")
    default:
        break
    }
}

connection.start(queue: queue)
RunLoop.current.run()

전송계층과의 바인딩

이쯤 되면 눈치 빠른 사람은 어느정도 예상하고 있을 것이다.
소켓은 단지 전송 계층을 추상적으로 사용할 수 있는 API이다.
소켓은 추상적인 타입과, 프로토콜에 따른 내부 구체 타입이 다르며
이미 생성시에 “프로토콜에 맞춰져있는 상태“ 로 태어나며, 적절한 프로토콜의 전송계층과 바인딩된다.
이후 커널은 바인딩된 소켓의 버퍼를 전송계층의 출력 버퍼로 가져오고, 전송계층의 동작에 따라 바인딩된 소켓의 상태를 변경하는 등 소켓은 커널의 전송계층에 의해 좌지우지 된다.
따라서 어떤 의미로 “소켓은 전송계층의 래퍼” 라고 볼 수 있다.

소켓을 생성하면 전송계층과 바인딩되는데, 이는 TCP/UDP 초기화 루틴을 동반한다.
이 초기화 루틴에는 각 연결에 대한 정보(IP/포트 정보, TCP상태)를 저장할 자료구조도 초기화한다.

User space:
    socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)
  ↓ 
──────────────────────────────────────────────
Kernel space:
  도메인 리스트(domains)에서 AF_INET 검색
    ↓
  AF_INET 도메인의 protosw[] 배열 탐색
    ↓
  pr_type == SOCK_STREAM, pr_protocol == IPPROTO_TCP에 해당하는 protosw 선택
    ↓
  struct socket *so 생성
    ↓
  select TCP's protosw
    ↓
  so->so_proto = &tcp_protosw (protosw 포인터 연결)
    ↓
  tcp_protosw.pr_usrreqs->pru_attach() 호출
    ↓
  inpcb 할당 및 초기화 (so->so_pcb = inpcb)
    ↓
  tcpcb 할당 및 초기화 (inpcb->inp_ppcb = tcpcb)

주요 자료구조

struct protosw[]; 프로토콜 스위치 테이블 : 도메인 내 여러 프로토콜 구현을 함수 포인터와 함께 정의한 배열

• 커널 네트워크 스택 내에서 각 프로토콜 구현을 함수 포인터 테이블로 연결해 주는 역할을 함
  • pr_usrreqs에 커널 네트워크 소켓 인터페이스 함수들이 집약됨
    → bind(), connect(), send(), recv() 등 프로토콜별 구현체 연결
• socket() 호출 시 이 배열에서 올바른 프로토콜을 선택하여 소켓에 바인딩하고, 이후 프로토콜 처리 함수 호출의 출발점이 됨

struct protosw {
    short   pr_type;               // 소켓 타입 (SOCK_STREAM, SOCK_DGRAM 등)
    struct  domain *pr_domain;     // 도메인 (AF_INET, AF_UNIX 등)
    short   pr_protocol;           // 프로토콜 번호 (IPPROTO_TCP 등)
    short   pr_flags;              // 동작 플래그
  	void    *pr_ousrreq;           // 소켓 API의 각 요청에 대한 함수 포인터 집합

    // 주요 기능을 수행하는 함수 포인터들
    int   (*pr_input)(...);        // 수신 패킷 처리
    int   (*pr_output)(...);       // 전송 패킷 처리
    void  (*pr_ctlinput)(...);     // 제어 입력 처리 (예: ICMP 에러)
    int   (*pr_ctloutput)(...);    // 소켓 옵션 등 제어 출력 처리
    void  (*pr_init)(void);        // 초기화 함수
    void  (*pr_fasttimo)(void);    // 빠른 타이머 함수 (200ms)
    void  (*pr_slowtimo)(void);    // 느린 타이머 함수 (500ms)
    void  (*pr_drain)(void);       // 메모리 압박 시 drain 처리
    ...
};

struct pr_usrreqs {
    int (*pru_abort)(struct socket *);
    int (*pru_accept)(struct socket *, struct sockaddr **);
    int (*pru_attach)(struct socket *, int, struct thread *);
    int (*pru_bind)(struct socket *, struct sockaddr *, struct thread *);
    int (*pru_connect)(struct socket *, struct sockaddr *, struct thread *);
    int (*pru_disconnect)(struct socket *);
    int (*pru_listen)(struct socket *, struct thread *);
    int (*pru_rcvd)(struct socket *, int);
    int (*pru_send)(struct socket *, int, struct mbuf *,
                    struct sockaddr *, struct mbuf *, struct thread *);
    int (*pru_shutdown)(struct socket *);
    ...
};

struct domain: 주소 체계 집합, AF_INET, AF_INET6, ect...

• 네트워크 주소 체계(Address Family)를 나타내는 커널 내 자료구조
  (예: AF_INET (IPv4), AF_INET6 (IPv6), AF_UNIX (로컬 IPC) 등)
• 주소 체계별 프로토콜들의 그룹화와 관리 단위 이며, 관리 역할을 수행한다.
  • 커널 네트워크 스택은 여러 domain 객체를 리스트로 관리한다.
  • 소켓 생성 시 도메인 번호(dom_family)로 적절한 domain을 찾아낸다.
  • 그 도메인 내의 protosw[] 배열을 통해 프로토콜(TCP, UDP, ICMP 등) 구현을 찾는다.

struct domain {
    int dom_family;                 // 주소 체계 번호 (AF_INET, AF_UNIX 등)
    const char *dom_name;           // 도메인 이름 ("internet", "unix" 등)
    struct protosw *dom_protosw;    // 해당 도메인의 프로토콜 스위치 배열 (ex: TCP, UDP)
    struct protosw *dom_protoswNPROTOSW; // 프로토콜 스위치 배열 끝 포인터
    struct domain *dom_next;        // 커널 내 도메인 리스트에서 다음 도메인 포인터
    ...
};

• struct inpcb (Internet Protocol Control Block)
  • IP 계층 관련 정보 포함
  • 로컬 IP, 원격 IP, 포트 번호 저장
  • 소켓 포인터 역참조 가능
  • TCP, UDP 모두 이 계층에서 기본적으로 사용

struct inpcb {
    struct socket *inp_socket;    // 역참조 가능한 소켓
    struct in_addr inp_laddr;     // 로컬 IP
    struct in_addr inp_faddr;     // 원격 IP
    u_short inp_lport;            // 로컬 포트
    u_short inp_fport;            // 원격 포트
    void *inp_ppcb;               // 프로토콜별 PCB 포인터 (TCP: tcpcb)
    ...
};

• struct tcpcb (TCP Control Block)
  • TCP 연결의 상태를 상세히 관리
  • TCP FSM 상태, 송수신 시퀀스 번호, 타이머 상태 등 포함

struct tcpcb {
    struct inpcb *t_inpcb;    // 상위 inpcb 연결
    int t_state;             // TCP 연결 상태 (SYN_SENT, ESTABLISHED 등)
    u_int32_t snd_una;       // 송신에서 마지막으로 ACK 받은 시퀀스 번호
    u_int32_t snd_nxt;       // 다음 보낼 시퀀스 번호
    u_int32_t rcv_nxt;       // 다음 받을 시퀀스 번호
    ...
};

Let's binding

1. 사용자 호출
   • int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     • AF_INET : IPv4 도메인 선택
     • SOCK_STREAM : 스트림 타입 (TCP)
     • IPPROTO_TCP : TCP 프로토콜 명시
2. 커널 내부 절차 (sys_socket() → socreate())
   • 커널은 domain[] 리스트에서 AF_INET 도메인을 찾음.
   • AF_INET 도메인의 protosw[] 배열을 순회하면서 pr_type == SOCK_STREAM && pr_protocol == IPPROTO_TCP 인 프로토콜 스위치 엔트리를 찾음.
   • 이 엔트리를 선택하여 소켓의 so_proto 필드에 연결.
     • socket->so_proto = protosw_entry
3. 프로토콜 제어 블록(PCB) 생성 및 연결
   • 프로토콜 스위치 구조체(protosw) 안의 pr_usrreqs->pru_attach() 함수 호출 (TCP: tcp_attach()).
   • tcp_attach() 내에서 다음이 수행됨:
     1. struct inpcb 할당 및 초기화
        IP 주소 및 포트 등 네트워크 식별자용 상태 저장
     2. struct tcpcb 할당 및 연결
        TCP 연결 상태(상태 머신, 시퀀스 번호, 윈도우 크기 등) 저
   • struct socket의 so_pcb 포인터가 inpcb를 가리키고 inpcb->inp_ppcb가 tcpcb를 가리키는 형태로 2중 포인터 연결 구조를 형성

생명주기

1. socket()   → struct socket 생성 + proto 연결
2. bind()     → 로컬 주소 할당
3. listen()   → passive open (서버)
4. connect()  → active open (클라, SYN 전송)
5. accept()   → 클라 연결 수락
6. read/write(send/recv)  → mbuf을 통한 입출력
7. shutdown() → TCP FIN/FIN-ACK
8. close()    → 자원 해제, socket free

1. 소켓 생성 (소켓과 전송계층 바인딩)
   • 유저 공간:
     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
   • 커널 내부:
     • socket() 시스템 콜 → sys_socket()
     • socreate() 호출:
       • 주소 패밀리 (e.g., AF_INET)
       • 타입 (e.g., SOCK_STREAM)
       • 프로토콜 (e.g., IPPROTO_TCP)
     • 내부에서 도메인(domain, domain[])과 프로토콜 스위치(protosw[])를 탐색
     • struct socket 객체 생성
     • 관련 프로토콜 제어 블록 (inpcb, tcpcb) 등도 함께 할당
2. 소켓 바인딩 (선택적) (위의 바인딩과는 다름)
   • 유저 공간:
     bind(sockfd, ...);
   • 커널 내부:
     • sys_bind() → sobind() → 프로토콜 레벨의 pr_bind() 호출
       • 예: TCP라면 tcp_usrreq()에서 PRU_BIND 처리
     • inpcb에 로컬 주소(port, IP) 설정
3. 소켓 listen (서버의 경우)
   • 유저 공간:
     listen(sockfd, backlog);
   • 커널 내부:
     • sys_listen() → solisten()
       • 프로토콜의 pr_listen() 처리 (e.g., TCP에서 passive open)
       • so_options에 SO_ACCEPTCONN 설정
     • 백로그 큐 생성
4. 소켓 연결
   • 클라이언트:
     connect(sockfd, ...);
     • 커널에서는 soconnnect() 호출
     • 프로토콜의 pr_connect() (e.g., TCP의 active open → SYN 송신)
     • TCP 3-way handshake 시작
   • 서버:
     accept(sockfd, ...);
     • 커널에서 soaccept(), pr_accept() 호출
     • 새로운 struct socket 생성 (connected socket)
     • 기존 listen socket과 분리된 새로운 연결 소켓 반환
5. 데이터 송수신
   • 유저 공간:
     write(sockfd, buffer, len); // send
read(sockfd, buffer, len); // recv
   • 커널:
     • sosend() / soreceive() 호출
     • TCP: tcp_output() / tcp_input() → mbuf 단위로 so_snd/so_rcv 큐에 붙음
     • 수신된 TCP 세그먼트는 mbuf로 감싸져 소켓 수신 버퍼로 들어옴
6. 소켓 종료 (Shutdown/Close)
   • 유저 공간:
     shutdown(sockfd, SHUT_RDWR); close(sockfd);
   • 커널:
     • shutdown()은 soshutdown()을 통해 PRU_SHUTDOWN 처리 (TCP: FIN 전송)
     • close()는 soclose()를 호출:
       • 연결 종료 처리 (pr_disconnect)
       • 버퍼 비움
       • inpcb, tcpcb, mbuf 등 소켓 리소스 해제

원격지로 데이터 송신

[유저 write()]
    ↓
[sosend()]
    └─> check sbspace()
    └─> mbuf에 데이터 복사
    ↓
[tcp_usr_send()]
    ↓
[tcp_output()]
    └─> TCP 헤더 + 데이터 생성
    ↓
[ip_output()]
    ↓
[if_output() → NIC]
    ↓
[실제 송신]

--- 이후 ---
[ACK 수신]
    ↓
[tcp_ack_received()]
    ↓
[송신 버퍼 sb_cc 줄어듦]
    ↓
[sowwakeup()]

1. 유저 공간에서 write() 호출
   • 소켓의 함수 sosend() → mbuf에 데이터 저장
2. sosend() 호출 → 소켓 버퍼 확인 및 데이터 복사
   • so == struct socket — 소켓 전반 상태
   • buf == struct sockbuf — 송신 버퍼 (so_snd)
   • 내부 처리:
   1. sbspace(&so->so_snd)로 송신 버퍼에 여유 있는지 확인
   2. 여유 없으면:
      • blocking 모드면: sbwait()로 sleep → wakeup 기다림
      • non-blocking 모드면: EWOULDBLOCK 반환
   3. 여유 있으면:
      • 유저의 buf를 mbuf 체인으로 복사
      • 이 mbuf들을 so->so_snd.sb_mb에 연결
3. 프로토콜 처리 함수 호출 (TCP 레이어 진입)
   • sosend()의 마지막 단계에서 이 소켓이 바인딩된 프로토콜의 send 루틴 호출:so -> so_proto -> pr_usrreqs -> pru_send()
     이 함수 포인터는 tcp_usr_send()로 설정되어 있음. 즉:
     write() -> sosend() -> tcp_usr_send()
   • tcp_usr_send()`의 역할:
     • TCP 연결이 정상 상태인지 확인
     • 소켓 송신 버퍼의 mbuf 데이터를 읽음
     • → tcp_output() 호출하여 실질적 송신 수행
   • tcp_usr_send()가 TCP 계층 진입점
     • → 내부적으로 즉시 tcp_output() 호출
     • → TCP는 송신 버퍼를 참조해 세그먼트를 만들고, 보내기 시작함
4. TCP 계층에서 송신 세그먼트 생성 (tcp_output())
   • 여기서 드디어 TCP 헤더가 붙은 세그먼트가 생성됨.
   • 주요 처리:
     1. tcp_output()은 소켓의 so_snd.sb_mb에서 mbuf 데이터 읽음
     2. 세그먼트 크기 계산 (MSS 고려)
     3. 필요한 TCP 헤더 생성 (SEQ 번호 등)
     4. 버퍼로부터 데이터 m_copydata() 등으로 조립
     5. 패킷을 IP 계층에 넘김: ip_output() 호출
5. IP 계층 → 인터페이스 드라이버
   • ip_output()은 라우팅 테이블, MTU 확인, IP 헤더 생성
   • 이후 if_output() 통해 NIC 드라이버로 패킷 전달
   • 드라이버가 DMA 등으로 NIC에 패킷을 넘겨 실제 전송
6. 송신 완료 후 처리
   • 패킷이 전송된다고 해서 바로 버퍼에서 제거되진 않음
   • TCP는 ACK를 받아야 해당 데이터가 송신 완료되었다고 판단
     • -> TCP의 신뢰성 있는 전송 보장, ACK를 전송 완료 로 간주, 소켓 송신 버퍼 flush
   • ACK 수신 시 → tcp_ack_received() → sbfree() 또는 sbflush() 호출
     • → so_snd.sb_cc 감소 → 여유 공간 생김 → sowwakeup() 발생
     • select() 등에서 writable로 감지됨

원격지로부터 데이터 수신

[ Network Driver (NIC) ]
        ↓
[ IP 계층 ] ← (AF_INET 바인딩 기반 demux)
        ↓
[ TCP 계층 ] ← (inpcb lookup (dst ip, port) → tcpcb → 소켓 연결 → 조립)
        ↓
[ Socket 수신 버퍼(so_rcv.sb_mb) ] ← (TCP의 수신 데이터를 mbuf에 담아 버퍼에 append)
        ↓
[ 유저 공간에서 recv() / read() 로 읽음 ]

1. NIC → 커널 진입 (Ethernet 수신)
   • 네트워크 카드(NIC)가 인터럽트를 발생시켜 패킷을 커널로 전달
   • 커널의 드라이버 레벨에서 이더넷 프레임 수신 처리
   • 이더넷 프레임에서 EtherType(0x0800) → IPv4로 식별됨
     `ether_input() → ip_input()``
2. IP 계층 처리
   • ip_input() 함수가 호출되어 IP 헤더를 파싱
   • 목적지 IP, TTL, 체크섬, 프로토콜(TCP=6), 총 길이 등 확인
   • IP 계층은 상위 계층 demux를 위해 inetsw[] 배열을 사용함
   • 이 배열은 각 프로토콜(TCP, UDP 등)에 대한 처리 루틴을 등록한 것
   • TCP인 경우 inetsw[IPPROTO_TCP] → tcp_input() 호출
     ip_input() → inetsw[IPPROTO_TCP].pr_input = tcp_input
3. TCP 계층 처리 (tcp_input())
   • IP 페이로드를 TCP 세그먼트로 해석
     • TCP 헤더 파싱 (SEQ, ACK, 플래그, 체크섬, 윈도우 등)
     • 포트 번호(16비트)를 기반으로 커널 내부의 inpcb(프로토콜 제어 블록) 탐색
   • inpcb 탐색 (TCP 소켓에 바인딩된 상태 확인)
     • IP 주소 + 포트 번호 4쌍으로 매칭되는 inpcb 구조체 찾기
     • inpcb는 결국 tcpcb 구조체와 연결되어 있고, 이는 socket과 연결됨
     • tcp_input() → in_pcblookup_hash() // 목적지 소켓 찾기 → tp = intotcpcb(inpcb) // TCP 상태 구조 얻기
4. TCP 조립 (seq → 바이트 스트림)
   • 세그먼트가 정상적이고 순서에 맞으면 TCP 수신 윈도우에 따라 수용
     • tcp_reass()로 조립 또는 순서대로 도착했으면 즉시 반영
     • sbappend()을 호출해 소켓 수신 버퍼에 붙임 (mbuf 체인)
       tcp_input() → tcp_reass() → sbappend(so, mbuf)
   • mbuf는 실제 데이터가 담긴 커널의 버퍼(+메타데이터) 객체
     • so->so_rcv.sb_mb 필드에 mbuf 체인이 추가됨
     • 버퍼의 크기는 SO_RCVBUF 크기 제한을 초과하지 않도록 조절됨
   • 왜 mbu를 사용하지?
     • 네트워크 데이터는 고정크기의 블록으로 오간다.
     • mbuf는 다음 mbuf를 가리키는 포인터를 갖고 있음
     • 커널이 작은 단위(mbuf)를 체인처럼 연결해서 TCP/IP 패킷 조립/전달에 씀.
5. 유저 공간 통지 (wake up)
   • 소켓이 blocking read 중이었다면 → sorwakeup() 호출되어 프로세스 깨움
     sorwakeup(so);
   • select/poll/epoll/kqueue 등 이벤트 기반 대기 중이었다면 → 해당 이벤트 발생
   • 유저 공간에서 recv(), read() 등 호출 시 soreceive() 진입
6. 유저 공간 수신 ( read()/recv() )
   • soreceive() 호출
   • 내부적으로 mbuf에서 데이터를 꺼내 유저 버퍼로 복사
   • 데이터를 소비하면 mbuf 해제 (m_free())