套接字的多种可选项

最新推荐文章于 2024-06-11 15:20:16 发布

ieeieii

最新推荐文章于 2024-06-11 15:20:16 发布

阅读量109

点赞数

分类专栏：网络编程文章标签：网络 tcp/ip 网络协议 c++ linux

本文链接：https://blog.csdn.net/weixin_45684629/article/details/127777894

版权

网络编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

我们在创建套接字的时候，是可以对套接字进行一些属性设置的，以满足在开发中遇到的不同的需求。本文介绍一些与套接字属性相关的函数的使用。

getsockopt

通过此函数我们可以获取套接字可选项。

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

sock：套接字文件描述符
level：要查看的可选项的协议层

可选项如下表所示：

协议层	选项名
SOL_SOCKET	SO_SNDBUF
套接字相关通用可选项	SO_RCVBUF
	SO_REUSEADDR
	SO_KEEPALIVE
	SO_BROADCAST
	SO_DONTROUTE
	SO_OOBINLINE
	SO_ERROR
	SO_TYPE
IPPROTO_IP	IP_TOS
IP层套接字相关属性	IP_TTL
	IP_MULTICAST_TTL
	IP_MULTICAST_LOOP
	IP_MULTICAST_IF
IPPROTO_TCP	TCP_KEEPALIVE
TCP层套接字相关属性	TCP_NODELAY
	TCP_MAXSEG

optname：要查看的可选项名，即上表的右边
optva：保存查看结果的缓冲地址值
optlen：optval保存的可选项信息的字节数

实例

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

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

int main(int argc, char *argv[])
{
    int tcp_sock, udp_sock;
    int sock_type;
    socklen_t optlen;
    int state;

    optlen = sizeof(sock_type);
    tcp_sock = socket(AF_INET, SOCK_STREAM, 0);
    udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
    printf("SOCK_STREAM: %d \n", SOCK_STREAM);
    printf("SOCK_DGRAM: %d \n", SOCK_DGRAM);

    // 获取TCP套接字选项值
    state = getsockopt(tcp_sock, SOL_SOCKET, SO_TYPE, (void*)&sock_type, &optlen);
    if(state) error_handing("getsockopt error");
    printf("tcp_socket type: %d \n", sock_type);

    // 获取UDP套接字选项值
    state = getsockopt(udp_sock, SOL_SOCKET, SO_TYPE, (void*)&sock_type, &optlen);
    if(state) error_handing("getsockopt error");
    printf("udp_socket type: %d \n", sock_type);

    return 0;
}

输出结果如下：
请添加图片描述
可以看到，直接输出SOCK_STREAM的属性值为1，SOCK_DGRAM的属性值为2，然后我们分别将这两个属性设置到套接字中，通过getsockopt获取套接字的属性，与这两个属性的值是一致的。

SOCK_SNDBUF、SOCK_RCVBUF

SOCK_SNDBUF是关于输入缓冲区大小的可选项，SOCK_RCVBUF是关于输出缓冲区大小的可选项。

实例

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

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

int main(int argc, char *argv[])
{
    int sock;
    int snd_buf, rcv_buf;
    int state;
    socklen_t len;
    
    sock = socket(AF_INET, SOCK_STREAM, 0);

    // 获取套接字输出缓冲区大小
    len = sizeof(snd_buf);
    state = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void*)&snd_buf, &len);
    if(state) error_handing("getsockopt error");

    // 获取套接字输入缓冲区大小
    len = sizeof(rcv_buf);
    state = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void*)&rcv_buf, &len);
    if(state) error_handing("getsockopt error");

    printf("输入缓冲区大小: %d \n", rcv_buf);
    printf("输出缓冲区大小: %d \n", snd_buf);
    
    snd_buf = 1024 * 3;
    rcv_buf = 1024 * 3;

    // 设置输入缓冲区大小
    state = setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&rcv_buf, sizeof(rcv_buf));
    if(state) error_handing("setsockopt error");

    // 设置输出缓冲区大小
    state = setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&snd_buf, sizeof(snd_buf));
    if(state) error_handing("setsockopt error");

    // 获取套接字输出缓冲区大小
    len = sizeof(snd_buf);
    state = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void*)&snd_buf, &len);
    if(state) error_handing("getsockopt error");

    // 获取套接字输入缓冲区大小
    len = sizeof(snd_buf);
    state = getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void*)&rcv_buf, &len);
    if(state) error_handing("getsockopt error");

    printf("输入缓冲区大小: %d \n", rcv_buf);
    printf("输出缓冲区大小: %d \n", snd_buf);

    return 0;
}

输出结果：
请添加图片描述
可以看出在我们设置输入输出缓冲区大小之前的大小，然后我们通过setsockopt设置了输入输出缓冲区的大小，明显发生了改变。但是与我们设置的3M字节大小的缓冲区的要求明显不符，这是因为我们只是将我们要设置的输入输出缓冲区大小告诉系统，但系统不会完全按照我们的要求来进行设置。总是，从这个实例我们可以通过getsockopt、setsockopt、SO_SNDBUF、SO_RCVBUF来获取和设置套接字输入输出缓冲区的大小。

SO_REUSEADDR

一般来说，服务器与客户端会经过三次握手建立连接，断开的时候也会经过四次挥手，服务器端请求断开会向客户端发送FIN消息，客户端回复ACK，然后再发送一个FIN，服务器再回复一个ACK,然后就会进入一个Time-wait状态，当我们立即重启服务器的时候，在调用bind函数的时候就会发生错误，需要等待一段时间才可以正常重启服务器。

对于这种情况，我们通过设置SO_REUSEADDR可选项，就可以立即正常调用bind函数，重启服务器。SO_REUSEADDR的默认值为0(假)，我们将其设置为1(真)就可以达成这个目的。

实例

reuseaddr_serv.c

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

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

int main(int argc, char *argv[])
{
    int serv_sock,clnt_sock;
    char message[30];
    int option, str_len;
    socklen_t optlen, clnt_addr_sz;
    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;
    
    serv_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(serv_sock == -1) error_handing("socket error");

    /*
    optlen = sizeof(option);
    option = 1;
    setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void *)&option, optlen);
    */

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1) error_handing("bind() error");
    if(listen(serv_sock, 5) == -1) error_handing("listen() error");

    clnt_addr_sz = sizeof(clnt_addr);
    clnt_sock = accept(serv_sock, (struct sockaddr*) &clnt_addr, &clnt_addr_sz);
    if(clnt_sock == -1) error_handing("accept() error");

    while((str_len = read(clnt_sock, message, sizeof(message))) != 0)
    {
        write(clnt_sock, message, str_len);
        write(1, message, str_len);
    }
    close(clnt_sock);
    close(serv_sock);
    return 0;
}

reuseaddr_clnt.c

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

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

int main(int argc, char* argv[]){
    int sock;
    struct sockaddr_in serv_addr;
    char message[] = "hello world!";
    int str_len;

    if(argc != 3){
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }
	// 创建面向连接的套接字
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1) error_handing("socket() error");
    
	// 初始化网络通信地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

    if(connect(sock,(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
		error_handing("connect() error");
	}
    str_len = read(sock, message, sizeof(message) - 1);
    if(str_len == -1) error_handing("connect() error");

    printf("Message from server: %s \n", message);
    close(sock);
    return 0;
}

我们将服务器与客户端进行连接，然后ctrl+ C强制中断服务器，并重启，就会在调用bind函数时发生错误：
请添加图片描述
然后我们将服务器设置SO_REUSEADDR部分的注释标记去掉重新运行：

当强制中断后立即重新运行服务器程序，我们发现不再会发生错误。

Nagle算法与TCP_NODELAY

Nagle算法是为了防止数据包过多从而发生网络过载设计的，应用于TCP层。在不使用Nagle算法，TCP发送数据包的时候，只要向发送缓冲区中写入数据，发送缓冲区就会将消息发送出去，比如发送Hello，就会往外发送五个数据包，'H'、'e'、'l'、'l'、'o'，而使用Nagle算法以后，TCP只有在收到上次消息的时确认报文才会发送下一条消息，在等待的这段时间，会持续的将要发送的消息写入发送缓冲区。首先写入H,然后将其发送出去(因为H之前没有其他消息发送出去，没有要等待的ACK)，进入等待ACK的状态，在这个状态过程中，持续的将wllo写入发送缓冲区，在收到ACK报文后，将ello发送出去，这样就将之前的五个报文，变成了'H'、'ello'两个报文，大大缩减了报文数量，降低了网络负载。
Nagle算法在TCP是默认开启的，如果要禁用的话，在Ubuntu中需要调用一下netinet/tcp/h，具体如下：

#include <netinet/tcp.h>
int opt_val = 1;
setsockopt(serv_sock, IPPROTO_TCP, TCP_NODELAY, (void *)&opt_val, sizeof(opt_val));

ieeieii

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
套接字的多种可选项

套接字的可选项
复制链接

扫一扫

专栏目录