About AF_LOCAL in Linux

About AF_LOCAL in Linux

一、Unix domain socket

    Unix domain socket 或者 IPC socket是一种终端，可以使同一台操作系统上的两个或多个进程进行数据通信。与管道相比，Unix domain sockets 既可以使用字节流，又可以使用数据队列，而管道通信则只能使用字节流。Unix domain sockets的接口和Internet socket很像，但它不使用网络底层协议来通信。Unix domainsocket 的功能是POSIX操作系统里的一种组件。

   Unix domain sockets 使用系统文件的地址来作为自己的身份。它可以被系统进程引用。所以两个进程可以同时打开一个Unix domain sockets来进行通信。不过这种通信方式是发生在系统内核里而不会在网络里传播。

   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通讯的。

     因为应用于IPC，所以UNIXDomain socket不需要IP和端口，取而代之的是文件路径来表示“网络地址”，这点体现在下面两个方面：

  1. 地址格式不同，UNIXDomain socket用结构体sockaddr_un表示，是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。   

   2. UNIX Domain Socket客户端一般要显式调用bind函数，而不象网络socket一样依赖系统自动分配的地址。客户端bind的socket文件名可以包含客户端的pid，这样服务器就可以区分不同的客户端。

二、相关API

·  int socket(int domain, int type, int protocol)

domain:说明我们网络程序所在的主机采用的通讯协族(AF_UNIX和AF_INET等). AF_UNIX只能够用于单一的Unix系统进程间通信,而AF_INET是针对Internet的,因而可以允许在远程主机之间通信
type:我们网络程序所采用的通讯协议(SOCK_STREAM,SOCK_DGRAM等) SOCK_STREAM表明我们用的是TCP协议,这样会提供按顺序的,可靠,双向,面向连接的比特流. SOCK_DGRAM 表明我们用的是UDP协议,这样只会提供定长的,不可靠,无连接的通信.
protocol:由于我们指定了type,所以这个地方我们一般只要用0来代替就可以了。
socket为网络通讯做基本的准备.成功时返回文件描述符,失败时返回-1,看errno可知道出错的详细情况。

·  int bind( int sockfd , const structsockaddr * my_addr, socklen_t addrlen)

sockfd:是由socket调用返回的文件描述符.
addrlen:是sockaddr结构的长度.
my_addr:是一个指向sockaddr的指针. 在中有 sockaddr的定义
struct sockaddr{
unisgned short as_family;
char sa_data[14];
};

·  int listen(int sockfd,int backlog)

sockfd:是bind后的文件描述符.
backlog:设置请求排队的最大长度.当有多个客户端程序和服务端相连时, 使用这个表示可以介绍的排队长度. listen函数将bind的文件描述符变为监听套接字.返回的情况和bind一样.

·  int accept(int sockfd, struct sockaddr *addr,int *addrlen)
sockfd:是listen后的文件描述符.
addr,addrlen是用来给客户端的程序填写的,服务器端只要传递指针就可以了. bind,listen和accept是服务器端用的函数,accept调用时,服务器端的程序会一直阻塞到有一个客户程序发出了连接. accept成功时返回最后的服务器端的文件描述符,这个时候服务器端可以向该描述符写信息了. 失败时返回-1

过程：有人从很远的地方通过一个你在侦听(listen())的端口连接(connect())到你的机器。它的连接将加入到等待接受(accept())的队列中。你调用accept()告诉它你有空闲的连接。它将返回一个新的套接字文件描述符！这样你就有两个套接字了，原来的一个还在侦听你的那个端口，新的在准备发送(send())和接收(recv())数据。这就是Linux Accept函数的过程！

Ps：linux Accept函数注意事项，在系统调用send()和recv()中你应该使用新的套接字描述符new_fd。如果你只想让一个连接进来，那么你可以使用close()去关闭原来的文件描述符sockfd来避免同一个端口更多的连接。

·  int connect(int sockfd, struct sockaddr * serv_addr,intaddrlen)
sockfd:socket返回的文件描述符.
serv_addr:储存了服务器端的连接信息.其中sin_add是服务端的地址
addrlen:serv_addr的长度
connect函数是客户端用来同服务端连接的.成功时返回0,sockfd是同服务端通讯的文件描述符失败时返回-1

·  ssize_t send(int sockfd, const void *buff, size_t nbytes, intflags)

recv 和send的前3个参数等同于read和write。

flags参数值为0或：

flags
MSG_DONTROUTE	说明	recv	send
MSG_DONTWAIT	绕过路由表查找		•
MSG_OOB	仅本操作非阻塞	•	•
MSG_PEEK	发送或接收带外数据	•	•
MSG_WAITALL	窥看外来消息	•
	等待所有数据	•

1. send解析

sockfd：指定发送端套接字描述符。

buff：    存放要发送数据的缓冲区

nbytes:  实际要改善的数据的字节数

flags：   一般设置为0

1) send先比较发送数据的长度nbytes和套接字sockfd的发送缓冲区的长度，如果nbytes > 套接字sockfd的发送缓冲区的长度, 该函数返回SOCKET_ERROR;

2) 如果nbtyes <= 套接字sockfd的发送缓冲区的长度，那么send先检查协议是否正在发送sockfd的发送缓冲区中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送sockfd的发送缓冲区中的数据或者sockfd的发送缓冲区中没有数据，那么send就比较sockfd的发送缓冲区的剩余空间和nbytes

3) 如果 nbytes > 套接字sockfd的发送缓冲区剩余空间的长度，send就一起等待协议把套接字sockfd的发送缓冲区中的数据发送完

4) 如果 nbytes < 套接字sockfd的发送缓冲区剩余空间大小，send就仅仅把buf中的数据copy到剩余空间里(注意并不是send把套接字sockfd的发送缓冲区中的数据传到连接的另一端的，而是协议传送的，send仅仅是把buf中的数据copy到套接字sockfd的发送缓冲区的剩余空间里)。

5) 如果send函数copy成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR; 如果在等待协议传送数据时网络断开，send函数也返回SOCKET_ERROR。

6) send函数把buff中的数据成功copy到sockfd的改善缓冲区的剩余空间后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个socket函数就会返回SOCKET_ERROR。（每一个除send的socket函数在执行的最开始总要先等待套接字的发送缓冲区中的数据被协议传递完毕才能继续，如果在等待时出现网络错误那么该socket函数就返回SOCKET_ERROR）

7) 在unix系统下，如果send在等待协议传送数据时网络断开，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的处理是进程终止。

·  ssize_t recv(int sockfd, void *buff, size_t nbytes, intflags);

2.recv函数

sockfd: 接收端套接字描述符

buff：   用来存放recv函数接收到的数据的缓冲区

nbytes: 指明buff的长度

flags:  一般置为0

   1) recv先等待s的发送缓冲区的数据被协议传送完毕，如果协议在传送sock的发送缓冲区中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR

   2) 如果套接字sockfd的发送缓冲区中没有数据或者数据被协议成功发送完毕后，recv先检查套接字sockfd的接收缓冲区，如果sockfd的接收缓冲区中没有数据或者协议正在接收数据，那么recv就一起等待，直到把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲区中的数据copy到buff中（注意协议接收到的数据可能大于buff的长度，所以在这种情况下要调用几次recv函数才能把sockfd的接收缓冲区中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的）

   3) recv函数返回其实际copy的字节数，如果recv在copy时出错，那么它返回SOCKET_ERROR。如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

   4) 在unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用 recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

ps:读数据的时候需要考虑的是当recv()返回的大小如果等于请求的大小，那么很有可能是缓冲区还有数据未读完，也意味着该次事件还没有处理完，所以还需要再次读取：

1.     while(rs)  

2.     {  

3.             buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);  

4.             if(buflen < 0)  

5.            {  

6.                // 由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可读  

7.                // 在这里就当作是该次事件已处理  

8.                if(errno == EAGAIN)  

9.                   break;  

10.            else  

11.           return;  

12.        } else if(buflen == 0)  

1.     {  

2.       // 这里表示对端的socket已正常关闭.  

3.     }  

4.     if(buflen != sizeof(buf))  

5.             rs = 0;  

6.     else  

7.             rs = 1;// 需要再次读取  

三、example

服务端：

1.     #include   

2.     #include   

3.     #include   

4.     #include   

5.     #include   

6.     #include   

7.     #include   

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, rs;  

113.     char rvbuf[2048];  

114.      for(i=0;i<2;i++)  

115.     {  

116.        //===========接收==============  

117.      do  

118.       {  

119.        size = recv(connfd, rvbuf, 804, 0);     

120.         if(size>=0)  

121.        {  

122.           // rvbuf[size]='\0';  

123.           printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);  

124.         }  

125.        if(size==-1)  

126.         {  

127.            printf("Error[%d] when recieving Data:%s.\n",errno,strerror(errno));      

128.                 break;       

129.        }  

130.      

131.         if(size != sizeof(rvbuf))  

132.                   rs = 1;// 需要再次读取  

133.          else  

134.                   rs = 0;  

135.      }while (rs);  

136.    /* 

137.    //===========发送============== 

138.         memset(rvbuf, 'c', 2048); 

139.            size = send(connfd, rvbuf, 2048, 0); 

140.         if(size>=0) 

141.        { 

142.            printf("Data[%d] Sended.\n",size); 

143.        } 

144.         if(size==-1) 

145.        { 

146.             printf("Error[%d] when Sending Data.\n",errno);      

147.                break;      

148.         } 

149.   */  

150.     sleep(30);  

151.     }  

152.       unix_socket_close(connfd);  

153.      printf("Server exited.\n");      

154.     }  

客户端：

1.     #include   

2.     #include   

3.     #include   

4.     #include   

5.     #include   

6.     #include   

7.     #include   

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.    }