#include <sys/socket.h>

int getsockopt(int sock,          //用于查看选项套接字描述符
               int level,         //要查看可选项的协议层
               int optname,       //要查看可选项名字
               void *optval,      //保存查看结果的缓冲地址值
               socklen_t *optlen  //指向第四个参数optval传递的缓冲大小的指针
               )
//成功时返回0，失败返回-1

#include <sys/socket.h>

int setsockopt(int sock,          //用于更改可选项套接字描述符
               int level,         //要更改可选项的协议层
               int optname,       //要更改可选项名字
               void *optval,      //要更改可选项的值
               socklen_t optlen   //第四个参数optval传递的可选项信息的字节数
               )
//成功时返回0，失败返回-1

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

//这个头文件里面包含设置TCP协议层保活三个参数的可选项
#include <netinet/tcp.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        int serv_sockfd, clnt_sockfd;
        struct sockaddr_in serv_addr,clnt_addr;

        serv_addr.sin_len = sizeof(struct sockaddr_in);
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(2000);
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

        serv_sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (bind(serv_sockfd, (struct sockaddr*)&serv_addr, serv_addr.sin_len) < 0) return 0;
        if (listen(serv_sockfd, 1) < 0) return 0;

        socklen_t len_t = sizeof(struct sockaddr_in);
        clnt_addr.sin_len = len_t;
        clnt_sockfd = accept(serv_sockfd, (struct sockaddr*)&clnt_addr, &len_t);
        if (clnt_sockfd < 0) return 0;
        close(serv_sockfd);
        printf("有客户端连接 IP:%s Port:%d\n",inet_ntoa(clnt_addr.sin_addr),ntohs(clnt_addr.sin_port));

        //1. 开启keepalive机制
        int keepAlive = 1; // 开启keepalive属性. 缺省值: 0(关闭)
        if (setsockopt(clnt_sockfd, SOL_SOCKET, SO_KEEPALIVE, &keepAlive, sizeof(keepAlive)) == -1)
            printf("开启keepalive机制失败 errorCode:%d descreption:%s\n",errno,strerror(errno));

        //2. 设置保活包检测发送时间间隔（TCP_KEEPIDLE 好像被替换为 TCP_KEEPALIVE）
        int keepIdle = 10; // 如果在60秒内没有任何数据交互,则进行探测. 缺省值:7200(s)
        if (setsockopt(clnt_sockfd, IPPROTO_TCP, TCP_KEEPALIVE, &keepIdle, sizeof(keepIdle)) == -1)
            printf("设置保活包检测发送时间间隔 errorCode:%d descreption:%s\n",errno,strerror(errno));

        //3. 设置保活包发送无响应重发时间间隔
        int keepInterval = 5; // 探测时发探测包的时间间隔为5秒. 缺省值:75(s)
        if (setsockopt(clnt_sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &keepInterval, sizeof(keepInterval)) == -1)
            printf("设置保活包发送无响应重发时间间隔 errorCode:%d descreption:%s\n",errno,strerror(errno));
        //4. 设置保活包发送无响应重发次数
        int keepCount = 3; // 探测重试的次数. 全部超时则认定连接失效..缺省值:9(次)
        if (setsockopt(clnt_sockfd, IPPROTO_TCP, TCP_KEEPCNT, &keepCount, sizeof(keepCount)) == -1)
            printf("设置保活包发送无响应重发次数 errorCode:%d descreption:%s\n",errno,strerror(errno));

        char recv_buffer[512];
        while (1) {
            memset(recv_buffer, 0, 512);
            ssize_t recv_len = recv(clnt_sockfd, recv_buffer, sizeof(recv_buffer), 0);
            if (recv_len == 0) {
                printf("收到数据包长度为0，可能是EOF包 errorCode:%d descreption:%s\n",errno,strerror(errno));
                break;
            }else if (recv_len < 0) {
                printf("读取数据出错 errorCode:%d descreption:%s\n",errno,strerror(errno));
                break;
            }else {
                printf("recv: %s\n",recv_buffer);
                ssize_t sendLen = send(clnt_sockfd, recv_buffer, recv_len, 0);
                if (sendLen < 0) {
                    printf("发送失败 errorCode:%d description:%s\n",errno,strerror(errno));
                }else {
                    printf("send: %s\n",recv_buffer);
                }
            }
        }
        printf("服务器关闭\n");
        close(clnt_sockfd);
    }
    return 0;
}

#include <sys/socket.h>

int enableReuseAddr(int sock)
{
    int optval = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1) {
        return 0;
    }
    return 1;
}

#include <sys/socket.h>

int enableLinger(int sock)
{
    struct linger so_linger;
    so_linger.l_onoff = 1;  //开启(非0) 关闭(0)
    so_linger.l_linger = 5; //滞留时间，设置为大于0时才起作用
    if (setsockopt(sock, SOL_SOCKET, SO_LINGER, &so_linger, sizeof(so_linger)) == -1) {
        return 0;
    }
    return 1;
}

int shutdown(int sock,  //需要断开套接字的文件描述符
             int howto  //传递断开方式信息
             );
//成功时返回0.失败返回-1

howto的可选值分别有如下三种
#define	SHUT_RD		0	断开输入流
#define	SHUT_WR		1	断开输出流
#define	SHUT_RDWR   2	同时断开I/O流

#include <sys/socket.h>

int setRecvTimeout(int sock)
{
    //设置套接字读取数据超时时间为5s
    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;
    if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == -1) {
        return 0;
    }
    return 1;
}

int setSendTimeout(int sock)
{
    //设置套接字发送数据的超时时间为5s
    struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 0;
    if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) == -1) {
        return 0;
    }
    return 1;
}

#include <sys/socket.h>

int getRecvBufferSize(int sock)
{
    int recvSize;
    socklen_t len;
    if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &recvSize, &len) == -1) {
        return 0;
    }else {
        printf("套接字的输入缓冲大小是: %d\n",recvSize);
    }
    return recvSize;
}

int setSendBufferSize(int sock)
{
    int sendSize;
    socklen_t len;
    if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, &sendSize, &len) == -1) {
        return 0;
    }else {
        printf("套接字的输出缓冲大小是: %d\n",sendSize);
    }
    return sendSize;
}

我自己写了一个客户端的TCP套接字，打印了一下看，这个应该以系统为准，系统不一样分配的大小也不一样！

套接字的输入缓冲大小是: 408300
套接字的输出缓冲大小是: 146988

#include <sys/socket.h>

int setRcvBufferLowerLimit(int sock)
{
    //设置套接字接收下限为10个字节
    int opval = 10;
    if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &opval, sizeof(opval)) == -1) {
        return 0;
    }
    return 1;
}

int setSendBufferLowerLimit(int sock)
{
    //设置套接字发送缓冲区的下限为10个字节
    int opval = 10;
    if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &opval, sizeof(opval)) == -1) {
        return 0;
    }
    return 1;
}

#include <sys/socket.h>

int getSocketType(int sock)
{
    int opval;
    socklen_t opvalLen;
    if (getsockopt(sock, SOL_SOCKET, SO_TYPE, &opval, &opvalLen) == -1) {
        return 0;
    }else {
        if (opval == SOCK_DGRAM) {
            printf("UDP套接字\n");
        }else if (opval == SOCK_STREAM) {
            printf("TCP套接字\n");
        }else {
            printf("套接字类型为: %d\n",opval);
        }
    }
    return opval;
}

int enableNagel(int sock)
{
    //禁用Nagle算法
    int opval = 1;
    if (setsockopt(sock, SOL_SOCKET, TCP_NODELAY, &opval, sizeof(opval)) == -1) {
        return 0;
    }
    return 1;
}