[C/C++] Socket Send/Receive Buffer에 대한 고찰

목차

---

• Socket Buffer? (Send Socket Buffer / Receive Socket Buffer)
• Socket Buffer 사이즈 변경, 사이즈 확인, 버퍼 데이터 확인
• Socket Buffer 동작 테스트

 

Socket Buffer? (Send Socket Buffer / Receive Socket Buffer)

---

[그림 1] 데이터 전송 시 TCP/IP 네트워크 스택의 각 레이어 별 동작 과정

위의 그림과 같이 TCP 통신에서 Application이 메시지를 write를 한다고 바로 메세지가 전송되는 것이 아니다.

소켓 버퍼(Send socket buffer)라는 버퍼에 쌓인 후 적절한 시기에 상대방에게 메시지가 전송되고 버퍼가 지워진다.

 

[그림 2] 데이터 수신 시 TCP/IP 네트워크 스택의 각 레이어 별 동작 과정

받는 쪽에서도 마찬가지로 메시지가 오면 일단, 소켓 버퍼(Receive socket buffer)에 저장 된 후 Application에서 read함수 호출을 통해 소켓 버퍼에 쌓인 메시지를 읽어 들인다.

그렇다면 메시지를 보낼 때 Send Socket Buffer가 꽉 찬 상태라면 어떻게 될까?

 

[그림 3] linux man 페이지 (https://linux.die.net/man/2/send)

 

리눅스 기준으로, 소켓이 Blocking 모드라면 Send Socket buffer가 비워질 때까지 Block 되고, NonBlocking 모드라면 EAGAIN 혹은 EWOULDBLOCK이라는 에러를 리턴한다.

https://linux.die.net/man/2/send

 

Socket Buffer 사이즈 변경, 사이즈 확인, 버퍼 데이터 확인

---

 Socket Buffer의 기본 사이즈는 리눅스 기준으로 다음과 같이 잡혀있다.

/proc/sys/net/core/wmem_max // send buffer
/proc/sys/net/core/rmem_max // receive buffer

위와 같은 파일을 수정함으로써 Socket Buffer의 사이즈를 변경할 수 있다.

 

프로그래밍상에서 각 소켓마다 Sockte Buffer 사이즈를 변경하고 확인하고 싶으면 아래 함수를 사용하면 된다.

#include <sys/types.h>
#include <sys/socket.h>
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

 

간단한 예제를 보자.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>

int main() {
    int serverSocket;
    struct sockaddr_in serverAddr;

    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(serverSocket == -1)
    {
        exit(1);
    }

    int bufSize = 1024 * 4;
    socklen_t len = sizeof(bufSize);
    setsockopt(serverSocket, SOL_SOCKET, SO_SNDBUF, &bufSize, sizeof(bufSize));
    getsockopt(serverSocket, SOL_SOCKET, SO_SNDBUF, &bufSize, &len);
    printf("socket buffer size: %d\n", bufSize);
    
    close(serverSocket);
    return 0;
}

socket buffer size: 8192

분명히 1024 * 4 = 4,096이라는 크기로 Socket Buffer 사이즈를 설정했는데 8,192라는 값이 나왔다.

그 이유는 다음과 같다.

 

[그림 4] linux man 페이지 (https://linux.die.net/man/7/tcp) 

해석하자면, 우리가 사이즈를 명시해준 대로 그대로 설정되는 게 아니다.

커널 내부에서 값을 2배 시켜주거나 적당한 값으로 설정해준다고 한다.

 

 Socket Buffer에 데이터를 write를 했을 때 Buffer에 데이터가 얼마나 있는지 확인은 어떤 방식으로 할까?

#include <sys/ioctl.h>
int ioctl(int d, int request, ...);

위와 같은 함수로 적절한 인자 값을 주어서 데이터를 확인한다. 두 말 필요 없이 간단한 예를 보자!

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/sockios.h>

int main() {
    int serverSocket;
    struct sockaddr_in serverAddr;

    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(serverSocket == -1)
    {
        exit(1);
    }
    int remainSize;
    ioctl(serverSocket, SIOCOUTQ, &remainSize);
    printf("remain data size: %d\n", remainSize);

    close(serverSocket);

    return 0;
}

remain data size: 0

 

Socket Buffer 동작 테스트

---

 마지막으로 Socket Buffer가 제대로 동작 하나 서버 - 클라이언트 기반으로 아래와 같이 테스트해봤다.

1. 서버 소켓을 생성한 뒤 bind - listen - accept 과정을 거쳐 클라이언트의 접속을 받음.

2. 접속된 클라이언트 소켓의 send socket buffer 사이즈를 변경

3. send socket buffer 사이즈보다 큰 메시지를 만들어 클라이언트 소켓으로 write

4. 3을 Blocking 모드와 NonBlocking모드로 수행

 

[서버 코드]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/sockios.h>

void errorHandling(char *message);

int main() {
    int serverSocket;
    int clientSocket;

    struct sockaddr_in serverAddr;
    struct sockaddr_in clientAddr;
    socklen_t clientAddrSize;

    printf("server start\n");

    serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if(serverSocket == -1)
    {
        errorHandling("socket() error");
    }

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(32452);

    if(bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1)
    {
        errorHandling("bind() error");
    }
    printf("bind ok\n");

    if(listen(serverSocket, 5) == -1)
    {
        errorHandling("listen() error");
    }
    printf("listen ok\n");

    clientAddrSize = sizeof(clientAddr);
    clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrSize);
    if(clientSocket == -1)
    {
        errorHandling("accept() error!");
    }
    printf("accept ok %s \n", inet_ntoa(clientAddr.sin_addr));

    int bufSize = 1024 * 4;
    socklen_t len = sizeof(bufSize);
    setsockopt(clientSocket, SOL_SOCKET, SO_SNDBUF, &bufSize, sizeof(bufSize));
    getsockopt(clientSocket, SOL_SOCKET, SO_SNDBUF, &bufSize, &len);
    printf("socket buffer size: %d\n", bufSize);

    // NonBlocking 모드로 테스트 할 경우 아래 주석 해제
//    int flag = fcntl(clientSocket, F_GETFL, 0);
//    fcntl(clientSocket, F_SETFL, flag | O_NONBLOCK);

    char message[bufSize * 2];
    for(int i = 0; i < 10; i ++)
    {
        ssize_t nBytes = send(clientSocket, message, sizeof(message), 0);
        if(nBytes == -1)
        {
            errorHandling("write error");
        }
        int remainSize;
        if (ioctl(clientSocket, SIOCOUTQ, &remainSize) == -1)
        {
            errorHandling("ioctl error");
        }
        printf("write message:%zd, remain buf size: %d\n", nBytes, remainSize);
    }

    close(clientSocket);
    close(serverSocket);

    return 0;
}

void errorHandling(char *message)
{
    printf("%s: %s\n", message, strerror(errno));
    exit(1);
}

간략하게 설명하자면, Socket Buffer Size를 4,096로 주고

한 번에 Socket Buffer Size의 2배 되는 크기의 메시지를 10회 보내는 코드다.

 

클라이언트 코드는 편의상 golang으로 짰다... (갑분고)

[클라이언트 코드]

package main

import (
	"net"
)

func main() {
	println("start")
	addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:32452")
	if err != nil {
		println(err.Error())
		return
	}
	ClientSideCode(addr)
}

func ClientSideCode(addr *net.TCPAddr) {
	conn, err := net.DialTCP("tcp", nil, addr)
	if err != nil {
		println(err.Error())
		return
	}
	println("connect")
	defer conn.Close()
	if err != nil {
		println(err.Error())
	}
	recvBuff := make([]byte, 1024)
	i := 0
	for {
		nBytes, err := conn.Read(recvBuff)
		if err != nil {
			println(err.Error())
			break
		}
		if nBytes == 0 {
			break
		}
		println("nBytes:", nBytes, i)
		i++
	}


	println("Client Exit..")
}

클라이언트 코드는 서버 쪽에 연결하고 Receive만 하는 코드다.

 

예상되는 결과는 당연히 Socket Buffer Size보다 큰 메시지를 보냈으니

Blocking 모드라면 무한 Blocking, NonBlocking모드라면 바로 에러 리턴이라는 결과를 예상했으나

실제 결과는 좀 달랐다.

 

[Blocking 모드 결과]

server start
bind ok
listen ok
accept ok 10.0.2.2
socket buffer size: 8192
write message:16384, remain buf size: 16384

 

[NonBlocking 모드 결과]

server start
bind ok
listen ok
accept ok 10.0.2.2
socket buffer size: 8192
write message:16384, remain buf size: 16384
write message:15736, remain buf size: 32120
write error: Resource temporarily unavailable

 

Blocking 모드와 NonBlocking 모드 둘 다 예상대로 각각 무한 Blocking, 에러 리턴을 하지만 버퍼의 사이즈가 좀 이상했다.

분명히 8,192(4,096 * 2)라는 버퍼 사이즈를 설정 및 확인했는데 그 이상(16,384)까지 버퍼에 데이터가 쌓이다니...

무수한 삽질 결과 다음과 같은 결론을 내리기로 했다.

[그림 5] 스택 오버 플로우 (https://stackoverflow.com/questions/8114280/effect-of-so-sndbuf)

우리가 Socket Buffer 사이즈를 명시하여 지정하였고,

getsockopt 함수를 통해 커널단에서 Socket Buffer 사이즈를 어떻게 지정했는지 받아와도 그것은 정확한 값이 아니다.

실제 커널 내부적으로는 getsockopt로 반환된 값보다 더 넉넉하게 잡아서 버퍼 사이즈를 사용하고 있다.

 

참고

---

linux man 페이지
https://linux.die.net/man/2/send
https://linux.die.net/man/7/tcp

TCP/IP 네트워크 스택 이해하기 - 김형엽 님
https://d2.naver.com/helloworld/47667

스택 오버 플로우
https://stackoverflow.com/questions/8114280/effect-of-so-sndbuf