《TCP/IP网络编程》第9章 套接字的多种可选项

套接字可选项

协议层	选项名	读取	设置
SOL_SOCKET	SO_SNDBUF	O	O
	SO_RCVBUF	O	O
	SO_REUSEADDR	O	O
	SO_KEEPALIVE	O	O
	SO_BROADCAST	O	O
	SO_DONTROUTE	O	O
	SO_OOBINLINE	O	O
	SO_ERROR	O	X
	SO_TYPE	O	X
IPPROTO_IP	IP_TOS	O	O
	IP_TTL	O	O
	IP_MULTICAST_TTL	O	O
	IP_MULTICAST_LOOP	O	O
	IP_MULTICAST_IF	O	O
IPPROTO_TCP	TCP_KEEPALIVE	O	O
	TCP_NODELAY	O	O
	TCP_MAXSEG	O	O

#include <sys/socket.h>
//成功0，失败-1
int getsockopt(int sock, int level, int optname, void *optval, socklen_t *optlen);
//成功0，失败-1
int setsockopt(int sock, int level, int optname, const void *optval, socklen_t *optlen);

//sock，套接字描述符
//level，可选项协议层
//optname，可选项名
//optval，结果缓冲地址
//optlen，optval字节数

SO_TYPE

套接字类型，创建时决定，只能读取，不能修改。

09.sock_type_linux.c

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

void error_handling(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    int tcp_sock = socket(PF_INET, SOCK_STREAM, 0);
    int udp_sock = socket(PF_INET, SOCK_DGRAM, 0);
    printf("SOCK_STREAM: %d\n", SOCK_STREAM);
    printf("SOCK_DGRAM: %d\n", SOCK_DGRAM);

    int sock_type;
    socklen_t optLen = sizeof(sock_type);
    int state = getsockopt(tcp_sock, SOL_SOCKET, SO_TYPE, (void *)&sock_type, &optLen);
    if (state)
        error_handling("getsockopt() error");
    printf("Socket type one: %d\n", sock_type);

    state = getsockopt(udp_sock, SOL_SOCKET, SO_TYPE, (void *)&sock_type, &optLen);
    if (state)
        error_handling("getsockopt() error");
    printf("Socket type two: %d\n", sock_type);

    close(udp_sock);
    close(tcp_sock);

    return 0;
}

// gcc 09.sock_type_linux.c -o 09.sock_type_linux && ./09.sock_type_linux

SO_REVBUF & SO_SNDBUF

SO_REVBUF，输入缓冲大小；
SO_SNDBUF，输出缓冲大小。

09.get_buf_linux.c

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

void error_handling(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    int sock = socket(PF_INET, SOCK_STREAM, 0);

    int snd_buf;
    socklen_t len = sizeof(snd_buf);
    // 输出缓冲大小
    int state = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, &len);
    if (state)
        error_handling("getsockopt() error");

    int rcv_buf;
    // 输入缓冲大小
    state = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, &len);
    if (state)
        error_handling("getsockopt() error");

    close(sock);

    printf("Input buffer size: %d\n", rcv_buf);
    printf("Output buffer size: %d\n", snd_buf);

    return 0;
}

// gcc 09.get_buf_linux.c -o 09.get_buf_linux && ./09.get_buf_linux

09.set_buf_linux.c

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

void error_handling(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    int sock = socket(PF_INET, SOCK_STREAM, 0);

    int snd_buf = 1024 * 3;
    int state = setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, sizeof(snd_buf));
    if (state)
        error_handling("setsockopt() error");

    int rcv_buf = 104 * 3;
    state = setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, sizeof(rcv_buf));
    if (state)
        error_handling("setsockopt() error");

    socklen_t len = sizeof(snd_buf);

    // 输出缓冲大小
    state = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, &len);
    if (state)
        error_handling("getsockopt() error");
    printf("Output buffer size: %d\n", snd_buf);

    // 输入缓冲大小
    state = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, &len);
    if (state)
        error_handling("getsockopt() error");
    printf("Input buffer size: %d\n", rcv_buf);

    close(sock);

    return 0;
}

// gcc 09.set_buf_linux.c -o 09.set_buf_linux && ./09.set_buf_linux

SO_REUSEADDR

Ctrl+C，强制终止程序时，操作系统会关闭文件及套接字（close），会向对端传递FIN消息。

只有先断开连接（先发送FIN消息）的主机才会经历Time-wait状态（套接字延迟释放，确保对方收到最后的ACK消息），此时相应端口是正在使用状态（几分钟），再次使用同一端口会出现“bind() error”。

客户端先断开连接（先发送FIN消息），套接字也会有Time-wait状态，但客户端每次运行程序时会动态分配端口号，无需过多关注Time-wait状态。

09.reuseaddr_eserver_linux.c

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

#define PORT 9999
#define BUF_SIZE 30
#define TRUE 1
#define FALSE 0

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    int serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1)
        error_handling("socket() error");

    int option = TRUE;
    setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void *)&option, sizeof(option));

    socklen_t addr_size = sizeof(struct sockaddr_in);

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, addr_size);
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(PORT);

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, addr_size) == -1)
        error_handling("bind() error");

    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    for (int i = 0; i < 5; i++)
    {
        struct sockaddr_in clnt_addr;
        int clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &addr_size);
        if (clnt_sock == -1)
            error_handling("accept() error");
        else
            printf("Connected client %d\n", i + 1);

        int str_len;
        char message[BUF_SIZE];
        while ((str_len = read(clnt_sock, message, BUF_SIZE)) != 0)
            write(clnt_sock, message, str_len);

        close(clnt_sock);
    }

    close(serv_sock);

    return 0;
}

// gcc 09.reuseaddr_eserver_linux.c -o 09.reuseaddr_eserver_linux && ./09.reuseaddr_eserver_linux

TCP_NODELAY

• TCP套接字默认使用Nagle算法交换数据，最大限度地进行缓冲，直到收到ACK，防止数据包过多发生网络过载（影响传输），提高网络传输效率。（尽可能少地串行发送数据包）

• “大文件数据”应禁用Nagle算法，可以提高传输速度，类似于并行传输，不用等上一个数据包收到ACK后再发送下一个数据包，可以同时发送多个数据包。（尽可能多地并行发送数据包），可能数据包过多发生网络过载且少量数据包其头信息可能几十个字节。

//禁用Nagle算法
int opt_val=1;
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void *)&opt_val, sizeof(opt_val));

int opt_val;
socklen_t opt_len=sizeof(opt_val);
getsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void *)&opt_val, &opt_val);

Windows实现

#include <winsock2.h>
//成功0，失败SOCKET_ERROR
int getsockopt(SOCKET sock, int level, int optname, char *optval, int *optlen);
//成功0，失败-1
int setsockopt(SOCKET sock, int level, int optname, const char *optval, int optlen);

//sock，套接字描述符
//level，可选项协议层
//optname，可选项名
//optval，结果缓冲地址
//optlen，optval字节数

09.buf_win.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

void ErrorHanding(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

void ShowSocketBufSize(SOCKET sock)
{
    int snd_buf;
    int len = sizeof(snd_buf);
    int state = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&snd_buf, &len);
    if (state == SOCKET_ERROR)
        ErrorHanding("getsockopt() error");
    printf("Output buffer size: %d\n", snd_buf);

    int rcv_buf;
    len = sizeof(rcv_buf);
    state = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&rcv_buf, &len);
    if (state == SOCKET_ERROR)
        ErrorHanding("getsockopt() error");
    printf("Input buffer size: %d\n", rcv_buf);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    SOCKET sock = socket(PF_INET, SOCK_STREAM, 0);

    ShowSocketBufSize(sock);

    int snd_buf = 1024 * 3;
    int state = setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&snd_buf, sizeof(snd_buf));
    if (state == SOCKET_ERROR)
        ErrorHanding("setsockopt() error");

    int rcv_buf = 104 * 3;
    state = setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&rcv_buf, sizeof(rcv_buf));
    if (state == SOCKET_ERROR)
        ErrorHanding("setsockopt() error");

    ShorSocketBufSize(sock);

    closesocket(sock);

    WSACleanup();

    return 0;
}

// gcc 09.buf_win.c -o 09.buf_win -lws2_32 && 09.buf_win