2. 程式人生 > >UNIX Domain Socket使用

UNIX Domain Socket使用

阿新 • • 發佈：2019-02-01

一、Socket概述

Socket最初用在基於TCP/IP網路間程序通訊中，以客戶端/伺服器模式進行通訊。

實現非同步操作，共享資源集中處理，提高客戶端響應能力。

Tcp通訊基本流程：

　　伺服器端                                                                       客戶端

　　1.建立socket                                                             1.建立socket

　　2.bind（）                                                                         

　　3.listen（）

　　4.accecp（）

　　----等待客戶端連線----                                                2.connect（）

　　5.讀資料（recv）                                                       3.寫資料（send）

　　6.寫資料（send）                                                      4.讀資料（recv）

　　7.關閉socket（closesocket（））                               5.關閉socket（closesocket（））

二、Unix domain socket

    Unix domain socket 或者 IPC socket是一種終端，可以使同一臺作業系統上的兩個或多個程序進行資料通訊。與管道相比，Unix domain sockets 既可以使用位元組流，又可以使用資料佇列，而管道通訊則只能使用位元組流。Unix domain sockets的介面和Internet socket很像，但它不使用網路底層協議來通訊。Unix domain socket 的功能是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 struct sockaddr * 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,int addrlen)
sockfd:socket返回的檔案描述符.
serv_addr:儲存了伺服器端的連線資訊.其中sin_add是服務端的地址
addrlen:serv_addr的長度
connect函式是客戶端用來同服務端連線的.成功時返回0,sockfd是同服務端通訊的檔案描述符失敗時返回-1

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

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

recv 和send的前3個引數等同於read和write。

flags引數值為0或：

flags 說明 recv send
 MSG_DONTROUTE 繞過路由表查詢    •
 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訊號，程序對該訊號的處理是程序終止。

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()返回的大小如果等於請求的大小，那麼很有可能是緩衝區還有資料未讀完，也意味著該次事件還沒有處理完，所以還需要再次讀取：

[cpp] view plain copy print?
  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)  
while(rs)
{
        buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
        if(buflen < 0)
       {
           // 由於是非阻塞的模式,所以當errno為EAGAIN時,表示當前緩衝區已無資料可讀
           // 在這裡就當作是該次事件已處理
           if(errno == EAGAIN)
              break;
           else
          return;
       } else if(buflen == 0)
[cpp] view plain copy print?
  1. {  
  2.   // 這裡表示對端的socket已正常關閉.  
  3. }  
  4. if(buflen != sizeof(buf))  
  5.         rs = 0;  
  6. else  
  7.         rs = 1;// 需要再次讀取  
       {
         // 這裡表示對端的socket已正常關閉.
       }
       if(buflen != sizeof(buf))
               rs = 0;
       else
               rs = 1;// 需要再次讀取
}

四、example

服務端：

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

	  if(size != sizeof(rvbuf))
               rs = 1;// 需要再次讀取
       else
               rs = 0;
   }while (rs);
/*
 //===========傳送==============
	 memset(rvbuf, 'c', 2048);
         size = send(connfd, rvbuf, 2048, 0);
	 if(size>=0)
	 {
		printf("Data[%d] Sended.\n",size);
	 }
	 if(size==-1)
	 {
	     printf("Error[%d] when Sending Data.\n",errno);	 
             break;		
	 }
*/
 sleep(30);
  }
   unix_socket_close(connfd);
   printf("Server exited.\n");    
 }

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

相關推薦

由一個簡單需求到Linux環境下的syslog、unix domain socket

message python domain 服務器 import 需求：回到頂部　　工作中有一個在Linux（debian8）環境下運行的服務器程序，用python語言實現，代碼中有不同優先級的日誌需要記錄，開發的時候都是使用python的logging模塊輸出到文件，示例代碼如下：　　

Unix domain socket 簡介

進程間通訊 ima cli strlen side 組件 errno doc i++ Unix domain socket 又叫 IPC(inter-process communication 進程間通信) socket，用於實現同一主機上的進程間通信。socket 原本是

go語言實現unix domain socket 客戶端/服務端

sock domain tin soc reader ted ips for urn /*server.go */package mainimport ( "bufio" "fmt" &quo

linux一切皆檔案之Unix domain socket描述符（二）

一、知識準備 1、在linux中，一切皆為檔案，所有不同種類的型別都被抽象成檔案（比如：塊裝置，socket套接字，pipe佇列） 2、操作這些不同的型別就像操作檔案一樣，比如增刪改查等 3、主要用於：執行在同一臺機器上的2個程序相互之間的資料通訊 4、它們和網路檔案描述符非常相似（比如：TCP

基於libevent和unix domain socket的本地server

https://www.pacificsimplicity.ca/blog/libevent-echo-server-tutorial 根據這一篇寫一個最簡單的demo。然後開始寫client。 client調優 client最初的程式碼如下： 1 #include <sys/socke

Linux下程序間通訊方式 - UNIX Domain Socket

概述 Linux下程序通訊方式有很多,比較典型的有套接字,平時比較常用的套接字是基於TCP/IP協議的,適用於兩臺不同主機上兩個程序間通訊, 通訊之前需要指定IP地址. 但是如果同一臺主機上兩個程序間通訊用套接字,還需要指定ip地址,有點過於繁瑣. 這個時候就需要用到UNIX Domain Sock

UNIX Domain Socket

Unix domain socket 又叫 IPC(inter-process communication 程序間通訊) socket，用於實現同一主機上的程序間通訊。socket 原本是為網路通訊設計的，但後來在 socket 的框架上發展出一種 IPC 機制，就是 UNIX domain soc

android原始碼中採用Unix Domain Socket跨程序通訊

      今天看android原始碼Zygote程序啟動流程，無意間發現使用了一種檔案描述符作為跨程序通訊的地址，於是仔細研究了一下：  從字面來理解是傳統的Socket使用，但個人覺得不應該是，特地找資料學習了一下，下面的介紹比較詳細到位。又進一步瞭解一下，使用的其實是

linux一切皆檔案之Unix domain socket描述符

一、知識準備 1、在linux中，一切皆為檔案，所有不同種類的型別都被抽象成檔案（比如：塊裝置，socket套接字，pipe佇列） 2、操作這些不同的型別就像操作檔案一樣，比如增刪改查等 二、環境準備 元件 版本 OS CentOS Linux release 7.5.1804

UNIX DOMAIN SOCKET效率

nvidia 4.5 1.3 但是 效率 cti work mman running 關於UNIX DOMAIN SOCKET和普通udp socket的對比 在TX1（4核A57 1.7GHz）的板卡上進行測試，每個包大小設置為1024，全速收發，UDS的速度在90Mbp

[外一篇]關於Unix Domain Socket

咋一看名字，雖然有個socket，但是它的用場和常說的“網路”socket有所不同。它實際上是一種本地IPC，以socket為名是因為它和普通socket使用的介面是一致的。 雖說普通的socket也可以用作本地IPC，但是從效率上和功能上，要遜於Unix Domain

unix Domain socket(python)

1. unix Domain Socket 簡介 Unix Domain Socket通常稱為 【unix域套介面】 或 【本地套介面】，它用於位於同一臺機器（作業系統）的程序間通訊。它已經被納入POSIX Operating Systems標準。 它支援以

UNIX Domain Socket使用

一、Socket概述 Socket最初用在基於TCP/IP網路間程序通訊中，以客戶端/伺服器模式進行通訊。 實現非同步操作，共享資源集中處理，提高客戶端響應能力。 Tcp通訊基本流程： 　　伺服器端                                                  

如何獲得unix domain socket的對端PID

1. 什麼是unix domain socket 2. 有兩種方法，第一種是通過猜測，第二種是debug linux核心 第一種方法的示例： [[email protected] ipc]$ /usr/sbin/lsof -p 31854 COMMAND

使用psql命令基於udp(unix-domain-socket)協議連線postgresql資料庫

對於資料庫連線而言，通過netstat可以檢視當前連線協議，是udp還是tcp（包括ipv4和ipv6）。 實驗1： 如果本地直接使用psql命令連線，則為udp： 視窗1： postgres@pgdb-> psql psql (9.5.7) T

socket unix domain IPC程式碼示例

僅供參考： 服務端：socket->bind->listen->send/recv->close 客戶端：socket->bind->connect->send/recv->close #include <sys/socke

Impala cannot read or execute the parent directory of dfs.domain.socket.path

valid short-circuit reads configuration: Impala cannot read or execute the parent directory of dfs.domain.socket.path 解決方法： 1、去HDFS中找到dfs.

unix域socket繫結路徑不建立檔案問題[c語言]

unix域socket繫結地址時，需要指定一個檔案路徑，存在兩種情況： （1）socket自動建立一個bind指定的檔案路徑對應的檔案  （2）不需要建立socket檔案，只需要命名一個全域性名字即可讓客戶端根據此名字進行連線。後者的實現過程與前者的差別是，後者在對地址結構

UNIX域Socket名稱空間

socket程序通訊命名方式有兩種：1、普通名稱空間  2、抽象名稱空間 1、普通名稱空間： socket會根據此命名建立一個同名的socket檔案，客戶端連線的時候讀取該socket檔案連結到soc

MySQL故障處理一例_Another MySQL daemon already running with the same unix socket

read mon 解決 roo blog local 啟動mysql style 處理 MySQL故障處理一例：“Another MySQL daemon already running with the same unix socket”。 [root@test-121