• 网络编程：网络超时检测(select poll setsockopt alarm)

    一、网络超时检测

    1.1 概念

    阻塞：

    以读阻塞为例，如果缓冲区中有内容，则程序正常执行，

    如果缓冲区没有内容，程序会一直阻塞，直到有内容，读取内容继续向下运行。

    非阻塞:

    以读阻塞为例，如果缓冲区中有内容，则程序正常执行，

    如果缓冲区没有内容，程序会立即返回，然后继续向下运行。

    超时检测：

    介于阻塞和非阻塞之间，需要设置一定的时间，如果时间到达之前，缓冲区中没有数据

    程序会阻塞，如果时间到了，缓冲区中还没有数据，则程序立即返回，继续向下执行。

    二超时检测的方法：

    2.3以下所用程序的客户端：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #define N 128
    11.  
    12. #define ERRLOG(msg) do{\
    13.     printf("%s,%s,[%d]\n", __FILE__, __func__, __LINE__);\
    14.     perror(msg);\
    15.     exit(-1);\
    16. }while(0)
    17.  
    18. int main(int argc, char const *argv[])
    19. {
    20.     if (argc != 3){
    21.         ERRLOG("输入参数错误\n");
    22.     }
    23.  
    24.     int socketfd;
    25.     if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
    26.         ERRLOG("socket fd error");
    27.     }
    28.  
    29.     struct sockaddr_in clientaddr;
    30.     clientaddr.sin_family = AF_INET;
    31.     clientaddr.sin_addr.s_addr = inet_addr(argv[1]);
    32.     clientaddr.sin_port = htons(atoi(argv[2]));
    33.     socklen_t clientaddr_len = sizeof(clientaddr);
    34.  
    35.     if (-1 == connect(socketfd,(struct sockaddr*)&clientaddr, clientaddr_len)){
    36.         ERRLOG("connect error");
    37.     } 
    38.  
    39.     printf("连接成功...\n");
    40.  
    41.     char buff[N];
    42.     while (1){
    43.         memset(buff, 0, sizeof(buff));
    44.  
    45.         printf("请输入>>");
    46.         fgets(buff, N, stdin);
    47.         buff[strlen(buff) -1] = '\0';
    48.  
    49.         if (-1 == send(socketfd, buff, strlen(buff), 0)){
    50.             ERRLOG("send error");
    51.         }
    52.  
    53.         if (strncmp("quit", buff, 5) == 0){
    54.             break;
    55.         }
    56.         memset(buff, 0, sizeof(buff));
    57.         if (-1 == recv(socketfd, buff, sizeof(buff), 0)){
    58.             ERRLOG("recv error");
    59.         }
    60.  
    61.         printf("%s\n", buff);
    62.     }
    63.  
    64.     close(socketfd);
    65.     return 0;
    66. }

    2.2select函数自带超时检测

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #define N 128
    12.  
    13. #define ERRLOG(msg) do{\
    14.     printf("%s,%s,[%d]\n", __FILE__, __func__, __LINE__);\
    15.     perror(msg);\
    16.     exit(-1);\
    17. }while(0)
    18.  
    19. int main(int argc, char const *argv[])
    20. {
    21.     if (argc != 3){
    22.         printf("输入格式错误\n");
    23.         exit(-1);
    24.     }
    25.  
    26.     int socketfd;
    27.  
    28.     if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
    29.         ERRLOG("socketfd erro");
    30.     }
    31.  
    32.     struct sockaddr_in serveraddr;
    33.     memset(&serveraddr, 0, sizeof(serveraddr));
    34.     serveraddr.sin_family = AF_INET;
    35.     serveraddr.sin_port = htons(atoi(argv[2]));
    36.     serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    37.     socklen_t serveraddr_len = sizeof(serveraddr);
    38.  
    39.     if (-1 == bind(socketfd, (struct sockaddr*)&serveraddr, serveraddr_len)){
    40.         ERRLOG("bind error");
    41.     }
    42.     
    43.     if (-1 == listen(socketfd, 5)){
    44.         ERRLOG("listen error");
    45.     }
    46.  
    47.     int nbytes;
    48.     int ret;
    49.     int i;
    50.     int maxfd = 0;
    51.     int acceptfd;
    52.     char buff[128] = {0};
    53.  
    54.     fd_set readfs;
    55.     fd_set readfs_temp;
    56.     FD_ZERO(&readfs);
    57.     FD_ZERO(&readfs_temp);
    58.  
    59.     FD_SET(socketfd, &readfs);
    60.     maxfd = maxfd > socketfd ? maxfd: socketfd;
    61.     
    62.     struct timeval tm;
    63.     while (1){
    64.         readfs_temp = readfs;
    65.         tm.tv_sec = 5;
    66.         tm.tv_usec = 0;
    67.         if (-1 == (ret = select(maxfd + 1, &readfs_temp, NULL, NULL, &tm))){
    68.             ERRLOG("select error");
    69.         } else if (ret == 0){
    70.             printf("timeout.....\n");
    71.         } else {
    72.             for (i = 3; i < maxfd + 1 && ret != 0; i++){
    73.                 if (FD_ISSET(i, &readfs_temp)){
    74.                     if (i == socketfd){
    75.                         if (-1 == (acceptfd = accept(i, NULL, NULL))){
    76.                             ERRLOG("acceptfd error");
    77.                         }
    78.                             printf("111111111\n");
    79.                         FD_SET(acceptfd, &readfs);
    80.  
    81.                         maxfd = maxfd > acceptfd ? maxfd : acceptfd;
    82.                     } else {
    83.                         memset(buff, 0, sizeof(buff));
    84.  
    85.                         if (-1 == (nbytes = recv(i, buff, sizeof(buff), 0))){
    86.                             ERRLOG("recv error");
    87.                         } else if(nbytes == 0){
    88.                             printf("断开链接...\n");
    89.                             FD_CLR(i, &readfs);
    90.                             close(i);
    91.                             continue;
    92.                         }
    93.  
    94.                         if (!strncmp("quit", buff, 5)){
    95.                             printf("退出链接...\n");
    96.                             FD_CLR(i, &readfs);
    97.                             close(i);
    98.                             continue;
    99.                         }
    100.  
    101.                         printf("%s\n", buff);
    102.  
    103.                         strcat(buff, "hhhh");
    104.  
    105.                         if (-1 == send(i, buff, sizeof(buff), 0)){
    106.                             ERRLOG("send error");
    107.                         }
    108.                     }
    109.                     ret--;
    110.                 }
    111.             }
    112.         }   
    113.     }
    114.     close(socketfd);
    115.     return 0;
    116. }

    2.2poll函数也自带超时器

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define ERRLOG(msg) do{\
    13.         printf("%s %s(%d):", __FILE__, __func__, __LINE__);\
    14.         perror(msg);\
    15.         exit(-1);\
    16.     }while(0)
    17.  
    18. #define N 128
    19.  
    20.  
    21. int main(int argc, char const *argv[])
    22. {
    23.     if (argc != 3){
    24.         printf("输入过程\n");
    25.         exit(-1);
    26.     }
    27.  
    28.     int socketfd;
    29.     if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
    30.         ERRLOG("socket error");
    31.     }
    32.  
    33.     struct sockaddr_in serveraddr;
    34.     memset(&serveraddr, 0, sizeof(serveraddr));
    35.     serveraddr.sin_family = AF_INET;
    36.     serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    37.     serveraddr.sin_port = htons(atoi(argv[2]));
    38.     socklen_t serveraddr_len = sizeof(serveraddr);
    39.  
    40.     if (-1 == bind(socketfd, (struct sockaddr*)&serveraddr, serveraddr_len)){
    41.         ERRLOG("bind error");
    42.     }
    43.  
    44.     if (-1 == listen(socketfd, 5)){
    45.         ERRLOG("listen error");
    46.     }
    47.  
    48.     int maxfd = 0;
    49.     int ret = 0;
    50.     int nbytes = 0;
    51.     int i;
    52.     int j;
    53.     int acceptfd;
    54.     char buff[128];
    55.  
    56.     struct pollfd my_fds[1024];
    57.     for (i = 0; i < 1024; i++){
    58.         my_fds[i].fd = -1;
    59.     }
    60.  
    61.     my_fds[0].fd = socketfd;
    62.     my_fds[0].events |= POLLIN;
    63.     maxfd = maxfd > socketfd ? maxfd : socketfd;
    64.  
    65.     while (1){
    66.         if (-1 == (ret = poll(my_fds, maxfd, 5000))){
    67.  
    68.         } else if (ret == 0){
    69.             printf("time out...\n");
    70.         } else {
    71.             for (i = 0; i <= maxfd && ret != 0; i++){
    72.                 if (my_fds[i].revents & POLLIN != 0){
    73.                     if (my_fds[i].fd == socketfd){ 
    74.                         if (-1 == (acceptfd = accept(socketfd, NULL, NULL))){
    75.                             ERRLOG("accepfd error");
    76.                         }
    77.  
    78.                         printf("客户端[%d]连接了\n", acceptfd);
    79.  
    80.                         maxfd = maxfd > acceptfd ? maxfd : acceptfd;
    81.  
    82.                         for (j = 0; j < 1024 ; j++){
    83.                             if (my_fds[j].fd == -1){
    84.                                 my_fds[j].fd = acceptfd;
    85.                                 my_fds[j].events = POLLIN;
    86.  
    87.                                 break;                                
    88.                             }
    89.                         }
    90.  
    91.                         if (j == 1024){
    92.                             printf("满了\n");
    93.                             close(acceptfd);
    94.                         }
    95.                     }else {
    96.                         memset(buff, 0, sizeof(buff));
    97.  
    98.                         if (-1 == (nbytes = recv(my_fds[i].fd, buff, 128, 0))){
    99.                             ERRLOG("recv error");
    100.                         }else if (nbytes == 0){
    101.                             printf("断开连接...\n");
    102.                             close(my_fds[i].fd);
    103.                             my_fds[i].fd = -1;
    104.                             continue;
    105.                         }
    106.  
    107.                         if (!strncmp("quit", buff, 5)){
    108.                             printf("退出连接..\n");
    109.                             printf("断开连接...\n");
    110.                             close(my_fds[i].fd);
    111.                             my_fds[i].fd = -1;
    112.                             continue;
    113.                         }
    114.  
    115.                         printf("%s\n", buff);
    116.  
    117.                         strcat(buff, "jhhh");
    118.  
    119.                         if (-1 == send(my_fds[i].fd, buff, sizeof(buff), 0)){
    120.                             ERRLOG("send errro");
    121.                         }
    122.                     }
    123.                 }
    124.             }
    125.         }
    126.     }
    127.  
    128.  
    129.     close(socketfd);
    130.     return 0;
    131. }

    2.3使用 setsockopt 函数实现超时检测

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. #define ERRLOG(msg) do{\
    15.         printf("%s %s(%d):", __FILE__, __func__, __LINE__);\
    16.         perror(msg);\
    17.         exit(-1);\
    18.     }while(0)
    19.  
    20. #define N 128
    21.  
    22. typedef struct _MSG{
    23.     int acceptfd;
    24.     struct sockaddr_in clientaddr;
    25. }msg_t;
    26.  
    27. void *deal_read_write(void *arg){
    28.     msg_t msg = *(msg_t *)arg;
    29.     char buff[N] = {0};
    30.     int nbytes = 0;
    31.     printf("客户端 [%s:%d] 连接了\n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
    32.     
    33.     //收发数据
    34.     while(1){
    35.         memset(buff, 0, N);
    36.         //接受数据
    37.         //由已经设置过超时时间的sockfd产生的accpetfd会继承超时属性
    38.         //如果想设置的超时时间是一样的，直接使用即可
    39.         //如果不想设置一样，也可以对每个acceptfd单独调用 setsockopt 进行设置
    40.         if(-1 == (nbytes = recv(msg.acceptfd, buff, 128, 0))){
    41.             if(errno == EAGAIN){
    42.                 printf("recv timeout..\n");
    43.                 close(msg.acceptfd);
    44.                 break;
    45.             }
    46.             perror("recv error");
    47.             break;
    48.         }else if(0 == nbytes){
    49.             printf("[%s:%d]:断开了连接...\n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
    50.             break;
    51.         }
    52.         if(!strncmp(buff, "quit", 5)){
    53.             printf("[%s:%d]:退出了...\n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
    54.             break;
    55.         }
    56.         //打印数据
    57.         printf("[%s:%d]:[%s]\n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port), buff);
    58.         //组装应答
    59.         strcat(buff, "--hqyj");
    60.         //发送应答
    61.         if(-1 == send(msg.acceptfd, buff, N, 0)){
    62.             ERRLOG("send error");
    63.         }
    64.     }
    65.     close(msg.acceptfd);
    66.     pthread_exit(NULL);
    67. }
    68.  
    69. int main(int argc, const char *argv[]){
    70.     if(3 != argc){
    71.         printf("Usage: %s  \n", argv[0]);
    72.         return -1;
    73.     }
    74.  
    75.     //创建流式套接字
    76.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    77.     if(-1 == sockfd){
    78.         ERRLOG("socket error");
    79.     }
    80.  
    81.     //填充服务器网络信息结构体
    82.     struct sockaddr_in serveraddr;
    83.     memset(&serveraddr, 0, sizeof(serveraddr));
    84.     serveraddr.sin_family = AF_INET;
    85.     //网络字节序的端口号 8888  9999  6789 等 都可以
    86.     serveraddr.sin_port = htons(atoi(argv[2]));
    87.     //网络字节序的IP地址，IP地址不能乱填
    88.     //自己的主机ifconfig 查到的ip地址是多少就填多少
    89.     //如果本机测试使用 也可以填写 127.0.0.1
    90.     serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    91.     
    92.     socklen_t serveraddr_len = sizeof(serveraddr);
    93.  
    94.     //设置允许端口复用
    95.     int on = 1;
    96.     if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))){
    97.         perror("setsockopt error");
    98.     }
    99.  
    100.     //将套接字和网络信息结构体绑定
    101.     if(-1 == bind(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
    102.         ERRLOG("bind error");
    103.     }
    104.  
    105.     //将套接字设置成被动监听状态
    106.     if(-1 == listen(sockfd, 5)){
    107.         ERRLOG("listen error");
    108.     }
    109.  
    110.     //设置sockfd接收超时时间为 5s
    111.     struct timeval tm;
    112.     tm.tv_sec = 5;
    113.     tm.tv_usec = 0;
    114.     if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tm, sizeof(tm))){
    115.         ERRLOG("setsockopt error");
    116.     }
    117.  
    118.     //定义一个保存客户端信息的结构体
    119.     struct sockaddr_in clientaddr;
    120.     memset(&clientaddr, 0, sizeof(clientaddr));
    121.     socklen_t clientaddr_len = sizeof(clientaddr);
    122.  
    123.     msg_t msg;
    124.     pthread_t tid = 0;
    125.  
    126.     //阻塞等待客户端连接
    127.     int acceptfd = 0;
    128.     while(1){
    129.         if(-1 == (acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len))){
    130.             if(errno == EAGAIN){
    131.                 printf("5秒内没有客户端连接到服务器..\n");
    132.                 continue;
    133.             }
    134.             ERRLOG("acceptfd error");
    135.         }
    136.         memset(&msg, 0, sizeof(msg));
    137.         msg.clientaddr = clientaddr;
    138.         msg.acceptfd = acceptfd;
    139.         //有客户端连接就创建线程专门处理读写
    140.         if(0 != pthread_create(&tid, NULL, deal_read_write, (void *)&msg)){
    141.             ERRLOG("pthread_create error");
    142.         }
    143.  
    144.         //设置线程分离属性 由操作系统回收线程的资源
    145.         pthread_detach(tid);
    146.     }
    147.  
    148.     close(sockfd);
    149.  
    150.     return 0;
    151. }

    2.4使用 alarm 闹钟实现超时检测

    2.4.1 概念

    alarm是一个函数，可以通过他设置一个时间，当时间到达的时候，会给进程发一个

    SIGALRM 信号。

    使用alarm函数设置完超时时间后，进程会继续执行，直到设置的时间到了，

    进程收到 SIGALRM 信号

    进程对该信号默认的处理方式是 终止进程，我们的是服务器程序，不能使用默认的方式

    所以需要对 该信号进行一个捕捉的操作。

    如果使用 捕捉的操作，当信号产生时，回去执行信号处理函数，执行完信号处理函数

    进程会继续向下执行，这种属性，叫做信号的自重启属性。

    我们想要使用该信号实现超时检测，也就是说，执行完信号处理函数，不应该直接向下运行

    而是应该给我们返回一个错误，也就是说，需要关闭信号的自重启属性。

    2.4.2关闭自重启属性的方式，使用 sigaction 函数

    1. struct sigaction action;
    2. //获取旧的行为
    3. sigaction(SIGALRM, NULL, &action);
    4. //取消自重启属性
    5. action.sa_flags &= (~SA_RESTART);
    6. //指定信号处理函数
    7. action.sa_handler = my_function;
    8. //再将行为重新设置回去
    9. sigaction(SIGALRM, &action, NULL);

    2.4.3代码实现

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #define ERRLOG(msg) do{\
    14. 	printf("%s %s(%d):", __FILE__, __func__, __LINE__);\
    15. 	perror(msg);\
    16. 	exit(-1);\
    17. }while(0)
    18.  
    19. #define N 128
    20.  
    21. void my_function(int x){
    22. 	//什么都不用作  我们只是通过这种方法捕获信号
    23. 	printf("helle\n");
    24. }
    25.  
    26. int main(int argc, const char *argv[]){
    27. 	if(3 != argc){
    28. 		printf("Usage: %s  \n", argv[0]);
    29. 		return -1;
    30. 	}
    31.  
    32. 	//创建流式套接字
    33. 	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    34. 	if(-1 == sockfd){
    35. 		ERRLOG("socket error");
    36. 	}
    37.  
    38. 	//填充服务器网络信息结构体
    39. 	struct sockaddr_in serveraddr;
    40. 	memset(&serveraddr, 0, sizeof(serveraddr));
    41. 	serveraddr.sin_family = AF_INET;
    42. 	//网络字节序的端口号 8888  9999  6789 等 都可以
    43. 	serveraddr.sin_port = htons(atoi(argv[2]));
    44. 	//网络字节序的IP地址，IP地址不能乱填
    45. 	//自己的主机ifconfig 查到的ip地址是多少就填多少
    46. 	//如果本机测试使用 也可以填写 127.0.0.1
    47. 	serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    48.  
    49. 	socklen_t serveraddr_len = sizeof(serveraddr);
    50.  
    51. 	//设置端口复用
    52. 	int on = 1;
    53. 	if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))){
    54. 		perror("setsockopt error");
    55. 	}
    56.  
    57. 	//将套接字和网络信息结构体绑定
    58. 	if(-1 == bind(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
    59. 		ERRLOG("bind error");
    60. 	}
    61.  
    62. 	//将套接字设置成被动监听状态
    63. 	if(-1 == listen(sockfd, 5)){
    64. 		ERRLOG("listen error");
    65. 	}
    66.  
    67. 	//定义一个保存客户端信息的结构体
    68. 	struct sockaddr_in clientaddr;
    69. 	memset(&clientaddr, 0, sizeof(clientaddr));
    70. 	socklen_t clientaddr_len = sizeof(clientaddr);
    71.  
    72. 	char buff[N] = {0};
    73. 	int nbytes = 0;
    74.  
    75. 	//关闭SIGALRM信号的自重启属性
    76. 	struct sigaction action;
    77. 	//获取旧的行为
    78. 	sigaction(SIGALRM, NULL, &action);
    79. 	//取消自重启属性
    80. 	action.sa_flags &= (~SA_RESTART);
    81. 	//指定信号处理函数
    82. 	action.sa_handler = my_function;
    83. 	//再将行为重新设置回去
    84. 	sigaction(SIGALRM, &action, NULL);
    85.  
    86. 	//阻塞等待客户端连接
    87. 	int acceptfd = 0;
    88. 	while(1){
    89. 		alarm(5);
    90. 		if(-1 == (acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len))){
    91. 			if(errno == EINTR){
    92. 				printf("accept timeout..\n");
    93. 				continue;
    94. 			}
    95. 			ERRLOG("acceptfd error");
    96. 		}
    97. 		printf("客户端 [%s:%d] 连接了\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
    98.  
    99. 		//收发数据
    100. 		while(1){
    101. 			memset(buff, 0, N);
    102. 			//接受数据
    103. 			alarm(5);
    104. 			if(-1 == (nbytes = recv(acceptfd, buff, 128, 0))){
    105. 				if(errno == EINTR){
    106. 					printf("recv timeout..\n");
    107. 					break;
    108. 				}
    109. 				ERRLOG("recv error");
    110. 			}else if(0 == nbytes){
    111. 				printf("[%s:%d]:断开了连接...\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
    112. 				break;
    113. 			}
    114. 			if(!strncmp(buff, "quit", 5)){
    115. 				printf("[%s:%d]:退出了...\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
    116. 				break;
    117. 			}
    118. 			//打印数据
    119. 			printf("[%s:%d]:[%s]\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port), buff);
    120. 			//组装应答
    121. 			strcat(buff, "--hqyj");
    122. 			//发送应答
    123. 			if(-1 == send(acceptfd, buff, N, 0)){
    124. 				ERRLOG("send error");
    125. 			}
    126. 		}
    127. 		//关闭套接字
    128. 		close(acceptfd);
    129. 	}
    130.  
    131. 	//这句代码一般不会执行到
    132. 	//服务器程序一般不会主动退出
    133. 	close(sockfd);
    134.  
    135. 	return 0;
    136. }

  • 相关阅读:
    springboot二手书籍线上回收网站java ssm-0401u
    大数据技术基础实验十三：Kafka实验——订阅推送示例
    Maven—POM简介
    框架中的单例模式
    天龙八部科举答题问题和答案（全1/8）
    浅谈终端安全接入
    前端开发调试技巧
    受害者被锤 法官遭殃 背后的它公关赢了？
    聊起日本文化大家首先会想起什么
    通达OA V12版本，好用的自定义函数
  • 原文地址：https://blog.csdn.net/a2998658795/article/details/126449828