Linux下的IPC－UNIX Domain Socket【转】

时间  2019-11-29
标签 linux ipc unix domain socket 栏目 Linux 繁體版
原文   原文链接

本文转载自：http://blog.csdn.net/guxch/article/details/7041052linux

1、 概述编程

UNIX Domain Socket是在socket架构上发展起来的用于同一台主机的进程间通信（IPC），它不须要通过网络协议栈，不须要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另外一个进程。UNIX Domain Socket有SOCK_DGRAM或SOCK_STREAM两种工做模式，相似于UDP和TCP，可是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。服务器

UNIX Domain Socket可用于两个没有亲缘关系的进程，是全双工的，是目前使用最普遍的IPC机制，好比X Window服务器和GUI程序之间就是经过UNIX Domain Socket通信的。网络

2、工做流程架构

UNIX Domain socket与网络socket相似，能够与网络socket对比应用。dom

上述两者编程的不一样以下：socket

  • address family为AF_UNIX
  • 由于应用于IPC，因此UNIXDomain socket不须要IP和端口，取而代之的是文件路径来表示“网络地址”。这点体如今下面两个方面。
  • 地址格式不一样，UNIXDomain socket用结构体sockaddr_un表示，是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用建立，若是调用bind()时该文件已存在，则bind()错误返回。
  • UNIX Domain Socket客户端通常要显式调用bind函数，而不象网络socket同样依赖系统自动分配的地址。客户端bind的socket文件名能够包含客户端的pid，这样服务器就能够区分不一样的客户端。

UNIX Domain socket的工做流程简述以下（与网络socket相同）。函数

服务器端：建立socket—绑定文件（端口）—监听—接受客户端链接—接收/发送数据—…—关闭测试

客户端：建立socket—绑定文件（端口）—链接—发送/接收数据—…—关闭网站

3、阻塞和非阻塞（SOCK_STREAM方式）

读写操做有两种操做方式：阻塞和非阻塞。

1.阻塞模式下

阻塞模式下，发送数据方和接收数据方的表现状况如同命名管道，参见本人文章“Linux下的IPC－命名管道的使用（http://blog.csdn.NET/guxch/article/details/6828452）”

2.非阻塞模式

在send或recv函数的标志参数中设置MSG_DONTWAIT，则发送和接收都会返回。若是没有成功，则返回值为-1，errno为EAGAIN 或 EWOULDBLOCK。

4、测试代码

 服务器端

[cpp]  view plain  copy
 
  1. #include <stdio.h>  
  2. #include <sys/stat.h>  
  3. #include <sys/socket.h>  
  4. #include <sys/un.h>  
  5. #include <errno.h>  
  6. #include <stddef.h>  
  7. #include <string.h>  
  8.   
  9. // the max connection number of the server  
  10. #define MAX_CONNECTION_NUMBER 5  
  11.   
  12. /* * Create a server endpoint of a connection. * Returns fd if all OK, <0 on error. */  
  13. int unix_socket_listen(const char *servername)  
  14. {   
  15.   int fd;  
  16.   struct sockaddr_un un;   
  17.   if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)  
  18.   {  
  19.      return(-1);   
  20.   }  
  21.   int len, rval;   
  22.   unlink(servername);               /* in case it already exists */   
  23.   memset(&un, 0, sizeof(un));   
  24.   un.sun_family = AF_UNIX;   
  25.   strcpy(un.sun_path, servername);   
  26.   len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);   
  27.   /* bind the name to the descriptor */   
  28.   if (bind(fd, (struct sockaddr *)&un, len) < 0)  
  29.   {   
  30.     rval = -2;   
  31.   }   
  32.   else  
  33.   {  
  34.       if (listen(fd, MAX_CONNECTION_NUMBER) < 0)      
  35.       {   
  36.         rval =  -3;   
  37.       }  
  38.       else  
  39.       {  
  40.         return fd;  
  41.       }  
  42.   }  
  43.   int err;  
  44.   err = errno;  
  45.   close(fd);   
  46.   errno = err;  
  47.   return rval;    
  48. }  
  49.   
  50. int unix_socket_accept(int listenfd, uid_t *uidptr)  
  51. {   
  52.    int clifd, len, rval;   
  53.    time_t staletime;   
  54.    struct sockaddr_un un;  
  55.    struct stat statbuf;   
  56.    len = sizeof(un);   
  57.    if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)   
  58.    {  
  59.       return(-1);       
  60.    }  
  61.  /* obtain the client's uid from its calling address */   
  62.    len -= offsetof(struct sockaddr_un, sun_path);  /* len of pathname */  
  63.    un.sun_path[len] = 0; /* null terminate */   
  64.    if (stat(un.sun_path, &statbuf) < 0)   
  65.    {  
  66.       rval = -2;  
  67.    }   
  68.    else  
  69.    {  
  70.        if (S_ISSOCK(statbuf.st_mode) )   
  71.        {   
  72.           if (uidptr != NULL) *uidptr = statbuf.st_uid;    /* return uid of caller */   
  73.           unlink(un.sun_path);       /* we're done with pathname now */   
  74.           return clifd;        
  75.        }   
  76.        else  
  77.        {  
  78.           rval = -3;     /* not a socket */   
  79.        }  
  80.     }  
  81.    int err;  
  82.    err = errno;   
  83.    close(clifd);   
  84.    errno = err;  
  85.    return(rval);  
  86.  }  
  87.    
  88.  void unix_socket_close(int fd)  
  89.  {  
  90.     close(fd);       
  91.  }  
  92.   
  93. int main(void)  
  94. {   
  95.   int listenfd,connfd;   
  96.   listenfd = unix_socket_listen("foo.sock");  
  97.   if(listenfd<0)  
  98.   {  
  99.      printf("Error[%d] when listening...\n",errno);  
  100.      return 0;  
  101.   }  
  102.   printf("Finished listening...\n",errno);  
  103.   uid_t uid;  
  104.   connfd = unix_socket_accept(listenfd, &uid);  
  105.   unix_socket_close(listenfd);    
  106.   if(connfd<0)  
  107.   {  
  108.      printf("Error[%d] when accepting...\n",errno);  
  109.      return 0;  
  110.   }    
  111.    printf("Begin to recv/send...\n");    
  112.   int i,n,size;  
  113.   char rvbuf[2048];  
  114.   for(i=0;i<2;i++)  
  115.   {  
  116. //===========接收==============  
  117.    size = recv(connfd, rvbuf, 804, 0);     
  118.      if(size>=0)  
  119.      {  
  120.        // rvbuf[size]='\0';  
  121.         printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);  
  122.      }  
  123.      if(size==-1)  
  124.      {  
  125.          printf("Error[%d] when recieving Data:%s.\n",errno,strerror(errno));      
  126.              break;       
  127.      }  
  128. /* 
  129.  //===========发送============== 
  130.      memset(rvbuf, 'c', 2048); 
  131.          size = send(connfd, rvbuf, 2048, 0); 
  132.      if(size>=0) 
  133.      { 
  134.         printf("Data[%d] Sended.\n",size); 
  135.      } 
  136.      if(size==-1) 
  137.      { 
  138.          printf("Error[%d] when Sending Data.\n",errno);      
  139.              break;      
  140.      } 
  141. */  
  142.  sleep(30);  
  143.   }  
  144.    unix_socket_close(connfd);  
  145.    printf("Server exited.\n");      
  146.  }  

 

客户端代码

[cpp]  view plain  copy
 
  1. #include <stdio.h>  
  2. #include <stddef.h>  
  3. #include <sys/stat.h>  
  4. #include <sys/socket.h>  
  5. #include <sys/un.h>  
  6. #include <errno.h>  
  7. #include <string.h>  
  8.   
  9. /* Create a client endpoint and connect to a server.   Returns fd if all OK, <0 on error. */  
  10. int unix_socket_conn(const char *servername)  
  11. {   
  12.   int fd;   
  13.   if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)    /* create a UNIX domain stream socket */   
  14.   {  
  15.     return(-1);  
  16.   }  
  17.   int len, rval;  
  18.    struct sockaddr_un un;            
  19.   memset(&un, 0, sizeof(un));            /* fill socket address structure with our address */  
  20.   un.sun_family = AF_UNIX;   
  21.   sprintf(un.sun_path, "scktmp%05d", getpid());   
  22.   len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);  
  23.   unlink(un.sun_path);               /* in case it already exists */   
  24.   if (bind(fd, (struct sockaddr *)&un, len) < 0)  
  25.   {   
  26.      rval=  -2;   
  27.   }   
  28.   else  
  29.   {  
  30.     /* fill socket address structure with server's address */  
  31.       memset(&un, 0, sizeof(un));   
  32.       un.sun_family = AF_UNIX;   
  33.       strcpy(un.sun_path, servername);   
  34.       len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);   
  35.       if (connect(fd, (struct sockaddr *)&un, len) < 0)   
  36.       {  
  37.           rval= -4;   
  38.       }   
  39.       else  
  40.       {  
  41.          return (fd);  
  42.       }  
  43.   }  
  44.   int err;  
  45.   err = errno;  
  46.   close(fd);   
  47.   errno = err;  
  48.   return rval;      
  49. }  
  50.    
  51.  void unix_socket_close(int fd)  
  52.  {  
  53.     close(fd);       
  54.  }  
  55.   
  56.   
  57. int main(void)  
  58. {   
  59.   srand((int)time(0));  
  60.   int connfd;   
  61.   connfd = unix_socket_conn("foo.sock");  
  62.   if(connfd<0)  
  63.   {  
  64.      printf("Error[%d] when connecting...",errno);  
  65.      return 0;  
  66.   }  
  67.    printf("Begin to recv/send...\n");    
  68.   int i,n,size;  
  69.   char rvbuf[4096];  
  70.   for(i=0;i<10;i++)  
  71.   {  
  72. /* 
  73.     //=========接收===================== 
  74.     size = recv(connfd, rvbuf, 800, 0);   //MSG_DONTWAIT 
  75.      if(size>=0) 
  76.      { 
  77.         printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]); 
  78.      } 
  79.      if(size==-1) 
  80.      { 
  81.          printf("Error[%d] when recieving Data.\n",errno);    
  82.              break;      
  83.      } 
  84.          if(size < 800) break; 
  85. */  
  86.     //=========发送======================  
  87. memset(rvbuf,'a',2048);  
  88.          rvbuf[2047]='b';  
  89.          size = send(connfd, rvbuf, 2048, 0);  
  90.      if(size>=0)  
  91.      {  
  92.         printf("Data[%d] Sended:%c.\n",size,rvbuf[0]);  
  93.      }  
  94.      if(size==-1)  
  95.      {  
  96.         printf("Error[%d] when Sending Data:%s.\n",errno,strerror(errno));     
  97.             break;        
  98.      }  
  99.          sleep(1);  
  100.   }  
  101.    unix_socket_close(connfd);  
  102.    printf("Client exited.\n");      
  103.  }  

 

5、 讨论

经过实际测试，发现UNIXDomain Socket与命名管道在表现上有很大的类似性，例如，UNIX Domain Socket也会在磁盘上建立一个socket类型文件；若是读端进程关闭了，写端进程“写数据”时，有可能使进程异常退出，等等。查阅有关文档，摘录以下：

Send函数
当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲的 长度，若是len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；若是len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，若是是就等待协议把数据发送完，若是协议尚未开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么 send就比较s的发送缓冲区的剩余空间和len，若是len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，若是len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并非send把s的发送缓冲中的数据传到链接的另外一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。若是send函数copy数据成功，就返回实际copy的字节数，若是send在copy数据时出现错误，那么send就返回SOCKET_ERROR；若是send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。
要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，可是此时这些数据并不必定立刻被传到链接的另外一端。若是协议在后续的传送过程当中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，若是在等待时出现网络错误，那么该Socket函数就返回 SOCKET_ERROR）
注意：在Unix系统下，若是send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

Recv函数与send相似，看样子系统在实现各类IPC时，有些地方是复用的。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程