参考网上的实现，进行了一点改进，本来想用FIFO实现的，后来发现不行，必须使用系统的sendmsg函数，代码格式有点乱，不过功能可以实现，改天有空整理一下~~

讲究看哈~

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include <strings.h>
#include<sys/wait.h>
#include <string.h>
#include <errno.h>
#include <sys/un.h>
#include <sys/uio.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>

#define FIFO_NAME "/home/907684/my_fifo_file"
//#define BUFFER_SIZE PIPE_BUF
#define BUFFER_SIZE 10
#define TEN_MEG (1024*10)
#define CONTROLLEN sizeof (struct cmsghdr) + sizeof (int)
#define false 0
#define true 1
//异步写打开FIFO，必须先有读打开FIFO 否则会失败！

int proccess_num=-1;

void show_struct_byte(const char * buf, int len)
{
 if (len <= 0) return;
 
 int i;
 printf("[%d]show struct len :%d. \r\n",proccess_num,len);
 printf("[%d]show struct as string :%s. \r\n *** \r\n",proccess_num,buf);
 
 for(i=0;i<len;i++)
 {
  printf("%d ",(int)(*buf++));
 }
 printf("\r\n[%d]finish show struct byte \r\n", proccess_num);
}

int send_sock_fd(int pipe_fd, int sock_fd)
{
    if (pipe_fd <0 || sock_fd < 0) return false;
     
     
    int bytes = 0,res;
    int return_flag=true;
    printf("[%d]enter send_sock_fd()... \r\n",proccess_num);
    /*    
    char buf_str[] = "firt recieved Client speaking!\n";
    //int ret = write(sock_fd, buf_str, sizeof(buf_str));
    //write() 异常判断...
   
    struct cmsghdr *  cmptr = 0;
    struct msghdr msg;
    struct iovec  iov[1];
    char   buf[2];
   
    iov[0].iov_base = buf;
    iov[0].iov_len  = 2;
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
    msg.msg_name = NULL;
    msg.msg_namelen = 0;
   
    cmptr = (struct cmsghdr *)malloc(sizeof(struct cmsghdr) + sizeof(int));
    cmptr->cmsg_level = SOL_SOCKET;
    cmptr->cmsg_type  = SCM_RIGHTS;
    cmptr->cmsg_len   = sizeof(struct cmsghdr) + sizeof(int);
    *(int *)CMSG_DATA(cmptr) = sock_fd;
    msg.msg_control = cmptr;
    msg.msg_controllen = sizeof(struct cmsghdr) + sizeof(int);
    
    buf[1] = 0; buf[0] = 1;
    */

char tmpbuf[CONTROLLEN];
     struct cmsghdr *cmptr = (struct cmsghdr *) tmpbuf;
     struct iovec iov[1];
     struct msghdr msg;
     char buf[1];
     iov[0].iov_base = buf;
     iov[0].iov_len = 1;
     msg.msg_iov = iov;
     msg.msg_iovlen = 1;
     msg.msg_name = NULL;
     msg.msg_namelen = 0;
     msg.msg_control = cmptr;
     msg.msg_controllen = CONTROLLEN;
     cmptr->cmsg_level = SOL_SOCKET;
     cmptr->cmsg_type = SCM_RIGHTS;
     cmptr->cmsg_len = CONTROLLEN;
     *(int *)CMSG_DATA (cmptr) = sock_fd;
 
     show_struct_byte((char *)&msg, sizeof(msg));

while (bytes < sizeof(msg))
        {
          printf("[%d]call write()... \r\n",proccess_num);
    
            res = write(pipe_fd, (void *)&msg, sizeof(msg));
            //res = sendmsg(pipe_fd,&msg,0);
           
            printf("[%d]res = %d && errno = %d. \r\n",proccess_num,res,errno);
            if (res == -1 )
            {
              if(errno == EAGAIN)
              {
                 printf("[%d]write no data. try later... \r\n",proccess_num);
                 continue;
               }
               else
               {
               printf("[%d]write error. exit! \r\n",proccess_num);
                fprintf(stderr, "Write error on pipe\r\n");
               
                 return_flag=false; 
                 break;              
               }
            }
            bytes += res;
            printf("[%d]write data:%d bytes, sleep...\r\n",proccess_num,res);
            //sleep(9);
        }
        printf("[%d]Total %d bytes send to fifo. send sock_fd:%d. sizeof(msg):%d \r\n",proccess_num,bytes, sock_fd, sizeof(msg));
        sleep(5);
       
        //free(cmptr);
        //close(sock_fd); //NOT close?
        //close(pipe_fd); //NOT close?
 
    return return_flag;
}

int read_sock_fd(int pipe_fd, int* sock_fd)
{
    if (pipe_fd < 0 || sock_fd < 0) return false;

int bytes = 0, res;
    int return_flag = true;
    printf("[%d]enter read_sock_fd()... \r\n",proccess_num);
    /*
    //get client fd
    char buf[2];
    int newfd = -1;
    struct iovec   iov[1];
    struct msghdr  msg;
    struct cmsghdr * cmptr = (struct cmsghdr *)malloc(sizeof(struct cmsghdr) + sizeof(int));
    
    iov[0].iov_base = buf;
    iov[0].iov_len  = sizeof(buf);
    msg.msg_iov     = iov;
    msg.msg_iovlen  = 1;
    msg.msg_name    = NULL;
    msg.msg_namelen = 0;
    msg.msg_control = cmptr;
    msg.msg_controllen = sizeof(struct cmsghdr) + sizeof(int);
    */
    
     char tmpbuf[CONTROLLEN];
     struct cmsghdr *cmptr = (struct cmsghdr *) tmpbuf;
     struct iovec iov[1];
     struct msghdr msg;
     char buf[1];
     iov[0].iov_base = buf;
     iov[0].iov_len = sizeof (buf);
     msg.msg_iov = iov;
     msg.msg_iovlen = 1;
     msg.msg_name = NULL;
     msg.msg_namelen = 0;
     msg.msg_control = cmptr;
     msg.msg_controllen = CONTROLLEN;
   
        printf("[%d] loop call read() fifo... \r\n", proccess_num);
    while (bytes < sizeof(msg))
        {
          res = read(pipe_fd, &msg, sizeof(msg));
          //res = recvmsg(pipe_fd,&msg,0);
          sleep(2);

printf("[%d]res = %d && errno = %d. \r\n", proccess_num,res,errno);
            if (res == -1 )
            {
              if(errno == EAGAIN)
              {
                 //printf("read no data. try later... \r\n");
                 continue;
               }
               else
               {
               printf("[%d]read error. exit! \r\n",proccess_num);
                fprintf(stderr, "Write error on pipe\r\n");
                 return_flag = false;      
                 break;         
               }
            }
            bytes += res;
            printf("[%d]read data:%d bytes.\r\n",proccess_num,res);
            //sleep(9);
        }
        printf("[%d]%d bytes read from fifo. sizeof(msg):%d \r\n",proccess_num,bytes,sizeof(msg));
       
        //get client socket
        if (return_flag)
        {
         /*
         printf("[%d]read fifo succeed. pase client fd.\r\n",proccess_num);
         printf("[%d]*(int*)CMSG_DATA(cmptr):%d,cmptr:%d.\r\n",proccess_num,*(int*)CMSG_DATA(cmptr),cmptr);
  show_struct_byte((char *)&msg, sizeof(msg)); 
   
         *sock_fd = *(int*)CMSG_DATA(cmptr);
         */
         
         printf("[%d]*(int*)CMSG_DATA(cmptr):%d,cmptr:%d.\r\n",proccess_num,*(int *)CMSG_DATA (cmptr),cmptr);

show_struct_byte((char *)&msg, sizeof(msg)); 
         *sock_fd = *(int *)CMSG_DATA (cmptr);
   
     printf("[%d]CMSG_FIRSTHDR(&msg) ret:%d (should not be 0!) \r\n", proccess_num,CMSG_FIRSTHDR(&msg));

}
        else
        {
         printf("[%d]read fifo failed. set sock_fd = -1. \r\n",proccess_num);
         *sock_fd = -1;
         }
        printf("[%d]get client fd:%d.\r\n",proccess_num,*sock_fd);
        //sleep(5);
        close(pipe_fd);
        //close(sock_fd); //NOT close?
        //free(cmptr);

return return_flag;
}

int init_fifo_write()
{
  //***** fifo *****
    int write_pipe_fd;
    int res;
    int open_mode = O_WRONLY|O_NONBLOCK;

int bytes = 0;
    //char buffer[BUFFER_SIZE + 1] = "hello";

if (access(FIFO_NAME, F_OK) == -1)
    {
        res = mkfifo(FIFO_NAME, 0777);
        if (res != 0)
        {
            fprintf(stderr, "Could not create fifo %s \r\n", FIFO_NAME);
            return -1;
        }
    }

printf("[%d] write opeining FIFO :%s  \r\n", proccess_num, FIFO_NAME);
    //printf("fifo buffer size:%d",BUFFER_SIZE);
   
    int read_fd = open(FIFO_NAME, O_RDONLY | O_NONBLOCK);
    if (read_fd == -1)
    {
      printf("[%d]read open fifo file failed. exit. \r\n",proccess_num);
        return -1;
    }   
   
    write_pipe_fd = open(FIFO_NAME, O_WRONLY|O_NONBLOCK);   
    if (write_pipe_fd == -1)
    {
      printf("[%d]write open fifo file failed. exit. \r\n",proccess_num);
        return -1;
    }  
    printf("[%d]Process %d result %d\r\n",proccess_num, getpid(), write_pipe_fd);
   
    return write_pipe_fd; 
   
   }

int init_fifo_read()
{
    int read_pipe_fd;
    int res;

int open_mode = O_RDONLY|O_NONBLOCK;
    char buffer[BUFFER_SIZE + 1];
    int bytes = 0;

memset(buffer, 0, sizeof(buffer));

printf("[%d] read opeining FIFO :%s  \r\n", proccess_num, FIFO_NAME);
    //printf("fifo buffer size:%d",BUFFER_SIZE);
    read_pipe_fd = open(FIFO_NAME, O_RDONLY|O_NONBLOCK);
    printf("Process %d result %d\r\n", getpid(), read_pipe_fd);

if (read_pipe_fd == -1)
    {
      printf("read open fifo file failed. exit. \r\n");
        return -1;
    }  
    printf("Process %d result %d\r\n", getpid(), read_pipe_fd);
   
    return read_pipe_fd; 
 }
 //***** fifo *****

//************************ send socket fd
static struct sockaddr_un addr = {0}; 
static int s_create_usockfd()
{
 static char* path = "/home/907684/test/fd_send/share_fd";

int sockfd; 
 addr.sun_family = AF_UNIX;    
 strcpy(addr.sun_path, path);
 sockfd = socket(PF_UNIX, SOCK_DGRAM, 0);    
 if(sockfd == -1)
 {
  printf("create unix sockfd failed, %d, %s\n", errno, strerror(errno));        
  return 0;    
 }    
 else
 {
  printf("create unix sockfd ok\n");    
 }

//还需要使用bind函数来创建S_IFSOCK类型文件!!!!!!

//否则可能提示文件不存在!!!
 return sockfd;
}

static int s_send_fd(int sockfd, int fd)
{
 struct msghdr msg = {0};
 char ccmsg[CMSG_SPACE(sizeof(fd))];    
 struct cmsghdr* cmsg;     int rv; 
 msg.msg_name = (struct sockaddr*)&addr;    
 msg.msg_namelen = sizeof(addr); 
 msg.msg_control = ccmsg;
 msg.msg_controllen = sizeof(ccmsg); 
 cmsg = CMSG_FIRSTHDR(&msg);    
 cmsg->cmsg_level = SOL_SOCKET;    
 cmsg->cmsg_type = SCM_RIGHTS;
 cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); 
 *(int*)CMSG_DATA(cmsg) = fd;    
 msg.msg_control = ccmsg;
 msg.msg_controllen = cmsg->cmsg_len;    
 msg.msg_flags = 0; 
 printf("sendmsg file fd[%d] to socket fd[%d]\n",fd, sockfd);

rv = (sendmsg(sockfd, &msg, 0) != -1);    
 printf("sendmsg return %d \r\n",rv);
 if(rv)
 {
  printf("sendmsg ok, file fd is %d\n", fd);        
  close(fd);    
 }    
 else
 {
  printf("sendmsg failed to socket fd[%d], errno[%d], error str:%s\n", sockfd, errno, strerror(errno));    
 } 
 printf("send fd[%d] to shared file finish.\r\n", fd);

return rv;
}

int get_fd_to_send()
{
 char * file_shared_path = "/home/907684/test/fd_send/file_shared.txt";
 int sfd = open(file_shared_path, O_CREAT|O_RDWR|O_TRUNC, 0644); 
 return sfd; 
}

//************************ send socket fd

//************************ recv socket fd
static int r_create_usockfd(char* path)
{
    struct sockaddr_un addr = {0};
    int opt = 1;
    int fd;
 
    addr.sun_family = AF_UNIX;
 
    unlink(path);
    strcpy(addr.sun_path, path); 
 
    fd = socket(PF_UNIX, SOCK_DGRAM, 0);
 
    if(bind(fd, (struct sockaddr*)&addr, sizeof(addr))){
        printf("[%d]recv bind failed, %d, %s\n",proccess_num, errno, strerror(errno));
    }
    else{
        printf("[%d]recv bind ok\n", proccess_num);
    }
 
    return fd;
}
 
static int r_recv_fd(int fd)
{
    struct msghdr msg = {0};
    int rv = 0;
    int cfd = -1;
    char ccmsg[CMSG_SPACE(sizeof(cfd))];
    struct cmsghdr* cmsg;
 
    msg.msg_control = ccmsg;
    msg.msg_controllen = sizeof(ccmsg);
 
    while(1){
        rv = recvmsg(fd, &msg, 0);
        if(rv == -1){
            printf("recvmsg failed, return %d, %d, %s\n", rv, errno, strerror(errno));
            sleep(1);
        }
        else{
            printf("[%d]recvmsg ok.\n",proccess_num);
            break;
        }
    }
 
    cmsg = CMSG_FIRSTHDR(&msg);

int client_fd=*(int*)CMSG_DATA(cmsg);
    printf("[%d]recieved client socket fd[%d].\n",proccess_num,client_fd);

return client_fd;
}

int get_share_fd()
{
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    sfd = socket(AF_INET, SOCK_STREAM, 0);  // waste some fd
 
    static char* path = "/home/907684/test/fd_send/share_fd";
    int sockfd = r_create_usockfd(path);
    int cfd = r_recv_fd(sockfd);
    return cfd;
}

void send_msg_to_client(int cfd)
{
    char* str = "This is the second proccess speaking.\n";
    printf("[%d]write string to recieved file fd[%d]. string[%s]\r\n",proccess_num, cfd,str);
    int res = write(cfd, str, strlen(str));
    if(res<0)
    {
        printf("write error. res:%d\r\n",res);
    }

}

//************************ recv socket fd

int main(int argc, char ** argv)
{
 pid_t pid;
 char *msg;
 int n,i,j;
 int exit_code;
 int res=0,WR_fifo_fd,RD_fifo_fd;
 
 //***** socket *****
 int listenfd,connfd;
 socklen_t clilen;
 struct sockaddr_in cliaddr,servaddr;
 
 listenfd = socket(AF_INET,SOCK_STREAM,0);
 
 //set non_block
 int flags = fcntl(listenfd, F_GETFL, 0);
 if( -1 == fcntl(listenfd, F_SETFL, flags|O_NONBLOCK) )
 {
  printf("Set NONBLOCK for socket fd %d failed", listenfd);
  exit(1);
 }

bzero(&servaddr,sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 servaddr.sin_port = htons(8060);
 
 bind(listenfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr));
 listen(listenfd, 1024);
 //***** socket *****
 
 printf("start.\r\n");
 
 for( i=0;i<3;i++)
 {
  pid=fork();
  proccess_num=i;
  if(pid == 0 || pid == -1)
  {
   printf(" not fork.\r\n");
   break;
  }
 }
 
 if (pid == -1)
 {
  printf("fork error.\r\n");
  exit(1);
 }
 else if(pid == 0)
 {
  //child procces.
  //********
  printf("[%d] enter for...\r\n",proccess_num);
  
  if (proccess_num == 1) // 1 write fifo
  {
   printf("[%d] init_fifo_write.\r\n",proccess_num);

res = init_fifo_write();
   if (res == -1)
   {
    printf("init fifo write failed. exit.");
    exit(EXIT_FAILURE);
    }
   WR_fifo_fd = res;
  }
  
  if (proccess_num == 2) // 2 read fifo
  {
   printf("[%d] init_fifo_read. \r\n",proccess_num);
   res = init_fifo_read();
   if (res == -1)
   {
    printf("init fifo read failed. exit.");
    exit(EXIT_FAILURE);
    }
   RD_fifo_fd = res;
  }
  
  printf("[%d] child loop call accept() .\r\n",proccess_num);
  for(;;)
  {
    //printf("[%d] sleep 2 sec.\r\n",proccess_num);
    sleep(1);

//read fifo .
    if (proccess_num == 2) // 2 read fifo
    {
     int clifd=-1;
     //printf("[%d] fifo read.\r\n",proccess_num);

int shared_fd;

shared_fd = get_share_fd();
     send_msg_to_client(shared_fd);

/*     
     res = read_sock_fd(RD_fifo_fd,&clifd);
     if (res != true)
     {
      printf("[%d]read socket fd failed! \r\n",proccess_num);
     }
     else
     {
      printf("[%d]read socket fd succeed! fd:%d \r\n",proccess_num,clifd);
      //send some data to client
      printf("send some data to client! \r\n");
      char buf_str[] = "This is second recieved Client!\n";
      int ret = write(clifd, buf_str, sizeof(buf_str));  
      printf("write ret:%d. buf_str size:%d \r\n", ret,sizeof(buf_str));    
     
      printf("[%d] close client fd:%d \r\n",proccess_num,clifd);
      time_t t;
      time(&t);
      printf("[%d]time: %ld\n",proccess_num,t);
      close(clifd);
     }*/
    }
    else if (proccess_num == 1) // 1 write fifo
    {
     clilen = sizeof(cliaddr);
     //printf("[%d] child call accept() .\r\n",proccess_num);
     if((connfd = accept(listenfd,(struct sockaddr*)&cliaddr, &clilen)) < 0)
     {
      //printf("[%d] accept failed. fd: %d.\r\n",proccess_num,connfd);
      if(errno == EAGAIN)
      {
       //printf("[%d] accept EAGAIN.continue...\r\n",proccess_num);
       continue;
      }
      else
      {
       printf("[%d] accept error.\r\n",proccess_num);
       exit(1);
      }
     }
     else
     {
      printf("[%d] accept succeed. fd:%d \r\n",proccess_num,connfd);
      //sleep(10);
      
      /*if (1) // 1 write fifo
      {
       printf("[%d] fifo write.\r\n",proccess_num);
       //send socket fd to other proccess.
       res = send_sock_fd(WR_fifo_fd, connfd);
       if (res != true)
        printf("[%d]send socket fd %d failed! sleep 10...\r\n",proccess_num,connfd);
       else
        printf("[%d]send socket fd %d succeed! sleep 10...\r\n",proccess_num,connfd);
       sleep(10);
      }*/

//send socket fd to other proccess!
      int local_sockfd = s_create_usockfd();    
      //int client_fd = get_fd_to_send();  
      int client_fd = connfd;
      s_send_fd(local_sockfd,client_fd); 
      
      
      printf("[%d]send socket fd[%d] to other proccess finish. close socket fd. \r\n",proccess_num,connfd);
      close(connfd); //NOT close? 
      time_t t;
      time(&t);
      printf("[%d]time: %ld\n",proccess_num,t); 
     }
    }
  //********
  //exit(0);
  }
 }
 else
 {
  //parent.
  printf("parent wait...\r\n");
  while(1);
  printf("parent exit.\r\n");
  exit(0);
  }
 
 }

client的代码：

#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>

#define BUF_LEN    50
/************关于本文档********************************************
*filename: client.c
*purpose: 这是在Linux下用C语言写的一个简单sokcet客户端，用来向共享socket发送消息，以测试共享socket
进程接收消息情况。
使用方法：./client server-ip

更多开源软件，请访问http://fossd.net/?fromuid=32

*********************************************************************/

#include<time.h>

int main(int argc,char* argv[])
{
  if (!argv[1])
  {
   printf(" useage: ./client   [server ip] \r\n eixt. \r\n");
 return -1;
   }
 
   int ret;
   int fd;
  
    int i,len;
   struct sockaddr_in servaddr;
   char buf[BUF_LEN];
   fd_set writefds;

strcpy(buf,"hi, i am client\n");
   fd =  socket(AF_INET,SOCK_STREAM,0);
   if(fd <= 0)
   {
      perror("socket");
   return fd;
   }

servaddr.sin_family = AF_INET;
   servaddr.sin_port = htons(8060);
   servaddr.sin_addr.s_addr = inet_addr(argv[1]);

printf("connect to server... \r\n");
   ret = connect(fd,(struct sockaddr*)&servaddr,sizeof(servaddr));
   if(ret != 0)
   {
      perror("connect");
   return ret;
   }

bzero(buf,BUF_LEN);
   sprintf(buf,"%d hi,i came from client",i);
   len = strlen(buf);
   ret = write(fd,buf,BUF_LEN);
   printf("write ret:%d \r\n",ret);
   if (ret <= 0)
   {
    printf("write ret <= 0 \r\n");
   }

char read_buf[1024]={0};
   if(read(fd, read_buf, 1024) > 0)
   {
    printf("read data:%s \r\n", read_buf  );
   }
   else
   {
    printf("read ret <= 0 \r\n");
    }
  
   printf("read finish. exit.\r\n");
  
   time_t t;
   time(&t);
   printf("time: %ld\n",t);

/*
   while(1)
   {
       int i,len,ret;
 
       for(i = 0; i < 2000; i++)
       {
        bzero(buf,BUF_LEN);
     sprintf(buf,"%d hi,i came from client",i);
     len = strlen(buf);
    
     ret = write(fd,buf,BUF_LEN);

}
       sleep(3);
   }
  */

}