unix进程间通信方式(下)-unix域套接字

最新推荐文章于 2024-03-22 08:23:54 发布

caoyan_12727

最新推荐文章于 2024-03-22 08:23:54 发布

阅读量3.5k

点赞数 1

分类专栏： unix操作系统文章标签： unix进程通信 unix域套接字 unix命名域套接字套接字

本文链接：https://blog.csdn.net/caoyan_12727/article/details/52180075

版权

unix操作系统专栏收录该内容

13 篇文章 2 订阅

订阅专栏

　　　　在之前的博客中已经总结了其它7种进程间的通信方式。unix域套接字用于在同一台计算机上的进程间通信，虽然因特网域套接字可用于同一目的，但是unix域套接字的效率更高。unix域套接字并不进行协议处理，不需要添加或删除网络报头，无需计算校验和，不需要产生顺序号，无需发送确认报文。UNIX与套接字提供和数据报两种接口，UNIX域数据报服务是可靠的，就不会丢失消息也不会传递出错。UNIX域套接字是套接字和管道之间的混合物。为了创建一对非命名的，相互连接的UNXI域套接字，用户可以使用socketopair函数。创建一对互相连接的unix域套接字可以用socketpair函数：

1.unix未命名套接字

#include<sys/socket.h>  
int socketpari(int domain, int type, int protocol, int sockfd[2]); //若成功则返回0，出错则返回-1.

《在unix环境高级编程》一书中是这样描述的：

下面我们就用一个简单的程序来验证上面的管道模型是否正确！！！

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <iostream>
#include <unistd.h> 
using namespace std;

int main(void){
        int fd[2];
        int pid;
	int n=0;
        char wbuf[16] = "1234567890";
        char rbuf[16]={'\0'};
        if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0){
                printf("socketpair error!\n");
                return -1;
        }

        if((pid = fork())<0){
                printf("fork error!\n");
                return -1;
        }else if(pid == 0){//child
                close(fd[0]);
                if((n=write(fd[1],wbuf,strlen(wbuf))) < 0){
                        printf("child write error!\n");
                        exit(-1);
                }
                sleep(1);//子进程等待1秒
		cout<<"the data of rbuf of child before commubication is :"<<rbuf<<endl;
                if((n=read(fd[1],rbuf,16))<0){//子进程从fd[1]读取数据
                	printf("child read error!\n");
                        exit(-1);
                }
		rbuf[n]=0;
                printf("son read data from father: %s\n",rbuf);
                exit(0);
        }else{//parent
        	sleep(1);//父进程等待1秒钟
                close(fd[1]);
		cout<<"the data of rbuf of parent before commubication is :"<<rbuf<<endl;
                if((n=read(fd[0],rbuf,16)) < 0){
                        printf("parent read error!\n");
                        exit(-1);
                }
		rbuf[n]=0;
                printf("parent read data from son :%s\n",rbuf);
                if(write(fd[0],wbuf,strlen(wbuf)) < 0){
                        printf("parent write error!\n");
                        exit(-1);
                }
                exit(0);
        }
        return 0;
}

测试结果：

　　　由图可以看出父进程和子进程构成的通道正如图17-1所示，也就是说父进程或子进程都可以向它们的唯一端口fd[0]或fd[1]同时读写数据，而这一切都是因为unix域套接字的声明。接下来我们来验证声明一个管道，看能不能在同一段进行读写：

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <iostream>
#include <unistd.h> 
using namespace std;

int main(void){
        int fd[2];
        int pid;
	int n=0;
        char wbuf[16] = "1234567890";
        char rbuf[16]={'\0'};
	if(pipe(fd) < 0){
        //if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0){
                printf("socketpair error!\n");
                return -1;
        }

        if((pid = fork())<0){
                printf("fork error!\n");
                return -1;
        }else if(pid == 0){//child
                close(fd[0]);
                if((n=write(fd[1],wbuf,strlen(wbuf))) < 0){
                        printf("child write error!\n");
                        exit(-1);
                }
                sleep(1);//子进程等待1秒
		cout<<rbuf<<endl;
                if((n=read(fd[1],rbuf,16))<0){//子进程从fd[1]读取数据
                	printf("child read error!\n");
                        exit(-1);
                }
		rbuf[n]=0;
                printf("child read data from father: %s\n",rbuf);
                exit(0);
        }else{//parent
        	sleep(1);//父进程等待1秒钟
                close(fd[1]);
		cout<<rbuf<<endl;
                if((n=read(fd[0],rbuf,16)) < 0){
                        printf("parent read error!\n");
                        exit(-1);
                }
		rbuf[n]=0;
                printf("parent read data from son :%s\n",rbuf);
                if(write(fd[0],wbuf,strlen(wbuf)) < 0){
                        printf("parent write error!\n");
                        exit(-1);
                }
                exit(0);
        }
        return 0;
}

测试结果：

从测试结果中可以看出，对于管道来说，我们不能在管道的同一端进行读写，这样只能报错！！！！！

unix域套接字的经典应用：

我们知道消息队列存在一个问题，即不能将它们和poll或者select一起使用，这是因为它们不能关联到文件描述符，然而，套接字和文件描述符是相关联的消息到达时，可以用套接字来通知，即消息到达时我们将起写入到套接字的一端，那么我们可以用poll来轮询unix域套接字的另一端即可判断消息有没有到来，这个时候相当于多了一层中介。下面就来看看这个非常巧妙的设计：

server.c

<span style="color:#000000;">#include "apue.h"
#include <poll.h>
#include <pthread.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include<iostream>
using namespace std;

#define NQ  3 /* number of queues */
#define MAXMSZ	512		/* maximum lenth */
#define KEY	0x123	/* key for first message queue */

struct threadinfo {
	int qid;// the quene id 
	int fd;// the fd used to write
};

struct mymesg {
	long mtype;
	char mtext[MAXMSZ];
};

void * helper(void *arg){
	int n;
	struct mymesg m;
	struct threadinfo *tip = (struct threadinfo *)arg;
	for(;;) {
		memset(&m, 0, sizeof(m));
		if ((n = msgrcv(tip->qid, &m, MAXMSZ, 0, MSG_NOERROR)) < 0)printf("msgrcv error\n");
		if (write(tip->fd, m.mtext, n) < 0)printf("write error\n");
	}
}

int main(){
	int i,n,err;
	int fd[2];
	int qid[NQ];
	struct pollfd pfd[NQ];
	struct threadinfo ti[NQ];
	pthread_t tid[NQ];
	char buf[MAXMSZ];
	for (i = 0; i < NQ; i++) {
		if ((qid[i] = msgget((KEY+i), IPC_CREAT|0666)) < 0)printf("msgget error\n");
		cout<<"the msgque id of server is "<<qid[i]<<endl;
		printf("queue ID %d is %d\n", i, qid[i]);
		if (socketpair(AF_UNIX, SOCK_DGRAM, 0, fd) < 0)printf("socketpair error\n");
		cout<<"fd[0] is: "<<fd[0]<<"fd[1] is: "<<fd[1]<<endl;
		pfd[i].fd = fd[0];
		pfd[i].events = POLLIN;
		ti[i].qid = qid[i];
		ti[i].fd = fd[1];
		if ((err = pthread_create(&tid[i], NULL, helper, &ti[i])) != 0)printf("pthread_create error\n");
	}
	for (;;) {//reading data
		if (poll(pfd, NQ, -1) < 0)printf("poll error\n");
		for (i = 0; i < NQ; i++) {
			if (pfd[i].revents & POLLIN) {
				if ((n = read(pfd[i].fd, buf, sizeof(buf))) < 0)printf("read error\n");
				buf[n] = 0;
				printf("queue id %d, message %s\n", qid[i], buf);
			}
		}
	}
	exit(0);
}

</span>

client.c

<span style="color:#000000;">#include "apue.h"
#include <sys/msg.h>
#include<iostream>
using namespace std;

#define MAXMSZ 512

struct mymesg {
	long mtype;
	char mtext[MAXMSZ];
};

int main(int argc, char *argv[]){
	key_t key;
	long qid;
	size_t nbytes;
	struct mymesg m;
	if (argc != 3) {
		fprintf(stderr, "usage: sendmsg KEY message\n");
		exit(1);
	}
	key = strtol(argv[1], NULL, 0);
	if ((qid = msgget(key, 0)) < 0)printf("can't open queue key %s", argv[1]);
	cout<<"the id of the queue is"<<qid<<endl;
	memset(&m, 0, sizeof(m));
	strncpy(m.mtext, argv[2], MAXMSZ-1);
	nbytes = strlen(m.mtext);
	m.mtype = 1;
	if (msgsnd(qid, &m, nbytes, 0) < 0)printf("can't send message\n");
	exit(0);
}</span>

测试结果：

从图中我们可以看到，１．服务器段利用poll来间接轮询来自客户端的消息；２．对于msgget，如果使用相同的key(比如ox123)那么得到的消息队列的id是一样的！！！！

2.unix命名域套接字

　　　虽然socketpair函数能创建一对相互连接的套接字，但是每一个套接字却没有名字，无关的进程不能使用它们。如果我们绑定一个地址，这个地址就是一个路径，那么无关的进程就可以使用它们，下面是地址的格式：

<span style="color:#000000;">struct sockaddr_un {
 sa_family_t sun_family; /*PF_UNIX或AF_UNIX */
 char sun_path[UNIX_PATH_MAX]; /* 路径名 */
};</span>

下面我们来看以个简单的例子：

#include "apue.h"
#include <sys/socket.h>
#include <sys/un.h>

int main(){
	int fd, size;
	struct sockaddr_un un;
	un.sun_family = AF_UNIX;
	strcpy(un.sun_path, "/home/caoyan/unix/unix-domain-socket/socket");
	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)printf("socket failed\n");
	size = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);//the total lenght of address
	if (bind(fd, (struct sockaddr *)&un, size) < 0)
		printf("bind failed\n");
	printf("UNIX domain socket bound\n");
	exit(0);
}

其中offsetof是个宏：

＃define offsetof(TYPE，MEMBER) ((int)&(TYPE *)０->MEMBER)

测试结果：

从下面的结果我们可以看出，我们的文件夹里多了一个管道文件socket，这个文件的大小为0。