UNP卷1：第十五章（unix域协议）

最新推荐文章于 2023-05-23 18:35:30 发布
最新推荐文章于 2023-05-23 18:35:30 发布
阅读量1k 收藏
点赞数
分类专栏： UNP #####UNIX##### UNIX网络编程学习专栏 文章标签： UNP socket unix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzyz_sb/article/details/39757501
版权

1. 概述

    unix域协议并不是一个实际的协议族，而是在单个主机上执行客户/服务器通信的一种方法。unix域提供两类套接字：字节流套接字（类似TCP）和数据报套接字（类似UDP）。使用unix域协议有如下的优势：
（1）unix域套接字往往比通信两端位于同一个主机的TCP套接字快出一倍。
（2）unix域套接字可用于在同一个主机上的不同进程之间传递描述符。
（3）unix域套接字较新的实现把客户的凭证（用户ID和组ID）提供给服务器，从而能够提供额外的安全检查措施。

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

1) unix域套接字地址结构

struct sockaddr_un{
    sa_family_t    sun_family;        /*AF_LOCAL*/
    char        sun_path[104];        /*null-terminated pathname*/
};

2) unix域套接字的bind调用

#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <netdb.h>

#define SA struct sockaddr

int main(int argc, char **argv)
{
	int		sockfd;
	socklen_t	len;
	struct	sockaddr_un	addr1, addr2;

	if (argc != 2){
		printf("argument should be 2\n");
		exit(1);
	}

	sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);

	unlink(argv[1]);

	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);
	printf("bound name = %s, returned len = %d\n", addr2.sun_path, len);

	return 0;
}


程序输出：

leichaojian@ThinkPad-T430i:~$ ./unixbind /tmp/moose
bound name = /tmp/moose, returned len = 13
leichaojian@ThinkPad-T430i:~$ ll /tmp/moose
srwxrwxr-x 1 leichaojian leichaojian 0 10月  8 22:18 /tmp/moose=

3）套接字函数

（1）由bind创建的路径名默认访问权限应为0777，并按照当前umask值进行修正。
（2）与unix域套接字关联的路径名应该是一个绝对路径名，而不是一个相对路径名。避免使用后者的原因是它的解析依赖于调用者的当前工作目录。也就是说，要是服务器捆绑一个相对路径名，客户就得在与服务器相同的目录中（或者必须知道这个目录）才能成功调用connect或sendto。
（3）在connect调用中指定的路径名必须是一个当前绑定在某个打开的unix域套接字上的路径名，而且它们的套接字类型（字节流或数据报）也必须一致。出错条件包括：（a）该路径名已存在却不是一个套接字（unlink来删除已存在文件）；（b）该路径名已存在且是一个套接字，不过没有与之关联的打开的描述符；（c）该路径名已存在且是一个打开的套接字，不过类型不符。
（4）调用connect连接一个unix域套接字涉及的权限测试等同于调用open以只写方式访问相应的路径名。
（5）unix域字节流套接字类似TCP套接字：它们都为进程提供一个无记录边界的字节流接口。
（6）如果对于某个unix域字节流套接字的connect调用发现这个监听套接字的队列已满，调用就立即返回一个ECONNREFUSED错误。
（7）unix域数据报套接字类似于UDP套接字：它们都提供一个保留记录边界的不可靠的数据报服务。
（8）在一个未绑定的unix域套接字上发送数据报不会自动给这个套接字捆绑一个路径名，connect也一样。


2. unix域字节流客户/服务器程序

服务端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#define SA struct sockaddr
#define MAXLINE 1024
#define UNIXSTR_PATH "/tmp/unix.str"
extern int errno;
void sig_chld(int);
void str_echo(int sockfd);

int main(int argc, char **argv)
{
	int		listenfd, connfd;
	pid_t	childpid;
	socklen_t	clilen;
	struct	sockaddr_un	cliaddr, servaddr;

	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, 5);

	signal(SIGCHLD, sig_chld);

	for ( ; ; ){
		clilen = sizeof(cliaddr);
		if ((connfd = accept(listenfd, (SA *)&cliaddr, &clilen)) < 0){
			if (errno == EINTR)
				continue;
			else{
				printf("accept error\n");
				exit(0);
			}
		}

		if ((childpid = fork()) == 0){
			close(listenfd);
			str_echo(connfd);
			exit(0);
		}

		close(connfd);
	}
}

void str_echo(int sockfd)
{
	char		recvline[MAXLINE];
	int			n;

	while ((n = read(sockfd, recvline, MAXLINE)) > 0){
		recvline[n] = '\0';
		write(sockfd, recvline, n);
	}
}

void sig_chld(int signo)
{
	pid_t	pid;
	int		stat;

	while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
		printf("child %d terminated\n", pid);
	return;
}

客户端： 

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SA struct sockaddr
#define UNIXSTR_PATH "/tmp/unix.str"
#define MAXLINE 1024
void str_cli(FILE *fd, int sockfd);
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);

	exit(0);
}
void str_cli(FILE *fd, int sockfd)
{
	int		n;
	int		recvline[MAXLINE], sendline[MAXLINE];
	while (fgets(sendline, MAXLINE, fd) != NULL){
		write(sockfd, sendline, strlen(sendline));
		if ((n = read(sockfd, recvline, MAXLINE)) > 0){
			fputs(recvline, stdout);
		}
	}
}

程序输出：

服务端：

leichaojian@ThinkPad-T430i:~$ ./unixstrserv
child 12698 terminated
child 12700 terminated
客户端： 

leichaojian@ThinkPad-T430i:~$ ./unixstrcli
hello world
hello world
^C
leichaojian@ThinkPad-T430i:~$ ./unixstrcli
what
what
^C


3. 描述符传递

    当考虑从一个进程到另一个进程传递打开的描述符时，我们通常会想到：

1）fork调用返回之后，子进程共享父进程的所有打开的描述符。

2）exec调用执行之后，所有描述符通常保持打开状态不变。

    在第一个例子中，进程先打开一个描述符，再调用fork，然后父进程关闭这个描述符，子进程则处理这个描述符。这样一个打开的描述符就从父进程传递到子进程。那如何从子进程传递描述符到父进程呢？

    当前的unix系统提供了用于从一个进程向任一其他进程传递任一打开的描述符的方法。这种技术要求首先在这两个进程之间创建一个unix域套接字，然后使用sendmsg跨这个套接字发送一个特殊信息。这个消息由内核来专门处理，会把打开的描述符从发送进程传递到接收进程。

    在两个进程之间传递描述符涉及的步骤如下：

1） 创建一个字节流或数据报的unix域套接字

    如果目标是fork一个子进程，让子进程打开待传递的描述符，再把它传递回父进程，那么父进程可以预先调用socketpair创建一个可用于父子进程之间交换描述符的流管道。

    如果进程之间没有亲缘关系，那么服务器必须创建一个unix域字节流套接字，bind一个路径名到该套接字，以允许客户进程connect到该套接字。然后客户可以向服务器发送一个打开某个描述符的请求，服务器再把该描述符通过unix域套接字传递回客户。

2） 发送进程通过调用返回描述符的任一unix函数打开一个描述符，这些函数的例子有open，pipe，mkfifo，socket和accept，可以在进程之间传递的描述符不限类型。

3） 发送进程创建一个msghdr结构，其中含有待传递的描述符。

4） 接收进程调用recvmsg在来自步骤1的unix域套接字上接收这个描述符。

程序mycat.c如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

extern int errno;
#define BUFFSIZE 4096


int my_open(const char *pathname, int mode);
ssize_t read_fd(int fd, void *tr, size_t nbytes, int *recvfd);

int main(int argc, char **argv)
{
	int		fd, n;
	char	buff[BUFFSIZE];

	if (argc != 2){
		printf("argument should be 2\n");
		return 1;
	}

	if ((fd = my_open(argv[1], O_RDONLY)) < 0){
		printf("cannot open %s\n", argv[1]);
		exit(1);
	}

	while ((n = read(fd, buff, BUFFSIZE)) > 0)
		write(STDOUT_FILENO, buff, n);

	return 0;
}


int my_open(const char *pathname, int mode)
{

	int		fd, sockfd[2], status;
	pid_t	childpid;
	char	c, argsockfd[10], argmode[10];

	//socketpair函数创建两个随后连接起来的套接字，因为随后fork，所以实际上sockfd存储的是连接起来的父子进程
	socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd);

	if ((childpid = fork()) == 0){
		close(sockfd[0]);	//因为子进程会完全复制父进程的描述符，所以要关闭父进程的描述符
		snprintf(argsockfd, sizeof(argsockfd), "%d", sockfd[1]);	//子进程将描述符传递给流管道父进程的一端（即sockfd[1]）
		snprintf(argmode, sizeof(argmode), "%d", mode);
		execl("./openfile", "openfile", argsockfd, pathname, argmode, (char *)NULL);
		printf("execl error\n");
	}

	close(sockfd[1]);		//父进程中关闭子进程的描述符(这里如果父进程关闭sockfd[1],则子进程就关闭sockfd[0],反之亦然)

	waitpid(childpid, &status, 0);
	if (WIFEXITED(status) == 0){
		printf("child did not terminate\n");
		exit(1);
	}

	if ((status = WEXITSTATUS(status)) == 0)
		read_fd(sockfd[0], &c, 1, &fd);
	else{
		errno = status;	
		fd = -1;
	}

	close(sockfd[0]);
	return (fd);

	return 1;

}


ssize_t read_fd(int fd, void *ptr, size_t nbytes, int *recvfd)
{
	struct	msghdr  msg;
	struct	iovec	iov[1];
	ssize_t	n;
#ifdef HAVE_MSGHDR_MSG_CONTROL
	union{
		struct		cmsghdr	cm;
		char		control[CMSG_SPACE(sizeof(int))];
	} control_un;
	struct	cmsghdr *cmptr;

	msg.msg_control = control_un.control;
	msg.msg_controllen = sizeof(control_un.control);
#else
//	int		newfd;

//	msg.msg_accrights = (caddr_t)&newfd;
//	msg.msg_accrightslen = sizeof(int);
#endif

	msg.msg_name = NULL;
	msg.msg_namelen = 0;

	iov[0].iov_base = ptr;
	iov[0].iov_len = nbytes;
	msg.msg_iov = iov;
	msg.msg_iovlen = 1;

	if ((n = recvmsg(fd, &msg, 0)) <= 0)
		return n;
#ifdef HAVE_MSGHDR_MSG_CONTROL
	if ((cmptr = CMSG_FIRSTHDR(&msg)) != NULL &&
			cmptr->cmsg_len == CMSG_LEN(sizeof(int))){
		if (cmptr->cmsg_level != SQL_SOCKET){
			printf("control level != SOL_SOCKET\n");
			exit(1);
		}
		if (cmptr->cmsg_type != SCM_RIGHTS){
			printf("control type != SCM_RIGHTS\n");
			exit(1);
		}
		*recvfd = *((int)*)CMSG_DATA(cmptr);
	} else
		*recvfd = -1;
#else
//	if (msg.msg_accrightslen == sizeof(int))
//		*recvfd = newfd;
//	else
//		*recvfd = -1;
#endif
	return n;
}

    但是我在调试程序的时候发现，在函数my_open中并没有进入子进程，即fork()后并没有进入子进程进行执行execl函数，导致程序的失败，这到底是为什么呢？


fzyz_sb
关注
专栏目录
Unix域协议
amoscykl的博客
05-25 1395
Unix域协议并不是一个实际的协议族，而是在单个主机上执行客户/服务器通信的一种方法。Unix域提供两类套接字：字节流套接字和数据报套接字。使用Unix域套接字的理由：1.Unix域套接字往往比通信两端位于同一个主机的TCP套接字快出一倍。2.Unix域套接字可用于在同一个主机上的不同进程之间传递描述符。3.Unix域套接字较新的实现把客户的凭证(用户ID和组ID)提供给服务器，从而能够提供额外的...
UNIX网络编程(UNP) 第五章学习笔记
404lz保留地
11-23 274
在本章中，我们将完成一个可以回射的服务器和客户端，并且我们需要理解在每一个环节可能出现什么问题，并且加以预防 代码（带注释） // server #include "../unp.h" int main(int argc, char **argv) { int listenfd,connfd; pid_t child_pid; socklen_t clilen; s...
UNIX网络编程卷一 学习笔记 第十五章 Unix域协议
最新发布
tus00000的博客
05-23 721
先给出一个描述符传递的程序，名为mycat，它通过命令行参数获取一个路径名，打开这个文件，再把文件内容复制到标准输出，但该程序不是调用普通的open函数打开文件，而是调用我们的my_open函数，my_open创建一个流管道，并调用fork和exec执行另一个程序，该程序打开文件，并把打开描述符通过流管道传回父进程。这种技术要求首先在这两个进程间创建一个Unix域套接字，然后调用sendmsg跨这个套接字发送一个特殊消息，这个消息由内核处理，会把打开的描述符从发送进程传递到接收进程。
UNP卷1：第十三章（守护进程和inetd超级服务器）
fzyz_sb的专栏
10-03 1720
1. 概述     守护进程是在后台运行且不与任何控制终端关联的进程。unix系统通常有很多守护进程在后台运行，执行不同的管理任务。     守护进程没有控制终端通常源于它们由系统初始化脚本启动。然而守护进程也可能从某个终端由用户在shell提示符下键入命令行启动，这样的守护进程必须亲自脱离与控制终端的关联，从而避免与作业控制，终端会话管理，终端产生信号等发生任何不期望的交互，也可以避免在后台
TCP-IP详解卷三：TCP事务协议，HTTP，NNTP和UNIX域协议
01-25
第15章 NNTP：网络新闻传送协议 166 15.1 概述 166 15.2 NNTP 167 15.3 一个简单的新闻客户 170 15.4 一个复杂的新闻客户 171 15.5 NNTP的统计资料 172 15.6 小结 173 第三部分 Unix域协议 第16章 Unix域协议：概述 ...
TCP-IP详解卷三：TCP事务协议，HTTP，NNTP和UNIX域协议——高清文字（china-pub经典系列）
06-30
第15章 NNTP：网络新闻传送协议 166 15.1 概述 166 15.2 NNTP 167 15.3 一个简单的新闻客户 170 15.4 一个复杂的新闻客户 171 15.5 NNTP的统计资料 172 15.6 小结 173 第三部分 Unix域协议 第16章 Unix域协议：概述 ...
TCP-IP详解卷3：TCP事务协议，HTTP，NNTP和UNIX域协议
05-28
第15章 NNTP：网络新闻传送协议 166 15.1 概述 166 15.2 NNTP 167 15.3 一个简单的新闻客户 170 15.4 一个复杂的新闻客户 171 15.5 NNTP的统计资料 172 15.6 小结 173 第三部分 Unix域协议 第16章 Unix域协议：概述 ...
TCP-IP详解卷3：TCP事务协议，HTTP，NNTP和UNIX域协议.rar
03-18
第15章 NNTP：网络新闻传送协议 166 15.1 概述 166 15.2 NNTP 167 15.3 一个简单的新闻客户 170 15.4 一个复杂的新闻客户 171 15.5 NNTP的统计资料 172 15.6 小结 173 第三部分 Unix域协议 第16章 Unix域协议：概述 ...
UNP卷1：第一章（简介）
fzyz_sb的专栏
09-13 2468
1. 时间获取程序 服务端：srv.c
UDP卷1：第六章（I/O复用：select和poll函数）
fzyz_sb的专栏
09-18 2320
1. I/O模型     一个输入
unix/linux编程实践教程：who命令
fzyz_sb的专栏
08-26 2091
1. who命令的编写
TCP/IP详解卷1：第六章（ICMP：internet控制报文协议）
fzyz_sb的专栏
10-22 1892
1. ICMP基础知识
UNP卷1：第四章（基本TCP套接字编程）
fzyz_sb的专栏
09-15 1452
1. socket函数     为了执行网络I/O，一个
TCP/IP详解卷1：第一章（概述）
fzyz_sb的专栏
10-20 1122
1. 分层     TCP/IP通常被认为是一个四层协议系统。 1）链路层：有时也被称作数据链路层或网络接口层，通常包括操作系统中的设备驱动程序和计算机中对应的网络接口卡。它们一起处理与电缆的物理接口细节。 2）网络层：有时也称作互联网层，处理分组在网络中的活动，例如分组的选路。在TCP/IP协议族中，网络层协议包括IP协议（网际协议），ICMP协议（internet互联网控制保温协议），以
UNP卷1：第十一章（名字与地址转换）
fzyz_sb的专栏
09-30 1082
1. gethostbyname函数 #include struct hostent *gethostbyname( const char *hostname ); 返回：若成功则为非空指针，若出错则为NULL且设置h_errno而hostent的结构如下：
TCP/IP详解卷1：第二章（链路层）
fzyz_sb的专栏
10-20 1072
1. 以太网和IEEE 802封装
unix/linux编程实践教程：ls命令
fzyz_sb的专栏
08-26 1050
1. ls命令比较简单 #include #include #include #include void do_ls( char [] ); void dostat( char * ); void show_file_info( char *, struct stat * ); void mode_to_letters( int, char [] ); char *uid_to_nam
UNP卷1：第八章（基本UNP套接字编程）
fzyz_sb的专栏
09-22 1038
1. 简单的UDP回射程序 1） 服务器
TCP/IP详解：TCP事务协议与UNIX域协议实现分析
TCP/IP详解卷三深入剖析了UNIX域协议的实现细节，包括其源代码结构、关键数据结构和系统调用的使用，这对于理解操作系统内核中的进程间通信机制具有极高的价值。通过阅读和理解这部分内容，开发者可以更好地掌握本地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值