UNIX域协议

Love The Way You Lie 2022-08-05 01:20 179阅读 0赞

文章参考UNP，例子也来源于该书。

Unix域协议**并不是**一个实际的协议族，而**是在单个主机上执行客户/服务器通信的一种方法**，所使用的API就是在不同主机上执行客户/服务器通信所用的API（套接字API）。

Unix域套接字仅仅复制数据，并不执行协议处理，不需要添加或删除网络报头，无需计算校验和，不要产生顺序号，无需发送确认报文。Unix域套接字提供**流和数据报**两种接口。Unix域数据报服务是可靠的，既不会丢失消息也不会传递出错。它**是套接字和管道之间的混合物**。

**使用Unix域套接字的理由**：

（1）Unix域套接字往往比通信两端位于同一主机的TCP套接字快一倍（TCPv3）。Unix域套接字仅仅复制数据，并不执行协议处理，不需要添加或删除网络报头，无需计算校验和，不要产生顺序号，无需发送确认报文。

（2）可用于在同一台主机的不同进程之间传递描述符。

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

为了创建一对非命名的、相互连接的UNIX域套接字，用户可以**使用面向网络的域套接字接口**，也可以**使用socketpair函数**。

# 使用面向网络的域套接字接口 #

还是字符串回射服务器

## 字节流客户/服务器程序 ##

//服务器端
    /* 从客户端读入数据，并将数据回射到客户端。 */  
    void str_echo(int sockfd) {  
       ssize_t n;  
       char buf[1024];  
    again:  
       while (( n = read(sockfd, buf, 1024)) > 0)  
          write(sockfd, buf, n);  
       if (n < 0 && errno == EINTR)  
          goto again;  
       else if (n < 0) {  
          err_exit("str_echo: read error.");     
       }  
    } 
    
    int main(int argc, char **argv)
    {
    	int					listenfd, connfd;
    	pid_t				childpid;
    	socklen_t			clilen;
    	//<sys/un.h>中定义的unix域套接字地址结构
    	struct sockaddr_un	cliaddr, servaddr;
    	void				sig_chld(int);
    
    	//用以创建一个Unix域字节流套接字
    	listenfd = Socket(AF_LOCAL, SOCK_STREAM, 0);
    
    	//先unlink路径名，以防早先某次运行本程序导致该路径名已经存在
    	//在调用bind前初始化套接字地址结构。unlink出错没关系
    	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);
    
    	for ( ; ; ) {
    		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) {	/* child process */
    			Close(listenfd);	/* close listening socket */
    			str_echo(connfd);	/* process request */
    			exit(0);
    		}
    		Close(connfd);			/* parent closes connected socket */
    	}
    }

//客户端
    void str_cli(FILE *fp, int sockfd) {  
       char sendline[1024], recvline[1024];  
       while (fgets(sendline, 1024, fp) != NULL) {  
          write(sockfd, sendline, strlen(sendline));  
          if (read(sockfd, recvline, 1024) == 0) {  
             err_exit("str_cli: server terminated prematurely");  
          }  
          fputs(recvline, stdout);  
       }  
    }  
    
    int main(int argc, char **argv)
    {
    	int					sockfd;
    	struct sockaddr_un	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);
    }

## 数据报客户/服务器程序    ##

//服务器端
    //该函数时一个简单的循环，使用recvfrom读入下一个到达服务器端口的数据报，再使用sendto发送给发送者  
    void dg_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)  
    {  
      int n;  
      socklen_t len;  
      char mesg[MAXLINE];  
      for ( ; ; ) {  
        len = clilen;  
        n = Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);  
        Sendto(sockfd, mesg, n, 0, pcliaddr, len);  
      }  
    }  
    
    int main(int argc, char **argv)
    {
    	int					sockfd;
    	struct sockaddr_un	servaddr, cliaddr;
    
    	sockfd = Socket(AF_LOCAL, SOCK_DGRAM, 0);
    
    	unlink(UNIXDG_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));
    }

//客户端
    //使用fgets从标准输入读入一行文本，使用sendto将文本发送到服务器，  
    //使用recvfrom读回服务器的回射，使用fputs把回射内容显示在标准输出。   
    void dg_cli(FILE *fp, int sockfd, const struct sockaddr *pservaddr,  
            socklen_t servlen) {  
      int n;  
      char sendline[MAXLINE], recvline[MAXLINE + 1];  
      while (Fgets(sendline, MAXLINE, fp) != NULL) {  
        Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr,servlen);  
          
        n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);  
          
        recvline[n] = 0;  
        Fputs(recvline, stdout);  
      }  
    }  
    
    int main(int argc, char **argv)
    {
    	int					sockfd;
    	struct sockaddr_un	cliaddr, servaddr;
    
    	sockfd = Socket(AF_LOCAL, SOCK_DGRAM, 0);
    
    	bzero(&cliaddr, sizeof(cliaddr));		/* bind an address for us */
    	cliaddr.sun_family = AF_LOCAL;
    	strcpy(cliaddr.sun_path, tmpnam(NULL));
    
    	Bind(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
    
    	bzero(&servaddr, sizeof(servaddr));	/* fill in server's address */
    	servaddr.sun_family = AF_LOCAL;
    	strcpy(servaddr.sun_path, UNIXDG_PATH);
    
    	dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr));
    
    	exit(0);
    }

# 使用socketpair函数 #

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

socketpair()函数建立一对匿名的已经连接的套接字，其特性由协议族d、类型type、协议protocol决定，建立的两个套接字描述符会放在sockfd\[0\]和sockfd\[1\]中。  
第1个参数d，表示协议族，只能为AF\_LOCAL或者AF\_UNIX（两者含义一样，POSIX把Unix域协议重新命名为“本地IPC”，以消除它对Unix系统的依赖，把AF\_UNIX变为AF\_LOCAL）；  
第2个参数type，表示类型，只能为0。  
第3个参数protocol，表示协议，可以是SOCK\_STREAM或者SOCK\_DGRAM。用SOCK\_STREAM建立的套接字对是 管道流， **与一般的管道相区别的是，套接字对建立的通道是双向的**，即每一端都可以进行读写。参数sockfd，用于保存建立的套接字对，新创建的两个套接字描述符作为sockfd\[0\]和sockfd\[1\]返回。