unp&chapter7 套接字选项

// 设置套接字选项
int setsockopt(int sockfd, int level, int optname,
               const void *optval, socklen_t optlen);

// 获取套接字选项
int getsockopt(int sockfd, int level, int optname,
               void *optval, socklen_t *optlen);

#include "unp.h"

union val {
    int				    i_val;
    long				l_val;
    struct linger		linger_val;
    struct timeval	    timeval_val;
} val;

struct sock_opts {
    const char *opt_str;
    int opt_level;
    int opt_name;
    char *(*opt_val_str)(union val*, int);
};

static char	*sock_str_flag(union val *, int);
static char	*sock_str_int(union val *, int);
static char	*sock_str_linger(union val *, int);
static char	*sock_str_timeval(union val *, int);

static struct sock_opts sockOpts[] = {
{ "SO_BROADCAST",		SOL_SOCKET,	SO_BROADCAST,	sock_str_flag },
{ "SO_DEBUG",			SOL_SOCKET,	SO_DEBUG,		sock_str_flag },
{ "SO_DONTROUTE",		SOL_SOCKET,	SO_DONTROUTE,	sock_str_flag },
{ "SO_ERROR",			SOL_SOCKET,	SO_ERROR,		sock_str_int },
{ "SO_KEEPALIVE",		SOL_SOCKET,	SO_KEEPALIVE,	sock_str_flag },
{ "SO_LINGER",			SOL_SOCKET,	SO_LINGER,		sock_str_linger },
{ "SO_OOBINLINE",		SOL_SOCKET,	SO_OOBINLINE,	sock_str_flag },
{ "SO_RCVBUF",			SOL_SOCKET,	SO_RCVBUF,		sock_str_int },
{ "SO_SNDBUF",			SOL_SOCKET,	SO_SNDBUF,		sock_str_int },
{ "SO_RCVLOWAT",		SOL_SOCKET,	SO_RCVLOWAT,	sock_str_int },
{ "SO_SNDLOWAT",		SOL_SOCKET,	SO_SNDLOWAT,	sock_str_int },
{ "SO_RCVTIMEO",		SOL_SOCKET,	SO_RCVTIMEO,	sock_str_timeval },
{ "SO_SNDTIMEO",		SOL_SOCKET,	SO_SNDTIMEO,	sock_str_timeval },
{ "SO_REUSEADDR",		SOL_SOCKET,	SO_REUSEADDR,	sock_str_flag }
};

int main(int argc, char **argv) {
    int fd;
    socklen_t len;
    struct sock_opts *ptr;

    for (ptr = sockOpts; ptr->opt_str != NULL; ++ptr) {
        printf("%s: \n", ptr->opt_str);
        if (ptr->opt_val_str == NULL)
            printf("undefined\n");
        else {
            switch (ptr->opt_level) {
                case SOL_SOCKET:
                case IPPROTO_IP:
                case IPPROTO_TCP:
                    fd = Socket(AF_INET, SOCK_STREAM, 0);
                    break;
                case IPPROTO_SCTP:
                    fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
                default:
                    err_quit("Can't create fd for level %d\n", ptr->opt_level);
            }

            len = sizeof(val);
            if (getsockopt(fd, ptr->opt_level, ptr->opt_name, &val, &len) == -1) {
                err_ret("get sockopt error\n");
            } else {
                printf("default = %s \n", (*ptr->opt_val_str)(&val, len));
            }

            close(fd);
        }
    }
    exit(0);
}

static char	strres[128];

static char	*
sock_str_flag(union val *ptr, int len)
{
    if (len != sizeof(int))
        snprintf(strres, sizeof(strres), "size (%d) not sizeof(int)", len);
    else
        snprintf(strres, sizeof(strres),
                 "%s", (ptr->i_val == 0) ? "off" : "on");
    return(strres);
}

static char	*
sock_str_int(union val *ptr, int len)
{
    if (len != sizeof(int))
        snprintf(strres, sizeof(strres), "size (%d) not sizeof(int)", len);
    else
        snprintf(strres, sizeof(strres), "%d", ptr->i_val);
    return(strres);
}

static char	*
sock_str_linger(union val *ptr, int len)
{
    struct linger	*lptr = &ptr->linger_val;

    if (len != sizeof(struct linger))
        snprintf(strres, sizeof(strres),
                 "size (%d) not sizeof(struct linger)", len);
    else
        snprintf(strres, sizeof(strres), "l_onoff = %d, l_linger = %d",
                 lptr->l_onoff, lptr->l_linger);
    return(strres);
}

static char	*
sock_str_timeval(union val *ptr, int len)
{
    struct timeval	*tvptr = &ptr->timeval_val;

    if (len != sizeof(struct timeval))
        snprintf(strres, sizeof(strres),
                 "size (%d) not sizeof(struct timeval)", len);
    else
        snprintf(strres, sizeof(strres), "%ld sec, %ld usec",
                 tvptr->tv_sec, tvptr->tv_usec);
    return(strres);
}

// linux 系统tcp 保活机制
root>sysctl -a | grep tcp_keepalive
net.ipv4.tcp_keepalive_intvl = 75
net.ipv4.tcp_keepalive_probes = 9
net.ipv4.tcp_keepalive_time = 7200

// socket fd 配置保活机制
    /* 打开 TCP keepalive 功能 */
    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
                   &yes, sizeof(yes)) < 0) {
        perror("setsockopt SO_KEEPALIVE");
        return 1;
    }

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct linger ling;

    /*
     1) 默认行为（不设置 SO_LINGER）or l_onoff = 0（默认行为）
        - close() 立即返回
        - 内核后台继续发送缓冲区数据
        - 正常 FIN 关闭
        - 内核会等发送缓冲区的数据发完，再发 FIN。
    */
    // close(sockfd);

    /*
    2) l_onoff = 1, l_linger = 0
        - close() 立即返回
        - 丢弃发送缓冲区数据
        - 直接发送 RST 强制关闭连接
    */
    ling.l_onoff  = 1;
    ling.l_linger = 0;
    setsockopt(sockfd, SOL_SOCKET, SO_LINGER,
            &ling, sizeof(ling));
    // close(sockfd);

    /*
    3) l_onoff = 1, l_linger > 0
        - close() 阻塞最多 l_linger 秒
        - 等待数据发送并收到对端 ACK
        - 发送 FIN 并收到对端 ACK 后 close() 才返回
        - 若超时未完成上述确认 → 发送 RST 强制关闭
    */
    ling.l_onoff  = 1;
    ling.l_linger = 5;
    setsockopt(sockfd, SOL_SOCKET, SO_LINGER,
            &ling, sizeof(ling));
    close(sockfd);

    return 0;
    }

int main() {
    int sockfd;
    struct sockaddr_in servaddr;

    // 1. 创建 TCP 套接字
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // ===========================
    // 2. 设置非阻塞模式
    // ===========================
    int flags = fcntl(sockfd, F_GETFL, 0);   // 获取当前文件状态标志
    if (flags < 0) {
        perror("fcntl F_GETFL");
        exit(EXIT_FAILURE);
    }
    flags |= O_NONBLOCK;                     // 设置非阻塞标志
    if (fcntl(sockfd, F_SETFL, flags) < 0) { // 更新文件状态标志
        perror("fcntl F_SETFL");
        exit(EXIT_FAILURE);
    }
    // 说明：非阻塞套接字在 read/write/connect 时不会阻塞，结合 select/poll 可以实现异步 I/O

    // ===========================
    // 3. 设置 close-on-exec 标志
    // ===========================
    flags = fcntl(sockfd, F_GETFD);         // 获取文件描述符标志
    if (flags < 0) {
        perror("fcntl F_GETFD");
        exit(EXIT_FAILURE);
    }
    flags |= FD_CLOEXEC;                     // 设置 close-on-exec
    if (fcntl(sockfd, F_SETFD, flags) < 0) {
        perror("fcntl F_SETFD");
        exit(EXIT_FAILURE);
    }
    // 说明：设置 FD_CLOEXEC 后，当调用 exec 系列函数创建子进程时，sockfd 会自动关闭
    // 避免子进程继承不必要的文件描述符

    // ===========================
    // 4. 绑定和连接示例（可选）
    // ===========================
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0) {
        if (errno == EINPROGRESS) {
            // 非阻塞套接字 connect 尚未完成，可以使用 select/poll 检测可写事件
            printf("Connection in progress (non-blocking)\n");
        } else {
            perror("connect");
            exit(EXIT_FAILURE);
        }
    }

    printf("Socket setup complete.\n");

    close(sockfd);
    return 0;
}