Socket 用于进程间通信 --- UNIX Domain Socket

　　socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。

　　UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIX Domain Socket通讯的。

　　使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。

　　UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。

　　以下程序将UNIX Domain socket绑定到一个地址。

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

int main(void)  
{ 
    int fd, size;  
    struct sockaddr_un un;

    memset(&un, 0, sizeof(un));  
    un.sun_family = AF_UNIX;  
    strcpy(un.sun_path, "foo.socket");  
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) 
    {  
        perror("socket error");
        exit(1);  
    }  
    size = offsetof(struct sockaddr_un, sun_path)   +strlen(un.sun_path);
  
    if (bind(fd, (struct sockaddr *)&un, size) < 0) 
    {  
        perror("bind error");  
        exit(1); 
     }  

    printf("UNIX domain socket bound/n");  
    exit(0);  
    }               

　　注意程序中的offsetof宏，它在stddef.h头文件中定义：

　　#define offsetof(TYPE, MEMBER) ((int)&((TYPE *)0)->MEMBER)      

　　offsetof(struct sockaddr_un, sun_path)就是取sockaddr_un结构体的sun_path成员在结构体中的偏移，也就是从结构体的第几个字节开始是sun_path成员。想一想，这个宏是如何实现这一功能的？(先将TYPE类型的指针首地址设为0，然后取MEMBER成员的地址就是该成员在TYPE中的偏移数。)

该程序的运行结果如下。

$ ./a.out  UNIX domain socket bound  
$ ls -l 
foo.socket  srwxrwxr-x 1 user        0 Aug 22 12:43 foo.socket  
$ ./a.out  bind error: Address already in use  
$ rm foo.socket  
$ ./a.out  UNIX domain socket bound      

　　以下是服务器的listen模块，与网络socket编程类似，在bind之后要listen，表示通过bind的地址（也就是socket文件）提供服务。

#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>

#define QLEN 10

/*
* Create a server endpoint of a connection.
* Returns fd if all OK, <0 on error.
*/

int serv_listen(const char *name)
{
    int fd, len, err, rval;
    struct sockaddr_un  un;

    /* create a UNIX domain stream socket */
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
        return(-1);
    unlink(name);   /* in case it already exists */

    /* fill in socket address structure */
    memset(&un, 0, sizeof(un));
    un.sun_family = AF_UNIX;

    strcpy(un.sun_path, name);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(name);

    /* bind the name to the descriptor */
    if (bind(fd, (struct sockaddr *)&un, len) < 0)
    {
        rval = -2;
        goto errout;
    }

    if (listen(fd, QLEN) < 0)
    { /* tell kernel we're a server */
        rval = -3;
        goto errout;
    }

    return(fd);

errout:
    err = errno;
    close(fd);
    errno = err;
    return(rval);
}

　　以下是服务器的accept模块，通过accept得到客户端地址也应该是一个socket文件，如果不是socket文件就返回错误码，如果是 socket文件，在建立连接后这个文件就没有用了，调用unlink把它删掉，通过传出参数uidptr返回客户端程序的user id。

#include <stddef.h>  
#include <sys/stat.h>  
#include <sys/socket.h>  
#include <sys/un.h>  
#include <errno.h>  

int serv_accept(int listenfd, uid_t *uidptr)  
{  int clifd, len, err, rval;  
　　time_t staletime;  
　　struct sockaddr_un  un;  
　　struct stat statbuf;
　　len = sizeof(un);
　　if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)  
　　　　return(-1);     
/* often errno=EINTR, if signal caught */  
/* obtain the client's uid from its calling address */  
　　len -= offsetof(struct sockaddr_un, sun_path); /* len of pathname */  
　　un.sun_path[len] = 0;           /* null terminate */  
　　if (stat(un.sun_path, &statbuf) < 0) 
　　{  
　　　　rval = -2;  
　　　　goto errout;  
　　}  
　　if (S_ISSOCK(statbuf.st_mode) == 0) 
　　{  
　　　　rval = -3;     
　　　　/* not a socket */  
　　　　goto errout;  
　　} 
　　if (uidptr != NULL)  
　　　　*uidptr = statbuf.st_uid;   /* return uid of caller */  
　　unlink(un.sun_path);        /* we're done with pathname now */  
　　
　　return(clifd);  

errout:  　
　　err = errno;  
　　close(clifd);  
　　errno = err;  
　　return(rval);  
}      

　　以下是客户端的connect模块，与网络socket编程不同的是，UNIX Domain Socket客户端一般要显式调用bind函数，而不依赖系统自动分配的地址。客户端bind一个自己指定的socket文件名的好处是，该文件名可以包含客户端的pid以便服务器区分不同的客户端。

/*
 * ss.c
 *
 *  Created on: 2013-7-29
 *      Author: Administrator
 */
#include <stdio.h>
#include <stddef.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>

#define CLI_PATH    "/var/tmp/"

/* +5 for pid = 14 chars */
/*
 * Create a client endpoint and connect to a server.
 * Returns fd if all OK, <0 on error.
 */
int cli_conn(const char *name)
{
    int fd, len, err, rval;
    struct sockaddr_un un;
    /* create a UNIX domain stream socket */
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
        return(-1);  /* fill socket address structure with our address */
    memset(&un, 0, sizeof(un));
    un.sun_family = AF_UNIX;
    sprintf(un.sun_path, "%s%05d", CLI_PATH, getpid());
    len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
    unlink(un.sun_path);
    /* in case it already exists */
    if (bind(fd, (struct sockaddr *)&un, len) < 0)
    {
        rval = -2;
        goto errout;
    }
    /* fill socket address structure with server's address */
    memset(&un, 0, sizeof(un));
    un.sun_family = AF_UNIX;
    strcpy(un.sun_path, name);
    len = offsetof(struct sockaddr_un, sun_path) + strlen(name);
    if (connect(fd, (struct sockaddr *)&un, len) < 0)
    {
        rval = -4;
        goto errout;
    }  return(fd);
    errout:  err = errno;
    close(fd);
    errno = err;
    return(rval);  
}

　　服务器端：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <stddef.h>
#include <string.h>

// the max connection number of the server
#define MAX_CONNECTION_NUMBER 5

/* * Create a server endpoint of a connection. * Returns fd if all OK, <0 on error. */
int unix_socket_listen(const char *servername)
{ 
  int fd;
  struct sockaddr_un un; 
  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
  {
       return(-1); 
  }
  int len, rval; 
  unlink(servername);               /* in case it already exists */ 
  memset(&un, 0, sizeof(un)); 
  un.sun_family = AF_UNIX; 
  strcpy(un.sun_path, servername); 
  len = offsetof(struct sockaddr_un, sun_path) + strlen(servername); 
  /* bind the name to the descriptor */ 
  if (bind(fd, (struct sockaddr *)&un, len) < 0)
  { 
    rval = -2; 
  } 
  else
  {
      if (listen(fd, MAX_CONNECTION_NUMBER) < 0)    
      { 
        rval =  -3; 
      }
      else
      {
        return fd;
      }
  }
  int err;
  err = errno;
  close(fd); 
  errno = err;
  return rval;    
}

int unix_socket_accept(int listenfd, uid_t *uidptr)
{ 
   int clifd, len, rval; 
   time_t staletime; 
   struct sockaddr_un un;
   struct stat statbuf; 
   len = sizeof(un); 
   if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0) 
   {
      return(-1);     
   }
 /* obtain the client's uid from its calling address */ 
   len -= offsetof(struct sockaddr_un, sun_path);  /* len of pathname */
   un.sun_path[len] = 0; /* null terminate */ 
   if (stat(un.sun_path, &statbuf) < 0) 
   {
      rval = -2;
   } 
   else
   {
       if (S_ISSOCK(statbuf.st_mode) ) 
       { 
          if (uidptr != NULL) *uidptr = statbuf.st_uid;    /* return uid of caller */ 
          unlink(un.sun_path);       /* we're done with pathname now */ 
          return clifd;         
       } 
       else
       {
          rval = -3;     /* not a socket */ 
       }
    }
   int err;
   err = errno; 
   close(clifd); 
   errno = err;
   return(rval);
 }
 
 void unix_socket_close(int fd)
 {
    close(fd);     
 }

int main(void)
{ 
  int listenfd,connfd; 
  listenfd = unix_socket_listen("foo.sock");
  if(listenfd<0)
  {
     printf("Error[%d] when listening...
",errno);
     return 0;
  }
  printf("Finished listening...
",errno);
  uid_t uid;
  connfd = unix_socket_accept(listenfd, &uid);
  unix_socket_close(listenfd);  
  if(connfd<0)
  {
     printf("Error[%d] when accepting...
",errno);
     return 0;
  }  
   printf("Begin to recv/send...
");  
  int i,n,size;
  char rvbuf[2048];
  for(i=0;i<2;i++)
  {
//===========接收==============
   size = recv(connfd, rvbuf, 804, 0);   
     if(size>=0)
     {
       // rvbuf[size]='';
        printf("Recieved Data[%d]:%c...%c
",size,rvbuf[0],rvbuf[size-1]);
     }
     if(size==-1)
     {
         printf("Error[%d] when recieving Data:%s.
",errno,strerror(errno));     
             break;        
     }
/*
 //===========发送==============
     memset(rvbuf, 'c', 2048);
         size = send(connfd, rvbuf, 2048, 0);
     if(size>=0)
     {
        printf("Data[%d] Sended.
",size);
     }
     if(size==-1)
     {
         printf("Error[%d] when Sending Data.
",errno);     
             break;        
     }
*/
 sleep(30);
  }
   unix_socket_close(connfd);
   printf("Server exited.
");    
 }

　　客户端：

#include <stdio.h>
#include <stddef.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <string.h>

/* Create a client endpoint and connect to a server.   Returns fd if all OK, <0 on error. */
int unix_socket_conn(const char *servername)
{ 
  int fd; 
  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)    /* create a UNIX domain stream socket */ 
  {
    return(-1);
  }
  int len, rval;
   struct sockaddr_un un;          
  memset(&un, 0, sizeof(un));            /* fill socket address structure with our address */
  un.sun_family = AF_UNIX; 
  sprintf(un.sun_path, "scktmp%05d", getpid()); 
  len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
  unlink(un.sun_path);               /* in case it already exists */ 
  if (bind(fd, (struct sockaddr *)&un, len) < 0)
  { 
       rval=  -2; 
  } 
  else
  {
    /* fill socket address structure with server's address */
      memset(&un, 0, sizeof(un)); 
      un.sun_family = AF_UNIX; 
      strcpy(un.sun_path, servername); 
      len = offsetof(struct sockaddr_un, sun_path) + strlen(servername); 
      if (connect(fd, (struct sockaddr *)&un, len) < 0) 
      {
          rval= -4; 
      } 
      else
      {
         return (fd);
      }
  }
  int err;
  err = errno;
  close(fd); 
  errno = err;
  return rval;      
}
 
 void unix_socket_close(int fd)
 {
    close(fd);     
 }


int main(void)
{ 
  srand((int)time(0));
  int connfd; 
  connfd = unix_socket_conn("foo.sock");
  if(connfd<0)
  {
     printf("Error[%d] when connecting...",errno);
     return 0;
  }
   printf("Begin to recv/send...
");  
  int i,n,size;
  char rvbuf[4096];
  for(i=0;i<10;i++)
  {
/*
    //=========接收=====================
    size = recv(connfd, rvbuf, 800, 0);   //MSG_DONTWAIT
     if(size>=0)
     {
        printf("Recieved Data[%d]:%c...%c
",size,rvbuf[0],rvbuf[size-1]);
     }
     if(size==-1)
     {
         printf("Error[%d] when recieving Data.
",errno);     
             break;        
     }
         if(size < 800) break;
*/
    //=========发送======================
memset(rvbuf,'a',2048);
         rvbuf[2047]='b';
         size = send(connfd, rvbuf, 2048, 0);
     if(size>=0)
     {
        printf("Data[%d] Sended:%c.
",size,rvbuf[0]);
     }
     if(size==-1)
     {
        printf("Error[%d] when Sending Data:%s.
",errno,strerror(errno));     
            break;        
     }
         sleep(1);
  }
   unix_socket_close(connfd);
   printf("Client exited.
");    
 }

 参考链接：

http://blog.csdn.net/guxch/article/details/7041052