• Linux——网络编程二

    一、多路复用：

    基本常识：


       linux中每个进程默认情况下，最多可以打开1024个文件，最多有1024个文件描述符
       文件描述符的特点：　　
         1.非负整数
    　 2.从最小可用的数字来分配
    　３.每个进程启动时默认打开０，１,２三个文件描述符

    多路复用针对不止套接字fd,也针对普通的文件描述fd

    I\O模型

     阻塞IO模型

    sendto不阻塞 

    读阻塞

     写阻塞

     非阻塞模式IO

     

     轮询不需要阻塞，一般写成这样很欠揍👀👀👀👀👀

    非阻塞模型实现

     多路复用IO思想

    多路复用服务器模型：

     select()/poll()实现多路复用

     select参数

     函数select

     select宏

     TCP多路复用

     

     其它函数

     demo

     伪代码

    1. int main (void)
    2. {
    3. 	fd_set rset;
    4. 	int maxfd = -1;
    5.  
    6. 	struct timeval tout;
    7.  
    8. 	fd = socket ( ...);
    9. 	bind (fd, ...);
    10. 	listen (fd, ...);
    11.  
    12. 	while (1) {
    13. 		maxfd = fd;
    14. 		FD_ZERO (&rset);
    15.  
    16. 		FD_SET (fd, &rset);
    17. 		//依次把已经建立好连接fd加入到集合中,记录下来最大的文件描述符maxfd
    18. 		//...FIXME!!
    19. #if 0
    20. 		select (maxfd + 1, &rset, NULL, NULL, NULL);
    21. #else
    22. 		tout.tv_sec = 5;
    23. 		tout.tv_usec = 0;
    24. 		select (maxfd + 1, &rset, NULL, NULL, &tout);
    25. #endif
    26. 		if (FD_ISSET (fd, &rset)) {
    27. 			newfd = accept (fd, ....);
    28. 		}
    29. 		//依次判断已建立连接的客户端是否有数据
    30. 		//...FIXME!
    31.  
    32. 	}
    33. 	return 0;
    34. }

    测试代码

    1. /*./client serv_ip serv_port */
    2. #include "net.h"
    3.  
    4. void usage (char *s)
    5. {
    6. 	printf ("\n%s serv_ip serv_port", s);
    7. 	printf ("\n\t serv_ip: server ip address");
    8. 	printf ("\n\t serv_port: server port(>5000)\n\n");
    9. }
    10.  
    11. int main (int argc, char **argv)
    12. {
    13. 	int fd = -1;
    14.  
    15. 	int port = -1;
    16. 	struct sockaddr_in sin;
    17.  
    18. 	if (argc != 3) {
    19. 		usage (argv[0]);
    20. 		exit (1);
    21. 	}
    22. 	/* 1. 创建socket fd */
    23. 	if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
    24. 		perror ("socket");
    25. 		exit (1);
    26. 	}
    27.  
    28. 	port = atoi (argv[2]);
    29. 	if (port < 5000) {
    30. 		usage (argv[0]);
    31. 		exit (1);
    32. 	}
    33. 	/*2.连接服务器 */
    34.  
    35. 	/*2.1 填充struct sockaddr_in结构体变量 */
    36. 	bzero (&sin, sizeof (sin));
    37.  
    38. 	sin.sin_family = AF_INET;
    39. 	sin.sin_port = htons (port);	//网络字节序的端口号
    40. #if 0
    41. 	sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
    42. #else
    43. 	if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
    44. 		perror ("inet_pton");
    45. 		exit (1);
    46. 	}
    47. #endif
    48.  
    49. 	if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
    50. 		perror ("connect");
    51. 		exit (1);
    52. 	}
    53.  
    54. 	printf ("Client staring...OK!\n");
    55.  
    56. 	int ret = -1;
    57. 	fd_set rset;
    58. 	int maxfd = -1;
    59. 	struct timeval tout;
    60. 	char buf[BUFSIZ];
    61.  
    62. 	while (1) {
    63. 		FD_ZERO (&rset);
    64. 		FD_SET (0, &rset);
    65. 		FD_SET (fd, &rset);
    66. 		maxfd = fd;
    67.  
    68. 		tout.tv_sec = 5;
    69. 		tout.tv_usec = 0;
    70.  
    71. 		select (maxfd + 1, &rset, NULL, NULL, &tout);
    72. 		if (FD_ISSET (0, &rset)) {	//标准键盘上有输入
    73. 			//读取键盘输入，发送到网络套接字fd
    74. 			bzero (buf, BUFSIZ);
    75. 			do {
    76. 				ret = read (0, buf, BUFSIZ - 1);
    77. 			} while (ret < 0 && EINTR == errno);
    78. 			if (ret < 0) {
    79. 				perror ("read");
    80. 				continue;
    81. 			}
    82. 			if (!ret)
    83. 				continue;
    84.  
    85. 			if (write (fd, buf, strlen (buf)) < 0) {
    86. 				perror ("write() to socket");
    87. 				continue;
    88. 			}
    89.  
    90. 			if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    91. 				printf ("Client is exiting!\n");
    92. 				break;
    93. 			}
    94. 		}
    95.  
    96. 		if (FD_ISSET (fd, &rset)) {	//服务器给发送过来了数据
    97. 			//读取套接字数据，处理
    98. 			bzero (buf, BUFSIZ);
    99. 			do {
    100. 				ret = read (fd, buf, BUFSIZ - 1);
    101. 			} while (ret < 0 && EINTR == errno);
    102. 			if (ret < 0) {
    103. 				perror ("read from socket");
    104. 				continue;
    105. 			}
    106. 			if (!ret)
    107. 				break;			/* 服务器关闭 */
    108.  
    109. 			//There is a BUG,FIXME!!
    110. 			printf ("server said: %s\n", buf);
    111. 			if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    112. 				printf ("Sender Client is exiting!\n");
    113. 				break;
    114. 			}
    115.  
    116. 		}
    117. 	}
    118.  
    119. 	/*4.关闭套接字 */
    120. 	close (fd);
    121. }

    1. #ifndef __MAKEU_NET_H__
    2. #define __MAKEU_NET_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 			/* See NOTES */
    11. #include 
    12. #include 
    13. #include 			/* superset of previous */
    14.  
    15. #include 
    16. #include 
    17. //#include 
    18. #include 
    19.  
    20.  
    21.  
    22. #define SERV_PORT 5002
    23. #define SERV_IP_ADDR "192.168.7.246"
    24. #define BACKLOG 5
    25.  
    26. #define QUIT_STR "quit"
    27.  
    28. #endif

    1. #include 
    2. #include 
    3. #include "net.h"
    4.  
    5. void cli_data_handle (void *arg);
    6.  
    7. void sig_child_handle(int signo)
    8. {
    9. 	if(SIGCHLD == signo) {
    10. 		waitpid(-1, NULL,  WNOHANG);
    11. 	}
    12. }
    13. int main (void)
    14. {
    15.  
    16. 	int fd = -1;
    17. 	struct sockaddr_in sin;
    18. 	
    19. 	signal(SIGCHLD, sig_child_handle);	
    20.  
    21. 	/* 1. 创建socket fd */
    22. 	if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
    23. 		perror ("socket");
    24. 		exit (1);
    25. 	}
    26.  
    27. 	/*优化4： 允许绑定地址快速重用 */
    28. 	int b_reuse = 1;
    29. 	setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
    30.  
    31.  
    32. 	/*2. 绑定 */
    33. 	/*2.1 填充struct sockaddr_in结构体变量 */
    34. 	bzero (&sin, sizeof (sin));
    35. 	sin.sin_family = AF_INET;
    36. 	sin.sin_port = htons (SERV_PORT);	//网络字节序的端口号
    37.  
    38. 	/*优化1: 让服务器程序能绑定在任意的IP上 */
    39. #if 1
    40. 	sin.sin_addr.s_addr = htonl (INADDR_ANY);
    41. #else
    42. 	if (inet_pton (AF_INET, SERV_IP_ADDR, (void *) &sin.sin_addr) != 1) {
    43. 		perror ("inet_pton");
    44. 		exit (1);
    45. 	}
    46. #endif
    47. 	/*2.2 绑定 */
    48. 	if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
    49. 		perror ("bind");
    50. 		exit (1);
    51. 	}
    52.  
    53. 	/*3. 调用listen()把主动套接字变成被动套接字 */
    54. 	if (listen (fd, BACKLOG) < 0) {
    55. 		perror ("listen");
    56. 		exit (1);
    57. 	}
    58. 	printf ("Server starting....OK!\n");
    59. 	int newfd = -1;
    60. 	/*4. 阻塞等待客户端连接请求 */
    61. 	
    62.         struct sockaddr_in cin;
    63.         socklen_t addrlen = sizeof (cin);
    64. 	while(1) {
    65. 		pid_t pid = -1;
    66. 		if ((newfd = accept (fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
    67.                         perror ("accept");
    68.                         break;
    69.                 }
    70. 		/*创建一个子进程用于处理已建立连接的客户的交互数据*/
    71. 		if((pid = fork()) < 0) {
    72. 			perror("fork");
    73. 			break;
    74. 		}
    75. 		
    76. 		if(0 == pid) {  //子进程中
    77. 			close(fd);
    78. 			char ipv4_addr[16];
    79.                 
    80. 			if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
    81.                         	perror ("inet_ntop");
    82.                         	exit (1);
    83.                	 	}
    84.  
    85.                	 	printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, ntohs(cin.sin_port));	
    86. 			cli_data_handle(&newfd);		
    87. 			return 0;	
    88. 		
    89. 		} else { //实际上此处 pid >0, 父进程中 
    90. 			close(newfd);
    91. 		}
    92. 		
    93.  
    94. 	}		
    95.  
    96.  
    97. 	close (fd);
    98. 	return 0;
    99. }
    100.  
    101. void cli_data_handle (void *arg)
    102. {
    103. 	int newfd = *(int *) arg;
    104.  
    105. 	printf ("Child handling process: newfd =%d\n", newfd);
    106.  
    107. 	//..和newfd进行数据读写
    108.  
    109.  
    110. 	int ret = -1;
    111. 	char buf[BUFSIZ];
    112. 	char resp_buf[BUFSIZ+10];
    113. 	while (1) {
    114. 		bzero (buf, BUFSIZ);
    115. 		do {
    116. 			ret = read (newfd, buf, BUFSIZ - 1);
    117. 		} while (ret < 0 && EINTR == errno);
    118. 		if (ret < 0) {
    119.  
    120. 			perror ("read");
    121. 			exit (1);
    122. 		}
    123. 		if (!ret) {				//对方已经关闭
    124. 			break;
    125. 		}
    126. 		printf ("Receive data: %s\n", buf);
    127. 		
    128. 		if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    129. 			printf ("Client(fd=%d) is exiting!\n", newfd);
    130. 			break;
    131. 		}
    132.  
    133. 		bzero(resp_buf, BUFSIZ+10);
    134. 		
    135. 		strncpy(resp_buf, SERV_RESP_STR, strlen(SERV_RESP_STR));
    136. 		strcat(resp_buf, buf); 	
    137. 		do {
    138. 			ret = write(newfd, resp_buf, strlen(resp_buf));	
    139. 		}while(ret < 0 && EINTR == errno);
    140. 		
    141. 	}
    142. 	close (newfd);
    143.  
    144. }
    1.   1 #Makefile
    2.   2 #CROSS_COMPILE = arm-linux-gnu-
    3.   3 #CC = $(CROSS_COMPILE)gcc
    4.   4 CC = gcc
    5.   5 DEBUG = -g -o0 -Wall
    6.   6 CFLAGS += $(DEBUG)
    7.   7 PROGS = ${patsubst %.c, %, ${wildcard *.c}}
    8.   8 % : %.c
    9.   9         $(CC)  $(CFLAGS)  $< -o $@ -lpthread
    10.  10 all : $(PROGS)
    11.  11

    这里出现了点问题老师的ubuntu和我的版本不同所以我还需要加两个头文件

    具体可看报错合集2

    然后有个错误有个宏不认识，man了半天，最后发现是自己定义的

    #define SERV_RESP_STR "SERVER:"

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. typedef struct sockaddr Addr;
    12. typedef struct sockaddr_in Addr_in;
    13. typedef struct Node{
    14. 	int fd;
    15. 	struct Node *next;
    16. }Node;
    17.  
    18. #define BACKLOG 5
    19.  
    20. void Argment(int argc, char *argv[]);
    21. void NodeCreate(Node **p);
    22. void AcceptHandle(int sfd, Node **H);
    23. int ClientHandle(int fd);
    24.  
    25. int main(int argc, char *argv[])
    26. {
    27. 	int ret, sfd, nfd = 0;
    28. 	Addr_in saddr;
    29. 	fd_set rfds;
    30. 	Node *H, *p = NULL;
    31.  
    32. 	Argment(argc, argv);
    33.  
    34. 	NodeCreate(&H);
    35.  
    36. 	sfd = socket(AF_INET, SOCK_STREAM, 0);
    37. 	if(sfd < 0)
    38. 	{
    39. 		perror("socket");
    40. 		exit(0);
    41. 	}
    42.  
    43. 	saddr.sin_family = AF_INET;
    44. 	saddr.sin_port = htons(atoi(argv[2]));
    45. 	saddr.sin_addr.s_addr = inet_addr(argv[1]);
    46.  
    47. 	if(bind(sfd, (Addr *)&saddr, sizeof(Addr_in)))
    48. 	{
    49. 		perror("bind");
    50. 		exit(0);
    51. 	}
    52.  
    53. 	if(listen(sfd, BACKLOG))
    54. 	{
    55. 		perror("listen");
    56. 		exit(0);
    57. 	}
    58.  
    59. 	H->fd =sfd;
    60. 	while(1)
    61. 	{
    62. 		FD_ZERO(&rfds);
    63. 		p = H;
    64. 		nfd = 0;
    65. 		while(p != NULL)
    66. 		{
    67. 			if(p->fd > nfd)
    68. 				nfd = p->fd;
    69. 			FD_SET(p->fd, &rfds);
    70. 			p = p->next;
    71. 		}
    72. 		printf("nfd = %d run select...\n", nfd);
    73. 		ret =select(nfd+1, &rfds, NULL, NULL, NULL);
    74. 		if(!ret)
    75. 			continue;
    76. 		if(ret < 0)
    77. 		{
    78. 			perror("select");
    79. 			exit(0);
    80. 		}
    81. 		p = H;
    82. 		while(p->next != NULL)
    83. 		{
    84. 			if(FD_ISSET(p->fd, &rfds))
    85. 			{
    86. 				if(ClientHandle(p->fd) <= 0)
    87. 				{
    88. 					close(p->fd);
    89. 					Node *q = p->next;
    90. 					p->fd = q->fd;
    91. 					p->next = q->next;
    92. 					free(q);
    93. 					continue;
    94. 				}
    95. 			}
    96. 			p = p->next;
    97. 		}
    98. 		if(FD_ISSET(p->fd, &rfds))
    99. 			AcceptHandle(p->fd, &H);
    100. #if 1
    101. 		p = H;
    102. 		puts("");
    103. 		printf("Node:");
    104. 		while(p != NULL)
    105. 		{
    106. 			printf("%d ", p->fd);
    107. 			p = p->next;
    108. 		}
    109. #endif
    110. 		if(H->next == NULL)
    111. 			break;
    112. 	}
    113. 	close(sfd);
    114. 	free(H);
    115. 	return 0;
    116. }
    117.  
    118. void Argment(int argc, char *argv[])//错误输出
    119. {
    120. 	if(argc != 3)
    121. 	{
    122. 		fprintf(stderr, "%s [addr] [port]\n", argv[0]);
    123. 		exit(0);
    124. 	}
    125. }
    126.  
    127. void NodeCreate(Node **p)//创建节点
    128. {
    129. 	*p = malloc(sizeof(Node));
    130. 	if(p == NULL)
    131. 	{
    132. 		perror("malloc");
    133. 		exit(0);
    134. 	}
    135. 	bzero(*p, sizeof(Node));
    136. }
    137.  
    138. void AcceptHandle(int sfd, Node **H)//Accept句柄
    139. {
    140. 	Node *p = NULL;
    141. 	Addr_in caddr;
    142. 	socklen_t caddr_len = sizeof(Addr_in);
    143. 	int cfd = accept(sfd, (Addr *)&caddr, &caddr_len);
    144. 	if(cfd < 0)
    145. 	{
    146. 		perror("accept");
    147. 		exit(0);
    148. 	}
    149. 	fprintf(stderr, "client %s:%d connect success.\n",
    150. 			inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
    151. 	NodeCreate(&p);
    152. 	p->fd = cfd;
    153. 	p->next = *H;
    154. 	*H = p;
    155. }
    156.  
    157. int ClientHandle(int fd)//客户端句柄
    158. {
    159. 	int ret;
    160. 	char buf[1024] = {};
    161. 	ret = recv(fd, buf, 1024, 0);
    162. 	if(ret <= 0)
    163. 		return 0;
    164. 	printf("fd=%d buf = %s\n",fd, buf);
    165. 	if(buf[0] == '#')
    166. 		return 0;
    167. 	return ret;
    168. }

  • 相关阅读:
    NEON优化2：ARM优化高频指令总结
    企业财务数字化转型怎么才能落地？_光点科技
    Selenium+Python系列 - 开发环境搭建
    uni-app初步认识
    Redis 入门和数据类型讲解
    c语言tips-函数指针和指针函数
    升级node到指定版本
    [深入研究4G/5G/6G专题-54]: L3信令控制-3-软件功能与流程的切分-CU-UP网元的信令
    【Java】将Base64格式的图片等比伸缩至目标尺寸代码实现
    lvs+Keepalived高可用集群
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/127948144