Unix域协议

浅浅的花香味﹌ 2022-05-24 10:54 132阅读 0赞

Unix域协议并不是一个实际的协议族，而是在单个主机上执行客户/服务器通信的一种方法。

Unix域提供两类套接字：字节流套接字和数据报套接字。

使用Unix域套接字的理由：

1.Unix域套接字往往比通信两端位于同一个主机的TCP套接字快出一倍。

2.Unix域套接字可用于在同一个主机上的不同进程之间传递描述符。

3.Unix域套接字较新的实现把客户的凭证(用户ID和组ID)提供给服务器，从而能够提供额外的安全检查措施。

Unix域用于标识客户和服务器的协议地址是普通文件系统中的路径名。

Unix域套接字地址结构

#include<sys/un.h>
    struct sockaddr_un {
        sa_family_t  sun_family;         //AF_LOCAL
        char         sun_path[104];      //路径名
    }

存放在sun\_path数组中的路径名必须以空字符结尾。

实现提供的SUN\_LEN宏以一个指向sockaddr\_un结构的指针为参数并返回该结构的长度，其中包含路径名中非空字节数。

Unix域套接字的bind调用

创建一个Unix域套接字，往其上bind一个路径名，再调用getsockname输出这个绑定的路径名

#include "unp.h"
    
    int main(int argc, char *argv[])
    {
        int sockfd;
        socklen_t len;
        struct sockaddr_un addr1, addr2;
        
        if (argc != 2)
        err_quit("usage: unixbind <pathname>");
        
        sockfd = socket(AF_LOCAL, SOCK_STREAM,0);
        
        unlink(argv[1]);            //使用bind绑定命令行参数的路径名，先用unlink删除要绑定的路径名，以防已经存在。
        
        bzero(&addr1, sizeof(addr1));
        addr1.sun_family = AF_LOCAL;
        strncpy(addr1.sun_path,argv[1],sizeof(addr1.sun_path) - 1);
        bind(sockfd, (SA *) &addr1, SUN_LEN(&addr1));
        
        len = sizeof(addr2);
        getsockname(sockfd, (SA *) &addr2, &len);   //调用getsockname取得刚绑定的路径名到addr2中。
        printf("bound name = %s, returned len = %d \n",addr2.sun_path, len);
        
        exit(0);
    }

socketpair函数

socketpair函数创建两个随后连接起来的套接字。

int socketpair(int family, int type, int protocol, int sockfd[2]);

family参数必须为AF\_LOCAL,protocol参数必须为0.type参数可以是SOCK\_STREAM,也可以是SOCK\_DGRAM。

新创建的两个套接字描述符作为sockfd\[0\]和sockfd\[1\]返回。

type参数为SOCK\_STREAM创建得到的为流管道，它与调用pipe创建的普通UNIX管道类似。

使用Unix域TCP协议的回射客户/服务器程序

先定义两个使用的路径名：

#define UNIXSTR_PATH    "/tmp/unix.str" /* Unix domain stream */  
    #define UNIXDG_PATH     "/tmp/unix.dg"  /* Unix domain datagram */

服务器端：

/* echo_localserv.c */
    #include "unp.h"
    
    int main(int argc, char *argv[])
    {
    	int listenfd, connfd;
    	pid_t childpid;
    	socklen_t clilen;
    	struct sockaddr_un cliaddr, servaddr;
    	void sig_chld(int);
    
    	listenfd = socket(AF_LOCAL,SOCK_STREAM,0);
    
    	unlink(UNIXSTR_PATH);
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sun_family = AF_LOCAL;
    	strcpy(servaddr.sun_path, UNIXSTR_PATH);
    
    	bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
    
    	listen(listenfd,LISTENQ);
    
    	signal(SIGCHLD, sig_chld);
    
    	while(1) {
    		clilen = sizeof(cliaddr);
    		if( (connfd = accept(listenfd, (SA *) &cliaddr, *clilen)) < 0) {
    			if (errno == EINTR)
    				continue;		//back to for()
    			else 
    				err_sys("accept error");
    		}
    
    		if( (childpid = fork()) == 0) {
    			close(listenfd);
    			str_echo(connfd);
    			exit(0);
    		}
    		close(connfd);
    	}
    }
    
    void sig_chld(int signo)  
    {  
        pid_t pid;  
        int stat;  
      
        /*等待所有子进程终止*/  
        while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)  
            printf("child %d terminated\n", pid);  
        return;  
    }

客户端：

/* echo_localclnt.c */
    #include "unp.h"
    
    int main(int argc, char *argv[])
    {
    	int sockfd;
    	struct sockaddr_in servaddr;
    
    	sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
    
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sun_family = AF_LOCAL;
    	strcpy(servaddr.sun_path, UNIXSTR_PATH);
    
    	connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
    
    	str_cli(stdin,sockfd);	//do it all 
    
    	exit(0);
    }

使用Unix域UDP协议的客户/服务器程序

服务器端：

/* echo_unpserv.c */
    #include "unp.h"
    
    int main(int argc, char *argv[])
    {
    	int sockfd;
    	struct sockaddr_un servaddr, cliaddr;
    
    	sockfd = socket(AF_LOCAL, SOCK_DGRAM, 0);
    
    	unlink(UNIXD_PATH);
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sun_family = AF_LOCAL;
    	strcpy(servaddr.sun_path, UNIXDG_PATH);
    
    	bind(sockfd, (SA *) &servaddr, sizeof(servaddr));
    
    	dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
    }

客户端：

/* echo_unpclnt.c */
    #include "unp.h"
    
    int main(int argc, char *argv[])
    {
    	int sockfd;
    	struct sockaddr_un cliaddr, servaddr;
    
    	sockfd = socket(AF_LOCAL, SOCK_DGRAM, 0 );
    
    	bzero(&cliaddr, sizeof(cliaddr));
    	cliaddr.sun_family = AF_LOCAL;
    	strcpy(cliaddr.sun_path, tmpnam(NULL));
    
    /*与TCP客户不同的是，当使用UNIX域数据报协议时，必须显式bind一个路径名*/  
    	bind(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
    
    	bzero(&servaddr, sizeof(servaddr));
    	servaddr.sun_family = AF_LOCAL;
    	strcpy(servaddr.sun_path, UNIXDG_PATH);
    
    	dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr));
    
    	exit(0);
    }

描述符传递的例子

一个例子：mycat

通过命令行参数取得一个路径名，打开这个文件，再把文件的内容复制到标准输出。

调用 my\_open函数，创建一个流管道，并调用fork和exec启动执行另一个程序，期待输出的文件由这个程序打开。该程序随后必须把打开的描述符通过流管道传递回父进程。

下图：调用socketpair创建一个流管道后的mycat进程。我们以\[0\]和\[1\]标识socketpair返回的两个描述符。

![70][]

mycat进程接着调用fork，子进程再调用exec执行openfile程序。父进程关闭\[1\]描述符，子进程关闭\[0\]描述符。

![70 1][]

mycat.c:

#include "unp.h"
    
    int myopen(const char *, int);
    
    int main(int argc, char *argv[])
    {
    	int fd, n;
    	char buf[BUFFSIZE];
    
    	if (argc != 2)
    		err_quit("usage: mycat <pathname>");
    
    	if ((fd = my_open(argv[1], O_RDONLY)) < 0 )
    		err_sys("cannot open %s",argv[1]);
    
    	while ( (n = read(fd, buff, BUFFSIZE)) > 0)
    		write(STDOUT_FILENO, buff, n);
    
    	exit(0);
    }
    
    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);1
    
    	if ( (childpid = fork()) == 0) {
    		close(sockfd[0]);
    		snprintf(argcsockfd, sizeof(argsockfd), "%d", sockfd[1]);
    		snprintf(argmode, sizeof(argmode), "%d", mode);
    		excel("./openfile","openfile",argsockfd,pathname,argmode,(char *) NULL);
    		err_sys("excel error");
    	}
    
    	/* parent process - wait for the child to terminate */
    	close(sockfd[1]);
    
    	waitpid(childpid, *status, 0);
    	if (WIFEXITED(status) == 0)
    		err_quit("child did not terminate");
    	if (( status = WEXITSTATUS(status)) == 0)
    		read_fd(sock[0], &c, 1, &fd);
    	else {
    		errno = status;
    		fd = -1;
    	}
    
    	close(sockfd[0]);
    	return(fd);
    }

[70]: /images/20220524/2db61ba90a0e450a8c35c4999b597ed0.png
[70 1]: /images/20220524/b08b334164dd4871adae0269cb4a2793.png