• 高级套接字

    高级套接字

    一、UNIX域函数

    UNIX域的协议族是在同一台主机上的客户/服务器通信时使用的一 种方法。相对其他方法（例如进程间通信的管道），它在形式上与传统套接字API的调用方法相同。UNIX域有两种类型的套接字：字节流套接字和数据报套接字，字节流套接字类似于TCP, 数据报套接字类似于UDP，UNIX域的套接字有如下的特点值得注意：

    1. UNIX域套接字与TCP套接字相比较，在同一台主机的传输速度前者是后者的两倍。

    2. UNIX域套接字可以在同 一 台主机上各进程之间传递描述符。

    3. UNIX域套接字与传统套接字的区别是用路径名来表示协议族的描述。

    1.UNIX域函数的地址结构

    UNIX域的地址结构在文件中定义，结构如下：

    #define UNIX_PATH_MAX 108
struct sockaddr_un{
    //AF_UNIX协议族名称
	sa_family_t sun_family;//值为：AF_UNIX或者AF_LOCAL
	//路径名
	char sun_path[UNIX_PATH_MAX];//属性为0777，可以进行读写等操作。
	};


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    结构sockaddr_un的长度使用宏`SUN_LEN`定义，默认大小为108，`SUN_LEN`宏的定义如下·：

    • 1
    #define SUM_LEN(ptr)  ((size_t)  (((struct sockaddr_un*) 0)->sun_path)+strlen((ptr)->sun_path));

    • 1

    2.套接字函数

    UNIX域的套接字函数虽然和以太网（AF_INET）的函数相同，但用于UNIX还是有点差别，例;

    1. 使用函数bind()进行套接字和地址的绑定的时候，地址结构中的路径名和路径名所表示的文件的默认访问权限为0777, 即用户、用户所属的组和其他组的用户都能读、写和执行。

    2. 结构sum_path中的路径名必须是一个绝对路径，不能是相对路径。

    3. 函数connect()使用的路径名必须是一个绑定在某个已打开的 U NIX域套接字上的路径名，而且套接字的类型必须 一 致。下列情况将出错： (a)该路径名存在但不是一 个套接字； (b)路径名存在且是 一 个套接口，但没有与该路径名相关联的打开的描述字;©路径名存在且是 一 个打开的套接字，但类型不符。

    4. 用函数connect()连接UNIX域套接字时的权限检查和用函数open()以只写方式访问路径名完全相同。

    5. UNIX域字节流套接字和TCP套接字类似：它们都为进程提供一个没有记录边界的字节流接口。

    6. 如果UNIX域字节流套接字的connect()函数发现监听套接字的队列已满，会立刻返回一个ECONNREFUSED 错误。这和 TCP 有所不同：如果监听套接字的队列已满，它将忽略到来的SYN, TCP连接的发起方会接着发送几次SYN重试。

    7. UNIX域数据报套接字和UDP套接字类似：它们都提供一个保留记录边界的不可靠的数据服务。

    8. 与UDP套接字不同的是，在未绑定的UNIX域套接字上发送数据报不会给它捆绑一 个路径名。这意味着，数据报发送者除非绑定一 个路径名，否则接收者无法发回应答数据报。同样，与TCP和UDP不同的是，给UNIX域数据报套接字调用connect()不会捆绑一个路径名。

    3.使用UNIX域函数进行套接字编程

    使用UNIX域函数进行套接字编程与AF_INET的方式一致，不同的地方在于地址结构不同，例：

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

/*
*错误处理函数
*/
static void display_err(const char*on_what)
{
	perror(on_what);
	exit(1);
}

int main(int argc,char*argv[])
{
	int error;	 							/*错误值*/
	int sock_UNIX;							/*socket;存放创建的套接字文件描述符*/
	struct sockaddr_un addr_UNIX;			/*AF_UNIX族地址*/
	int len_UNIX;							/*AF_UNIX族地址长度*/
	const char path[] = "/demon/path";		/*路径名*/

	/*
	*建立套接字
	*/
	sock_UNIX = socket(AF_UNIX,SOCK_STREAM,0);
	
	if(sock_UNIX == -1)
		display_err("socket()");

	/*
	*由于之前已经使用了path路径用于其他用途
	*需要将之前的绑定取消
	*/
	unlink(path);//AF_UNIX地址会创建一个文件系统对象，如果不再需要需删除，如果这个程序最后一次运行时没有删除，这条语句会试着进行删除。

	/*
	*填充地址结构
	*/
	memset(&addr_UNIX,0,sizeof(addr_UNIX));//将adrr_UNIX的地址清零


	addr_UNIX.sun_family = AF_LOCAL;
	strcpy(addr_UNIX.sun_path,path);//向地址结构中复制路径名
	len_UNIX = sizeof(struct sockaddr_un);//计算长度

	/*
	*绑定地址到socket sock_UNIX
	*/
	error = bind(sock_UNIX,
			(struct sockaddr*)&addr_UNIX,
			len_UNIX);//调用bind()函数，将格式化的地址复赋值为上面创建的窗口
	if(error == -1)
		display_err("bind()");
	
	/*
	*关闭socket
	*/
	close(sock_UNIX);
	unlink(path);//调用bind()函数时删除为套机口所创建的UNIX路径名

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    上面的例子中，需要首先建立一 个路径名为"/dem on/path"的目录，如果需要建立一个临时使用的套接字，而又不方便手动建立，可以使用Linux中的一 个特殊方法，即格式化抽象本地地址。
    格式化抽象本地地址的方式需要将路径名的第一 个字符设置为空字符，即"\0"例如，对于上面的例子，可以len_UNIX = sizeof(struct sockaddr_un);插入如下代码：

    addr_UNIX.sun_path[0] = 0;

    • 1

    插入后，strcmpy()函数中结构addr_UNIX的成员sun_path的内容将为如表所示：

    在这里插入图片描述

    上面对sun_path的内容进行了修改，进行bind的时候，其路径名已经发生了变化，其实是对字符串"demon/path"进行了绑定，在bind()函数时sun_path 的内容如下表所示。
    在这里插入图片描述

    计算UNIX域结构的长度使用sizeof()函数，其实可以使用SUN_LEN宏来结算：

    len_UNIX = SUN_LEN(addr_un);

    • 1

    4.传递文件描述符

    1. 在进程之间经常遇到需要在各进程之间传递文件描述符的情况，例如有一 种设备它在加电期间只能打开一 次，如果关闭后再次打开就会发生错误。

    2. 在进程之间经常遇到需要在各进程之间传递文件描述符的情况，例如有一 种设备它在加电期间只能打开一 次，如果关闭后再次打开就会发生错误。

    3. 这时就需要有一个调度程序，它调度多个相同设备，当有客户端需要此类型的设备时会向它发送一 个请求，服务器会把某个设备的描述符给客户端。

    4. 但是，由于不同进程之间的文件描述符所表示的对象是不同的，这需要一 种特殊的机制来实现上述的要求。

    Linux系统中解决方法是可以从一 个进程中将一 个已经打开的文件描述符传递给其他的任何进程。其基本过程如下所述:

    • 创建一 个字节流或者数据报的UNlX 域套接字。

    1. 如果目标是fork()一 个子进程，让子进程打开描述符并将它返回给父进程，那么父进程可以用socketpair()创建一 个流管道，用它来传递描述字。

    2. 如果进程之间没有亲缘关系，那么服务器必须创建UNIX域字节流套接字，绑定路径名，客户连接到套接字。客户端在向服务器发送请求打开某个描述字，服务器将描述符通过UNIX域套接字传回。在客户端和服务器之间也可以使用UNIX数据报套接字，但容易数据报存在丢失的可能性。

    • 进程可以用任何返回描述符的UNIX函数打开，例如函数open()、pipe()、mkfifo()、 socket()或者accept()。可以在进程间传递任何类型的描述符。

      • 发送进程建立msghdr结构，其中包含要传递的描述符。在POSIX 中说明该描述符作为辅助数据发送，但老的实现使用msg_accright成员。发送进程调用sendmsg()通过第一步得到的UNIX 域套接字发出套接字。在发送进程调用sendmsg()之后、在接受进程调用recvmsg()之前将描述符关闭，它仍会为接收进程保持打开状态。描述符的发送导致它的访问统计数加1。

      • 接收进程调用recvmsg()在UNIX域套接字上接收套接字。通常接收进程收到的描述符的编号和发送进程中的描述符的编号不同，但这没有问题。传递描述符不是传递描述符的编号，而是在接收进程中建立一个新的描述符，指向内核的文件表中与发送进程发送的描述符相同的项。

    5.socketpair()函数

    socketpair()函数建立一 对匿名的已经连接的套接字，其特性由协议族 d、类型 type、协议protocol决定，建立的两个套接字描述符会放在sv[0]和sv[1]中。

    socketpair()函数的原型如下：

    #include
#include

int socketpair(int d,int type,int protocol,int sv[2]);
//d:协议族;只能为AF_LOCAL或者AF_UNIX。
//type:类型,只能为0。
//protocol:协议;可以是SOCK_STREAM或者SOCK_DGRAM
//用SOCK_STREAM建立的套接字对是管道流，与一般的管道相区别的是，套接字对建立的通道是双向的，即每一端都可以进行读写。参数sv, 用于保存建立的套接字对。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    socketpair()函数的返回值为0时表示调用成功，为-1表示发生错误，错误值在变量errno中，errno含义如下：

    在这里插入图片描述

    socketpair()函数建立两个套接字文件描述符sv[0]和sv[1], 如下图所示。

    在这里插入图片描述

    socketpair()函数建立的描述符可以使用类似管道的处理方法在两个进程之间通信。使用函数socketpair()建立套接字描述符后，在一个进程中关闭其中的一个，在另一个进程中关闭另一个，如下图所示。
    在这里插入图片描述
    调用函数 socketpair()后，fork 进程在进程 A 中关闭 sv[0],在进程B中关闭sv[1], 则会形成图中所示的状况。

    传递文件描述符的例子

    进程A：
    根据用户输入的文件名称打开一个文件，将文件描述符打包到消息结构中，然后发送给进程B。

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


//此函数向文件描述符fd发送消息，将sendfd打包到消息体中
ssize_t send_fd(int fd, void *data, size_t bytes, int sendfd)
{
	struct msghdr msghdr_send;				/*发送消息*/
	struct iovec iov[1];					/*向量*/
	/*方便操作msg的结构*/
	union{
		struct cmsghdr cm;					/*control msg结构*/
		char control[CMSG_SPACE(sizeof(int))];
									/*字符指针，方便控制*/
	}control_un;
	struct cmsghdr*pcmsghdr = NULL;			/*控制头部的指针*/
	msghdr_send.msg_control = control_un.control;	/*控制消息*/
	msghdr_send.msg_controllen = sizeof(control_un.control);
									/*长度*/
	
	pcmsghdr = CMSG_FIRSTHDR(&msghdr_send);	/*取得第一个消息头*/
	pcmsghdr->cmsg_len = CMSG_LEN(sizeof(int));	/*由于发送的是个文件描述符，所以长度为一个int类型长度;获得长度*/
	pcmsghdr->cmsg_level = SOL_SOCKET;			/*用于控制消息*/
	pcmsghdr->cmsg_type = SCM_RIGHTS;
	*((int*)CMSG_DATA(pcmsghdr))= sendfd;		/*socket值*/
	
	
	msghdr_send.msg_name = NULL;				/*名称*/
	msghdr_send.msg_namelen = 0;				/*名称长度*/
	
	iov[0].iov_base = data;						/*向量指针*/
	iov[0].iov_len = bytes;						/*数据长度*/
	msghdr_send.msg_iov = iov;					/*填充消息*/
	msghdr_send.msg_iovlen = 1;
	
	return (sendmsg(fd, &msghdr_send, 0));		/*发送消息*/
}

int main(int argc, char*argv[])
{
	int fd;
	ssize_t n;
	
	if(argc != 4)
		printf("socketpair error\n");
	if((fd = open(argv[2],atoi(argv[3])))<0) /*打开输入的文件名称*/
		return 0;
		
	if((n =send_fd(atoi(argv[1]),"",1,fd))<0)	/*发送文件描述符*/
		return 0;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    进程B：

    获得进程A中发送过来的信息，并从中获得文件描述符。根据获得的文件描述符，直接从文件中读取数据，并将数据在标准输出打印出来。

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

/*
*	从fd中接收消息，并将文件描述符放在指针recvfd中
*/
ssize_t recv_fd(int fd, void*data, size_t bytes, int*recvfd)
{
	struct msghdr msghdr_recv;					/*接收消息接收*/
	struct iovec iov[1];						/*接收数据的向量*/
	size_t n;
	
	union{
		struct cmsghdr cm;
		char control[CMSG_SPACE(sizeof(int))];	
	}control_un;
	struct cmsghdr*pcmsghdr;						/*消息头部*/
	msghdr_recv.msg_control = control_un.control;	/*控制消息*/
	msghdr_recv.msg_controllen = sizeof(control_un.control);	
											/*控制消息的长度*/
	
	msghdr_recv.msg_name = NULL;	/*消息的名称为空*/
	msghdr_recv.msg_namelen = 0;	/*消息的长度为空*/
	
	iov[0].iov_base = data;			/*向量的数据为传入的数据*/
	iov[0].iov_len = bytes;			/*向量的长度为传入数据的长度*/
	msghdr_recv.msg_iov = iov;		/*消息向量指针*/
	msghdr_recv.msg_iovlen = 1;		/*消息向量的个数为1个*/
	if((n = recvmsg(fd, &msghdr_recv, 0))<=0)	/*接收消息*/
		return n;
		
	if((pcmsghdr = CMSG_FIRSTHDR(&msghdr_recv))!= NULL &&
											/*获得消息的头部*/
pcmsghdr->cmsg_len == CMSG_LEN(sizeof(int))){	
											/*获得消息的长度为int*/
		if(pcmsghdr->cmsg_level != SOL_SOCKET)
											/*消息的level应该为SOL_SOCKET*/
			printf("control level != SOL_SOCKET\n");
		
		if(pcmsghdr->cmsg_type != SCM_RIGHTS)	/*消息的类型判断*/
			printf("control type != SCM_RIGHTS\n");
			
		*recvfd =*((int*)CMSG_DATA(pcmsghdr));
						/*获得打开文件的描述符*/
	}else
		*recvfd = -1;
		
	return n;						/*返回接收消息的长度*/
}

int my_open(const char*pathname, int mode)
{
	int fd, sockfd[2],status;
	pid_t childpid;
	char c, argsockfd[10],argmode[10];
	
	socketpair(AF_LOCAL,SOCK_STREAM,0,sockfd);	/*建立socket*/
	if((childpid = fork())==0){					/*子进程*/
		close(sockfd[0]);						/*关闭sockfd[0]*/
		snprintf(argsockfd, sizeof(argsockfd),"%d",sockfd[1]);															/*socket描述符*/
		snprintf(argmode, sizeof(argmode),"%d",mode);
														/*打开文件的方式*/
		execl("./openfile","openfile",argsockfd, pathname,argmode,(char*)NULL)					;/*执行进程A*/
		printf("execl error\n");
	}	
	/*父进程*/
	close(sockfd[1]);
	/*等待子进程结束*/
	waitpid(childpid, &status,0);
	
	if(WIFEXITED(status)==0)				/*判断子进程是否结束*/
		printf("child did not terminate\n")	;
	if((status = WEXITSTATUS(status))==0){	/*子进程结束*/
		recv_fd(sockfd[0],&c,1,&fd);	/*接收进程A打开的文件描述符*/
	}else{
		errno = status;
		fd = -1;	
	}	
	
	close(sockfd[0]);					/*关闭sockfd[0]*/
	return fd;							/*返回进程A打开文件的描述符*/

}

#define BUFFSIZE 256					/*接收的缓冲区大小*/
int main(int argc, char*argv[])
{
	int fd, n;
	char buff[BUFFSIZE];				/*接收缓冲区*/
	
	if(argc !=2)
		printf("error argc\n");
		
	if((fd = my_open(argv[1], O_RDONLY))<0)
								/*获得进程A打开的文件描述符*/
		printf("can't open %s\n",argv[1]);
	
	while((n = read(fd, buff, BUFFSIZE))>0)	/*读取数据*/
	write(1,buff,n);							/*写入标准输出*/
	
	return(0);	
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111

    二、广播

    TCP/IP基于单播，即一对一方式，而广播一对多的方式，广播由一个主机发向一个网络上所有主机的操作方式，例如：在一个局域网内进行广播，同一子网内的所有主机都可以接收到广播发送的数据。

    1.广播的IP地址

    使用广播，需了解IPv4特定的广播地址。IP地址分为左边的网络ID部分，以及右边的主机ID部分。
    广播地址所用的IP地址将表示主机ID的位全部设置为1。网卡正确配置以后，可以用下面的命令来显示所选用接口的广播地址。

    在这里插入图片描述

    注：自15版本开始网卡名称就不为etho。

    1. 第二行输出信息说明ens33网络接口的广播地址为192.168.236.255。

    2. 广播IP地址的网络ID,为192.168.236。

    3. 主机ID为：255(表示主机ID全为1的十进制)。

    4. 广播地址255.255.255.255是一 种特殊的广播地址，这种格式的广播地址是向全世界进行广播，但是却有更多的限制。

    5. 一 般情况下，这种广播类型不会被路由器路由，而一 个更为特殊的广播地址，例如192.168.0.255也许会被路由，这取决于路由器的配置。

    6. 通用的广播地址在不同的环境中的含义不同。例如，IP地址255.255.255.255, 一些UNIX系统将其解释为在主机的所有网络接口上进行广播，而有的UNIX内核只会选择其中的一 个接口进行广播。当一 个主机有多个网卡时，这就会成为一 个问题。

    如果必须向每个网络接口广播，程序在广播之前应执行下面步骤：

    1. 确定下一 个或第一 个接口名字。
    2. 确定接口的广播地址。
    3. 使用这个广播地址进行广播。
    4. 对于系统中其余的活动网络接口重复执行步骤(1) ~步骤(3)。

    在执行完这些步骤以后，就可以认为已经对每一 个接口进行广播。

    2.广播与单播的比较

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

    1. 单播的示意图如下所示，主机A向主机B发送UDP数据报，发送的目的IP为192.168.1.151, 端口为80, 目的MAC地址为00:00:00:00:00:02。

    2. 此数据经过UDP层、IP层，到达数据链路层，数据在整个以太网上传播，在此层中其他主机会判断目的MAC地址。

    3. 主机C的MAC地址为00:00:00:00:00:03, 与目的MAC地址00:00:00:00:00:02不匹配，数据链路层不会进行处理，直接丢弃此数据。

    4. 主机B的MAC地址为00:00:00:00:00:02,与目的MAC地址00:00:00:00:00:02 一 致，此数据会经过IP层、UDP层，到达接收数据的应用程序。

    在这里插入图片描述

    1. 广播的示意图如下所示，主机A向整个网络发送广播数据，发送的目的IP为192.168.1.255, 端口为80, 目的MAC地址为FF:FF:FF:FF:FF:FF。

    2. 此数据经过UDP层、IP层，到达数据链路层，数据在整个以太网上传播，在此层中其他主机会判断目的MAC地址。

    3. 由于目的MAC地址为FF:FF:FF:FF:FF:FF， 主机C和主机B会忽略MAC地址的比较（当然，如果协议栈不支持广播，则仍然比较MAC地址），处理接收到的数据。

    4. 主机B和主机C的处理过程 一 致，此数据会经过IP 层、UDP 层，到达接收数据的应用程序。

    在这里插入图片描述

    3.广播的示例

    客户端B在某个局域网启动的时候，不知道本局域网内是否有适合的服务器A存在，它会使用广播在本局域网内发送特定协议的请求，如果有服务器响应了这种请求，则使用响应请求的IP地址进行连接，这是一种服务器/客户端自动发现的常用方法。

    ①.广播例子简介

    1. 如下图所示使用广播的方法发现局域网上服务器的IP地址。服务器在局域网上侦听，当有数据到来的时候，判断数据是否有关键字IP_FOUND,

    2. 当存在此关键字的时候，发送IP_FOUND_ ACK到客户端。

    3. 客户端判断是否有服务器的响应IP_FOUD请求，并判断响应字符串是否包含IP_FOUND_ ACK来确定局域网上是否存在服务器，如果有服务器的响应，则根据recvfrom()函数的from变量可以获得服务器的IP地址。

    在这里插入图片描述

    ②.广播的服务器端代码

    #define IP_FOUND "IP_FOUND"        			/*IP发现命令*/
#define IP_FOUND_ACK "IP_FOUND_ACK"		/*IP发现应答命令*/
void HandleIPFound(void*arg)
{
	#define BUFFER_LEN 32
	int ret = -1;
	SOCKET sock = -1;
	struct sockaddr_in local_addr;			/*本地地址*/
	struct sockaddr_in from_addr;			/*客户端地址*/
   	int from_len;
	int count = -1;
	fd_set readfd;
	char buff[BUFFER_LEN];
	struct timeval timeout;	
	timeout.tv_sec = 2;						/*超时时间2s*/
	timeout.tv_usec = 0;

	DBGPRINT("==>HandleIPFound\n");
	
	sock = socket(AF_INET, SOCK_DGRAM, 0);	/*建立数据报套接字*/
	if( sock < 0 )
	{
		DBGPRINT("HandleIPFound: socket init error\n");
		return;
	}
	
	/*数据清零*/
	memset((void*)&local_addr, 0, sizeof(struct sockaddr_in));
											/*清空内存内容*/
	local_addr.sin_family = AF_INET;			/*协议族*/
	local_addr.sin_addr.s_addr = htonl(INADDR_ANY);/*本地地址*/
	local_addr.sin_port = htons(MCAST_PORT);		/*侦听端口*/
	/*绑定*/
	ret = bind(sock, (struct sockaddr*)&local_addr, sizeof(local_addr));
	if(ret != 0)
	{
		DBGPRINT("HandleIPFound:bind error\n");
		return;
	}

	/*主处理过程*/
	while(1)
	{
		/*文件描述符集合清零*/
		FD_ZERO(&readfd);
		/*将套接字文件描述符加入读集合*/
		FD_SET(sock, &readfd);
		/*select侦听是否有数据到来*/
		ret = selectsocket(sock+1, &readfd, NULL, NULL, &timeout);
		switch(ret)
		{
			case -1:
				/*发生错误*/
				break;
			case 0:
				/*超时*/
				//超时所要执行的代码
	
				break;
			default:
				/*有数据到来*/
				if( FD_ISSET( sock, &readfd ) )
				{
					/*接收数据*/
					count = recvfrom( sock, buff, BUFFER_LEN, 0, 
					( struct sockaddr*) &from_addr, &from_len );
					DBGPRINT( "Recv msg is %s\n", buff );
					if( strstr( buff, IP_FOUND ) )
					/*判断是否吻合*/
					{
						/*将应答数据复制进去*/
						memcpy(buff, IP_FOUND_ACK,strlen(IP_FOUND_ACK)+1);
						/*发送给客户端*/
						count = sendto( sock, buff, strlen( buff ),0,( struct sockaddr*) &from_addr, from_len );
					}
				}
		}
	}
	PRINT("<==HandleIPFound\n");

	return;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82

    ③.广播的客户端代码

    #define IP_FOUND "IP_FOUND"       			/*IP发现命令*/
#define IP_FOUND_ACK "IP_FOUND_ACK"		/*IP发现应答命令*/
#define IFNAME "eth0"
void IPFound(void*arg)
{
	#define BUFFER_LEN 32
	int ret = -1;
	SOCKET sock = -1;
	int so_broadcast = 1;
	struct ifreq ifr;  			
	struct sockaddr_in broadcast_addr;		/*本地地址*/
	struct sockaddr_in from_addr;			/*服务器端地址*/
	int from_len;
	int count = -1;
	fd_set readfd;
	char buff[BUFFER_LEN];
	struct timeval timeout;	
	timeout.tv_sec = 2;					/*超时时间2s*/
	timeout.tv_usec = 0;

	sock = socket(AF_INET, SOCK_DGRAM, 0);/*建立数据报套接字*/
	if( sock < 0 )
	{
		DBGPRINT("HandleIPFound: socket init error\n");
		return;
	}
	/*将需要使用的网络接口字符串名字复制到结构中*/
	strcpy(ifr.ifr_name,IFNAME,strlen(IFNAME));
	/*发送命令，获取网络接口的广播地址*/
	if(ioctl(sock,SIOCGIFBRDADDR,&ifr) == -1)
		perror("ioctl error"),exit(1);
	/*将获得的广播地址复制给变量broadcast_addr*/
	memcpy(&broadcast_addr, &ifr.ifr_broadaddr, sizeof(struct sockaddr_in ));
	broadcast_addr.sin_port = htons(MCAST_PORT);/*设置广播端口*/

	/*设置套接字文件描述符sock为可以进行广播操作*/
	ret = setsockopt(sock,SOL_SOCKET,SO_BROADCAST,&so_broadcast,sizeof so_broadcast);

	/*主处理过程*/
	int times = 10;
	int i = 0;
	for(i=0;i<times;i++)
	{
		/*广播发送服务器地址请求*/
		ret = sendto(sock,IP_FOUND,strlen(IP_FOUND),0,(struct sockaddr*)&broadcast_addr,sizeof(broadcast_addr));
		if(ret == -1){
			continue;	
		}
		/*文件描述符集合清零*/
		FD_ZERO(&readfd);
		/*将套接字文件描述符加入读集合*/
		FD_SET(sock, &readfd);
		/*select侦听是否有数据到来*/
		ret = selectsocket(sock+1, &readfd, NULL, NULL, &timeout);
		switch(ret)
		{
			case -1:
				/*发生错误*/
				break;
			case 0:
				/*超时*/
				//超时所要执行的代码
				break;
			default:
  				/*有数据到来*/
				if( FD_ISSET( sock, &readfd ) )
				{
					/*接收数据*/
					count = recvfrom( sock, buff, BUFFER_LEN, 0,( struct sockaddr*) &from_addr, &from_len );
					DBGPRINT( "Recv msg is %s\n", buff );
					if(strstr(buff, IP_FOUND_ACK))/*判断是否吻合*/
					{
						printf("found server, IP is %s\n",inet_ntoa(from_addr.sin_addr));
					}
					break;/*成功获得服务器地址，退出*/
				}
		}
	}	
	return;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    三、多播

    单播用于两个主机之间的端对端通信，广播用于一个主机对整个局域网上所有主机上的数据通信。单播和广播是两个极端，要么对一 个主机进行通信，要么对整个局域网上的主机进行通信。在实际情况下，经常需要对一 组特定的主机进行通信，而不是整个局域网上的所有主机，这就是多播的用途。

    1.多播的概念

    • **多播(组播)**将网络中同一业务类型主机进行了逻辑上的分组，进行数据收发的时候其数据仅仅在同 一 分组中进行，其他的主机没有加入此分组不能收发对应的数据。

      • 在广域网上广播的时候，其中的交换机和路由器只向需要获取数据的主机复制并转发数据。

        • 主机可以向路由器请求加入或退出某个组，网络中的路由器和交换机有选择地复制并传输数据，将数据仅仅传输给组内的主机。

    多播的功能，可以一次将数据发送到多个主机，又能保证不影响其他不需要（未加入组）的主机的其他通信。相对于传统的 一 对一 的单播，多播具有如下优点：

    1. 具有同种业务的主机加入同 一 数据流，共享同一通道，节省了带宽。

    2. 服务器的总带宽不受客户端带宽的限制。由于组播协议由接收者的需求来确定是否进行数据流的转发，所以服务器端的带宽是常量，与客户端的数量无关。

    3. 与单播一 样，多播是允许在广域网即Internet 上进行传输的，而广播仅仅在同一局域网上才能进行。

    多播缺点：

    1. 多播与单播相比没有纠错机制，当发生错误的时候难以弥补，但是可以在应用层来实现此种功能。

    2. 多播的网络支待存在缺陷，需要路由器及网络协议栈的支待。

    多播的应用主要有网上视频、网上会议等。

    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, 可限制多播范围。

    3.多播的编程

    setsockopt()函数和getsockopt()函数来实现多播，多播的选项是IP层的，其选项值和含义参见下图所示。

    在这里插入图片描述
    在这里插入图片描述
    ①.选项IP_MULTICAST_TTL

    选项IP_MULTICAST_TTL允许设置超时TTL，范围在0~255之间的任何值，例：

    unsigned char ttl = 255;
setsockopt(s,IPPROTO_IP,IP_MULTICAST_TTL,&ttl,sizeof(ttl));

    • 1
    • 2

    ②.IP_MULTICAST_IF

    选项IP_MULTICAST_IF用于设置组播的默认网络接口，会从给定的网络接口发送，另一个网络接口会忽略此数据，例：

    struct in_add addr;
setsockopt(s,IPPROTO_IP,IP_MULTICAST_IF,&addr,sizeof(addr));

    • 1
    • 2

    addr是多播输出接口的IP 地址，使用INADR_ANY 地址回送到默认接口。
    在默认情况下，当本机发送组播数据到某个网络接口时，在 IP 层，数据会回送到本地的回环接口，选项 IP_MULTICAST_LOOP 用于控制数据是否回送到本地的回环接口。例如：

    unisgned char loop;
setsockopt(s,IPPROTO_IP,IP_MULTICAST_LOOP,&loop,sizeof(loop));
//loop:设置0禁止回送，1允许回送

    • 1
    • 2
    • 3

    ③.IP_ADD_MEMBERSHIP和IP_DROP_MEMBERSHIP

    加入或退出一个组播组，通过选项IP_ADD_MEMBERSHIP和IP_DROP_MEMBERSHIP，对一个结构struct ip_mreq类型的变量进行控制，struct ip_mreq原型如下：

    struct ip_mreq
{
	struct in_addr imn_multiaddr;//加入或者退出的广播组IP地址
	struct in_adde imr_interface;//加入或者退出的网络接口IP地址
	};

    • 1
    • 2
    • 3
    • 4
    • 5

    选项 IP_ADD _MEMBERSHIP 用于加入某个广播组，可以向这个广播组发送数据或者从广播组接收数据。此选项的值为 mreq 结构，成员imn_ multiaddr 是需要加入的广播组 IP 地址，成员imr_ interface 是本机需要加入广播组的网络接口IP 地址。例如：

    struct ip_mreq mreq;;
setsockopt(s,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));

    • 1
    • 2

    使用 IP_ADD _MEMBERSHIP 选项每次只能加入一 个网络接口的IP 地址到多播组，但并不是一个多播组仅允许一 个主机 IP 地址加入，可以多次调用 IP_ADD_ MEMBERSHIP选项来实现多个IP地址加入同 一 个广播组，或者同一 个 IP 地址加入多个广播组。当imr _interface为INADDR_ANY时，选择的是默认组播接口。

    ④.IP_DROP_MEMBERSHIP

    选项IP_DROP_MEMBERSHIP用于从一个广播组退出。例:

    套接字(Socket)编程的基本方法（供初学者参考）
    txt 0星 超过10%的资源 11KB
    下载
    struct ip_mreq mreq;
setsockopt(s,IPPROTR_IP,IP_DROP_MEMBERSHIP,&mreq,sizeof(sreq));
//mreq包含了在IP_ADD_MEMBERSHIP中相同的值

    • 1
    • 2
    • 3

    ⑤.多播程序设计的框架

    进行多播，虚遵从一定的编程框架，例：

    在这里插入图片描述

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

    1. 建立一 个 socket。

    2. 然后设置多播的参数，例如超时时间TTL、本地回环许可LOOP等。

    3. 加入多播组。

    4. 发送和接收数据。

    5. 从多播组离开。

    4.内核中的多播

    Linux内核中的多播是利用结构struct ip_mc_socklist将多播的各个方面连接起来的，示意图如下所示。例：

    struct inet_sock{
	...
	_u8			mc_ttl;//多播TTL
	...
	_u8			...
					mc_loop:1；//多播回环设置;控制多播数据的本地发送。
	int			mc_index;//多播设备序号
	_be32		mc_addr;//多播地址
	struct ip_socklist  *mc_list;//多播群数组
	...
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在这里插入图片描述
    ①.结构ip_mc_socklist

    结构ip_mc_skcklist的原型为struct ip_mc_socklist，：

    struct ip_mc_socklist
{
		struct ip_mc_socklist	*next;//指向链表下一个节点。
		struct ip_mreqn		multi;//组信息，即在哪一个本地接口，加入那一个多播组。
		unsigned int			sfmode;//过滤模式，取值为MCAST_INCLUDE或MCAST_EXCLUDE，分别表示只接收sflist例出的那些源的多播数据报，和不接收sflist所列出的那些源的多播数据报。
		struct ip_sf_socklist	*sflist;//源列表
		};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    ②.结构ip_mreqn

    multi成员的原型为结构struct ip_mreqn,：

    struct ip_mreqn
{
	struct in_addr imr_multiaddr;//多播组的IP地址
	struct in_addr imr_address;//本地网络接口的IP地址
	int		imr_ifindex;//网络接口序号
	};
	//该命令字没有源过滤的功能，它相当于实现`IGMPv1`的多播加入服务接口。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    ③.结构ip_sf_socklist
    成员sflist的原型为结构strcut ip_sf_socklist，定义如下：

    struct ip_sf_socklist
{
	unsigned int sl_max;//表示源地址列表；
	unsigned int sl_count;//表示源地址列表中源地址的数量；
	__u32	sl_addr[0];//表示当前sl_addr数组的最大可容纳量。
	};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    ④.选项IP_ADD_MEMBERSHIP

    选项IP_ADD _MEMBERSHIP用于把本地的IP地址加入到多播组，在内核中其处理过程如下图所示，在应用层调用函数setsockopt()的选项IP_ADD_MEMBERSHIP后，内核的处理过程如下，主要调用了函数ip_mejoin_group()。

    1. 将用户数据复制如内核。

    2. 判断广播IP 地址是否合法。

    3. 查找IP地址对应的网络接口。

    4. 查找多播列表中是否已经存在多播地址。

    5. 将此多播地址加入列表。

    6. 返回处理值。

    在这里插入图片描述

    ⑤.选项IP_DROP_MEMBERSHIP

    选项IP_DROP _MEMBERSHIP用于把本地的IP 地址从多播组中取出，在内核中其处理过程如下图所示。在应用层调用setsockopt()函数的选项IP_DROP_ MEMBERSHIP后，内核的处理过程如下，主要调用了函数ip_mc_leave_group()。

    1. 将用户数据复制入内核。

    2. 查找IP地址对应的网络接口。

    3. 查找多播列表中是否已经存在多播地址。

    4. 将此多播地址从源地址中取出。

    5. 将此地址结构从多播列表中取出。

    6. 返回处理值。

    在这里插入图片描述

    一个多播例子的服务器端

    多播服务器的程序设计：建立一 个数据包套接字，选定多播的IP地址和端口，直接向此多播地址发送数据就可以了。多播服务器的程序设计，不需要服务器加入多播组，可以直接向某个多播组发送数据。

    下面的例子持续向多播IP地址"224.0.0.88"的8888端口发送数据"BROADCASTTESTDATA",每发送一次间隔5s。

    #define MCAST_PORT 8888;
#define MCAST_ADDR "224.0.0.88"/	/*一个局部连接多播地址，路由器不进行转发*/
#define MCAST_DATA "BROADCAST TEST DATA"			/*多播发送的数据*/
#define MCAST_INTERVAL 5							/*发送间隔时间*/
int main(int argc, char*argv[])
{
	int s;
	struct sockaddr_in mcast_addr;		
	s = socket(AF_INET, SOCK_DGRAM, 0);			/*建立套接字*/
	if (s == -1)
	{
		perror("socket()");
		return -1;
	}
	
	memset(&mcast_addr, 0, sizeof(mcast_addr));/*初始化IP多播地址为0*/
	mcast_addr.sin_family = AF_INET;				/*设置协议族类行为AF*/
	mcast_addr.sin_addr.s_addr = inet_addr(MCAST_ADDR);/*设置多播IP地址*/
	mcast_addr.sin_port = htons(MCAST_PORT);		/*设置多播端口*/
	
													/*向多播地址发送数据*/
	while(1) {
		int n = sendto(s, 							/*套接字描述符*/
									MCAST_DATA,		/*数据*/
									sizeof(MCAST_DATA),	 	/*长度*/
									0,
									(struct sockaddr*)&mcast_addr, 
									sizeof(mcast_addr));
		if( n < 0)
		{
			perror("sendto()");
			return -2;
		}		
		
		sleep(MCAST_INTERVAL);							/*等待一段时间*/
	}
	
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    一个多播例子的客户端

    多播的IP地址为224.0.0.88，端口为8888，当客户端接收到多播的数据后将打印出来。
    客户端只有在加入多播组后才能接收多播组的数据，因此多播客户端在接收多播组的数据之前需要先加入多播组，当接收完毕后要退出多播组。

    #define MCAST_PORT 8888
#define MCAST_ADDR "224.0.0.88"//一个局部连接多播地址，路由器不进行转发
#define MCAST_INTERVAL 5//发送间隔时间
#define BUFF_SIZE 256//接收缓冲区大小


int main(int argc,char*argv[])
{
        int s;//套接字文件描述符
        struct sockaddr_in local_addr;//本地地址
        int err = -1;

        s = socket(AF_INET,SOCK_DGRAM,0);//建立套接字
        if(s == -1)
        {
                perror("socket()");
                return -1;
        }
		
		//初始化地址
        memset(&local_addr,0,sizeof(lcoal_addr));
        lcoal_addr.sin_family = AF_INET;
        lcoal_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        local_addr.sin_port = htons(MCAST_PORT);

		//绑定socket
        err = bind(s,(struct sockaddr*)&local_addr,sizeof(local_addr));
        if(err<0)
        {
                perror("bind()");
                return -2;
        }
	
        int loop = 1;
        err = setsockopt(s,IPPROTO_IP,IP_MULTICAST_LLOP,&loop,sizeof(loop));

        if(err<0)
        {
                perror("bind()");
                return -2;
        }
     	//设置回环许可
        int loop = 1;
        err = setsockopt(s,IPPROTO_IP,IP_MULTICAST_LOOP,&loop,sizeof(loop));

        if(err<0)
        {
                perror("setsockopt():IP_MULTICAST_LOOP");
                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(s,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));
        if(err<0)
        {
                perror("setsocket():IP_ADD_MEMBERSHIP");
        }
        int times = 0;
        int addr_len = 0;
        char buff[BUFF_SIZE];
        int n = 0;
        //循环接收广播组信息，5次退出
        for(times = 0;times<5;times++)
        {
                addr_len = sizeof(local_addr);
                memset(buff,0,BUFF_SIZE);//清空接收缓冲区
                //接收数据
                n = recvfrom(s,buff,BUFF_SIZE,0,(struct sockaddr*)&local_addr,&addr_len);
                if(n == -1)
  {
                        perror("recvfrom()");
                }
                printf("Recv %dst message from server:%s\n",times,buff);
                sleep(MCAST_INTERVAL);
        }

        err = setsockopt(s,IPPROTO_IP,IP_DROP_MEMBERSHIP,&mreq,sizeof(mreq));
        close(s);
        return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84

    四、数据链路层访问

    在 Linux 下数据链路层的访问通常是通过编写内核驱动程序来实现的，在应用层使用SOCK_PACKET 类型的协议族可以实现部分功能。

    1.SOCK_PACKET类型

    建立套接字的时候选择 SOCK _PACKET 类型，内核将不对网络数据进行处理而直接交给用户，数据直接从网卡的协议栈交给用户。建立个 SOCK_PACET 类型的套接字使用

    sock(AF_INET,SOCK_PACKET,htons(0x0003));
// A F_INET 表示因特网协议族，
// SOCK_PACKET表示截取数据帧的层次在物理层，网络协议栈对数据不做处理。
// 值 0x0003 表示截取的数据帧的类型为不确定，处理所有的包。

    • 1
    • 2
    • 3
    • 4

    使用 SOCK _PACKET 进行程序设计的时候，需要注意的主要方面包括协议族选择、获取原始包、定位 IP 包、定位 TCP 包、定位 UDP 包、定位应用层数据几个部分。

    2.设置套接口以捕获链路帧的编程方法

    在 Linux 下编写网络监听程序，比较简单的方法是在超级用户模式下，利用类型为SGCK_pACKET 的套接口 （用 socket()函数创建）来捕获链路帧数据。Linux 程序中需引用如下头文件：

    #include  
#include  //ioctl命令
#include  //ethhdr 结构
#include  //ifreq 结构
#include  //in_addr结构
#include  //iphdr 结构
#include  //udphdr 结构
#include  //tcphdr结构

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    监视所有类型的包：

    int fd;
fd = socket(AF_INET,SOCK_PACKET,htons(0x0003));

    • 1
    • 2

    侦听其他主机网络的数据在局域网诊断中经常使用。如果要监听其他网卡的数据，需
    要将本地的网卡设置为"混杂"模式；还需要一个都连接于同一HUB的局域网或者
    具有＂镜像”功能的交换机    才可以，否则，只能接收到其他主机的广播包。

    char* ethname = "eth0";//对网卡ethO进行混杂设置
struct ifreq ifr;//网络接口结构
strcmp(ifr.ifr_name, ethname);//ethO"写入ifr结构的一个字段中
i = ioctl(fd, SIOCGIFFLAGS, &ifr);//获得ethO的标志位值
if (i < 0)//判断是否取出出错
{
	close(fd);
	perror("can't get flags\n");
	return -1;
}
ifr.ifr_flags |= IFF_PROMISC;//保留原来设置的情况下，在标志位中加入“混杂”方式
i = ioctl(fd, SIOCSIFFLAGS, &ifr);//将标志位设置写入
if (i < 0)//判断是否写入出错
{
	perror("promiscuous set error\n");
	return -2;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    ioctl()的SIOCGIFFLAGS和SIOCSIFFLAGS命令，用来取出和写入网络接口的标志设置。
    注意，在修改网络接口标志的时候，务必要先将之前的标志取出，与    想设置的位进行“位或“计算后再写入    ；不要直接将设置的位值写入，因为直接写入会覆盖之前的设置，造成网络接口混乱。

    遵循如下步骤：

    1. 取出标志位

    2. 目标标志位=取出的标志位|设置的标志位

    3. 写入目标标志位。

    3.从套接口读取链路帧的编程方法

    以太网的数据结构如下图所示，总长度最大为1518字节，最小为64字节，其中目标地址的MAC为6字节，源地址MAC为6字节，协议类型为2字节，含有46~1500字节的数据，尾部为4个字节的CRC校验和。以太网的CRC校验和一般由硬件自动设置或者剥离，应用层不用考虑。
    在这里插入图片描述

    VC++sock高级套接字编程教程
    ppt 5星 超过95%的资源 1.29MB
    下载

    在头文件中定义了如下常量:

    #define ETH_ALEN 6//以太网地址，即MAC地址，6字节
#define ETH_HLEN 14//以太网头部的总长度
#define ETH_ZLEN 60//不含CRC校验的数据最小长度
#define ETH_DATA_LEN //1500帧内数据的最大长度
#define RTH_FRAME_LEN 1514//不含CRC校验和的最大以太网数据长度

    • 1
    • 2
    • 3
    • 4
    • 5

    以太网头部结构定义如下形式：

    struct ethhdr
{
	unsigned char h_dest[ETH_ALEN];//目的以太网地址
	unsigned char h_source[ETH_ALEN];//源以太网地址
	_be16		h_proto;//包类型
	};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    套接字文件描述符建立后，从此描述符中读取数据，数据的格式为上述的以太网数据，即以太网帧。
    套接口建立以后，从中循环读取捕获的链路层以太网帧。要建立一个大小为ETH_FRAME_LEN 的缓冲区，并将以太网的头部指向此缓冲区，例如：

    char ef[ETH_FRAME_LEN];//以太缓冲区帧
struct ethhdr*p_ethhdr;//以太网头部指针
int n; 
p_ethhdr = (struct ethhdr*)ef; //使p_ethhdr指向以太网帧的帧头
//读取以太网数据，n为返回的实际捕获的以太帧的帧长
n =read(fd, ef, ETH_FRAME_LEN); 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    接收数据以后，缓冲区ef与以太网头部的对应关系如图所示：
    在这里插入图片描述
    因此，要获得以太网帧的目的MAC地址、源MAC地址和协议的类型，可以通过p_ethhdr->h _ dest、p_ ethhdr->h _ source 和 p_ ethhdr->h __proto 获得。下面的代码将以太网的信息打印出来：

    //打印以太网帧中的MAC地址和协议类型
//目的MAC地址
printf("dest MAC: "); 
for(i=O; i< ETH_ALEN-1; i++) { 
printf("%02x-", p_ethhdr->h_dest[i]) ;
}
printf{"%02x\n", p_ethhdr->h_dest[ETH_ALEN-1]); 
//源MAC地址
printf ("source MAC: "); 
for(i=O; i< ETH_ALEN-1; i++) { 
printf("%02x-", p_ethhdr->h_source[i]); 
}
printf("%02x\n ", p_ethhdr->h_dest[ETH_ALEN-1)); 
//协议类型，Ox0800为IP协议，Ox0806为ARP协议，Ox8035为RARP协议
printf("protocol_: Ox%04x", ntohs(p_ethhdr->h_proto)); 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    4.定位IP包头的编程方法

    获得以太帧后，当协议为0x0800时，其负载部分为IP协议，IP协议的数据结构如下所示：

    在这里插入图片描述

    IP头部的数据结构定义在头文件中，：

    struct iphdr {
#if defined (_LITTLE_ENDIAN_BITFIELD)//小端
	_u8 ihl : 4,//IP头部长度，单位为32bit
	version : 4;//IP版本，值为4
#elif defined (_BIG_ENDIAN_BITFIELD)//大端
	_u8 version : 4,//IP版本，值为4
		ihl : 4;//IP头部长度，单位为32bit
#else
#error "Please fix"
#endif
	_u8	tos;//服务类型
	_be16	tot_len;//总长度
	_be16	id;//标识
	_be16 frag_off;//片偏移
	_u8	ttl;//生存时间
	_u8	protocol;//协议类型
	_u16 check;//头部校验和
	_be32 saddr; //源IP地址
	_be32 daddr;//目的IP地址
	//IP选项
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    若捕获的以太帧中 h_proto 的取值为0x0800,将类型为 iphdr的结构指针指向帧头后面
    载荷数据的起始位置，则可以得到 IP 数据包的报头部分。

    通过saddr和daddr可以得到IP报文的源 IP 地址和目的IP地址，下面的代码打印IP 报文的源IP 地址和目的IP 地址。

    //打印IP报文的源IP地址和目的IP地址”
if(ntohs(p_ethhdr->h_proto)==OxO8OO){	//Ox0800: IP包
	//定位IP头部
	struct iphdr *p_iphdr = (struct iphdr*) (ef+ETH+HLEN);
	//打印源IP地址
	printf("src ip:%s\n",inet_ntoa(p_iphdr->saddr));
	//打印目的IP地址
	printf("dest ip:%s\n",inet_ntoa(p_iphdr->daddr));

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    5.定位TCP报头的编程方法

    TCP的数据结构如图所示：

    在这里插入图片描述

    对应的数据结构在头文件中定义，代码如下：

    struct tcphdr
{
	_u16	source;//源地址端口
	_u16 	dest;//目的地址端口
	_u32	seq;//序列号
	_u32	ack_seq;//确认序列号
#if defined(_LITTLE_ENDIAN_BITFIELD)
	_u16	resl:4; //保留
		doff:4,//偏移
		fin:1, //关闭连接标志
		syn: 1, //请求连接标志
		rst: 1,//重置连接标志
		psh:1,//接收方尽快将数据放到应用层标志
		ack: 1,//确认序号标志
		urg:1,//紧急指针标志
	    ece: 1,//拥塞标志位
        cwr:1;//拥塞标志位
#elif defined(_BIG_ENDIAN_BITFIELD)
	_u16 doff:4;//偏移
		resl:4,//保留
		cwr:1, //拥塞标志位
		ece: 1,//拥塞标志位
		 urg:1, //紧急指针标志
		 ack:1, ///确认序号标志
		 psh:1, //接收方尽快将数据放到应用层标志
		 rst:1,//重置连接标志
		 syn:1,//请求连接标志
		 fin:1;//关闭连接标志
#else
#error “Adjust your <asm/byteorder.h> defines”
#endif
	_u16	window;//滑动窗口大小
	_u16	check;//校验和＊
	_u16	urg_ptr;//紧急字段指针
	};
		     

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    对于TCP协议，其IP头部的 protocol的值应该为6 ，通过计算IP头部的长度可以得到TCP头部的地址，即TCP的头部为IP头部偏移ihl*4。
    TCP的源端口和目的端口可以通过成员 source 和dest来获得。下面的代码将源端口和目的端口的值打印出来：

    //打印TCP报文的源端口值和目的端口值
if (p _iphdr->protocol==6) 
{
// 取得TCP报头
struct tcphdr*p tcphdr = (struct tcphdr*) (p_iphdr+p_iphdr->ihl*4) ; 
//打印源端口值
printf("src port:%d\n", ntohs(p_tcphdr->source)); 
//打印目的端口值
printf("dest port:%d\n", ntohs(p_tcphdr->dest));
} 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    6.定位UDP报头的编程方法

    UDP的数据结构如图所示：

    在这里插入图片描述
    UDP的头部数据结构在文件中定义，：

    struct udphdr
{
	u_int16_t	source;//源地址端口
	u_int16_t	dest;//目的地址端口
	u_int16_t	len;//UDP长度
	u_int16_t	check;//UDP校验和
	};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    头部数据结构如下图所示，对于UDP协议，其IP头部的 protocol的值为17, 通过计算IP头部的长度可以得到UDP头部的地址，即UDP的头部IP头部偏移ihl*4。UDP的源端口和目的端口可以通过成员source和dest来获得。下面的代码将源端口和目的端口的值打印出来：在这里插入图片描述

    //打印UDP报文的源端口值和目的端口值
if(p_iphdr->protocol==l7) 
{
//取得UDP报头
struct udphdr*p_udphdr = (struct udphdr*) (p_iphdr+p_iphdr->ihl*4); 
//打印源端口值
printf("src port:%d\n", ntohs(p_udphdr->source)); 
//打印目的端口值
printf("dest port:%d\n", ntohs(p_udphdr->dest)); 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    7.定位应用层报文数据的编程方法

    定位了UDP和TCP头部地址后，其中的数据部分为应用层报文数据，根据TCP和UDP的协议获得应用程序指针的代码如下：

    char* app_data = NULL;//应用数据指针
int app_len = 0;//应用数据长度

//获得TCP或者UDP的应用数据
if (p_iphdr->protocol == 6)
{
	//获得TCP报头
	struct tcphdr* p_tcphdr = (struct tcphdr*)(p_iphdr + p_iphdr->ihl * 4);
	//获得TCP协议部分的应用数据地址
	app_data = p_tcphdr + 20;
	//获得TCP协议部分的应用数据长度
	app_len = n - 16 - p_iphdr->ihl * 4 - 20;
}else if(p_iphdr->protocol==17)
{
	//获得UDP报头
	struct udphdr* p_udphdr = (struct udphdr*)(p_iphdr + p_iphdr->ihl * 4);
	//获得UDP协议部分的应用数据地址
	app_data = p_udphdr + p_udphdr->len;
	//获得UDP协议部分的应用数据长度
	app_len = n - 16 - p_iphdr->ihl * 4 - p_udphdr->len;

}
//打印应用数据的地址和长度
printf("application data address:0x%x,length:%d\n", app_data, app_len);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    8.使用SOCK_PACKET编写ARP请求程序的例子

    ①.ARP协议数据和结构

    包含以太网头部数据的ARP协议数据结构如下图所示：
    在这里插入图片描述
    ARP的数据结构在头文件中定义，：

    struct arphdr
{
	_be16 ar_hrd;//硬件类型
	_be16 ar_pro;//协议类型
	unsigned char ar_hln;//硬件地址长度
	unsigned char ar_pln;//协议地址长度
	_be16 ar_op;//ARP操作码
	};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述

    ②.ARP数据结构

    struct arppacket
{
	unsigned short	ar_hrd;				/*硬件类型*/
	unsigned short	ar_pro;				/*协议类型*/
	unsigned char	ar_hln;				/*硬件地址长度*/
	unsigned char	ar_pln;				/*协议地址长度*/
	unsigned short	ar_op;				/*ARP操作码*/
	unsigned char	ar_sha[ETH_ALEN];	/*发送方MAC地址*/
	unsigned char*	ar_sip;			/*发送方IP地址*/
	unsigned char	ar_tha[ETH_ALEN];	/*目的MAC地址*/
	unsigned char*	ar_tip;			/*目的IP地址*/

};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    ③APR请求代码

    ARP 请求包的构建包含了以太网头部部分、ARP头部部分、ARP 的数据部分。需注意目的以太网地址，由于 ARP 的作用就是查找目的IP 地址的 MAC地址，所以目的以太网地址是未知的。而且需要在整个以太网上查找其 IP 地址，所以目的以太网地址是一 个全为1的值，即为{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF} 。

    #include 
#include 					/*ioctl 命令*/
#include 				/*ethhdr 结构*/
#include 						/*ifreq 结构*/
#include 
#include 
#include 
#include 					/*in_addr结构*/
#include 					/*iphdr 结构*/
#include 					/*udphdr 结构*/
#include 					/*tcphdr 结构*/
struct arppacket
{
	unsigned short	ar_hrd;				/*硬件类型*/
	unsigned short	ar_pro;				/*协议类型*/
	unsigned char	ar_hln;				/*硬件地址长度*/
	unsigned char	ar_pln;				/*协议地址长度*/
	unsigned short	ar_op;				/*ARP操作码*/
	unsigned char	ar_sha[ETH_ALEN];	/*发送方MAC地址*/
	unsigned char*	ar_sip;			/*发送方IP地址*/
	unsigned char	ar_tha[ETH_ALEN];	/*目的MAC地址*/
	unsigned char*	ar_tip;			/*目的IP地址*/

};
int main(int argc, char*argv[])
{
	char ef[ETH_FRAME_LEN];  			/*以太帧缓冲区*/
	struct ethhdr*p_ethhdr;				/*以太网头部指针*/
	/*目的以太网地址*/
	char eth_dest[ETH_ALEN]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};//表示在局域网进行广播
	/*源以太网地址*/
	char eth_source[ETH_ALEN]={0x00,0x0C,0x29,0x73,0x9D,0x15};
										/*目的IP地址*/
	
	int fd;       						/*fd是套接口的描述符*/
	fd = socket(AF_INET, SOCK_PACKET, htons(0x0003));
	
	/*使p_ethhdr指向以太网帧的帧头*/
	p_ethhdr = (struct ethhdr*) ef;
	/*复制目的以太网地址*/
	memcpy(p_ethhdr->h_dest, eth_dest, ETH_ALEN);
	/*复制源以太网地址*/
	memcpy(p_ethhdr->h_source, eth_source, ETH_ALEN);
	/*设置协议类型，以太网0x0806*/
	p_ethhdr->h_proto = htons(0x0806);
	
	struct arppacket*p_arp;	
	p_arp = (struct arppacket*)ef + ETH_HLEN;				/*定位ARP包地址*/
	p_arp->ar_hrd = htons(0x1);			/*arp硬件类型*/
	p_arp->ar_pro = htons(0x0800);		/*协议类型*/
	p_arp->ar_hln = 6;					/*硬件地址长度*/
	p_arp->ar_pln = 4;					/*IP地址长度*/
	/*复制源以太网地址*/
	memcpy(p_arp->ar_sha, eth_source, ETH_ALEN);
	/*源IP地址*/
	p_arp->ar_sip=(unsigned char*)inet_addr("192.168.1.152");
	/*复制目的以太网地址*/
	memcpy(p_arp->ar_tha, eth_dest, ETH_ALEN);
	/*目的IP地址*/
	p_arp->ar_tip = (unsigned char*)inet_addr("192.168.1.1");
	
	/*发送ARP请求8次，间隔1s*/
	int i = 0;
	for(i=0;i<8;i++){
		write(fd, ef, ETH_FRAME_LEN);/*发送*/
		sleep(1);						/*等待1s*/
	}
	close(fd);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    ①.带外数据

    带外数据指当连接中的双方如果有紧急的事情要通知对方，发送高优先级数据，发送通常使用MSG_OOB:

    send(s,"URC",3,MSG_OOB);

    • 1
    1. 接收方会接收到SIGURG的信号，根据此信号，接收方接收带外数据。
    2. 可以使用函数 sockatmark()来测试是否有带外数据存在。

    IP选项是在20个字节的空间之外的IP设置，通常IPv4选项为IP源路径选项，用于记录数据报经过的主机路径，即路由器地址的集合。

    路由套接字选项使用控制字来设置路由的特性，例如增加删除路由、路径信息、测度等信息。通常程序设计框架为：

    s = socket(AF_ROUTE, SOCK_RAW,0); 
struct rt_msghdr rtm; 
//设置rtm*/
...
write(s, rtm, rtm->rtm_msglen); 

    • 1
    • 2
    • 3
    • 4
    • 5

    即建立一 个 AF_ROUTE 的套接字文件描述符，设置路由消息 struct rt_ msghdr结构，通过发送和接收来控制消息。

  • 相关阅读:
    023-从零搭建微服务-推送服务（三）
    c++静态链接库的简单创建与使用
    Map接口和常用方法
    5年测试工程师在公司被看轻，只因不会自动化测试...
    操作系统图片一览
    软件设计原则-开闭原则讲解以及代码示例
    PLSQL导入导出表数据、表结构
    SAP UI5 ManagedObject 的 Event 讲解
    多线程之异步模式工作线程
    电脑提速方法：虚拟内存使用固态硬盘
  • 原文地址：https://blog.csdn.net/weixin_50866517/article/details/126260952