Linux系统编程4-网络编程

序号	内容	链接
1	多进程	点我访问
2	进程间通信	点我访问
3	多线程	点我访问
4	网络编程	点我访问
5	shell	点我访问
6	Makefile	点我访问
7	串口通信	点我访问
8	I2C通信	点我访问

一 网络编程的介绍

1.1 协议介绍

  网络编程就是利用网络应用编程接口编写网络应用程序，实现网络应用进程间的信息交互功能。
  OSI 通信协议 —国际标准通信协议，分为7层。
https://blog.csdn.net/taotongning/article/details/81352985

  套接字：一个 IP 地址和一个端口号合称为一个套接字（Socket）。
  查看电脑是否连网，可以使用ping 命令 。 ping IP

  虚拟机中是否可以连网？？也可以用ping命令查看。如何设置虚拟机连网？

  然后用ping命令 查看

如何关闭虚拟机的防火墙？？？

1.2 TCP/IP 协议的介绍

  TCP/IP 协议（ Transmission Control Protocol/ Internet Protocol）叫做传输控制/网际协议，又叫网络通信协议。

1.3 IP地址

  IP 地址的作用是标识计算机的网卡地址，每一台计算机都有一个 IP 地址。在程序中是通过IP 地址来访问一台计算机的。
  在windows 查看IP 命令 :ipconfig

  在虚拟机中查看IP

1.4 端口

  是指计算机中为了标识同一计算机中不同程序访问网络而设置的编号。
  查看 计算机端口号：

  如 WWW 服务使用的是 80 号端口， FTP 服务使用的是 21 号端口。

1.5 域名

  域名是用来代替 IP 地址来标识计算机的一种直观名称。如百度网站的 IP 地址是119.75.213.50，这个 IP 没有任何逻辑含义，是不便于记忆的。所以在访问计算机时，可以用这个域名来代替 IP 地址

1.6 套接字

1.6.1 定义：

  套接字由 3 个参数构成： IP 地址、 端口号、 传输层协议， 以区分不同应用程序进程间的网络通信与连接。
  写一个程序来存放IP地址和端口号，如何去写？ 192.168.1.1 65535

1.6.2 类型

（1）流式 socket（SOCK_STREAM）
  流式套接字提供可靠的、面向连接的通信流；它使用 TCP 协议，从而保证了数据传输的正确性和顺序性。
（2）数据报 socket（SOCK_DGRAM）
  数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠、无差错的。它使用数据报协议 UDP。
（3）原始 socket
  原始套接字允许对底层协议如 IP 或 ICMP 进行直接访问，它功能强大但使用较为不便，主要用于一些协议的开发。

1.6.3 结构

/usr/include/linux/socket.h
/usr/include/bits/socket.h 

struct sockaddr 的结构体类型为：

struct sockaddr{
    unisgned short as_family;   //选择通信类型
	char sa_data[14];         //存放 IP 和 端口的
};
struct sockaddr  socket;
socket.as_family = PF_INET ;  //选择IPV4 协议
socket.as_family = AF_INET6  ;   //选择IPV6协议

使用另一个结构体来描述套接字更加的方便

struct sockaddr_in {
	sa_family_t sin_family; 		 /* address family: AF_INET 地址族- 支持的协议*/
	in_port_t sin_port;			 /* port in network byte order 端口号 */ 
	struct in_addr sin_addr;		 /* internet address IP 地址 */
};
struct in_addr {
	in_addr_t s_addr;
}; 

  想使用TCP协议通信，那么 这个套接字是如何定义并赋值的？？？
struct sockaddr_in tcpsocket; //定义一个 struct sockaddr_in 类型的变量，名为tcpsocket 。（定义一个套接字）

tcpsocket. sin_family = SOCK_STREAM  ;  //选择TCP 协议
tcpsocket.sin_port  = htons(6666 );      //把端口号转成小端模式。将 16 位主机字符顺序转换成网络字符顺序
tcpsocket.sin_addr. s_addr = inet_addr( “192.168.1.1 “) ; //转成网络地址。

二 TCP 通信协议

2.1 TCP 协议的介绍

  TCP 是面向连接的协议。所谓连接，就是两个对等实体为进行数据通信而进行的一种结合。面向连接服务是在数据交换之前，必须先建立连接。当数据交换结束后，则应终止这个连接。面向连接服务具有：连接建立、数据传输和连接释放这三个阶段。在传送数据时是按序传送的。
  通信：必须要有双方。 一方叫服务器 ，另一方叫客户端。
  TCP是如何进行连接的？三次握手（这个过程我们并不看得到）。

2.2 TCP协议通信流程

服务器：

1. 创建套接字
2. 监听
3. 等待连接
4. 接收或发送数据
5. 关闭套接字

客户端：

1. 创建套接字
2. 连接
3. 接收或发送数据
4. 关闭套接字。

2.3 TCP程序编写

2.3.1 创建套接字

   #include           /* See NOTES */
   #include 
   int socket(int domain, int type, int protocol);

功能 ：创建套接字

参数：   domain
Name                Purpose                          Man page
AF_UNIX, AF_LOCAL   Local communication              unix(7)
AF_INET             IPv4 Internet protocols          ip(7)
AF_INET6            IPv6 Internet protocols          ipv6(7)
AF_IPX              IPX - Novell protocols
AF_NETLINK          Kernel user interface device     netlink(7)
AF_X25              ITU-T X.25 / ISO-8208 protocol   x25(7)
AF_AX25             Amateur radio AX.25 protocol
AF_ATMPVC           Access to raw ATM PVCs
AF_APPLETALK        Appletalk                        ddp(7)
AF_PACKET           Low level packet interface       packet(7)
type:
SOCK_STREAM     Provides sequenced, reliable, two-way, connection-based
              byte  streams.  An out-of-band data transmission mecha-
              nism may be supported.

SOCK_DGRAM      Supports datagrams (connectionless, unreliable messages
              of a fixed maximum length).
….

2.3.2 监听

int listen(int sockfd, int backlog);

sockfd :套接字
backlog ：设置监听的数量

2.3.3 等待连接

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

2.3.4 接收

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

server.c

#include
#include
#include
#include
#include
#include
#include
#include 
int main(int argc,char **argv)
{
	//1. 创建套接字
	int  serversocket ;
	serversocket = socket(AF_INET,SOCK_STREAM,0);//选择ipv4 ,TCP协议
	if (serversocket == -1)
		perror("socket err:");
			struct sockaddr_in serveraddr;  
	serveraddr. sin_family = AF_INET  ;  //选择TCP 协议
	serveraddr.sin_port  = htons(6666 );      //把端口号转成小端模式。将 16 位主机字符顺序转换成网络字符顺序
	serveraddr.sin_addr. s_addr = inet_addr("192.168.1.32") ; //转成网络地址。跟谁通信就写谁的IP
     int res= bind(serversocket, (const struct sockaddr *)&serveraddr,sizeof(serveraddr));
	if(res == -1)
		perror("bind err:");
	//2. 监听
	
	res = listen(serversocket,2); //可以监听2个
	if(res == -1)
		perror("listen err:");
	//3.等待连接
	int clientsocket;
	struct sockaddr_in clientaddr; 
	socklen_t clientaddrlen ;
    clientsocket = accept(serversocket, (struct sockaddr *)&clientaddr, &clientaddrlen);
    if(res == -1)
		perror("accept err:");
	//4.接收
	char readbuf[20]={0};
	res = recv(clientsocket,readbuf,20,0);
	if(res == -1)
		perror("recv err:");
	printf("read:%s\n",readbuf);
	//5.关闭套接字
	close(serversocket);
}

client.c

#include
#include
#include
#include
#include
#include
#include
#include 
int main(int argc,char **argv)
{
	//1. 创建套接字
	int  clientsocket ;
	clientsocket = socket(AF_INET,SOCK_STREAM,0);//选择ipv4 ,TCP协议
	if (clientsocket == -1)
		perror("socket err:");
	//2.连接
	struct sockaddr_in clientaddr;  
	clientaddr. sin_family = AF_INET ;  	//选择ipv4协议
	clientaddr.sin_port  = htons(6666 );      //把端口号转成小端模式。将 16 位主机字符顺序转换成网络字符顺序
	clientaddr.sin_addr. s_addr = inet_addr("192.168.1.32") ; //转成网络地址。跟谁通信就写谁的IP
    int res = connect(clientsocket, (struct sockaddr *)&clientaddr, sizeof(struct sockaddr));
    if(res == -1)
		perror("connect err:");
	else
		printf("connect ok\n");
	//3.发送
	char sendbuf[20]="hello world";
	res = send(clientsocket,sendbuf,12,0);
	if(res == -1)
		perror("send err:");
	//5.关闭套接字
	close(clientsocket);
}

三 UDP通信

3.1 UDP协议介绍

  UDP 是无连接的服务。在无连接服务的情况下，两个实体之间的通信不需先建立好一个连接。
　　单播用于两个主机之间的端对端通信，广播用于一个主机对整个局域网上所有主机上的数据通信。单播和广播是两个极端，要么对一个主机进行通信，要么对整个局域网上的主机进行通信。实际情况下，经常需要对一组特定的主机进行通信，而不是整个局域网上的所有主机，这就是多播的用途。
  通常我们讨论的udp的程序都是一对一的单播程序。本章将讨论一对多的服务：广播（broadcast）、多播（multicast）。对于广播，网络中的所有主机都会接收一份数据副本。对于多播，消息只是发送到一个多播地址，网络知识将数据分发给哪些表示想要接收发送到该多播地址的数据的主机。总得来说，只有UDP套接字允许广播或多播。

3.2 UDP通信流程

3.3 I/O 多路转接模型：

  在这种模型下，如果请求的 I/O 操作阻塞，且它不是真正阻塞 I/O，而是让其中的一个函数等待，在这期间， I/O 还能进行其他操作。select()函数，就是属于这种模型。

```c
       #include 
       #include 
       #include 
       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
		参数：nfds ：工程中打开所有的文件中，最大的文件描述符+1
			  readfds: 监测读
			  writefds：监测写
			  exceptfds：监测错误 
			timeout：监测时间 (每次调用select都要给超时时间从新赋值，超时时间才起作用)
           struct timeval {
               long    tv_sec;         /* seconds */
               long    tv_usec;        /* microseconds */
           };
		返回值：执行成功则返回文件描述词状态已改变的个数，如果返回 0 代表在描述词状态改变前已超过 timeout 时间，当有错误发生时则返回-1 如main.c 中
main()
{
	fd1 =open();
	fd2=open();
	fd3=open();
	read(fd1);
	read(fd2);
}
    void FD_CLR(int fd, fd_set *set);  删除一个文件描述符
    int  FD_ISSET(int fd, fd_set *set);判断一个文件描述符是否设置
    void FD_SET(int fd, fd_set *set);  设置一个文件描述符
    void FD_ZERO(fd_set *set);         将文件描述符清零。
	 // 监测fd1 是否可读？？设置fd1
	fd_set readfd;
	FD_ZERO(&readfd);    //清除之前的绑定 
	FD_SET(fd1,&readfd);//把fd1 监测读
	FD_CLR(fd1,&readfd); //把fd1 解除绑定
	if(FD_ISSET(fd1, ,&readfd))
	{
	//fd1 文件可读
	}
	
#include 
	void bzero(void *s, size_t n);
 	//清结构体struct STR  stu;
	bzero(&stu,sizeof(stu));

3.4 UDP广播

  广播UDP与单播UDP的区别就是IP地址不同，广播使用广播地址255.255.255.255，将消息发送到在同一广播网络上的每个主机。值得强调的是：本地广播信息是不会被路由器转发。当然这是十分容易理解的，因为如果路由器转发了广播信息，那么势必会引起网络瘫痪。这也是为什么IP协议的设计者故意没有定义互联网范围的广播机制。
  广播地址通常用于在网络游戏中处于同一本地网络的玩家之间交流状态信息等。其实广播顾名思义，就是想局域网内所有的人说话，但是广播还是要指明接收者的端口号的，因为不可能接受者的所有端口都来收听广播。

server.c

 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 using namespace std;
 int main()
 {
     setvbuf(stdout,NULL,_IONBF,0);
     fflush(stdout);
     int sock=-1;
     if((sock=socket(AF_INET,SOCK_DGRAM,0))==-1)
     {
         cout<<"sock error"<<endl;
         return -1;
     }
     const int opt=-1;
     int nb=0;
     nb=setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char*)&opt,sizeof(opt));//设置套接字类型
     if(nb==-1)
     {
         cout<<"set socket error...\n"<<endl;
         return -1;
     }
     struct sockaddr_in addrto;
     bzero(&addrto,sizeof(struct sockaddr_in));
     addrto.sin_family=AF_INET;
     addrto.sin_addr.s_addr=htonl(INADDR_BROADCAST);//套接字地址为广播地址
     addrto.sin_port=htons(6000);//套接字广播端口号为6000
     int nlen=sizeof(addrto);
     while(1)
     {
         sleep(1);
         char msg[]={"the message broadcast"};
         int ret=sendto(sock,msg,strlen(msg),0,(sockaddr*)&addrto,nlen);//向广播地址发布消息
         if(ret<0)
         {
             cout<<"send error...\n"<<endl;
             return -1;
         }
         else 
         {
             printf("ok\n");
         }
     }
    return 0;
}

client.c

#include
#include
#include
#include
#include
#include
#include
#include
#include


using namespace std;
int main()
{
     setvbuf(stdout,NULL,_IONBF,0);
     fflush(stdout);
     struct sockaddr_in addrto;
     bzero(&addrto,sizeof(struct sockaddr_in));
     addrto.sin_family=AF_INET;
     addrto.sin_addr.s_addr=htonl(INADDR_ANY);
     addrto.sin_port=htons(6000);
     socklen_t len=sizeof(addrto);
     int sock=-1;
     if((sock=socket(AF_INET,SOCK_DGRAM,0))==-1)
     {
             cout<<"socket error..."<<endl;
             return -1;
     }
     const int opt=-1;
     int nb=0;
     nb=setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char*)&opt,sizeof(opt));
     if(nb==-1)
     {
             cout<<"set socket errror..."<<endl;
             return -1;
     }
     if(bind(sock,(struct sockaddr*)&(addrto),len)==-1)
     {
             cout<<"bind error..."<<endl;
             return -1;
     }
     char msg[100]={0};
     while(1)
     {
             int ret=recvfrom(sock,msg,100,0,(struct sockaddr*)&addrto,&len);
             if(ret<=0)
             {
                     cout<<"read error..."<<endl;
             }
             else
             {
                     printf("%s\t",msg);
             }
             sleep(1);
     }
     return 0;
}

3.5 UDP多播

3.5.1 多播（组播）的概念

  多播，也称为“组播”，将网络中同一业务类型主机进行了逻辑上的分组，进行数据收发的时候其数据仅仅在同一分组中进行，其他的主机没有加入此分组不能收发对应的数据。
　　在广域网上广播的时候，其中的交换机和路由器只向需要获取数据的主机复制并转发数据。主机可以向路由器请求加入或退出某个组，网络中的路由器和交换机有选择地复制并传输数据，将数据仅仅传输给组内的主机。多播的这种功能，可以一次将数据发送到多个主机，又能保证不影响其他不需要（未加入组）的主机的其他通 信。
相对于传统的一对一的单播，多播具有如下的优点：

1. 具有同种业务的主机加入同一数据流，共享同一通道，节省了带宽和服务器的优点，具有广播的优点而又没有广播所需要的带宽。
2. 服务器的总带宽不受客户端带宽的限制。由于组播协议由接收者的需求来确定是否进行数据流的转发，所以服务器端的带宽是常量，与客户端的数量无关。
3. 与单播一样，多播是允许在广域网即Internet上进行传输的，而广播仅仅在同一局域网上才能进行。

组播的缺点：

1. 多播与单播相比没有纠错机制，当发生错误的时候难以弥补，但是可以在应用层来实现此种功能。
2. 多播的网络支持存在缺陷，需要路由器及网络协议栈的支持。
3. 多播的应用主要有网上视频、网上会议等。

3.5.2 广域网的多播

  多播的地址是特定的，D类地址用于多播。D类IP地址就是多播IP地址，即224.0.0.0至239.255.255.255之间的IP地址，并被划分为局部连接多播地址、预留多播地址和管理权限多播地址3类：

1. 局部多播地址：在224.0.0.0～224.0.0.255之间，这是为路由协议和其他用途保留的地址，路由器并不转发属于此范围的IP包。
2. 预留多播地址：在224.0.1.0～238.255.255.255之间，可用于全球范围（如Internet）或网络协议。
3. 管理权限多播地址：在239.0.0.0～239.255.255.255之间，可供组织内部使用，类似于私有IP地址，不能用于Internet，可限制多播范围。

  多播的程序设计使用setsockopt()函数和getsockopt()函数来实现，组播的选项是IP层的，其选项值

getsockopt()/setsockopt()的选项	含 义
IP_MULTICAST_TTL	设置多播组数据的TTL值
IP_ADD_MEMBERSHIP	在指定接口上加入组播组
IP_DROP_MEMBERSHIP	退出组播组
IP_MULTICAST_IF	获取默认接口或设置接口
IP_MULTICAST_LOOP	禁止组播数据回送

3.5.3 多播程序设计的框架

  要进行多播的编程，需要遵从一定的编程框架。多播程序框架主要包含套接字初始化、设置多播超时时间、加入多播组、发送数据、接收数据以及从多播组中离开几个方面。其步骤如下：

1. 建立一个socket。
2. 然后设置多播的参数，例如超时时间TTL、本地回环许可LOOP等。
3. 加入多播组。
4. 发送和接收数据。
5. 从多播组离开。

3.5.4 多播实现代码

server.c

 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #define MCAST_PORT 8888
 #define MCAST_ADDR "224.0.0.88"  // 多播地址
 #define MCAST_DATA "BROADCAST TEST DATA"  // 多播内容
 #define MCAST_INTERVAL 5  //多播时间间隔
 using namespace std;
 
 int main()
 {
	 int sock;
	 struct sockaddr_in mcast_addr;
	 sock=socket(AF_INET,SOCK_DGRAM,0);
	 if(sock==-1)
	 {
	         cout<<"socket error"<<endl;
	         return -1;
	 }
	 memset(&mcast_addr,0,sizeof(mcast_addr));
	 mcast_addr.sin_family=AF_INET;
	 mcast_addr.sin_addr.s_addr=inet_addr(MCAST_ADDR);
	 mcast_addr.sin_port=htons(MCAST_PORT);
	 while(1)
	 {       //向局部多播地址发送多播内容
	         int n=sendto(sock,MCAST_DATA,sizeof(MCAST_DATA),0,(struct sockaddr*)&mcast_addr,sizeof(mcast_addr));
	         if(n<0)
	         {
	                 cout<<"send error"<<endl;
	                 return -2;
	         }
	         else
	         {
	                 cout<<"send message is going ...."<<endl;
	         }
	         sleep(MCAST_INTERVAL);
	
	 }
	 return 0;
 }

client.c

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MCAST_PORT 8888
#define MCAST_ADDR "224.0.0.88" /*一个局部连接多播地址，路由器不进行转发*/
#define MCAST_INTERVAL 5  //发送时间间隔
#define BUFF_SIZE 256   //接收缓冲区大小
using namespace std;
int main()
{
	int sock;
	struct sockaddr_in local_addr;
	int err=-1;
	sock=socket(AF_INET,SOCK_DGRAM,0);
	if(sock==-1)
	{
	        cout<<"sock error"<<endl;
	        return -1;
	}
	/*初始化地址*/
	local_addr.sin_family=AF_INET;
	local_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	local_addr.sin_port=htons(MCAST_PORT);
	/*绑定socket*/
	err=bind(sock,(struct sockaddr*)&local_addr,sizeof(local_addr));
	if(err<0)
	{
	        cout<<"bind error"<<endl;
	        return -2;
	}
	/*设置回环许可*/
	int loop=1;
	err=setsockopt(sock,IPPROTO_IP,IP_MULTICAST_LOOP,&loop,sizeof(loop));
	if(err<0)
	{
	        cout<<"set sock error"<<endl;
	        return -3;
	}
	struct ip_mreq mreq;/*加入广播组*/
	mreq.imr_multiaddr.s_addr=inet_addr(MCAST_ADDR);//广播地址
	mreq.imr_interface.s_addr=htonl(INADDR_ANY); //网络接口为默认
	/*将本机加入广播组*/
	err=setsockopt(sock,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));
	if(err<0)
	{
	        cout<<"set sock error"<<endl;
	        return -4;
	}
	int times=0;
	socklen_t addr_len=0;
	char buff[BUFF_SIZE];
	int n=0;
	/*循环接受广播组的消息，5次后退出*/
	for(times=0;;times++)
	{
	        addr_len=sizeof(local_addr);
	        memset(buff,0,BUFF_SIZE);
	        n=recvfrom(sock,buff,BUFF_SIZE,0,(struct sockaddr*)&local_addr,&addr_len);
	        if(n==-1)
	        {
	                cout<<"recv error"<<endl;
	                return -5;
	        }
	        /*打印信息*/
	        printf("RECV %dst message from server : %s\n",times,buff);
	        sleep(MCAST_INTERVAL);
	}
	/*退出广播组*/
	err=setsockopt(sock,IPPROTO_IP,IP_DROP_MEMBERSHIP,&mreq,sizeof(mreq));
	close(sock);
	return 0;
}

3.6 UDP广播与单播的比较

  广播和单播的处理过程是不同的，单播的数据只是收发数据的特定主机进行处理，而广播的数据整个局域网都进行处理。
　　例如在一个以太网上有3个主机，主机的配置如表所示

主 机	A	B	C
IP地址	192.168.1.150	192.168.1.151	192.168.1.158
MAC地址	00:00:00:00:00:01	00:00:00:00:00:02	00:00:00:00:00:03

（1）单播流程：主机A向主机B发送UDP数据报，发送的目的IP为192.168.1.151，端口为 80，目的MAC地址为00:00:00:00:00:02。此数据经过UDP层、IP层，到达数据链路层，数据在整个以太网上传播，在此层中其他主机会 判断目的MAC地址。主机C的MAC地址为00:00:00:00:00:03，与目的MAC地址00:00:00:00:00:02不匹配，数据链路层 不会进行处理，直接丢弃此数据。
　　主机B的MAC地址为00:00:00:00:00:02，与目的MAC地址00:00:00:00:00:02一致，此数据会经过IP层、UDP层，到达接收数据的应用程序。
（2）广播的流程：主机A向整个网络发送广播数据，发送的目的IP为192.168.1.255，端口为 80，目的MAC地址为FF:FF:FF:FF:FF:FF。此数据经过UDP层、IP层，到达数据链路层，数据在整个以太网上传播，在此层中其他主机会 判断目的MAC地址。由于目的MAC地址为FF:FF:FF:FF:FF:FF，主机C和主机B会忽略MAC地址的比较（当然，如果协议栈不支持广播，则 仍然比较MAC地址），处理接收到的数据。
　　主机B和主机C的处理过程一致，此数据会经过IP层、UDP层，到达接收数据的应用程序。