socketpair的用途以及实现
2017-01-21 01:16
162 查看
一.概念及用途
一个问题：如何创建全双工管道？
直接的办法当然是pipe两次，创建两组管道，但是有没有更简单的呢？
socketpair就可以了，man socketpair:
socketpair - create a pair of connected sockets, The two sockets are indistinguishable，也就是说，用socketpair创建出来的两个描述符应该是等价的。
socketpair函数概要如下：
#include <sys/types.h>
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int sv[2]);
sys/types.h文件需要用来定义一些C宏常量。sys/socket.h文件必须包含进来定义socketpair函数原型。
socketpair函数需要四个参数。他们是：
套接口的域 套接口类型 使用的协议 指向存储文件描述符的指针
类型参数声明了我们希望创建哪种类型的套接口。socketpair函数的选择如下：
SOCK_STREAM
SOCK_DGRAM
对于socketpair函数，protocol参数必须提供为0。
参数sv[2]是接收代表两个套接口的整数数组。每一个文件描述符代表一个套接口，并且与另一个并没有区别。
如果函数成功，将会返回0值。否则将会返回-1表明创建失败，并且errno来表明特定的错误号。
关于流程。socketpair()函数创建出两个进程，fork()之后这两个进程都会执行主程序中的代码，这个一定要注意！尤其是bind的时候，如果bind两次的话，那就会出错了。一般会在子进程里调用一个带死循环的函数，这样就好了。（这个情况的例子会在综合运用中讲解）
二.用法
[cpp] view plaincopyprint?
#define DATA1 "test string 1"
#define DATA2 "test string 2"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
main()
{
int sockets[2], child;
char buf[1024];
if (socketpair(AF_UNIX, SOCK_STREAM,
0, sockets) < 0) {
printf("error %d on socketpair ", errno);
exit(1);
}
if ((child = fork()) == -1) {
printf("fork error %d ", errno);
exit(1);
}
if (child != 0) {
close(sockets[0]);
if (read(sockets[1], buf, sizeof(buf)) < 0) {
printf("error %d reading socket ", errno);
exit(1);
}
printf("parent:-->%s /n", buf);
if (write(sockets[1], DATA1, sizeof(DATA1)) < 0) {
printf("error %d writing socket ", errno);
exit(1);
}
close(sockets[1]);
} else {
close(sockets[1]);
if (write(sockets[0], DATA2, sizeof(DATA1)) < 0) {
printf("error %d writing socket ", errno);
exit(1);
}
if (read(sockets[0], buf, sizeof(buf)) < 0) {
printf("error %d reading socket ", errno);
exit(1);
}
printf("child: -->%s/n ", buf);
close(sockets[0]);
}
}
从上面的代码中，我们可以发现，父进程从sockets[1]中读写，子进程从sockets[0]中读写，的确是全双工形态。
唯一值得考虑的是为什么在父子进程中，要分别关闭sockets[0]和sockets[1]呢？
三。一个实现
[cpp] view plaincopyprint?
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <stdio.h>
socketpair(af, type, protocol, fd)
int af;
int type;
int protocol;
int fd[2];
{
int listen_socket;
struct sockaddr_in sin[2];
int len;
if (type != SOCK_STREAM)
return -1;
listen_socket = socket(af, type, protocol);
if (listen_socket < 0)
{
perror("creating listen_socket");
return -1;
}
sin[0].sin_family = af;
sin[0].sin_port = 0;
sin[0].sin_addr.s_addr = inet_makeaddr(INADDR_ANY, 0);
if (bind(listen_socket, &sin[0], sizeof(sin[0])) < 0)
{
perror("bind");
return -1;
}
len = sizeof(sin[0]);
if (getsockname(listen_socket, &sin[0], &len) < 0)
{
perror("getsockname");
return -1;
}
if (listen(listen_socket, 5) < 0)
{
perror("listen");
return -1;
}
fd[1] = socket(af, type, protocol);
if (fd[1] < 0)
{
perror("creating client_socket");
return -1;
}
fcntl(fd[1], F_SETFL, fcntl(fd[1], F_GETFL, 0) | O_NDELAY);
if (connect(fd[1], &sin[0], sizeof(sin[0])) < 0)
{
perror("connect");
return -1;
}
len = sizeof(sin[1]);
if ((fd[0] = accept(listen_socket, &sin[1], &len)) < 0)
{
perror("accept");
return -1;
}
fcntl(fd[1], F_SETFL, fcntl(fd[1], F_GETFL, 0) & ~O_NDELAY);
close(listen_socket);
return 0;
}
采用的是unix domain socket的技术，首先创建一个监听socket，因为是临时性的，其绑定的端口和Ip地址都可以任意（由系统指定即可）， 然后执行listen；接着创建client socket，其描述符为fd[1]，执行connect；最后返回服务端，执行accept，返回的描述符就是实际通信的描述符fd[0]。
我们知道父进程在子进程被fork出来之前打开的文件描述符是能被子进程继承下来的，但是一旦子进程已经创建后，父进程打开的文件描述符要怎样才能传递给子进程呢？Unix提供相应的技术来满足这一需求，这就是同一台主机上进程间的文件描述符传递，很美妙而且强大的技术。
想象一下我们试图实现一个服务器，接收多个客户端的连接，我们欲采用多个子进程并发的形式来处理多客户端的同时连接，这时候我们可能有两种想法：
1、客户端每建立一条连接，我们fork出一个子进程负责处理该连接；
2、预先创建一个进程池，客户端每建立一条链接，服务器就从该池中选出一个空闲(Idle)子进程来处理该连接。
后者显然更高效，因为减少了子进程创建的性能损耗，反应的及时性大大增强。这里恰恰就出现了我们前面提到的问题，所有子进程都是在服务器Listen到一条连接以前就已经fork出来了，也就是说新的连接描述符子进程是不知道的，需要父进程传递给它，它接收到相应的连接描述符后，才能与相应的客户端进行通信处理。这里我们就可以使用'传递文件描述符'的方式来实现。
在'UNIX网络编程第1卷'的14.7小节中对这种技术有详细的阐述，实际上这种技术就是利用sendmsg和recvmsg在一定的UNIX域套接口(或者是某种管道)上发送和接收一种特殊的消息，这种消息可以承载'文件描述符'罢了，当然操作系统内核对这种消息作了特殊的处理。在具体一点儿'文件描述符'是作为辅助数据(Ancillary Data)通过msghdr结构中的成员msg_control(老版本中称为msg_accrights)发送和接收的。值得一提的是发送进程在将'文件描述符'发送出去后，即使立即关闭该文件描述符，该文件描述符对应的文件设备也没有被真正的关闭，其引用计数仍然大于一，直到接收进程成功接收后，再关闭该文件描述符，如果这时文件设备的引用计数为0，那么才真正关闭该文件设备。
OK，下面是一个简单的文件描述符传递的例子，该例子实现这样一个功能：即子进程负责在父进程传递给它的文件描述符对应的文件尾加上特定的'LOGO'字符串。例子环境为Solaris 9 + GCC 3.2
[cpp] view plaincopyprint?
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
#define MY_LOGO "-- Tony Bai"
static int send_fd(int fd, int fd_to_send)
{
struct iovec iov[1];
struct msghdr msg;
char buf[1];
if (fd_to_send >= 0) {
msg.msg_accrights = (caddr_t)&fd_to_send;
msg.msg_accrightslen = sizeof(int);
} else {
msg.msg_accrights = (caddr_t)NULL;
msg.msg_accrightslen = 0;
}
msg.msg_name = NULL;
msg.msg_namelen = 0;
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
if(sendmsg(fd, &msg, 0) < 0) {
printf("sendmsg error, errno is %d\n", errno);
return errno;
}
return 0;
}
static int recv_fd(int fd, int *fd_to_recv)
{
struct iovec iov[1];
struct msghdr msg;
char buf[1];
msg.msg_accrights = (caddr_t)fd_to_recv;
msg.msg_accrightslen = sizeof(int);
msg.msg_name = NULL;
msg.msg_namelen = 0;
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
if (recvmsg(fd, &msg, 0) < 0) {
return errno;
}
if(msg.msg_accrightslen != sizeof(int)) {
*fd_to_recv = -1;
}
return 0;
}
int x_sock_set_block(int sock, int on)
{
int val;
int rv;
val = fcntl(sock, F_GETFL, 0);
if (on) {
rv = fcntl(sock, F_SETFL, ~O_NONBLOCK&val);
} else {
rv = fcntl(sock, F_SETFL, O_NONBLOCK|val);
}
if (rv) {
return errno;
}
return 0;
}
int main() {
pid_t pid;
int sockpair[2];
int rv;
char fname[256];
int fd;
rv = socketpair(AF_UNIX, SOCK_STREAM, 0, sockpair);
if (rv < 0) {
printf("Call socketpair error, errno is %d\n", errno);
return errno;
}
pid = fork();
if (pid == 0) {
close(sockpair[1]);
for ( ; ; ) {
rv = x_sock_set_block(sockpair[0], 1);
if (rv != 0) {
printf("[CHILD]: x_sock_set_block error, errno is %d\n", rv);
break;
}
rv = recv_fd(sockpair[0], &fd);
if (rv < 0) {
printf("[CHILD]: recv_fd error, errno is %d\n", rv);
break;
}
if (fd < 0) {
printf("[CHILD]: child process exit normally!\n");
break;
}
rv = write(fd, MY_LOGO, strlen(MY_LOGO));
if (rv < 0) {
printf("[CHILD]: write error, errno is %d\n", rv);
} else {
printf("[CHILD]: append logo successfully\n");
}
close(fd);
}
exit(0);
}
for ( ; ; ) {
memset(fname, 0, sizeof(fname));
printf("[PARENT]: please enter filename:\n");
scanf("%s", fname);
if (strcmp(fname, "exit") == 0) {
rv = send_fd(sockpair[1], -1);
if (rv < 0) {
printf("[PARENT]: send_fd error, errno is %d\n", rv);
}
break;
}
fd = open(fname, O_RDWR | O_APPEND);
if (fd < 0) {
if (errno == ENOENT) {
printf("[PARENT]: can't find file '%s'\n", fname);
continue;
}
printf("[PARENT]: open file error, errno is %d\n", errno);
}
rv = send_fd(sockpair[1], fd);
if (rv != 0) {
printf("[PARENT]: send_fd error, errno is %d\n", rv);
}
close(fd);
}
wait(NULL);
return 0;
}
编译：gcc -o test_fdpass -lsocket -lnsl test_fdpass.c
执行：test_fdpass(事先在同一目录下创建一个文件kk.log)
[PARENT]: please enter filename:
kk.log
[CHILD]: append logo successfully
[PARENT]: please enter filename:
cc.log
[PARENT]: can't find file 'cc.log'
exit
[CHILD]: child process exit normally!
你可以发现kk.log内容的末尾已经加上了我的独特LOGO '-- Tony Bai'。^_^
关于文件描述符传递的更多细节， W. Richard Stevens的'UNIX网络编程第1卷'和'UNIX环境高级编程'两本书中都有详细说明，参读即可
一个问题：如何创建全双工管道？
直接的办法当然是pipe两次，创建两组管道，但是有没有更简单的呢？
socketpair就可以了，man socketpair:
socketpair - create a pair of connected sockets, The two sockets are indistinguishable，也就是说，用socketpair创建出来的两个描述符应该是等价的。
socketpair函数概要如下：
#include <sys/types.h>
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int sv[2]);
sys/types.h文件需要用来定义一些C宏常量。sys/socket.h文件必须包含进来定义socketpair函数原型。
socketpair函数需要四个参数。他们是：
套接口的域 套接口类型 使用的协议 指向存储文件描述符的指针
类型参数声明了我们希望创建哪种类型的套接口。socketpair函数的选择如下：
SOCK_STREAM
SOCK_DGRAM
对于socketpair函数，protocol参数必须提供为0。
参数sv[2]是接收代表两个套接口的整数数组。每一个文件描述符代表一个套接口，并且与另一个并没有区别。
如果函数成功，将会返回0值。否则将会返回-1表明创建失败，并且errno来表明特定的错误号。
关于流程。socketpair()函数创建出两个进程，fork()之后这两个进程都会执行主程序中的代码，这个一定要注意！尤其是bind的时候，如果bind两次的话，那就会出错了。一般会在子进程里调用一个带死循环的函数，这样就好了。（这个情况的例子会在综合运用中讲解）
二.用法
[cpp] view plaincopyprint?
#define DATA1 "test string 1"
#define DATA2 "test string 2"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
main()
{
int sockets[2], child;
char buf[1024];
if (socketpair(AF_UNIX, SOCK_STREAM,
0, sockets) < 0) {
printf("error %d on socketpair ", errno);
exit(1);
}
if ((child = fork()) == -1) {
printf("fork error %d ", errno);
exit(1);
}
if (child != 0) {
close(sockets[0]);
if (read(sockets[1], buf, sizeof(buf)) < 0) {
printf("error %d reading socket ", errno);
exit(1);
}
printf("parent:-->%s /n", buf);
if (write(sockets[1], DATA1, sizeof(DATA1)) < 0) {
printf("error %d writing socket ", errno);
exit(1);
}
close(sockets[1]);
} else {
close(sockets[1]);
if (write(sockets[0], DATA2, sizeof(DATA1)) < 0) {
printf("error %d writing socket ", errno);
exit(1);
}
if (read(sockets[0], buf, sizeof(buf)) < 0) {
printf("error %d reading socket ", errno);
exit(1);
}
printf("child: -->%s/n ", buf);
close(sockets[0]);
}
}
从上面的代码中，我们可以发现，父进程从sockets[1]中读写，子进程从sockets[0]中读写，的确是全双工形态。
唯一值得考虑的是为什么在父子进程中，要分别关闭sockets[0]和sockets[1]呢？
三。一个实现
[cpp] view plaincopyprint?
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <stdio.h>
socketpair(af, type, protocol, fd)
int af;
int type;
int protocol;
int fd[2];
{
int listen_socket;
struct sockaddr_in sin[2];
int len;
if (type != SOCK_STREAM)
return -1;
listen_socket = socket(af, type, protocol);
if (listen_socket < 0)
{
perror("creating listen_socket");
return -1;
}
sin[0].sin_family = af;
sin[0].sin_port = 0;
sin[0].sin_addr.s_addr = inet_makeaddr(INADDR_ANY, 0);
if (bind(listen_socket, &sin[0], sizeof(sin[0])) < 0)
{
perror("bind");
return -1;
}
len = sizeof(sin[0]);
if (getsockname(listen_socket, &sin[0], &len) < 0)
{
perror("getsockname");
return -1;
}
if (listen(listen_socket, 5) < 0)
{
perror("listen");
return -1;
}
fd[1] = socket(af, type, protocol);
if (fd[1] < 0)
{
perror("creating client_socket");
return -1;
}
fcntl(fd[1], F_SETFL, fcntl(fd[1], F_GETFL, 0) | O_NDELAY);
if (connect(fd[1], &sin[0], sizeof(sin[0])) < 0)
{
perror("connect");
return -1;
}
len = sizeof(sin[1]);
if ((fd[0] = accept(listen_socket, &sin[1], &len)) < 0)
{
perror("accept");
return -1;
}
fcntl(fd[1], F_SETFL, fcntl(fd[1], F_GETFL, 0) & ~O_NDELAY);
close(listen_socket);
return 0;
}
采用的是unix domain socket的技术，首先创建一个监听socket，因为是临时性的，其绑定的端口和Ip地址都可以任意（由系统指定即可）， 然后执行listen；接着创建client socket，其描述符为fd[1]，执行connect；最后返回服务端，执行accept，返回的描述符就是实际通信的描述符fd[0]。
我们知道父进程在子进程被fork出来之前打开的文件描述符是能被子进程继承下来的，但是一旦子进程已经创建后，父进程打开的文件描述符要怎样才能传递给子进程呢？Unix提供相应的技术来满足这一需求，这就是同一台主机上进程间的文件描述符传递，很美妙而且强大的技术。
想象一下我们试图实现一个服务器，接收多个客户端的连接，我们欲采用多个子进程并发的形式来处理多客户端的同时连接，这时候我们可能有两种想法：
1、客户端每建立一条连接，我们fork出一个子进程负责处理该连接；
2、预先创建一个进程池，客户端每建立一条链接，服务器就从该池中选出一个空闲(Idle)子进程来处理该连接。
后者显然更高效，因为减少了子进程创建的性能损耗，反应的及时性大大增强。这里恰恰就出现了我们前面提到的问题，所有子进程都是在服务器Listen到一条连接以前就已经fork出来了，也就是说新的连接描述符子进程是不知道的，需要父进程传递给它，它接收到相应的连接描述符后，才能与相应的客户端进行通信处理。这里我们就可以使用'传递文件描述符'的方式来实现。
在'UNIX网络编程第1卷'的14.7小节中对这种技术有详细的阐述，实际上这种技术就是利用sendmsg和recvmsg在一定的UNIX域套接口(或者是某种管道)上发送和接收一种特殊的消息，这种消息可以承载'文件描述符'罢了，当然操作系统内核对这种消息作了特殊的处理。在具体一点儿'文件描述符'是作为辅助数据(Ancillary Data)通过msghdr结构中的成员msg_control(老版本中称为msg_accrights)发送和接收的。值得一提的是发送进程在将'文件描述符'发送出去后，即使立即关闭该文件描述符，该文件描述符对应的文件设备也没有被真正的关闭，其引用计数仍然大于一，直到接收进程成功接收后，再关闭该文件描述符，如果这时文件设备的引用计数为0，那么才真正关闭该文件设备。
OK，下面是一个简单的文件描述符传递的例子，该例子实现这样一个功能：即子进程负责在父进程传递给它的文件描述符对应的文件尾加上特定的'LOGO'字符串。例子环境为Solaris 9 + GCC 3.2
[cpp] view plaincopyprint?
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
#define MY_LOGO "-- Tony Bai"
static int send_fd(int fd, int fd_to_send)
{
struct iovec iov[1];
struct msghdr msg;
char buf[1];
if (fd_to_send >= 0) {
msg.msg_accrights = (caddr_t)&fd_to_send;
msg.msg_accrightslen = sizeof(int);
} else {
msg.msg_accrights = (caddr_t)NULL;
msg.msg_accrightslen = 0;
}
msg.msg_name = NULL;
msg.msg_namelen = 0;
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
if(sendmsg(fd, &msg, 0) < 0) {
printf("sendmsg error, errno is %d\n", errno);
return errno;
}
return 0;
}
static int recv_fd(int fd, int *fd_to_recv)
{
struct iovec iov[1];
struct msghdr msg;
char buf[1];
msg.msg_accrights = (caddr_t)fd_to_recv;
msg.msg_accrightslen = sizeof(int);
msg.msg_name = NULL;
msg.msg_namelen = 0;
iov[0].iov_base = buf;
iov[0].iov_len = 1;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
if (recvmsg(fd, &msg, 0) < 0) {
return errno;
}
if(msg.msg_accrightslen != sizeof(int)) {
*fd_to_recv = -1;
}
return 0;
}
int x_sock_set_block(int sock, int on)
{
int val;
int rv;
val = fcntl(sock, F_GETFL, 0);
if (on) {
rv = fcntl(sock, F_SETFL, ~O_NONBLOCK&val);
} else {
rv = fcntl(sock, F_SETFL, O_NONBLOCK|val);
}
if (rv) {
return errno;
}
return 0;
}
int main() {
pid_t pid;
int sockpair[2];
int rv;
char fname[256];
int fd;
rv = socketpair(AF_UNIX, SOCK_STREAM, 0, sockpair);
if (rv < 0) {
printf("Call socketpair error, errno is %d\n", errno);
return errno;
}
pid = fork();
if (pid == 0) {
close(sockpair[1]);
for ( ; ; ) {
rv = x_sock_set_block(sockpair[0], 1);
if (rv != 0) {
printf("[CHILD]: x_sock_set_block error, errno is %d\n", rv);
break;
}
rv = recv_fd(sockpair[0], &fd);
if (rv < 0) {
printf("[CHILD]: recv_fd error, errno is %d\n", rv);
break;
}
if (fd < 0) {
printf("[CHILD]: child process exit normally!\n");
break;
}
rv = write(fd, MY_LOGO, strlen(MY_LOGO));
if (rv < 0) {
printf("[CHILD]: write error, errno is %d\n", rv);
} else {
printf("[CHILD]: append logo successfully\n");
}
close(fd);
}
exit(0);
}
for ( ; ; ) {
memset(fname, 0, sizeof(fname));
printf("[PARENT]: please enter filename:\n");
scanf("%s", fname);
if (strcmp(fname, "exit") == 0) {
rv = send_fd(sockpair[1], -1);
if (rv < 0) {
printf("[PARENT]: send_fd error, errno is %d\n", rv);
}
break;
}
fd = open(fname, O_RDWR | O_APPEND);
if (fd < 0) {
if (errno == ENOENT) {
printf("[PARENT]: can't find file '%s'\n", fname);
continue;
}
printf("[PARENT]: open file error, errno is %d\n", errno);
}
rv = send_fd(sockpair[1], fd);
if (rv != 0) {
printf("[PARENT]: send_fd error, errno is %d\n", rv);
}
close(fd);
}
wait(NULL);
return 0;
}
编译：gcc -o test_fdpass -lsocket -lnsl test_fdpass.c
执行：test_fdpass(事先在同一目录下创建一个文件kk.log)
[PARENT]: please enter filename:
kk.log
[CHILD]: append logo successfully
[PARENT]: please enter filename:
cc.log
[PARENT]: can't find file 'cc.log'
exit
[CHILD]: child process exit normally!
你可以发现kk.log内容的末尾已经加上了我的独特LOGO '-- Tony Bai'。^_^
关于文件描述符传递的更多细节， W. Richard Stevens的'UNIX网络编程第1卷'和'UNIX环境高级编程'两本书中都有详细说明，参读即可
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- socketpair的用途以及实现
- socketpair的用途以及实现
- 双工pipe的实现： socketpair的用途以及实现
- 双工pipe的实现： socketpair的用途以及实现
- 高级IO中socketpair实现进程间通信以及重定向
- Wordpress主题与插件实现机制以及部分主题插件用途配置说明
- 在c#中如何实现对图象的翻转、放大、缩小操作以及缩微图
- 打印的简单实现，以及更改打印设置
- VC点滴 之 WinMain（windows程序的运行原理以及VC++的实现过程）
- 如何在DataGrid控件中实现编辑、删除、分类以及分页操作
- Google Hacking 的实现以及应用
- Shark 用户管理以及认证管理实现分析
- google hacking的实现以及应用
- 动网论坛上传文件漏洞的原理以及攻击的代码实现
- (转载)Google Hacking的实现以及应用
- Google Hacking 的实现以及应用 转
- 如何选择合适的容器以及其实现品
- 如何在DataGrid控件中实现编辑、删除、分类以及分页操作
- wap页面的返回实现以及go任务
- VB的ShowInTaskbar功能分析以及用VC的实现