Linux 环境下的阻塞网络编程原理（十九）

ゝ一世哀愁。 2022-10-29 13:28 182阅读 0赞

今天分析Linux 环境下的阻塞网络编程原理

一、阻塞网络原理：

Linux 环境下 的基础网络编程和  JDK  中的  BIO  几乎差不多，参见下面的代码图片：

***1、客户端代码示例：***

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #define PORT 8888								/*侦听端口地址*/
    
    int main(int argc, char *argv[])
    {
    	int s;										/*s为socket描述符*/
    	struct sockaddr_in server_addr;			/*服务器地址结构*/
    	
    	s = socket(AF_INET, SOCK_STREAM, 0); 		/*建立一个流式套接字 */
    	if(s < 0){									/*出错*/
    		printf("socket error\n");
    		return -1;
    	}	
    	
    	/*设置服务器地址*/
    	bzero(&server_addr, sizeof(server_addr));	/*清零*/
    	server_addr.sin_family = AF_INET;					/*协议族*/
    	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);	/*本地地址*/
    	server_addr.sin_port = htons(PORT);				/*服务器端口*/
    	
    	/*将用户输入的字符串类型的IP地址转为整型*/
    	inet_pton(AF_INET, argv[1], &server_addr.sin_addr);	
    	/*连接服务器*/
    	connect(s, (struct sockaddr*)&server_addr, sizeof(struct sockaddr));
    	process_conn_client(s);						/*客户端处理过程*/
    	close(s);									/*关闭连接*/
    	return 0;
    }

客户端的处理过程：

#include <stdio.h>
    #include <string.h>
    /*客户端的处理过程*/
    void process_conn_client(int s)
    {
    	ssize_t size = 0;
    	char buffer[1024];							/*数据的缓冲区*/
    	
    	for(;;){									/*循环处理过程*/
    		/*从标准输入中读取数据放到缓冲区buffer中*/
    		size = read(0, buffer, 1024);
    		if(size > 0){							/*读到数据*/
    			write(s, buffer, size);				/*发送给服务器*/
    			size = read(s, buffer, 1024);		/*从服务器读取数据*/
    			write(1, buffer, size);				/*写到标准输出*/
    		}
    	}	
    }

2、java 代码示例：

public static void main(String[] args) throws IOException {
            //客户端启动必备
            Socket socket = null;
            //实例化与服务端通信的输入输出流
            ObjectOutputStream output = null;
            ObjectInputStream input = null;
            //服务器的通信地址
            InetSocketAddress addr = new InetSocketAddress("127.0.0.1",10001);
            try{
                socket = new Socket();
                socket.connect(addr);//连接服务器
                output = new ObjectOutputStream(socket.getOutputStream());
                input = new ObjectInputStream(socket.getInputStream());
                /*向服务器输出请求*/
                output.writeUTF("Mark");
                output.flush();
                //接收服务器的输出
                System.out.println(input.readUTF());
            }finally{
                if (socket!=null) socket.close();
                if (output!=null) output.close();
                if (input!=null) input.close();
            }
        }

和在  Java  中的客户端差不多，也要创建一个  socket  套接字，也要连接服务器，连接成功后，进行网络的读写。

***3、服务端  java代码示例：***

public static void main(String[] args) throws IOException {
            //服务端启动必备
            ServerSocket serverSocket = new ServerSocket();
            //表示服务端在哪个端口上监听
            serverSocket.bind(new InetSocketAddress(10001));
            System.out.println("Start Server ....");
            try{
                while(true){
                    new Thread(new ServerTask(serverSocket.accept())).start();
                }
            }finally {
                serverSocket.close();
            }
        }

***4、服务端  C 语言代码示例：***

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #define PORT 8888						/*侦听端口地址*/
    #define BACKLOG 2						/*侦听队列长度*/
    
    int main(int argc, char *argv[])
    {
    	int ss,sc;		/*ss为服务器的socket描述符，sc为客户端的socket描述符*/
    	struct sockaddr_in server_addr;	/*服务器地址结构*/
    	struct sockaddr_in client_addr;	/*客户端地址结构*/
    	int err;							/*返回值*/
    	pid_t pid;							/*分叉的进行ID*/
    
    	/*建立一个流式套接字*/
    	ss = socket(AF_INET, SOCK_STREAM, 0);
    	if(ss < 0){							/*出错*/
    		printf("socket error\n");
    		return -1;	
    	}
    	
    	/*设置服务器地址*/
    	bzero(&server_addr, sizeof(server_addr));			/*清零*/
    	server_addr.sin_family = AF_INET;					/*协议族*/
    	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);	/*本地地址*/
    	server_addr.sin_port = htons(PORT);				/*服务器端口*/
    	
    	/*绑定地址结构到套接字描述符*/
    	err = bind(ss, (struct sockaddr*)&server_addr, sizeof(server_addr));
    	if(err < 0){/*出错*/
    		printf("bind error\n");
    		return -1;	
    	}
    	
    	/*设置侦听*/
    	err = listen(ss, BACKLOG);
    	if(err < 0){										/*出错*/
    		printf("listen error\n");
    		return -1;	
    	}
    	
    		/*主循环过程*/
    	for(;;)	{
    		socklen_t addrlen = sizeof(struct sockaddr);
    		
    		sc = accept(ss, (struct sockaddr*)&client_addr, &addrlen); 
    		/*接收客户端连接*/
    		if(sc < 0){							/*出错*/
    			continue;						/*结束本次循环*/
    		}	
    		
    		/*建立一个新的进程处理到来的连接*/
    		pid = fork();						/*分叉进程*/
    		if( pid == 0 ){						/*子进程中*/
    			process_conn_server(sc);		/*处理连接*/
    			close(ss);						/*在子进程中关闭服务器的侦听*/
    		}else{
    			close(sc);						/*在父进程中关闭客户端的连接*/
    		}
    	}
    }

C语言服务端处理过程

/*服务器对客户端的处理*/
    void process_conn_server(int s)
    {
    	ssize_t size = 0;
    	char buffer[1024];							/*数据的缓冲区*/
    	
    	for(;;){									/*循环处理过程*/		
    		size = read(s, buffer, 1024);			/*从套接字中读取数据放到缓冲区buffer中*/
    		if(size == 0){							/*没有数据*/
    			return;	
    		}
    		
    		/*构建响应字符，为接收到客户端字节的数量*/
    		sprintf(buffer, "%d bytes altogether\n", size);
    		write(s, buffer, strlen(buffer)+1);/*发给客户端*/
    	}	
    }

和在 Java 中的服务端差不多，也要创建一个 socket 套接字，也要绑定端口并侦听，接受客户端的连接请求，连接建立后产生一个新的 socket 进行网络的读写。

***二、Linux环境*** ***网络通信***

***1、*** ***从***  ***Linux***  ***代码结构看网络通信***

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

Linux  内核的源码包含的东西很多，在  Linux  的源代码中，网络设备驱动对应的逻辑位于driver/net/ethernet, 其中  intel  系列网卡的驱动在  driver/net/ethernet/intel  目录下。协议栈模

块代码位于  kernel  和  net  目录。其中 net  目录中包含  Linux  内核的网络协议栈的代码。子目录  ipv4  和  ipv6  为  TCP/IP  协议栈的 IPv4  和  IPv6  的实现，主要包含了  TCP 、 UDP 、 IP  协议的代码，还有  ARP  协议、 ICMP  协议、IGMP  协议代码实现，以及如  proc 、 ioctl  等控制相关的代码。站在网络通信的角度，源代码组织的表现形式如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1][]

网络协议栈是由若干个层组成的，网络数据的流程主要是指在协议栈的各个层之间的传递。 一个 TCP  服务器的流程按照建立  socket() 函数，绑定地址端口  bind() 函数，侦听端口  listen()

函数，接收连接 accept() 函数，发送数据  send() 函数，接收数据  recv() 函数，关闭  socket() 函数的顺序来进行。与此对应内核的处理过程也是按照此顺序进行的，网络数据在内核中的处理过程主要是在网卡和协议栈之间进行: 从网卡接收数据，交给协议栈处理 ; 协议栈将需要发送的数据通过网络发出去。由下图中可以看出，数据的流向主要有两种。应用层输出数据时，数据按照自上而下的顺序，依次通过应用 API  层、协议层和接口层 ; 当有数据到达的时候，自下而上依次通过接口层、协议层和应用 API  层的方式，在内核层传递。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2][]

应用层  Socket  的初始化、绑定 (bind) 和销毁是通过调用内核层的  socket() 函数进行资源的申请和销毁的。 发送数据的时候，将数据由应用 API  层传递给协议层，协议层在  UDP  层添加  UDP  的首部、TCP 层添加  TCP  的首部、 IP  层添加  IP  的首部，接口层的网卡则添加以太网相关的信息后，通过网卡的发送程序发送到网络上。接收数据的过程是一个相反的过程，当有数据到来的时候，网卡的中断处理程序将数据从以太网网卡的 FIFO  对列中接收到内核 , 传递给协议层 , 协议层在  IP  层剥离  IP  的首部、 UDP  层剥离 UDP  的首部、 TCP  层剥离  TCP  的首部后传递给应用  API  层，应用  API  层查询  socket  的 标识后，将数据送给用户层匹配的 socket 。在 Linux  内核实现中，链路层协议靠网卡驱动来实现，内核协议栈来实现网络层和传输层。

内核对更上层的应用层提供  socket  接口来供用户进程访问。

***2、中断、上半部、下半部***

内核和设备驱动是通过中断的方式来处理的。所谓中断，可以理解为当设备上有数据到达的时候，会给 CPU  的相关引脚上触发一个电压变化，以通知  CPU  来处理数据。 计算机执行程序时，会有优先级的需求。比如，当计算机收到断电信号时（电容可以保存少许电量，供 CPU 运行很短的一小段时间），它应立即去保存数据，保存数据的程序具有较高的优先级。 一般而言，由硬件产生的信号需要 cpu 立马做出回应（不然数据可能就丢失），所以它的优先级很高。cpu  理应中断掉正在执行的程序，去做出响应；当  cpu  完成对硬件的响应后， 再重新执行用户程序。中断的过程如下图，和函数调用差不多。只不过函数调用是事先定好位置，而中断的位置由“信号”决定。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3][]

以键盘为例，当用户按下键盘某个按键时，键盘会给  cpu  的中断引脚发出一个高电平。cpu 能够捕获这个信号，然后执行键盘中断程序。同样，当网卡把数据写入到内存后，网卡向 cpu  发出一个中断信号，操作系统便能得知有新数据到来，再通过网卡中断程序去处理数据。对于网络模块来说，由于处理过程比较复杂和耗时，如果在中断函数中完成所有的处理， 将会导致中断处理函数（优先级过高）将过度占据 CPU ，将导致  CPU  无法响应其它设备，例如鼠标和键盘的消息。因此 Linux  中断处理函数是分上半部和下半部的。上半部是只进行最简单的工作，快速处理然后释放 CPU ，接着  CPU  就可以允许其它中断进来。剩下将绝大部分的工作都放到下半部中，可以慢慢从容处理。2.4  以后的内核版本采用的下半部实现方式是软中断，由  ksoftirqd内核线程全权处理。和硬中断不同的是，硬中断是通过给 CPU  物理引脚施加电压变化，而软中断是通过给内存中的一个变量的二进制值以通知软中断处理程序。

***三、Linux***  ***网络包接收过程***

内核收包的概览

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 4][]

当网卡上收到数据以后， Linux  中第一个工作的模块是网络驱动。 网络驱动会以  DMA  的方式把网卡上收到的帧写到内存里。再向 CPU  发起一个中断，以通知  CPU  有数据到达。第

二步，当  CPU  收到中断请求后，会去调用网络驱动注册的中断处理函数。 网卡的中断处理函数并不做过多工作，发出软中断请求，然后尽快释放 CPU 。 ksoftirqd  检测到有软中断请求到 达，调用 poll  开始轮询收包，收到后交由各级协议栈处理。最后会被放到用户  socket  的接收队列中。

1、准备工作

1) 、创建  ksoftirqd  内核线程

Linux  的软中断都是在专门的内核线程（ ksoftirqd ）中进行的，因此我们非常有必要看一下这些进程是怎么初始化的，这样我们才能在后面更准确地了解收包过程。该进程数量不是 1 个，而是  N  个，其中  N  等于你的机器的核数。系统初始化的时候会创建出 softirqd  进程。当 ksoftirqd  被创建出来以后，它就会进入自己的线程循环函数不停地判断有没有软中断需要被处理。这里需要注意的一点是，软中断不仅仅只有网络软中断，还有其它类型。

2) 、网络子系统初始化

linux  内核通过  net/core/dev.c  中  net\_dev\_init  函数进行网络子系统的初始化，在这个函数里，会为每个 CPU  都申请一个  softnet\_data  数据结构。 同时会给每一种软中断都注册一个处理函数。比如网络处理中  NET\_TX\_SOFTIRQ  中断的处理函数为 net\_tx\_action ， NET\_RX\_SOFTIRQ  中断的为  net\_rx\_action 。

3) 、协议栈注册

内核实现了网络层的  ip  协议，也实现了传输层的  tcp  协议和  udp  协议。 这些协议对应的实现函数分别是 ip\_rcv() ， tcp\_v4\_rcv() 和  udp\_rcv() 。和我们平时写代码的方式不一样的是， 内核是通过注册的方式来实现的。 在 net/ipv4/af\_inet.c  中的  inet\_init(void) 负责网络协议栈注册。 通过 inet\_init ，将这些函数注册到了  inet\_protos  和  ptype\_base  两个数据结构中。

inet\_protos  记录着  udp ， tcp  的处理函数地址， ptype\_base  存储着  ip\_rcv() 函数的处理地址。软中断中会通过 ptype\_base  找到  ip\_rcv  函数地址，进而将  ip  包正确地送到  ip\_rcv() 中执行。 在 ip\_rcv  中将会通过  inet\_protos  找到  tcp  或者  udp  的处理函数，再而把包转发给  udp\_rcv() 或 tcp\_v4\_rcv() 函数。

4) 、网卡驱动初始化和启动网卡，中间的工作包括分配内存、注册中断处理函数，注册供内核使用的函数、开启；硬中断等等工作。

2、Socket  的创建

调用链： net/Socket.c:sys\_socket()->sock\_create()->\_\_sock\_create()->sock\_alloc()；

主要的工作则是：

1) 、和  Linux  文件系统挂钩；

2) 、使用协议族来初始化  socket ，在前面的初始化过程中，我们知道有个协议栈注册过程，找到内核初始化时注册的协议域，然后调用其 create  方法进行  socket  实例的创建；

3) 、初始化和  socket  通信有关的缓冲区、队列等等；

3、接受数据的到来

1) 、首先当数据帧从网线到达网卡上的时候，第一站是网卡的接收队列。网卡在分配给自己的 RingBuffer  中寻找可用的内存位置，找到后  DMA  引擎会把数据  DMA  到网卡之前关联的

内存里，这个时候  CPU  都是无感的。当 DMA  操作完成以后，网卡会向  CPU  发起一个硬中断，通知  CPU  有数据到达。 CPU  调用网卡注册的硬中断处理函数，这个处理过程非常短。只是记录了一个寄存器，修改了一下CPU 的  softnet\_data  中的列表，告诉  CPU  当前有设备有数据需要处理，然后发出个软中断，硬中断工作就算是完成了。

2) 、在网络子系统初始化小节，我们看到为  NET\_RX\_SOFTIRQ  注册了处理函数  net\_rx\_action ，这个函数中的核心逻辑执行就是执行网卡驱动注册到 softnet\_data  中的函数，把数据帧从RingBuffer 上取下来，被送到协议栈中，从数据包中取出协议信息，然后遍历注册在这个协议上的回调函数列表，调用到了协议层注册的处理函数了。对于 ip  包来讲，就会进入到  ip\_rcv ， IP  层处理完成后如协议注册小节看到  inet\_protos  中 保存着 tcp\_rcv() 和  udp\_rcv() 的函数地址。这里将会根据包中的协议类型选择进行分发，在这里 skb  包将会进一步被派送到更上层的协议中， udp  和  tcp 。 udp 和  tcp  层根据  skb  来寻找对应的  socket ，当找到以后将数据包放到  socket  的接收队列中。而我们一般网络编程里的读取数据方法，就是访问这个接收队列。

到此，Linux 环境下的阻塞网络编程原理分析完毕，下篇分析JDK中BIO实现原理，敬请期待！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221024/24eac2a48fe04e87b59fcb81061cc19b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221024/75763d5c2bff4ccfba3bc9a142100e12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221024/2faa78cac0b540f39b2cb2b3ac2d2820.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 3]: /images/20221024/41020ba1b6454cb095950fe2f5285669.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 4]: /images/20221024/0cc2da140af5424bb627bc3b008e0575.png