UNIX 域协议使用！在进程间传递“文件描述符” 实例

不念不忘少年蓝@ 2022-06-13 09:15 311阅读 0赞

你需要知道的：

注意：首先你要有一个测试文件存在！( 因为下面要打开一个文件，然后传递它的描述符 )  
  
1 >:  
  
此程序的整体结构是：  
  
进程1中创建一个socketpair用于父子进程通信  
            |  
进程1中创建一个子进程  
            |  
子进程中使用execl启动另一个进程来打开此文件并将fd通过参数传入的socket传回子进程  
注意：父进程在这个时候的动作是waitpid而已  
            |  
那么由于父子进程是的socket端口是全双工的，所以一旦子进程那里有信息就会发送过来  
            |  
那么父进程就可以在一个端口上获得信息，然后再在自己的环境下打开文件，写到stdout  
  
请注意：其中最重要的就是怎么使用struct msghdr来封装数据传递！！！  
  
  
2 >:  
  
关于msghdr结构体：  
struct msghdr  
\{  
    void                 \*msg\_name;                //!> 对方主机的地址  
    socklen\_t        msg\_namelen;            //!> 长度  
      
    struct iovec     \*msg\_iov;                    //!> io vector 的内容  
    size\_t               msg\_iovlen;                //!> 个数  
      
    void                  \*msg\_control;            //!> 控制信息  
    size\_t               msg\_controllen;            //!> 控制信息长度  
      
    int                      msg\_flags;                    //!> 标志  
\};  
  
分成4组，具体的信息网上到处都是，此处不多说哦～  
  
3 >:  
  
关于：struct cmsghdr  
>: 我们在接收msghdr的时候需要这样一个结构体的指针来遍历整个CMSG\_DATA的内容！  
>: 在发送的时候需要使用这个写入头信息：pCmsghdr = CMSG\_FIRSTHD(&msghdr\_send);  
    pCmsghdr = CMSG\_FIRSTHDR( &msghdr\_send );    //!> the info of head  
    pCmsghdr->cmsg\_len = CMSG\_LEN(sizeof(int));       //!> the msg len  
    pCmsghdr->cmsg\_level = SOL\_SOCKET;             //!> -> stream mode                 
    pCmsghdr->cmsg\_type = SCM\_RIGHTS;              //!> -> file descriptor  
    \*((int \*)CMSG\_DATA( pCmsghdr )) = file\_fd;            //!> data: the file fd  
  
>: cmsg\_len与CMSG\_LEN()宏值所显示的长度相同。  
   cmsg\_level        这个值表明了原始的协议级别(例如，SOL\_SOCKET)。  
   cmsg\_type        这个值表明了控制信息类型(例如，SCM\_RIGHTS代表文件描述符)。  
                       SCM\_RIGHTS        附属数据对象是一个文件描述符  
                    SCM\_CREDENTIALS        附属数据对象是一个包含证书信息的结构  
  
4 >:  
  
关于一些宏：  
  
>: CMSG\_LEN：计算cmsghdr头结构加上所需要的填充字符的字节长度。  
                     这个值用来设置cmsghdr对象的cmsg\_len成员  
                     上面的意思也就是说：输入的CMSG\_DATA是什么类型的，对应的长度！  
                     例如此处是fd，那么 就是CSMG\_LEN(sizeof( int ))！！！  
                      
>: CMSG\_SPACE：计算附属数据以及其头部所需的总空白。尽管CMSG\_LEN()宏计算了一  
                       个相似的长度，CMSG\_LEN()值并不包括可能的结尾的填充字符。  
                        CMSG\_SPACE(sizeof fd)  
                        此宏调用来得到所需的总空间  
  
>: CMSG\_DATA：接受一个指向cmsghdr结构的指针。返回的指针值指向跟随在头部以及填  
                      充字节之后的附属数据的第一个字节(如果存在)。  
                      fd = \*(int \*)CMSG\_DATA(ptr)；  
                        
>: CMSG\_FIRSTHDR：返回一个指向附属数据缓冲区内的第一个附属对象的struct cmsghdr指  
                           针。输入值为是指向struct msghdr结构的指针(不要与structcmsghdr相  
                           混淆)。  
                           这个宏会估计msghdr的成员msg\_control与msg\_controllen来确定在缓  
                           冲区中是否存在附属对象。然后，他会计算返回的指针。如果不存在  
                               附属数据对象则返回的指针值为NULL。否则，这个指针会指向存在  
                               的第一个struct cmsghdr。这个宏用在一个for循环的开始处，来开始  
                               在附属数据对象中遍历。  
                             
>: CMSG\_NXTHDR：返回下一个附属数据对象的struct cmsghdr指针。这个宏会接受两个输  
                         入参数：指向struct msghdr结构的指针指向当前struct cmsghdr的指针  
                         如果没有下一个附属数据对象，这个宏就会返回NULL。遍历附属数据  
                         当接收到一个附属数据时，我们可以使用CMSG\_FIRSTHDR()与  
                         CMSG\_NXTHDR()宏来在附属数据对象中进行遍历。  
  
5 >:  
  
注意的是：此处是采用socketpair来创建两个socket来处理的，本是是采用的“全双工”模式而已～  
  
  
6 >:  
  
注意： WIFEXITED, WEXITSTATUS  
  
WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。  
( 当然status是由waitpid得到的！waitpid( pid, &status, 0 ) )  
  
WEXITSTATUS：  
解释：  
    WEXITSTATUS(status) 当WIFEXITED返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用exit(5)退出，WEXITSTATUS(status) 就会返回5；如果子进程调用exit(7)，      
    WEXITSTATUS(status)就会返回7。请注意，如果进程不是正常退出的，也就是说，WIFEXITED返回0，这个值就毫无意义。

第一个进程代码：

/*
    	这个进程需要做的就是创建一个子进程，然后
    	在子进程中尝试打开一个文件，注意是调用另
    	外一个进程处理，然后另外的进程将文件描述符
    	返回给此进程，再有此进程的处理！
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/wait.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/un.h>
    
    #define 	BUFLINE		1024
    
    //!> when we recv from the socket,we should give the same data struct
    int recv_file_fd( int fd, void * data, size_t len, int * recv_fd )
    {
    	struct msghdr 	msghdr_recv;		//!> the info struct
    	struct iovec	iov[1];	                //!> io vector
    	size_t		n;	                //!>
    	
    	union
    	{
    		struct cmsghdr	cm;			//!> control msg
    		char 	ctl[CMSG_SPACE(sizeof( int ))];	//!> the pointer of char
    	}ctl_un;
    	
    	struct cmsghdr * pCmsghdr = NULL;		//!> the pointer of control
    	
    	msghdr_recv.msg_control = ctl_un.ctl;	
    	msghdr_recv.msg_controllen = sizeof( ctl_un.ctl );
    	
    	//!> these infos are nosignification
    	msghdr_recv.msg_name = NULL;			//!> the name	
    	msghdr_recv.msg_namelen = 0;		        //!> len of name
    	
    	iov[0].iov_base = data;			        //!> no data here
    	iov[0].iov_len = len;				//!> the len of data
    	
    	msghdr_recv.msg_iov = iov;			//!> the io/vector info
    	msghdr_recv.msg_iovlen = 1;			//!> the num of iov
    	
    	if( ( n = recvmsg( fd, &msghdr_recv, 0 ) ) < 0 )//!> recv msg
    	{						//!> the msg is recv by msghdr_recv
    		printf("recv error : %d\n", errno);
    		exit(EXIT_FAILURE);
    	}
    	
    	//!> now, we not use 'for' just because only one test_data_ 
    	if(     ( pCmsghdr = CMSG_FIRSTHDR( &msghdr_recv ) ) != NULL 	//!> now we need only one,
    	  && pCmsghdr->cmsg_len == CMSG_LEN( sizeof( int ) )		//!> we should use 'for' when 
    	 )																				//!> there are many fds
    	 {
    	 	if( pCmsghdr->cmsg_level != SOL_SOCKET )
    	 	{
    	 		printf("Ctl level should be SOL_SOCKET\n");
    	 		exit(EXIT_FAILURE);
    	 	}
    	 	
    	 	if( pCmsghdr->cmsg_type != SCM_RIGHTS )
    	 	{
    	 		printf("Ctl type should be SCM_RIGHTS\n");
    	 		exit(EXIT_FAILURE);
    	 	}
    	 	
    	 	*recv_fd =*((int*)CMSG_DATA(pCmsghdr));	//!> get the data : the file des* 
    	 }
    	 else
    	 {
    	 	*recv_fd = -1;
    	 }
    	 
    	 return n;
    	
    }
    
    int open_file( char * path_name, int mode )
    {
    	int 		fd;
    	int		sockfd[2];		//!> for sockpair()
    	int 		status;			//!> the status of child process
    	char 	c;
    	char	arg_fd[10];			//> fd arg
    	char	arg_mode[10]; 	//> mode arg
    	pid_t	chi_pid;
    	
    	//!> create the socketpair
    	if( socketpair( AF_LOCAL, SOCK_STREAM, 0, sockfd ) == -1 )
    	{
    		printf( "create socketpair error : %d\n", errno );
    		exit( EXIT_FAILURE );
    	}
    	
    	//!> the child process
    	if( ( chi_pid = fork() ) == 0 )
    	{
    		close( sockfd[0] );		//!> child use the #1 port; so , close the #0
    		
    		snprintf( arg_fd, sizeof( arg_fd ), "%d", sockfd[1] );
    		snprintf( arg_mode, sizeof( arg_mode ), "%d", mode );
    
    		//!> call the new process
    		execl( "./second", "second", arg_fd, path_name, arg_mode, (char*)NULL );
    		printf("execl the second process error : %d\n", errno);	
    		//!> you know : the usge of execl
    		exit( EXIT_FAILURE );
    	}
    	
    	//!> parent :
    	
    	close( sockfd[1] );				//!> yes
    	
    	waitpid( chi_pid, &status, 0 );			//!> wait the child process
    
    	if( WIFEXITED( status ) != 0 )			//!> we should know the usge of WIFEXITED
    	{
    		if( ( status = WEXITSTATUS( status ) ) == 0 )	//!> end
    		{
    			recv_file_fd( sockfd[0], &c, 1, &fd );	//!> recv from sockfd[0]
    		}
    		else
    		{
    			errno = status;
    			fd = -1;
    		}		
    		close( sockfd[0] );
    		return fd;
    	}
    	
    	return -1;
    
    }
    
    int main( int argc, char ** argv )
    {
    	int 		fd;		//!> get the file_descriptor
    	int 		n_read;
    	char	buf[BUFLINE];
    
    	if( argc != 2 )			//!> input the file path
    	{
    		printf("Input : file path\n");
    		exit( EXIT_FAILURE );
    	}
    	
    	if( ( fd = open_file( argv[1], O_RDONLY ) ) < 0 ) //!> fork a child
    	{						  //!> then: child -> execl a new process
    		printf("Open file error : %d\n", errno);  //!>        parent -> wair and recv the fd from child
    		exit( EXIT_FAILURE );
    	}
    	
    	printf("Get the new fd == %d\n", fd);
    	
    	while( ( n_read = read( fd, buf, BUFLINE ) ) > 0 ) //!> read from fd
    	{
    		write( 1, buf, n_read );		   //!> write to std_out
    	}
    	
    	return 0;
    }

第二个个进程代码：

/*
    	在这个文件中我们需要做的是：将打开的文件描述符，
    	这个文件描述符是第二个进程进行fork的子进程中init的，
    	所以也就是相当于在第二个进程的子进程中执行此程序，
    	此程序传递打开的文件描述符再给第二个进程！
    	这里其实是复杂化了程序，就是故意构造这样的一个状态！
    	呵呵！～
    	( 注意不仅仅是文件描述符，可以是所有的描述符 )
    	例如open()、pipe()、mkfifo()、socket()或者accept() 都可以
    	
    	注意：此进程的是由第二个进程进行调用的！
    	use UDP 
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/un.h>
    #include <sys/wait.h>
    
    int send_back( int fd_send_to, void * data, size_t len, int file_fd )
    {
    	struct msghdr 	msghdr_send;		//!> the info struct
    	struct iovec		iov[1];		//!> io vector
    	size_t				n;	//!>
    	
    	union
    	{
    		struct cmsghdr	cm;			//!> control msg
    		char 	ctl[CMSG_SPACE(sizeof( int ))];	//!> the pointer of char
    	}ctl_un;
    	
    	struct cmsghdr * pCmsghdr = NULL;		//!> the pointer of control
    	
    	msghdr_send.msg_control = ctl_un.ctl;	
    	msghdr_send.msg_controllen = sizeof( ctl_un.ctl );
    	
    	//!> design : the first info
    	pCmsghdr = CMSG_FIRSTHDR( &msghdr_send );	//!> the info of head
    	pCmsghdr->cmsg_len = CMSG_LEN(sizeof(int));     //!> the msg len
    	pCmsghdr->cmsg_level = SOL_SOCKET; 		//!> -> stream mode           	
    	pCmsghdr->cmsg_type = SCM_RIGHTS;  		//!> -> file descriptor
    	*((int *)CMSG_DATA( pCmsghdr )) = file_fd;	//!> data: the file fd 
    	
    	//!> these infos are nosignification
    	msghdr_send.msg_name = NULL;			//!> the name	
    	msghdr_send.msg_namelen = 0;		        //!> len of name
    	
    	iov[0].iov_base = data;				//!> no data here
    	iov[0].iov_len = len;				//!> the len of data
    	
    	msghdr_send.msg_iov = iov;			//!> the io/vector info
    	msghdr_send.msg_iovlen = 1;			//!> the num of iov
    	
    	return ( sendmsg( fd_send_to, &msghdr_send, 0 ) );	//!> send msg now
    }
    
    int main( int argc, char ** argv )
    {
    	
    	int 		fd;	//!> the fd of the open_file
    	ssize_t		ret_n;	//!> the return of n
    	
    	if( argc != 4 )
    	{
    		printf("useg:<unix_domain socket> <file_name> <open_mode>\n");
    		exit( 0 );
    	}
    	
    	//!> open the file
    	if( ( fd = open( argv[2], atoi( argv[3] ) ) ) < 0 )
    	{
    		printf("open file error : %d\n", errno);
    		exit( EXIT_FAILURE );
    	}
    	
    	printf("Open the file, the fd == %d\n", fd);
    	
    	if( ( ret_n = send_back( atoi( argv[1]) , "", 1, fd ) ) < 0 )	//!> send back by the socket
    	{
    		printf("send back error : %d\n", errno);
    		exit( EXIT_FAILURE );
    	}
    	
    	return 0;
    }

在我的机子上输出的结果：

pt@ubuntu:~/桌面$ ./f file  
  
  
Open the file, the fd == 3  
Get the new fd == 4  
//!> 注意，下面是我的文件中的内容  
sdfvas  
dv  
asdf  
sdfb  
sfgn  
d  
sfynhfdgobfnadlfknjvbasdf  
bsdf'bsmd  
gfbka  
dfk  
ag  
as  
s