网络编程（学习）2024.9.2

怀九日2024-09-07 8:26

目录

服务器模型

1.循环服务器

2.并发服务器

（1）多进程模型

多进程特点

多进程案例

（2）多线程模型

多线程特点

多线程案例

网络超时检测

超时检测的必要性

网络超时检测方法

1.自带超时参数的函数

(1)select设置超时

(2)poll设置超时

2.利用setsockopt属性设置

设置sockfd接收超时

设置端口重用

服务器模型

1.循环服务器

一次只有一个客户端可以连接，但是客户端退出以后，下一个客户端可以继续连接

2.并发服务器

同时一时刻可以连接多个客户端，常见：IO多路复用(select、poll、epoll)、多进程、多线程

（1）多进程模型

多进程特点

1.fork之前的代码被复制，但是不会重新执行一遍；fork之后的代码被复制，并且再被执行一遍。

2.fork之后两个进程相互独立，子进程拷贝了父进程的所有代码，但内存空间独立

3.fork之前打开文件，fork之后拿到的是同一个文件描述符，操作的是同一个文件指针

多进程案例
cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/select.h>
#include <signal.h>
#include <wait.h>
#define N 64
char buf[N];
pid_t pid;

void father(int sig)
{
    waitpid(-1, NULL, WNOHANG); // 回收子进程资源
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = INADDR_ANY;
    socklen_t addrlen = sizeof(saddr);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        perror("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    while (1)
    {
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            perror("accept失败");
            return -1;
        }
        printf("acceptfd:%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d 已连接\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
        pid = fork();
        if (pid == 0)
        {
            // close(sockfd);
            while (1)
            {
                memset(buf, 0, N);
                int ret = recv(acceptfd, buf, N, 0);
                if (ret < 0)
                {
                    perror("recv失败\n");
                    break;
                }
                else if (ret == 0)
                {
                    printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                    break;
                }
                else
                {
                    printf("%s客户端： %s\n", inet_ntoa(caddr.sin_addr), buf);
                }
            }
            close(acceptfd);
            exit(0);
        }
        else
        {
            close(acceptfd);
            signal(SIGCHLD, father);
        }
    }
    return 0;
}

（2）多线程模型

多线程特点

每来一个连接创建一个线程,IO多路复用以外，应用最广泛的并发服务器模型

多线程案例
cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

#define N 64

void *mythread(void *arg)
{
    pthread_detach(pthread_self());
    int fd = *((int *)arg);
    free(arg);
    char buf[N];
    while (1)
    {
        memset(buf, 0, N);
        int ret = recv(fd, buf, N, 0);
        if (ret < 0)
        {
            perror("recv失败");
            break;
        }
        else if (ret == 0)
        {
            printf("客户端acceptfd:%d 退出\n", fd);
            close(fd);
            break;
        }
        else
        {
            printf("客户端： %s\n", buf);
        }
    }

    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：%s <port>\n", argv[0]);
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        perror("socket失败");
        return -1;
    }
    printf("sockfd：%d\n", sockfd);

    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = INADDR_ANY;
    socklen_t addrlen = sizeof(saddr);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    if (listen(sockfd, 7) < 0)
    {
        perror("listen失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    while (1)
    {
        int *acceptfd = malloc(sizeof(int)); // 为每个客户端连接分配内存
        if (acceptfd == NULL)
        {
            perror("内存分配失败");
            close(sockfd);
            return -1;
        }

        *acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (*acceptfd < 0)
        {
            perror("accept失败");
            free(acceptfd);
            continue;
        }
        printf("acceptfd: %d\n", *acceptfd);
        printf("客户端ip：%s 端口号：%d 连接\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        pthread_t tid;
        if (pthread_create(&tid, NULL, mythread, acceptfd) != 0)
        {
            perror("创建线程失败");
            close(*acceptfd);
            free(acceptfd);
            continue;
        }
    }

    close(sockfd);
    return 0;
}

网络超时检测

在网络通信中，很多操作会使得进程阻塞：

TCP套接字中的recv/accept

UDP套接字中的recvfrom

超时检测的必要性

○避免进程在没有数据时无限制地阻塞

○实现某些特定协议要求，比如某些设备规定，发送请求数据后，如果多长时间后没有收到来自设备的回复，需要做出一些特殊处理

网络超时检测方法

1.自带超时参数的函数

例如使用select/poll/epoll函数最后一个参数可以设置超时。

(1)select设置超时

struct timeval tm = {2, 0};//设置2s打算阻塞

sret = select(maxfd + 1, &tempfds, NULL, NULL, &tm);

第五个参数：

struct timeval

{

long tv_sec; /*秒*/

long tv_usec; /*微秒*/

};

注：select的超时检测不会更新，所以每次重新超时等待之前要更新等待时间

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/select.h>

#define N 64
char buf[N];
#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif

    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        ERR_MSG("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    // 第一步：建表初始化
    fd_set readfds, tempfds;
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);
    FD_SET(0, &readfds);
    int max = sockfd;

    while (1)
    {
        struct timeval tm = {2, 0};
        memset(buf, 0, N);
        tempfds = readfds;
        int ret = select(max + 1, &tempfds, NULL, NULL, &tm);
        if (ret == 0)
        {
            printf("time out\n");
        }
        if (FD_ISSET(sockfd, &tempfds))
        {
            // 4.accept阻塞等待链接
            int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
            if (acceptfd < 0)
            {
                ERR_MSG("accept失败\n");
                return -1;
            }
            printf("acceptfd：%d\n", acceptfd);
            printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
            FD_SET(acceptfd, &readfds);
            if (max < acceptfd)
            {
                max = acceptfd;
            }
        }
        // 5.发送
        else if (FD_ISSET(0, &tempfds))
        {
            scanf("%s", buf);
            for (int i = 4; i <= max; i++)
            {
                if (FD_ISSET(i, &readfds))
                {
                    send(i, buf, N, 0);
                }
            }
        }
        // 6.接收
        for (int n = 4; n <= max; n++)
        {
            if (FD_ISSET(n, &tempfds))
            {
                int ret = recv(n, buf, N, 0);
                if (ret < 0)
                {
                    perror("recv失败");
                    close(sockfd);
                    return -1;
                }
                else if (ret > 0)
                {
                    printf("客户端acceptfd%d：%s\n", n, buf);
                }
                else
                {
                    printf("客户端acceptfd：%d退出\n", n);
                    FD_CLR(n, &readfds);
                    close(n);
                    while (!FD_ISSET(max, &readfds))
                    {
                        max--;
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

(2)poll设置超时

直接在poll(fds, last + 1, 2000);设置，延迟2s；

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <poll.h>

#define N 64
char buf[N];
#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
    // #if 0
    //     saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    // #else
    //     saddr.sin_addr.s_addr = INADDR_ANY;
    // #endif

    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        ERR_MSG("bind失败");
        close(sockfd);
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        close(sockfd);
        return -1;
    }
    printf("listen成功\n");

    // 第一步：建表初始化
    struct pollfd fds[100];
    int last = -1;

    // 第二步：填表
    fds[++last].fd = 0;
    fds[last].events = POLLIN;
    fds[last].revents = 0;
    fds[++last].fd = sockfd;
    fds[last].events = POLLIN;
    fds[last].revents = 0;

    while (1)
    {
        memset(buf, 0, N);
        int po = poll(fds, last + 1, 2000);
        if (po == -1)
        {
            perror("select失败");
            close(sockfd);
            return -1;
        }
        for (int i = 0; i <= last; i++)
        {
            if (fds[i].revents == POLLIN)
            {
                if (fds[i].fd == sockfd)
                {
                    // 4.accept阻塞等待链接
                    int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
                    if (acceptfd < 0)
                    {
                        ERR_MSG("accept失败\n");
                        return -1;
                    }
                    printf("acceptfd：%d\n", acceptfd);
                    printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
                    fds[++last].fd = acceptfd;
                    fds[last].events = POLLIN;
                    fds[last].revents = 0;
                }
                else if (fds[i].fd == 0)
                {
                    scanf("%s", buf);
                    for (int j = 2; j <= last; j++)
                    {
                        send(fds[j].fd, buf, N, 0);
                    }
                }
                else
                {
                    int ret = recv(fds[i].fd, buf, N, 0);
                    if (ret < 0)
                    {
                        perror("recv失败");
                        close(sockfd);
                        return -1;
                    }
                    else if (ret > 0)
                    {
                        printf("客户端%s：%s\n", inet_ntoa(caddr.sin_addr), buf);
                    }
                    else
                    {
                        printf("客户端acceptfd：%d退出\n", fds[i].fd);
                        close(fds[i].fd);
                        fds[i] = fds[last];
                        last--;
                    }
                }
            }
        }
    }
    close(sockfd);
    return 0;
}

2.利用setsockopt属性设置

Linux中socket属性

API接口

功能：设置/获取网络属性;

#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);

参数：

int sockfd：指定要设置/获取哪个套接字的属性;

int level：指定要控制的协议层次;

SOL_SOCKET：应用层 通用套接字选项; man 7 socket

IPPROTO_TCP：TCP选项 man 7 TCP

IPPROTO_UDP：UDP选项 man 7 UDP

IPPROTO_IP：IP选项; man 7 IP

int optname：指定要控制的内容，指定控制方式；

--- SOL_SOCKET: man 7 socket -----

SO_REUSEADDR：允许端口快速重用 optval: int*

SO_BROADCAST：允许广播 optval: int*

SO_RCVBUF/SO_SNDBUF：接收缓冲区 发送缓冲区大小

SO_RCVTIMEO/SO_SNDTIMEO：接收超时时间，发送超时时间

void *optval：根据optname不同，该类型不同;

socklen_t optlen/socklen_t *optlen：真实的optval指针指向的内存空间的大小;

返回值：

成功:返回0

失败:返回-1

设置sockfd接收超时

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        return -1;
    }
    printf("listen成功\n");
    struct timeval val = {2, 0};
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &val, sizeof(val));
    while (1)
    {
        // 4.accept阻塞等待链接
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            if (errno == 11)
            {
               char a[10];
               printf("accept超时，是否继续，继续请输入yes，退出请输入no\n");
               scanf(" %s", a);
               if (strcmp(a, "yes") == 0)
               {
                   continue;
               }
               if (strcmp(a, "no") == 0)
               {
                   break;
               }
               else
               {
                   printf("输入错误，请重新输入\n");
                   continue;
               }
            }
            perror("accept失败");
            return -1;
        }
        printf("acceptfd：%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        // 5.发送
#define N 64
        char buf[N];
        while (1)
        {
            memset(buf, 0, N);
            int ret = recv(acceptfd, buf, N, 0); // MSG_DONTWAIT
            if (ret < 0)
            {
                if (errno == 11)
                {
                    printf("读缓存区内没数据\n");
                    continue;
                }
                else
                {
                    perror("recv失败\n");
                    return -1;
                }
            }
            else if (ret == 0)
            {
                printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                close(acceptfd);
                break;
            }
            else
            {
                printf("客户端%s\n", buf);
            }
        }
    }

    close(sockfd);
    return 0;
}

设置端口重用

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

#define ERR_MSG(msg)                           \
    do                                         \
    {                                          \
        fprintf(stderr, "line:%d ", __LINE__); \
        perror(msg);                           \
    } while (0)

int main(int argc, char const *argv[])
{
    if (argc != 2)
    {
        printf("用法：<port>\n");
        return -1;
    }
    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    printf("sorkfd：%d\n", sockfd);
    // 2.bind绑定IP和Port端口号
    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("192.168.50.213");
    socklen_t addrlen = sizeof(saddr);
#if 0
    saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
#else
    saddr.sin_addr.s_addr = INADDR_ANY;
#endif
    int flag;
    socklen_t len = sizeof(flag);
    getsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, &len);
    flag = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, len);
    printf("flag:%d\n", flag);
    if (bind(sockfd, (struct sockaddr *)&saddr, addrlen) < 0)
    {
        perror("bind失败");
        return -1;
    }
    printf("bind成功\n");

    // 3.监听listen将主动套接字变为被动套接字
    if (listen(sockfd, 7) < 0)
    {
        ERR_MSG("lisren失败");
        return -1;
    }
    printf("listen成功\n");
    while (1)
    {
        // 4.accept阻塞等待链接
        int acceptfd = accept(sockfd, (struct sockaddr *)&caddr, &addrlen);
        if (acceptfd < 0)
        {
            perror("accept失败");
            return -1;
        }
        printf("acceptfd：%d\n", acceptfd);
        printf("客户端ip：%s\t 端口号：%d\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

        // 5.发送
#define N 64
        char buf[N];
        while (1)
        {
            memset(buf, 0, N);
            int ret = recv(acceptfd, buf, N, 0); // MSG_DONTWAIT
            if (ret < 0)
            {
                if (errno == 11)
                {
                    printf("读缓存区内没数据\n");
                    continue;
                }
                else
                {
                    perror("recv失败\n");
                    return -1;
                }
            }
            else if (ret == 0)
            {
                printf("客户端ip：%s退出\n", inet_ntoa(caddr.sin_addr));
                close(acceptfd);
                break;
            }
            else
            {
                printf("客户端%s\n", buf);
            }
        }
    }

    close(sockfd);
    return 0;
}
相关推荐
五味香2 分钟前
Linux学习，ip 命令
linux·服务器·c语言·开发语言·git·学习·tcp/ip
Chef_Chen10 分钟前
从0开始学习机器学习--Day22--优化总结以及误差作业（上）
人工智能·学习·机器学习
raysync88814 分钟前
如何保障医院内部的隔离网安全跨网文件交换？
网络·安全
虾球xz26 分钟前
游戏引擎学习第11天
stm32·学习·游戏引擎
心怀梦想的咸鱼29 分钟前
Ue5 umg学习（三）文本控件
学习·ue5
心怀梦想的咸鱼30 分钟前
Ue5 umg学习（二）图像控件，锚点
学习·ue5
lb36363636361 小时前
整数储存形式(c基础)
c语言·开发语言
御控物联_姜1 小时前
IP、网关、子网掩码的验证逻辑及程序（.Net）
网络
网络安全-杰克1 小时前
助力网络安全发展，安全态势攻防赛事可视化
网络·安全·web安全
浪里个浪的10241 小时前
【C语言】从3x5矩阵计算前三行平均值并扩展到4x5矩阵
c语言·开发语言·矩阵
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化