Linux进程间通信方式--本地socket

客官°小女子只卖身不卖艺 2022-09-18 11:56 207阅读 0赞

先上一个代码

服务端：

//s_unix.c
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/un.h> 
    #define UNIX_DOMAIN "/tmp/UNIX.domain"
    int main(void)
    {
        socklen_t clt_addr_len;
        int listen_fd;
        int com_fd;
        int ret;
        int i;
        static char recv_buf[1024]; 
        int len;
        struct sockaddr_un clt_addr;
        struct sockaddr_un srv_addr;
        listen_fd=socket(PF_UNIX,SOCK_STREAM,0);
        if(listen_fd<0)
        {
            perror("cannot create communication socket");
            return 1;
        }  
        
        //set server addr_param
        srv_addr.sun_family=AF_UNIX;
        strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1);
        unlink(UNIX_DOMAIN);
        //bind sockfd & addr
        ret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));
        if(ret==-1)
        {
            perror("cannot bind server socket");
            close(listen_fd);
            unlink(UNIX_DOMAIN);
            return 1;
        }
        //listen sockfd 
        ret=listen(listen_fd,1);
        if(ret==-1)
        {
            perror("cannot listen the client connect request");
            close(listen_fd);
            unlink(UNIX_DOMAIN);
            return 1;
        }
        //have connect request use accept
        len=sizeof(clt_addr);
        com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len);
        if(com_fd<0)
        {
            perror("cannot accept client connect request");
            close(listen_fd);
            unlink(UNIX_DOMAIN);
            return 1;
        }
        //read and printf sent client info
        printf("/n=====info=====/n");
        for(i=0;i<4;i++)
        {
            memset(recv_buf,0,1024);
            int num=read(com_fd,recv_buf,sizeof(recv_buf));
            printf("Message from client (%d)) :%s/n",num,recv_buf);  
        }
        close(com_fd);
        close(listen_fd);
        unlink(UNIX_DOMAIN);
        return 0;
    }

客户端：

//c_unix.c
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/un.h>
    #define UNIX_DOMAIN "/tmp/UNIX.domain"
    int main(void)
    {
        int connect_fd;
        int ret;
        char snd_buf[1024];
        int i;
        static struct sockaddr_un srv_addr;
    //creat unix socket
        connect_fd=socket(PF_UNIX,SOCK_STREAM,0);
        if(connect_fd<0)
        {
            perror("cannot create communication socket");
            return 1;
        }   
        srv_addr.sun_family=AF_UNIX;
        strcpy(srv_addr.sun_path,UNIX_DOMAIN);
    //connect server
        ret=connect(connect_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));
        if(ret==-1)
        {
            perror("cannot connect to the server");
            close(connect_fd);
            return 1;
        }
        memset(snd_buf,0,1024);
        strcpy(snd_buf,"message from client");
    //send info server
        for(i=0;i<4;i++)
            write(connect_fd,snd_buf,sizeof(snd_buf));
        close(connect_fd);
        return 0;
    }

使用套接字除了可以实现网络间不同主机间的通信外，还可以实现同一主机的不同进程间的通信，且建立的通信是双向的通信。**socket**进程通信与网络通信使用的是统一套接口，只是地址结构与某些参数不同。

一、创建**[socket][]**流程

（1）创建socket，类型为AF\_LOCAL或AF\_UNIX，表示用于进程通信：

创建套接字需要使用 socket 系统调用，其原型如下：

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

其中，domain 参数指定协议族，对于本地套接字来说，其值须被置为 AF\_UNIX 枚举值；type 参数指定套接字类型，protocol 参数指定具体协议；type 参数可被设置为 SOCK\_STREAM（流式套接字）或 SOCK\_DGRAM（数据报式套接字），protocol 字段应被设置为 0；其返回值为生成的套接字描述符。

对于本地套接字来说，流式套接字（SOCK\_STREAM）是一个有顺序的、可靠的双向字节流，相当于在本地进程之间建立起一条数据通道；数据报式套接字（SOCK\_DGRAM）相当于单纯的发送消息，在进程通信过程中，理论上可能会有信息丢失、复制或者不按先后次序到达的情况，但由于其在本地通信，不通过外界网络，这些情况出现的概率很小。

二、命名**socket**。

SOCK\_STREAM 式本地套接字的通信双方均需要具有本地地址，其中服务器端的本地地址需要明确指定，指定方法是使用 struct sockaddr\_un 类型的变量。

struct sockaddr\_un \{  
    sa\_family\_t     sun\_family;     /\* AF\_UNIX \*/  
    char    sun\_path\[UNIX\_PATH\_MAX\];        /\* 路径名 \*/  
\};

这里面有一个很关键的东西，socket进程通信命名方式有两种。一是普通的命名，socket会根据此命名创建一个同名的socket文件，客户端连接的时候通过读取该socket文件连接到socket服务端。这种方式的弊端是服务端必须对socket文件的路径具备写权限，客户端必须知道socket文件路径，且必须对该路径有读权限。

另外一种命名方式是抽象命名空间，这种方式不需要创建socket文件，只需要命名一个全局名字，即可让客户端根据此名字进行连接。后者的实现过程与前者的差别是，后者在对地址结构成员sun\_path数组赋值的时候，必须把第一个字节置0，即sun\_path\[0\] = 0，下面用代码说明：

第一种方式：

//name the server socket 
    	server_addr.sun_family = AF_UNIX;
    	strcpy(server_addr.sun_path,"/tmp/UNIX.domain");
    	server_len = sizeof(struct sockaddr_un);
    	client_len = server_len;

第二种方式：

#define SERVER_NAME @socket_server

//name the socket
        server_addr.sun_family = AF_UNIX;
        strcpy(server_addr.sun_path, SERVER_NAME);
        server_addr.sun_path[0]=0;
        //server_len = sizeof(server_addr);
        server_len = strlen(SERVER_NAME)  + offsetof(struct sockaddr_un, sun_path);

其中，offsetof函数在\#include <stddef.h>头文件中定义。因第二种方式的首字节置0，我们可以在命名字符串SERVER\_NAME前添加一个占位字符串，例如:

#define SERVER_NAME @socket_server

前面的@符号就表示占位符，不算为实际名称。

**提示：**客户端连接服务器的时候，必须与服务端的命名方式相同，即如果服务端是普通命名方式，客户端的地址也必须是普通命名方式；如果服务端是抽象命名方式，客户端的地址也必须是抽象命名方式。

三、绑定

SOCK\_STREAM 式本地套接字的通信双方均需要具有本地地址，其中服务器端的本地地址需要明确指定，指定方法是使用 struct sockaddr\_un 类型的变量，将相应字段赋值，再将其绑定在创建的服务器套接字上，绑定要使用 bind 系统调用，其原形如下：

int bind(int socket, const struct sockaddr \*address, size\_t address\_len);

其中**[ socket][socket]**表示服务器端的套接字描述符，address 表示需要绑定的本地地址，是一个 struct sockaddr\_un 类型的变量，address\_len 表示该本地地址的字节长度。实现服务器端地址指定功能的代码如下（假设服务器端已经通过上文所述的 socket 系统调用创建了套接字，server\_sockfd 为其套接字描述符）：  
struct sockaddr\_un server\_address;  
server\_address.sun\_family = AF\_UNIX;  
strcpy(server\_address.sun\_path, "Server Socket");  
bind(server\_sockfd, (struct sockaddr\*)&server\_address, sizeof(server\_address));

客户端的本地地址不用显式指定，只需能连接到服务器端即可，因此，客户端的 struct sockaddr\_un 类型变量需要根据服务器的设置情况来设置，代码如下（假设客户端已经通过上文所述的 socket 系统调用创建了套接字，client\_sockfd 为其套接字描述符）：  
struct sockaddr\_un client\_address;  
client\_address.sun\_family = AF\_UNIX;  
strcpy(client\_address.sun\_path, "Server Socket");

四、监听  
服务器端套接字创建完毕并赋予本地地址值（名称，本例中为Server Socket）后，需要进行监听，等待客户端连接并处理请求，监听使用 listen 系统调用，接受客户端连接使用accept系统调用，它们的原形如下：  
int listen(int socket, int backlog);  
int accept(int socket, struct sockaddr \*address, size\_t \*address\_len);  
其中 socket 表示服务器端的套接字描述符；backlog 表示排队连接队列的长度（若有多个客户端同时连接，则需要进行排队）；address 表示当前连接客户端的本地地址，该参数为输出参数，是客户端传递过来的关于自身的信息；address\_len 表示当前连接客户端本地地址的字节长度，这个参数既是输入参数，又是输出参数。实现监听、接受和处理的代码如下：  
\#define MAX\_CONNECTION\_NUMBER 10  
int server\_client\_length, server\_client\_sockfd;  
struct sockaddr\_un server\_client\_address;  
listen(server\_sockfd, MAX\_CONNECTION\_NUMBER);  
while(1)  
\{  
    // ...... (some process code)  
    server\_client\_length　＝　sizeof(server\_client\_address);  
    server\_client\_sockfd = accept(server\_sockfd, (struct sockaddr\*)＆server\_client\_address, &server\_client\_length);  
    // ...... (some process code)  
\}  
这里使用死循环的原因是服务器是一个不断提供服务的实体，它需要不间断的进行监听、接受并处理连接，本例中，每个连接只能进行串行处理，即一个连接处理完后，才能进行后续连接的处理。如果想要多个连接并发处理，则需要创建线程，将每个连接交给相应的线程并发处理。  
客户端套接字创建完毕并赋予本地地址值后，需要连接到服务器端进行通信，让服务器端为其提供处理服务。对于 SOCK\_STREAM 类型的流式套接字，需要客户端与服务器之间进行连接方可使用。连接要使用 connect 系统调用，其原形为

int connect(int socket, const struct sockaddr \*address, size\_t address\_len);

其中socket为客户端的套接字描述符，address表示当前客户端的本地地址，是一个 struct sockaddr\_un 类型的变量，address\_len 表示本地地址的字节长度。实现连接的代码如下：  
connect(client\_sockfd, (struct sockaddr\*)&client\_address, sizeof(client\_address));  
无论客户端还是服务器，都要和对方进行数据上的交互，这种交互也正是我们进程通信的主题。一个进程扮演客户端的角色，另外一个进程扮演服务器的角色，两个进程之间相互发送接收数据，这就是基于本地套接字的进程通信。发送和接收数据要使用 write 和 read 系统调用，它们的原形为：  
int read(int socket, char \*buffer, size\_t len);  
int write(int socket, char \*buffer, size\_t len);  
其中 socket 为套接字描述符；len 为需要发送或需要接收的数据长度；对于 read 系统调用，buffer 是用来存放接收数据的缓冲区，即接收来的数据存入其中，是一个输出参数；对于 write 系统调用，buffer 用来存放需要发送出去的数据，即 buffer 内的数据被发送出去，是一个输入参数；返回值为已经发送或接收的数据长度。例如客户端要发送一个 "Hello" 字符串给服务器，则代码如下：  
char buffer\[10\] = "Hello";  
write(client\_sockfd, buffer, strlen(buffer));  
交互完成后，需要将连接断开以节省资源，使用close系统调用，其原形为：  
int close(int socket);  
不多说了，直接使用，大家一定都会，呵呵！  
上面所述的每个系统调用都有 -1 返回值，在调用不成功时，它们均会返回 -1，这个特性可以使得我们用 if - else 或异常处理语句来处理错误，为我们提供了很大的方便。  
SOCK\_DGRAM 数据报式本地套接字的应用场合很少，因为流式套接字在本地的连接时间可以忽略，所以效率并没有提高，而且发送接收都需要携带对方的本地地址，因此很少甚至几乎不使用。  
与本地套接字相对应的是网络套接字，可以用于在网络上传送数据，换言之，可实现不同机器上的进程通信过程。在 TCP/IP 协议中，IP 地址的首字节为 127 即代表本地，因此本地套接字通信可以使用 IP 地址为 127.x.x.x 的网络套接字来实现。

[socket]: http://blog.csdn.net/shanzhizi