• Linux——网络编程总结性学习

    什么是ISP？

    网络业务提供商_百度百科

    计算机网络有哪些分类方式,计算机网络有哪些分类？_陈泽杜的博客-CSDN博客

    路由器_百度百科

     目前实际的网络分层是TCP/IP四层协议

    当我们浏览⽹站找到想要下载的⽂件以后，找到相应的接⼝点击下载就好了。剩下的⼯作就交给⽹ 络了，那么⽹络是如果传输的呢？

            答案就是先封包然后再拆包。实际的远距离传输，可能会涉及多个⽹络，多个路由器。这⾥简化成 ⼀个来表示。我们看到，每⼀层都有相应的控制信息，需要加到数据前⾯，我们把这些控制信息称之为 包头。每层都有不同我包头，⽐如应⽤层可能就是FTP的包头，然后，传输层可能就是TCP包头，再往下 传输层： 应⽤层： 数据的封包与拆包 7 依次就是IP包，以太⽹ （Ethernet），到了物理层以后，上层交下来的数据，就会变成bit流，被放的实 际的物理设备上进⾏传输。

            如果⽬标在本⽹络内部，数据就会被直接发送的⽬标主机上⾯，作相反的操作，也就是拆包。⼀般 我们下载的⽂件基本上都存在于远程的服务器。所以，必然要经过多个⽹络，多个路由器。每个路由器 都按照如图所示的步骤，层层拆包，折到⽹络层的IP头以后，和⾃⼰的⼀个叫做路由表的东⻄进⾏⽐ 对，确定⼀个合适的⽹络地址，按照新的⽹络地址再次进⾏封装。下⼀个路由器⽣复这个动作，直到把 数据传送给⽬标主机为⽌。

            最后，再由⽬标主机，也就是你的电脑，进⾏拆包。然后把数据展示给你或者直接存储到磁盘上。

    网络程序的架构

    ⽹络程序通常有两种架构，⼀种是

    B/S（Browser/Server，浏览器/服务器）架构

    ⽐如我们使⽤⽕狐浏览器浏览Web⽹站，⽕狐浏览器就是⼀个Browser，⽹站上运⾏的Web就是⼀个服 务器。这种架构的优点是⽤户只需要在⾃⼰电脑上安装⼀个⽹⻚浏览器就可以了，主要⼯作逻辑都在服 务器上完成，减轻了⽤户端的升级和维护的⼯作量。

    另外⼀种架构是C/S（Client/Server，客户机/服务器）架构

    这种架构要在服务器端和客户端分部安装不同的软件，并且不同的应⽤，客户端也要安装不同的客户机 软件，有时候客户端的软件安装或升级⽐较复杂，维护起来成本较⼤。但此种架构的优点是可以较充分 地利⽤两端的硬件能⼒，较为合理地分配任务。值得注意的是，客户机和服务器实际指两个不同的进 程，服务器是提供服务的进程，客户机是请求服务和接受服务的进程，它们通常位于不同的主机上（也 可以是同⼀主机上的两个进程），这些主机有⽹络连接，服务器端提供服务并对来⾃客户端进程的请求 做出响应。⽐如我们常⽤的QQ，我们⾃⼰电脑上的QQ程序就是⼀个客户端，⽽在腾讯公司内部还有服 务器端器程序。

    基于套接字的⽹络编程中，通常使⽤C/S架构。⼀个简单的客户机和服务器之间的通信过程如下： 1. 客户机向服务器提出⼀个请求

    2. 服务器收到客户机的请求，进⾏分析处理

    3. 服务器将处理的结果返回给客户机 通常，⼀个服务器可以向多个客户机提供服务。因此对服务器来说，还需要考虑如何有效地处理多个客 户机的请求。 

     这里的ip是公网ip，局域网也一样，在一个局域网内IP也不能相同，他们经过一个路由统一封装成公网ip。

     网络桥接_百度百科

    从前192.168是专用局域网段

     

     一般不使用的特殊ip

     

    IP地址是分等级的地址结构，分两个等级的好处是

     (3) 地址掩码 ⼜称为⼦⽹掩码 (subnet mask)。

    位数：32 位。

    ⽬的：让机器从 IP 地址迅速算出⽹络地址。

    由⼀连串 1 和接着的⼀连串 0 组成，⽽ 1 的个数就是⽹络前缀的⻓度。

    /20 地址块的地址掩码：11111111 11111111 11110000 00000000

    点分⼗进制记法：255.255.240.0

    CIDR 记法：255.255.240.0/20。

    默认地址掩码

     

     IP地址在Linux当中的实现

     IP地址是⼀个32位的数据

    通常被封装成如下数据类型

    struct in_addr { uint32_t s_addr; };

    in_addr_t

    uint32_t

     

     

     常用的熟知端口

     

    计算机电路先处理低位字节，效率比较高，因为计算都是从低位开始的。所以，计算机的内部处理都是小端字节序。但是，人类还是习惯读写大端字节序。所以，除了计算机的内部处理，其他的场合比如网络传输和文件储存，几乎都是用的大端字节序。正是因为这些原因才有了字节序。

    计算机处理字节序的时候，如果是大端字节序，先读到的就是高位字节，后读到的就是低位字节。小端字节序则正好相反

    1. #include 
    2. typedef unsigned char byte;
    3. typedef unsigned int word;
    4.  
    5. //#define N 1
    6.  
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10. 	word val32 = 0x11223344;
    11. 	byte val8 = *( (byte*)&val32 );	
    12.  
    13. 	if(val8 == 0x44)
    14. 		printf("本机是⼩端字节序\n");
    15. 	else
    16. 		printf("本机是⼤端字节序\n");
    17. 	int c = 1;
    18. 	//int *a = c;
    19. 	char b = *(char*)&c;
    20. 	printf("%p %d\n",&c ,b);
    21.  
    22.  
    23. 	return 0;
    24. }

     

    1. #include 
    2. #include 
    3. typedef unsigned char byte;
    4. typedef unsigned int word;
    5. int main(int argc, char *argv[])
    6. {
    7. 	word val32 = 0x11223344;
    8. 	byte val8 = *( (byte*)&val32 );
    9. 	if(val8 == 0x44)
    10. 	{
    11. 		printf("本机是⼩端字节序\n");
    12. 		val32 = htonl(val32);
    13. 		val8 = *( (byte*)&val32 );
    14. 		if(val8 == 0x44)
    15. 			printf("字节序没有转换\n");
    16. 		else
    17. 			printf("转换成功, 现在是⽹络字节序了\n");
    18. 	}
    19. 	return 0;
    20. }

     IP地址的转换函数

     

    来个小实验，使用本机的两个虚拟机根据ip和端口号通信

     

    只能一对一谁手快和谁通信

     服务器是如何实现每台服务器都是公网IP的呢？

    socket分类

     

     

     

    流式套接字对应TCP数据报套接字对应UDP，所以protocol是0，只用用原始套接字时才需要有参数。

     套接字不知用于网络通信也可用于进程间通信，在网络通信中可选用IIPV4和IPV6

     

     

    !g就是shell中上次输入的g开头的命令

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. int main(int argc, char **argv)
    8. {
    9. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    10. 	if(fd < 0)
    11. 	{
    12. 		perror("socket");
    13. 		exit(0);
    14. 	}
    15. 	struct sockaddr_in addr;
    16. 	addr.sin_family = AF_INET;
    17. 	addr.sin_port = htons(8888);
    18. 	addr.sin_addr.s_addr = inet_addr("192.168.26.128");
    19. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)))//成功0/失败-1
    20. 	{
    21. 		perror("bind");
    22. 		exit(0);
    23. 	}
    24. 	struct sockaddr_in sin;
    25. 	socklen_t sinlen = sizeof(addr);
    26. 	if(getsockname(fd, (struct sockaddr *)&sin, &sinlen))
    27. 	{
    28. 		perror("getsockname");
    29. 		exit(0);
    30. 	}
    31. 	printf("文件描述符%d绑定地址是%s,端口号%d\n", fd, inet_ntoa(sin.sin_addr),ntohs(sin.sin_port));
    32. 	return 0;
    33. }

     

     

     

     

     

     

     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #define BACKLOG 5//可以有5个等待在队列中
    8.  
    9. int main(int argc, char **argv)
    10. {
    11. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    12. 	if(fd < 0)
    13. 	{
    14. 		perror("socket");
    15. 		exit(0);
    16. 	}
    17. 	struct sockaddr_in addr;
    18. 	addr.sin_family = AF_INET;
    19. 	addr.sin_port = htons(8888);
    20. 	addr.sin_addr.s_addr = inet_addr("192.168.26.128");
    21. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)))//成功0/失败-1
    22. 	{
    23. 		perror("bind");
    24. 		exit(0);
    25. 	}
    26. 	struct sockaddr_in sin;
    27. 	socklen_t sinlen = sizeof(addr);
    28. 	if(getsockname(fd, (struct sockaddr *)&sin, &sinlen))
    29. 	{
    30. 		perror("getsockname");
    31. 		exit(0);
    32. 	}
    33. 	printf("文件描述符%d绑定地址是%s,端口号%d\n", fd, inet_ntoa(sin.sin_addr),ntohs(sin.sin_port));
    34. 	if(listen(fd, BACKLOG)){
    35. 		perror("listen");
    36. 		exit(0);
    37. 	}
    38. 	printf("listen...\n");
    39. 	struct sockaddr_in cin;
    40. 	socklen_t cinlen = sizeof(cin);
    41. 	int newfd = accept(fd, (struct sockaddr *)&cin, &cinlen);
    42. 	//int newfd = accept(fd, NULL, NULL);
    43. 	if(newfd < 0)
    44. 	{
    45. 		perror("accept");
    46. 		exit(0);
    47. 	}
    48. 	printf("文件描述符%d绑定IP地址%s,端口号%d\n", newfd, inet_ntoa(cin.sin_addr), ntohs(cin.sin_port));
    49. 	char buf[1024] = {};
    50. 	read(newfd, buf, 1024);
    51. 	printf("%s\n", buf);
    52. 	
    53. 	close(newfd);
    54. 	close(fd);
    55.  
    56. 	return 0;
    57. }

     还是用nc这次可以看连接服务器用户的相关信息

     

     

     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. int main(int argc, char *argv[])
    11. {
    12. 	if(argc != 3)
    13. 	{
    14. 		printf("%s [IP][PORT]\n", argv[0]);
    15. 		exit(0);
    16. 	}
    17. /*1.创建套接字*/
    18. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    19. 	if(fd < 0)
    20. 	{
    21. 		perror("socket");
    22. 		exit(0);
    23. 	}
    24. /*2.设置通信结构体*/
    25. 	struct sockaddr_in sin;
    26. 	sin.sin_family = AF_INET;
    27. 	sin.sin_port = htons(atoi(argv[2]));
    28. 	sin.sin_addr.s_addr = inet_addr(argv[1]);
    29. /*3.向服务端发起连接请求*/
    30. 	if(connect(fd, (struct sockaddr *)&sin, sizeof(sin)))
    31. 	{
    32. 		perror("connect");
    33. 		exit(0);	
    34. 	}
    35. 	socklen_t sinlen = sizeof(sin);
    36. 	if(getsockname(fd, (struct sockaddr *)&sin, &sinlen))
    37. 	{
    38. 		perror("getsockname");
    39. 		exit(0);
    40. 	}
    41. 	printf("文件描述符%d绑定IP地址%s,端口号%d\n", fd, inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
    42. /*4.通信*/
    43. 	char buf[1024] = {"test\n"}; //8142	
    44. 	write(fd, buf, strlen(buf)+1);
    45. 	memset(buf, 0, 1024);
    46. 	//printf("input->");
    47. 	//fgets(buf, , stdin);
    48. 	//write(fd, buf, strlen(buf)+1);
    49. 	read(fd, buf, 1024);
    50. 	printf("buf = %s\n", buf);
    51. 	close(fd);
    52. 	return 0;
    53. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #define BACKLOG 5//可以有5个等待在队列中
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11. 	if(argc != 3)
    12. 	{
    13. 		fprintf(stderr, "%s [IP] [PORT] \n", argv[0]);
    14. 		exit(0);
    15. 	}
    16. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    17. 	if(fd < 0)
    18. 	{
    19. 		perror("socket");
    20. 		exit(0);
    21. 	}
    22. 	struct sockaddr_in addr;
    23. 	addr.sin_family = AF_INET;
    24. 	addr.sin_port = htons(atoi(argv[2]));
    25. 	addr.sin_addr.s_addr = inet_addr(argv[1]);
    26. 	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)))//成功0/失败-1
    27. 	{
    28. 		perror("bind");
    29. 		exit(0);
    30. 	}
    31. 	struct sockaddr_in sin;
    32. 	socklen_t sinlen = sizeof(addr);
    33. 	if(getsockname(fd, (struct sockaddr *)&sin, &sinlen))
    34. 	{
    35. 		perror("getsockname");
    36. 		exit(0);
    37. 	}
    38. 	printf("文件描述符%d绑定地址是%s,端口号%d\n", fd, inet_ntoa(sin.sin_addr),ntohs(sin.sin_port));
    39. 	if(listen(fd, BACKLOG)){
    40. 		perror("listen");
    41. 		exit(0);
    42. 	}
    43. 	printf("listen...\n");
    44. 	struct sockaddr_in cin;
    45. 	socklen_t cinlen = sizeof(cin);
    46. 	int newfd = accept(fd, (struct sockaddr *)&cin, &cinlen);
    47. 	//int newfd = accept(fd, NULL, NULL);
    48. 	if(newfd < 0)
    49. 	{
    50. 		perror("accept");
    51. 		exit(0);
    52. 	}
    53. 	printf("文件描述符%d绑定IP地址%s,端口号%d\n", newfd, inet_ntoa(cin.sin_addr), ntohs(cin.sin_port));
    54. 	char buf[1024] = {};
    55. 	read(newfd, buf, 1024);
    56. 	printf("%s\n", buf);
    57. 	
    58. 	close(newfd);
    59. 	close(fd);
    60.  
    61. 	return 0;
    62. }
    63.  
    64.

     

     

     哈哈天天ping百度百度不爱搭理了，ping一下华清试试 

    socket有两个缓冲区一个发送一个接收

     

     

    1. #include "net.h"
    2. int main(int argc, char *argv[])
    3. {
    4. if(argc != 3)
    5. {
    6. printf("%s [IP][PORT]\n", argv[0]);
    7. exit(0);
    8. }
    9. /*1.创建套接字*/
    10. int fd = socket(AF_INET, SOCK_DGRAM, 0);
    11. if(fd < 0)
    12. {
    13. perror("socket");
    14. exit(0);
    15. }
    16. /*2.设置通信结构体*/
    17. struct sockaddr_in sin;
    18. sin.sin_family = AF_INET;
    19. sin.sin_port = htons(atoi(argv[2]));
    20. sin.sin_addr.s_addr = inet_addr(argv[1]);
    21. /*3.向服务端发起连接请求*/
    22. if(connect(fd, (struct sockaddr *)&sin, sizeof(sin)))
    23. {
    24. perror("connect");
    25. exit(0);
    26. }
    27. /*4.通信*/
    28. char buf[BUFSIZ];
    29. while(1)
    30. {
    31. bzero(buf, BUFSIZ);
    32. printf("input->");
    33. fgets(buf, BUFSIZ, stdin);
    34. send(fd, buf, strlen(buf)+1, 0);
    35. printf("buf = %s\n", buf);
    36. if(buf[0] == '#')
    37. break;
    38. }
    39. close(fd);
    40. return 0;
    41. }

     

     

     

    相关程序参考Linux——UDP_宇努力学习的博客-CSDN博客 

    先win+R wt 然后telnet 

    win上没有nc可以用telnet

     

     

     看以往文章

    这里记录一个老师写的大型群体交流服务器

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define BACKLOG 5
    11.  
    12. void handle(int sig)
    13. {
    14. 	printf("child process exit...\n");
    15. 	wait(NULL);
    16. }
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20. 	if(argc != 3)
    21. 	{
    22. 		printf("%s[IP][PORT]\n", argv[0]);
    23. 		exit(0);
    24. 	}
    25.  
    26. 	signal(SIGCHLD, handle);
    27.  
    28. 	int fd = socket(AF_INET, SOCK_STREAM, 0);
    29. 	if(fd < 0)
    30. 	{
    31. 		perror("socket");
    32. 		exit(0);
    33. 	}
    34.  
    35. 	struct sockaddr_in addr;
    36. 	addr.sin_family = AF_INET;
    37. 	addr.sin_port = htons(atoi(argv[2]));
    38. 	addr.sin_addr.s_addr = inet_addr(argv[1]);
    39.  
    40. 	if( bind(fd, (struct sockaddr *)&addr, sizeof(addr)) )
    41. 	{
    42. 		perror("bind");
    43. 		exit(0);
    44. 	}
    45.  
    46. 	struct sockaddr_in sin;
    47. 	socklen_t sinlen = sizeof(addr);
    48. 	if(getsockname(fd, (struct sockaddr *)&sin, &sinlen))
    49. 	{
    50. 		perror("getsockname");
    51. 		exit(0);
    52. 	}
    53. 	printf("文件描述符%d绑定的IP地址是%s，端口号%d\n", fd, inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
    54.  
    55. 	if( listen(fd, BACKLOG) )
    56. 	{
    57. 		perror("listen");
    58. 		exit(0);
    59. 	}
    60.  
    61. 	printf("listen...\n");
    62.  
    63. 	pid_t pid;
    64. 	int newfd;
    65. 	char buf[1024] = {};
    66. 	struct sockaddr_in cin;
    67. 	socklen_t cinlen = sizeof(cin);
    68.  
    69. 	while(1)
    70. 	{
    71. 		newfd = accept(fd, (struct sockaddr *)&cin, &cinlen);
    72. 		if(newfd < 0)
    73. 		{
    74. 			perror("accept");
    75. 			exit(0);
    76. 		}
    77. 		printf("文件描述符%d绑定的IP地址是%s，端口号%d\n", newfd, inet_ntoa(cin.sin_addr), ntohs(cin.sin_port));
    78. 		pid = fork();
    79. 		if(pid < 0)
    80. 		{
    81. 			perror("fork");
    82. 			exit(0);
    83. 		}
    84. 		else if(!pid)
    85. 		{
    86. 			close(fd);
    87. 			while(1)
    88. 			{
    89. 				memset(buf, 0, 1024);
    90. 				if(!read(newfd, buf, 1024))
    91. 					break;
    92. 				printf("%s\n", buf);
    93. 			}
    94. 			close(newfd);
    95. 			exit(0);
    96. 		}
    97. 		else
    98. 			close(newfd);
    99. 	}
    100. 	close(fd);
    101. 	return 0;
    102. }

    select实现服务器

    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)
    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. }

  • 相关阅读:
    STM32物联网项目-HMI串口屏
    如何实现 Python Switch Case 语句？
    FPGA实现双向电平转换
    C#可视化 家用轿车信息查询系统（具体做法及全部代码）
    scp 出现Permission denied错误 解决方法
    Hystrix的原理及应用：构建微服务容错体系的利器（一）
    （2022牛客多校五）B-Watches(二分)
    Mysql的JDBC知识点
    《Python数据分析入门学习》- 3、进阶数据预处理
    Redis基础
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/127971032