• Linux学习——网络编程基础及TCP服务器

    TCP 协议分成了两个不同的协议：
    可靠传输： 用来检测网络传输中差错的传输控制协议TCP
    不可靠传输： 专门负责对不同网络进行互联的互联网协议IP

    一、网络采用分层的思想：


      1.每一层实现不同的功能，对上册的数据做透明传输
      2. 每一层向上层提供服务，同时使用下层提供的服务

    令牌环网：WIFI、 光纤。

    FDDI：GPRS、3G、4G。

    底层：Linux内核层

    FTP：传输文件

    SMTP：传输邮件

    TCP/IP协议分为哪四层，具体作用是什么——仅用于个人学习收藏分享_- Demon的博客-CSDN博客_tcp/ip协议包含哪几层

    二、各层典型的协议：

    1. 网络接口与物理层
     MAC地址： 48位全球唯一，网络设备的身份标识

    ARP/RARP:   
      ARP: IP地址----->MAC地址
      RARP: MAC地址--->IP地址

    PPP协议： 拨号协议（GPRS/3G/4G）
    网络层：
       IP地址
        IP: Internet protocol(分为IPV4和IPV6)
        ICMP: Internet控制管理协议，ping命令属于ICMP
        IGMP: Internet分组管理协议，广播、组播
    传输层：
           TCP: (Transfer Control protocol，传输控制协议) 提供面向连接的，一对一的可靠数据传输的协议
             即数据无误、数据无丢失、数据无失序、数据无重复到达的通信
           UDP: (user Datagram Protocol， 用户数据报协议)： 提供不可靠，无连接的尽力传输协议
            是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。
        SCTP： 是可靠传输，是TCP的增强版，它能实现多主机、多链路的通信（军方使用）

    流控制传输协议_百度百科

    应用层： 
      网页访问协议：HTTP/HTTPS
    　邮件发送接收协议： POP3（收）/SMTP(发) 、IMAP（可接收邮件的一部分)
        FTP（采用TCP的）,
        Telnet/SSH: 远程登录    （不太一样，前者是明文的，后者是加密的）
     嵌入式相关：
        NTP: 网络时钟协议
        SNMP: 简单网络管理协议（实现对网络设备集中式管理）      
        RTP/RTSP：用传输音视频的协议（安防监控）

    三、网络的封包和拆包：

    TCP和FTP之间用socket（系统调用）编程实现

    不断在数据前面加头部，在加上最后一个硬件头部后和CRC验证后，通过驱动来发给以太网或者网卡硬件设备来发送

    这就是一个以太网包 App加DATA就是FTP

    MSS和MTU



    最大传输单元_百度百科

    MSS（最大报文段长度）_百度百科

    路由器和交换机

    路由器与交换机基本原理_sj7575的博客-CSDN博客_交换机和路由器工作原理

    请问交换机和路由器分别的实现原理是什么？分别在哪个层次上面实现的？_keepingstudying的博客-CSDN博客_请问交换机和路由器分别的实现原理是什么?分别在哪个层次上面实现的?

    四、网络编程的预备知识

    4.1.SOCKET

     4.1.1 socket是一个应用编程的接口，它是一种特殊的文件描述符（对它执行IO的操作函数，比如,read(),write(),close()等操作函数）
     4.1.2 socket代表着网络编程的一种资源
     4.1.3 socket的类型：

     
    流式套接字(SOCK_STREAM)： 唯一对应着TCP
      提供了一个面向连接、可靠的数据传输服务，数据无差错、无重复的发送且按发送顺序接收。内设置流量控制，避免数据流淹没慢的接收方。数据被看作是字节流，无长度限制。
    数据报套接字(SOCK_DGRAM)： 唯一对应着UDP
       提供无连接服务。数据包以独立数据包的形式被发送，不提供无差错保证，数据可能丢失或重复，顺序发送，可能乱序接收。
    原始套接字(SOCK_RAW)：（对应着多个协议，发送穿透了传输层）
       可以对较低层次协议如IP、ICMP直接访问。

    4.2 IP地址


     

    1.IP地址分为IPV4和IPV6

      IPV4:采用32位的整数来表示
      IPV6：采用了128位整数来表示
    mobileIPV6: local IP(本地注册的IP)，roam IP(漫游IP)

    IPV4地址：
       点分形式： 192.168.7.246
       32位整数

     特殊IP地址:

       局域网IP: 192.XXX.XXX.XXX  10.XXX.XXX.XXX
       广播IP: xxx.xxx.xxx.255, 255.255.255.255(全网广播)
       组播IP: 224.XXX.XXX.XXX~239.xxx.xxx.xxx

    4.3 端口号


      16位的数字（1-65535）
        众所周知端口： 1~1023（FTP: 21，SSH： 22， HTTP:80， HTTPS:469）
        保留端口： 1024-5000（不建议使用）
        可以使用的：5000~65535
     TCP端口和UDP端口是相互独立的

    网络里面的通信是由 IP地址+端口号 来决定

    ip数据流走向图解(图)_JasonTome的博客-CSDN博客_ip数据流

    4.4 字节序

     字节序是指不同的CPU访问内存中的多字节数据时候，存在大小端（字节序）问题

     如CPU访问的是字符串，则不存在大小端问题

    一般来说：

       X86/ARM： 小端
       powerpc（摩托罗拉的）/mips, ARM作为路由器时，大端模式

       网络传输的时候采用大端模式
      =====

       本地字节序、网络字节序

    IP地址转换函数：
    in_addr_t inet_addr(const char *cp);

     cp: 点分形式的IP地址，结果是32位整数（内部包含了字节序的转换，默认是网络字节序的模式）
     特点： 1. 仅适应于IPV4
            2. 当出错时，返回-1
            3.此函数不能用于255.255.255.255的转换

    inet_pton()/inet_ntop()


       特点： 1.适应于IPV4和IPV6
              2.能正确的处理255.255.255.255的转换问题
         参数：
           1. af: 地址协议族（AF_INET或AF_INET6）
           2.src:是一个指针（填写点分形式的IP地址[主要指IPV4]）
    　　　 3.dst: 转换的结果给到dst

    RETURN VALUE
           inet_pton() returns 1 on success (network address was successfully con‐
           verted).  0 is returned if src  does  not contain  a  character  string representing a valid network address in the specified address family.  If af does not contain a valid address family, -1 is returned and errno is set to EAFNOSUPPORT.

    五、TCP编程API

    1.socket()函数

    1.1 参数：
      1.domain:
        AF_INET             IPv4 Internet protocols          ip(7)
        AF_INET6            IPv6 Internet protocols          ipv6(7)
        AF_UNIX, AF_LOCAL   Local communication              unix(7)
        AF_NETLINK          Kernel user interface device     netlink(7)
        AF_PACKET           Low level packet interface       packet(7)

      2.type:
       SOCK_STREAM: 流式套接字 唯一对应于TCP
       SOCK_DGRAM： 数据报套接字，唯一对应着UDP
       SOCK_RAW： 原始套接字
      3.protocol: 一般填0，原始套接字编程时需填充

    1.2 返回值：
     RETURN VALUE
           On  success,  a  file  descriptor  for  the new socket is returned.  On
           error, -1 is returned, and errno is set appropriately.

        成功时返回文件描述符，出错时返回为-1

    2.bind()函数

    2.1 参数：
       sockfd: 通过socket()函数拿到的fd
       addr: struct sockaddr的结构体变量的地址 
       addrlen: 地址长度 

      RETURN VALUE
           On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

    示例代码：
     
      如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程

      3.listen()函数: 把主动套接字变成被动套接字

          

    参数：
            sockfd: 通过socket()函数拿到的fd
            backlog： 同时允许几路客户端和服务器进行正在连接的过程（正在三次握手）
        一般填5， 测试得知,ARM最大为8

     TCP需要三次握手建立连接之后才能传输数据，所以使用TCP原始套接字传输数据需要先完成三次握手：
    第一次握手：客户端TCP头部 SYN位至为1 给定seq位的值
    第二次握手：服务端返回SYN+ACK(0x012)，ack_seq 为客户端第一次握手的seq位+1，并且会随机一个seq位值
    第三次握手：客户端需要获取到服务端响应seq位的值，将其+1，存入TCP头部ack_seq位中，seq位同样+1

    原始套接字构建 TCP三次握手 及相关问题_CodeGuN的博客-CSDN博客

      内核中服务器的套接字fd会维护2个链表：
              1. 正在三次握手的的客户端链表(数量=2*backlog+1)
    　　　　　２.已经建立好连接的客户端链表（已经完成３次握手分配好了newfd）

     比如：listen(fd, 5); //表示系统允许11(=2*5+1)个客户端同时进行三次握手

    返回值：

       RETURN VALUE
           On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

     4.accept(): 阻塞等待客户端连接请求

     

         ４.１　参数：
    　　　　　sockfd: 经过前面socket()创建并通过bind(),listen()设置过的fd
             addr和addrlen: 获取连接过来的客户的信息

         4.2 返回值：
          RETURN VALUE
           On  success,  these system calls return a nonnegative integer that is a descriptor for the accepted socket.  On
           error, -1 is returned, and errno is set appropriately.

           成功时返回已经建立好连接的新的newfd

    5.客户端的连接函数 connect()

    connect()函数和服务器的bind()函数写法类似：
    5.1 参数：
       sockfd: 通过socket()函数拿到的fd
       addr: struct sockaddr的结构体变量的地址 
       addrlen: 地址长度 

    5.2 返回值：
      RETURN VALUE
           If  the connection or binding succeeds, zero is returned.  On error, -1
           is returned, and errno is set appropriately.

    实验程序

    1. #ifndef __NET_H__
    2. #define __NET_H__
    3.  
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. #define SERV_PORT 5001
    17. #define SERV_IP_ADDR "192.168.26.128"
    18. #define BACKLOG 5
    19. #define QUIT_STR "quit"
    20.  
    21.  
    22. #endif
    1. #include "net.h"
    2. int main(void)
    3. {
    4. 	int fd = -1;
    5.         struct sockaddr_in sin;
    6.         /* 1. 创建socket fd*/
    7.         if( (fd = socket(AF_INET,SOCK_STREAM, 0)) < 0) {
    8.                 perror("socket");
    9.                 exit(1);
    10.         }
    11. 	/*2.连接服务器 */
    12. 	
    13.         /*2.1 填充struct sockaddr_in结构体变量 */
    14.         bzero(&sin,sizeof(sin));
    15.  
    16.         sin.sin_family = AF_INET;
    17.         sin.sin_port = htons(SERV_PORT); //网络字节序的端口号
    18. #if 0
    19.         sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
    20. #else
    21.         if( inet_pton(AF_INET, SERV_IP_ADDR, (void *)&sin.sin_addr) != 1) {
    22.                 perror("inet_pton");
    23.                 exit(1);
    24.         }
    25. #endif
    26.  
    27. 	if( connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
    28. 		perror("connect");
    29. 		exit(1);
    30. 	}
    31. 	
    32. 	printf("Client staring...OK!\n");
    33. 	/*3. 读写数据 */	
    34. 	char buf[BUFSIZ];
    35. 	int ret = -1;
    36. 	while(1) {
    37. 		bzero(buf, BUFSIZ);
    38. 		if( fgets(buf, BUFSIZ-1, stdin) ==NULL) {
    39. 			continue;
    40. 		} 
    41. 		do {
    42. 			ret = write(fd, buf, strlen(buf));
    43. 		}while(ret < 0 && EINTR == errno);
    44.  
    45. 		if( !strncasecmp(buf, QUIT_STR, strlen(QUIT_STR))) {  //用户输入了quit字符
    46.                         printf("Client is exiting!\n");
    47.                         break;
    48.                 }
    49. 	}	
    50.  
    51. 	/*4.关闭套接字 */
    52. 	close(fd);
    53. }
    1. #include "net.h"
    2.  
    3. int main()
    4. {
    5. 	int fd = -1;
    6. 	struct sockaddr_in sin;
    7. 	//创建socket fd*
    8. 	if((fd = socket(AF_INET,SOCK_STREAM, 0)) < 0){
    9. 		perror("socket");
    10. 		//return -1;
    11. 		exit(1);
    12. 	}
    13. 	//绑定
    14. 	//填充struct socketddr_in结构体变量
    15. 	bzero(&sin,sizeof(sin));//把sin全填充0
    16. 	sin.sin_family = AF_INET;
    17. 	sin.sin_port = htons(SERV_PORT); //网络字节端口号
    18. #if 0
    19. 	sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
    20. #else
    21. 	if( inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr) != 1){
    22. 		perror("inet_pton");
    23. 		exit(1);		
    24. 	}
    25. #endif
    26. 	//绑定
    27. 	if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
    28. 		perror("bind");
    29. 		exit(1);
    30. 	}
    31. 	//调用listen()把主动套接字变成被动套接字
    32. 	if(listen(fd,BACKLOG) < 0 ){
    33. 		perror("listen");
    34. 		exit(1);
    35. 	}
    36. 	printf("Server starting...OK!\n");
    37. 	int newfd = -1;
    38. 	//阻塞等待客户端连接
    39. 	newfd = accept(fd, NULL, NULL);
    40. 	if(newfd < 0){
    41. 		perror("accept");
    42. 		exit(1);
    43. 	}
    44. 	//5读写
    45. 	//..和newfd进行数据读写
    46. 	int ret = -1;
    47. 	char buf[BUFSIZ];
    48. 	bzero(buf,BUFSIZ);
    49. 	while(1){
    50. 	//	bzero(buf, BUFSIZ);
    51. 		do {
    52. 			ret = read(newfd, buf, BUFSIZ - 1);
    53. 		
    54. 		}while(ret < 0 && EINTR == errno);
    55. 		if(ret < 0) {
    56. 			perror("read");
    57. 			exit(1);
    58. 		}
    59. 		if(!ret) {
    60. 			break;
    61. 		}
    62. 		printf("Receive data: %s\n", buf);
    63. 		if(!strncasecmp(buf,QUIT_STR, strlen(QUIT_STR))) { // 用户输入了quit字符
    64. 			printf("Client is exiting!\n");
    65. 			break;
    66. 		}
    67. 	}
    68. 	close(newfd);
    69. 	close(fd);
    70. 		
    71. 	return 0;
    72. }
    73.  
    74.  
    75.  
    76.

    运行结果：

     现在还有一个问题换了机器后需要改程序把ip换成新机器的

     sin.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY = -1
    这样就可以绑定在任意ip上，htonl将本地字节序转化为网络字节序，INADDR_ANY = -1但是机器存的其实是全1，虽然大端字序小端字序一样但是这样写更严谨一些，这样写程序可以在任意一台机器运行，并且从同台机器的不同网卡接收到的信息都可处理。

    htonl(),htons(),ntohl(),ntons()--大小端模式转换函数 - 功夫 熊猫 - 博客园

    优化一下服务器和客户端：

    客户端：

    1. /*./client serv_ip serv_port */
    2. #include "net.h"
    3.  
    4.  
    5.  
    6. void usage (char *s)
    7. {
    8. 	printf ("\n%s serv_ip serv_port", s);
    9. 	printf ("\n\t serv_ip: server ip address");
    10. 	printf ("\n\t serv_port: server port(>5000)\n\n");
    11. }
    12.  
    13. int main (int argc, char **argv)
    14. {
    15. 	int fd = -1;
    16.  
    17. 	int port = -1;
    18. 	struct sockaddr_in sin;
    19.  
    20. 	if (argc != 3) {
    21. 		usage (argv[0]);
    22. 		exit (1);
    23. 	}
    24. 	/* 1. 创建socket fd */
    25. 	if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
    26. 		perror ("socket");
    27. 		exit (1);
    28. 	}
    29.  
    30. 	port = atoi (argv[2]);
    31. 	if (port < 5000) {
    32. 		usage (argv[0]);
    33. 		exit (1);
    34. 	}
    35. 	/*2.连接服务器 */
    36.  
    37. 	/*2.1 填充struct sockaddr_in结构体变量 */
    38. 	bzero (&sin, sizeof (sin));
    39.  
    40. 	sin.sin_family = AF_INET;
    41. 	sin.sin_port = htons (port);	//网络字节序的端口号
    42. #if 0
    43. 	sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
    44. #else
    45. 	if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
    46. 		perror ("inet_pton");
    47. 		exit (1);
    48. 	}
    49. #endif
    50.  
    51. 	if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
    52. 		perror ("connect");
    53. 		exit (1);
    54. 	}
    55.  
    56. 	printf ("Client staring...OK!\n");
    57. 	/*3. 读写数据 */
    58. 	char buf[BUFSIZ];
    59. 	int ret = -1;
    60. 	while (1) {
    61. 		bzero (buf, BUFSIZ);
    62. 		if (fgets (buf, BUFSIZ - 1, stdin) == NULL) {
    63. 			continue;
    64. 		}
    65. 		do {
    66. 			ret = write (fd, buf, strlen (buf));
    67. 		} while (ret < 0 && EINTR == errno);
    68.  
    69. 		if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    70. 			printf ("Client is exiting!\n");
    71. 			break;
    72. 		}
    73. 	}
    74.  
    75. 	/*4.关闭套接字 */
    76. 	close (fd);
    77. }
    78.  
    79.

    服务器端：

    1. #include "net.h"
    2. void cli_data_handle (void *arg);
    3. int main()
    4. {
    5. 	int fd = -1;
    6. 	struct sockaddr_in sin;
    7. 	//创建socket fd*
    8. 	if((fd = socket(AF_INET,SOCK_STREAM, 0)) < 0){
    9. 		perror("socket");
    10. 		//return -1;
    11. 		exit(1);
    12. 	}
    13. 	/*优化4： 允许绑定地址快速重用 */
    14. 	int b_reuse = 1;
    15. 	setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
    16. 	//绑定
    17. 	//填充struct socketddr_in结构体变量
    18. 	bzero(&sin,sizeof(sin));//把sin全填充0
    19. 	sin.sin_family = AF_INET;//地址族网际网区域
    20. 	sin.sin_port = htons(SERV_PORT); //网络字节端口号
    21. 	//优化使server可以绑定在任意IP上
    22. #if 1
    23. 	sin.sin_addr.s_addr = htonl(INADDR_ANY);//INADDY_ANY = -1
    24. #else
    25. 	if( inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr) != 1){
    26. 		perror("inet_pton");
    27. 		exit(1);		
    28. 	}
    29. #endif
    30. 	//绑定
    31. 	if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
    32. 		perror("bind");
    33. 		exit(1);
    34. 	}
    35. 	//调用listen()把主动套接字变成被动套接字
    36. 	if(listen(fd,BACKLOG) < 0 ){
    37. 		perror("listen");
    38. 		exit(1);
    39. 	}
    40. 	printf("Server starting...OK!\n");
    41. 	int newfd = -1;
    42. 	//阻塞等待客户端连接
    43. #if 0
    44. 	newfd = accept(fd, NULL, NULL);
    45. 	if(newfd < 0){
    46. 		perror("accept");
    47. 		exit(1);
    48. 	}
    49. #else
    50. //通过程序获取刚建立连接的socket客户端的ip地址和端口号
    51. 	pthread_t tid;
    52.  
    53. 	struct sockaddr_in cin;
    54. 	socklen_t addrlen = sizeof (cin);
    55.  
    56. 	while (1) {
    57. 		if ((newfd = accept (fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
    58. 			perror ("accept");
    59. 			exit (1);
    60. 		}
    61.  
    62. 		char ipv4_addr[16];
    63. 		if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
    64. 			perror ("inet_ntop");
    65. 			exit (1);
    66. 		}
    67.  
    68. 		printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, htons (cin.sin_port));
    69.  
    70. 		pthread_create (&tid, NULL, (void *) cli_data_handle, (void *) &newfd);
    71. 	}
    72.  
    73. 	close (fd);
    74. 	return 0;
    75. }
    76. #endif
    77. void cli_data_handle (void *arg)
    78. {
    79. 	int newfd = *(int *) arg;
    80.  
    81. 	printf ("handler thread: newfd =%d\n", newfd);
    82.  
    83. 	//..和newfd进行数据读写
    84. 	int ret = -1;
    85. 	char buf[BUFSIZ];
    86. 	while (1) {
    87. 		bzero (buf, BUFSIZ);
    88. 		do {
    89. 			ret = read (newfd, buf, BUFSIZ - 1);
    90. 		} while (ret < 0 && EINTR == errno);
    91. 		if (ret < 0) {
    92.  
    93. 			perror ("read");
    94. 			exit (1);
    95. 		}
    96. 		if (!ret) {				//对方已经关闭
    97. 			break;
    98. 		}
    99. 		printf ("Receive data: %s\n", buf);
    100.  
    101. 		if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    102. 			printf ("Client(fd=%d) is exiting!\n", newfd);
    103. 			break;
    104. 		}
    105. 	}
    106. 	close (newfd);
    107.  
    108. }
    109.  
    110.  
    111.  
    112.  
    113.

    结果：

     

    下面试试多进程服务器

    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. 	int ret = -1;
    109. 	char buf[BUFSIZ];
    110. 	while (1) {
    111. 		bzero (buf, BUFSIZ);
    112. 		do {
    113. 			ret = read (newfd, buf, BUFSIZ - 1);
    114. 		} while (ret < 0 && EINTR == errno);
    115. 		if (ret < 0) {
    116.  
    117. 			perror ("read");
    118. 			exit (1);
    119. 		}
    120. 		if (!ret) {				//对方已经关闭
    121. 			break;
    122. 		}
    123. 		printf ("Receive data: %s\n", buf);
    124.  
    125. 		if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) {	//用户输入了quit字符
    126. 			printf ("Client(fd=%d) is exiting!\n", newfd);
    127. 			break;
    128. 		}
    129. 	}
    130. 	close (newfd);
    131.  
    132. }

  • 相关阅读:
    a16z公布AI产品流量排名，ChatGPT占据榜首
    python将visio转换为 PDF 文件
    第五十七讲 GPIO子系统
    索尼 toio™应用创意开发征文｜toio俄罗斯方块游戏
    vscode使用插件KoroFileHeader添加注释
    断开自定义模块与自定义库的链接
    腾讯Mini项目课程前置学习笔记（第一轮）
    GBase 8c 产品运行环境
    jvm基础--JVM内存模型
    编写递归函数，求斐波那契数列第n项
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/127866679