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两次的话,那就会出错了。通常会在子进程里调用一个带死循环的函数,这样就好了。(这个情况的样例会在综合运用中解说)

一下给出个简单的样例。

// 建立socket对
       #include <sys/types.h>
       #include <sys/socket.h>
    
       #include <stdlib.h>
       #include <stdio.h>
    
       int main ()
       {
         int fd[2];
   
        int r = socketpair( AF_UNIX, SOCK_STREAM, 0, fd );
        if ( r < 0 ) {
          perror( "socketpair()" );
          exit( 1 );
        }
   
        if ( fork() ) {
          /* Parent process: echo client */
          int val = 0;
          close( fd[1] );
          while ( 1 ) {
            sleep( 1 );
            ++val;
            printf( "Sending data: %d/n", val );
            write( fd[0], &val, sizeof(val) );
            read( fd[0], &val, sizeof(val) );
            printf( "Data received: %d/n", val );
          }
        }
        else {
          /* Child process: echo server */
          int val;
          close( fd[0] );
          while ( 1 ) {
            read( fd[1], &val, sizeof(val) );
            ++val;
            write( fd[1], &val, sizeof(val) );
          }
        }
      }

在给出一个用sendmsg来传递数据的样例

/*****************************************
 *
 * Listing 1.2
 *
 * Example performing I/O on s socket pair:
 *
 * ******************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>

int main(int argc,char **argv)
{
    int z;        /* Status return code */
    int s[2];    /* Pair of sockets */
 struct msghdr msg;
    struct iovec iov[1];
 char send_buf[100] = "TEST";
 struct msghdr msgr;
    struct iovec iovr[1];
    char recv_buf[100];

/*
     * Create a pair of local sockets:
     */
    z = socketpair(AF_LOCAL,SOCK_STREAM,0,s);

if(z == -1)
    {
        fprintf(stderr,
                "%s:socketpair(AF_LOCAL,SOCK_STREAM,""0)/n",strerror(errno));
        return 1;    /* Failed */
    }

/*
     * Sendmsg s[1]:
     */

bzero(&msg, sizeof(msg));
         msg.msg_name = NULL;        /* attention this is a pointer to void* type */
         msg.msg_namelen = 0;
         iov[0].iov_base = send_buf;
         iov[0].iov_len = sizeof(send_buf);
         msg.msg_iov = iov;
         msg.msg_iovlen = 1;

printf("sendmsg begin./n");
   z = sendmsg( s[1], &msg, 0 );
   if(z == -1 )
   {
    fprintf(stderr,"Sendmsg failed.  errno : %s/n",strerror(errno));
    return -1;
   }
    printf("Sendmsg Success!/n");

/*
     * Read from socket s[0]:
     */

bzero(&msg, sizeof(msg));
         msgr.msg_name = NULL;        /* attention this is a pointer to void* type */
         msgr.msg_namelen = 0;
         iovr[0].iov_base = &recv_buf;
         iovr[0].iov_len = sizeof(recv_buf);
         msgr.msg_iov = iovr;
         msgr.msg_iovlen = 1;

z = recvmsg(  s[0], &msgr, 0);
   if(z == -1 )
   {
    fprintf(stderr,"Recvmsg failed.  errno : %s/n",strerror(errno));
    return -1;
   }
    printf("Recvmsg Success!/n");
 printf("recvmsg : %s/n", recv_buf);

/*
     * Close the sockets:
     */
    close(s[0]);
    close(s[1]);

puts("Done");
    return 0;
}

时间: 2024-08-08 09:26:22

socketpair的使用的相关文章

Libevent学习之SocketPair实现

Libevent设计的精化之一在于把Timer事件.Signal事件和IO事件统一集成在一个Reactor中,以统一的方式去处理这三种不同的事件,更确切的说是把Timer事件和Signal事件融合到了IO多路复用机制中. Timer事件的融合相对清晰简单,其套用了Reactor和Proactor模式(如Windows上的IOCP)中处理Timer事件的经典方法,其实Libevent就是一个Reactor嘛.由于IO复用机制(如Linux下的select.epoll)允许使用一个最大等待时间(即最

socketpair和pipe的区别

http://blog.csdn.net/bingqingsuimeng/article/details/9055499 管道pipe是半双工的,pipe两次才能实现全双工,使得代码复杂.socketpair直接就可以实现全双工. socketpair对两个文件描述符中的任何一个都可读和可写,而pipe是一个读,一个写.

socketpair双方管道

使用pipe只能对有血缘关系的单向管道进行通信.不过,Linux实现了一个源自BSD的socketpair调用 (3),可以实现上述在同一个文件描述符中进行读写的功能(该调用目前也是POSIX规范的一部分 (4)).该系统调用能创建一对已连接的(UNIX族)无名socket.在Linux中,完全可以把这一对socket当成pipe返回的文件描述符一样使用,唯一的区别就是这一对文件描述符中的任何一个都可读和可写. 这似乎可以是一个用来实现进程间通信管道的好方法.不过,要注意的是,为了解决我前面的提

socketpair实现进程通信

pipe用来创建管道,但是单个管道只能单向通信,一端用于读,而另一端用于写.如果要实现进程双向通信,必须创建一对管道.具体实现忽略.而socketpair则可以用来创建双向通信的管道.取决于底层实现,打开的还是一个文件,fd[0],fd[1],管道中f[0]读端,f[1]写端. #include <sys/types.h> #include <sys/socket.h> int socketpair(int domain, int type, int protocol, int s

socketpair函数详解

我们先来看看socketpair函数的原型如下: int socketpair(int domain,int type,int protocol,int sv[]) 第一个参数表示协议族,必须为AF_LOCAL; 第二个参数表示类型,既可以是SOCK_STREAM,又可以是SOCK_DGRAM,当参数指定为SOCK_STREAM时,得到的结果称为流管道,它与一般管道的区别是留管道是全双工的,即两个描述符即可读有可写; 第三个参数只能为0: 第四个参数用于保存创建的套接字对: socketpair

socketpair

int socketpair(int domain, int type, int protocol, int sockfd[2]); //创建未命名的全双工管道 domain只能为AF_UNIX,也就是限制在本地使用 type可以是SOCK_STREAM或SOCK_DGRAM,SOCK_STREAM相当于创建了双向流管道,管道的每一端都可以write或read,并且两端的数据流对流是分开的 protocol必须是0 sockfd数组返回管道两端的socket描述符 在2.6.27的内核版本后,t

高级IO中socketpair实现进程间通信以及重定向

sockpair实现进程间通信 我们以前学习的利用管道(此处为匿名管道)实现进程间通信,只能是单向的,一边只能读而另一边只能写,且只能在有血缘关系的进程间才能通信,若想实现双向通信就必须创建双向管道,而sockpair它的实现就是双向管道进行通信.它可以用来创建双向通信管道 1 #include<stdio.h>   2 #include<unistd.h>   3 #include<string.h>   4 #include<sys/types.h>  

[转] IPC之管道、FIFO、socketpair

管道和FIFO作为最初的UNIX IPC形式,现在已用得较少.SocketPair可作为全双工版本的管道,较为常用,这里简单做个笔记 管道 * 只用于有亲缘关系的进程间通信 * 单向,即半双工 (双向方法:1 使用2个管道 2 使用SocketPair) * pipe() => write()/read() FIFO (有名管道) * 可用于无亲缘关系的进程间通信 * 单向 * mkfifo() => open() => write()/read() SocketPair * 套接字(一

linux:利用socketpair来在进程间传递描述符

1.socketpair 2.sendmsg/recvmsg 3.UNIX域套接字传递描述字 功能:创建一个圈双工的流管道 原型: int socketpair(int domain, int type, int protocol, int sv[2]); 参数 domain :协议家族    type: 套接字种类    protocol:协议种类    sv:返回的套接字对 返回值: 成功返回0, 失败返回-1 通过sockpair创建的全双通管道可以实现父子间进程通讯 #include <