进程间通信的利器——unix域套接字编程详解

背景

最近项目中使用unix域数据报套接字实现线程间通信，在此总结一下。

进程间通信

进程间通信的方式很多，包括管道、FIFO、消息队列、信号量、共享内存unix域套接字等。

管道

一般是半双工的，只能在具有公共祖先的两个进程间使用。

#include <unistd.h>

int pipe(int fd[2]);/* 成功返回0，失败返回-1 */

FIFO

命名管道，可以在两个独立的进程间交换数据。

#include <sys/stat.h>

int mkfifo(const char *path, mode_t mode);/* 成功返回0，失败返回-1 */
int mkfifoat(int fd, const char *path, mode_t mode);/* 成功返回0，失败返回-1 */

消息队列

存储在内核中的消息链表，由消息队列标识符标识。

#include <sys/msg.h>

int msgget(key_t key, int flag);/* 成功返回消息队列id，失败返回-1 */

int msgctl(int msgid, int cmd, struct msqid_ds *buf);/* 成功返回0，失败返回-1 */

int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag);/* 成功返回0，失败返回-1 */

ssize_t msgrcv(int msqid, void *ptr, size_t nbytes, long byte, int flag);

信号量

计数器，用于为多个进程提供对共享数据对象的访问。

#include <sys/sem.h>

int semget(key_t key, int nsems, int flag);/* 成功返回信号量id，失败返回-1 */

int semctl(int semid, int semnum, int cmd, ...);/* union semun arg */

int semop(int semid, struct sembuf semoparray[], size_t nops);/* 成功返回0，失败返回-1 */

共享内存

允许两个或多个进程共享一个给定的存储区。数据不需要在客户进程和服务器进程之间复制，速度很快。

#include <sys/shm.h>

int shmget(key_t key, size_t size, int flag);/* 成功返回共享内存id，失败返回-1 */

int shmctl(int shmid, int cmd, struct shmid_ds *buf);/* 成功返回0，失败返回-1 */

void *shmat(int shmid, const void *addr, int flag);/* 成功返回指向共享存储段的指针，失败返回-1 */

int shmdt(const void *addr);/* 成功返回0，失败返回-1 */

unix域套接字

用于同一台pc上运行的进程之间通信，它仅仅复制数据，不执行协议处理，不需要增加删除网络报头，无需计算校验和，不产生顺序号，无需发送确认报文。

unix域套接字简介

简介

unix域协议并不是一个实际的协议族，而是在单个主机上执行客户/服务器通信的一种方法。

它提供两类套接字，字节流和数据报，分别类似于TCP和UDP。

使用unix域套接字的三个好处：

• unix域套接字通常比通信两端位于同一个主机的TCP套接字快出一倍
• unix域套接字可用于在同一个主机上的不同进程之间传递描述符
• unix能够提供额外的安全检查措施，较新的实现把客户的凭证（用户ID和组ID）提供给服务器

unix域套接字中用于标识客户和服务器的协议地址是普通文件系统中的路径名。

unix域套接字地址结构

unix域套接字地址结构如下定义：

#include <sys/un.h>

struct sockaddr_un {
    sa_family_t sun_family;/* AF_LOCAL */
    char sun_path[104];/* 以空字符结尾的字符串 */
}

socketpair函数

socketpair函数创建两个随后连接起来的套接字，本函数仅适用于unix域套接字。

#include <sys/socket.h>

int socketpair(int family, int type, int protocol, int sockfd[2]);/* 成功返回非0，失败返回-1 */

其中，family为AF_LOCAL, protocol为0，type可以为SOCK_STREAM或者SOCK_DGRAM。新创建的两个套接字描述符作为sockfd[0],sockfd[1]返回。

该函数与unix的pipe函数类似，返回两个彼此连接的描述符

unix域套接字实现

以下实例参考《unix网络编程》。

使用字节流模式实现客户/服务器回射程序

服务器端程序：

#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>

#define MAXLINE 4096
#define LISTENQ 1024
#define UNIX_STREAM_PATH "/tmp/unix_stream_path"

void str_echo(int sockfd)
{
    ssize_t n;
    char buf[MAXLINE];

again:
    while ((n = read(sockfd, buf, MAXLINE)) > 0) {
        write(sockfd, buf, n);
    }

    if (n < 0 && errno == EINTR) {
        goto again;
    } else if (n < 0) {
        printf("str_echo read error: %s\n", strerror(errno));
        exit(-1);
    }
}
int main(int argc, char **argv)
{
    int ret;
    int listenfd, connfd;
    pid_t childpid;
    socklen_t clilen;
    struct sockaddr_un cliaddr, servaddr;

    listenfd = socket(AF_LOCAL, SOCK_STREAM, 0);
    if (listenfd < 0) {
        printf("socket error: %s\n", strerror(errno));
        return -1;
    }

    unlink(UNIX_STREAM_PATH);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_LOCAL;
    strncpy(servaddr.sun_path, UNIX_STREAM_PATH, sizeof(servaddr.sun_path) - 1);

    ret = bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if (ret) {
        printf("bind error: %s\n", strerror(errno));
        return -1;
    }

    ret = listen(listenfd, LISTENQ);
    if (ret) {
        printf("listen error: %s\n", strerror(errno));
        return -1;
    }

    while (1) {
        clilen = sizeof(cliaddr);
        if ((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0) {
            if (errno == EINTR) {
                continue;
            } else {
                printf("accept error: %s\n", strerror(errno));
                return -1;
            }
        }

        if ((childpid = fork()) == 0) {
            /* child close listening socket and process connected socket */
            close(listenfd);
            str_echo(connfd);
            exit(0);
        }
        /* parent close connected socket */
        close(connfd);
    }
}

客户端：

#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/select.h>

#define MAXLINE 4096
#define UNIX_STREAM_PATH "/tmp/unix_stream_path"

int max(int a, int b)
{
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

void str_cli(FILE *fp, int sockfd)
{
    int maxfdp1, stdineof;
    fd_set rset;
    char buf[MAXLINE];
    int n;

    stdineof = 0;
    FD_ZERO(&rset);

    while (1) {
        if (stdineof == 0) {
            FD_SET(fileno(fp), &rset);
        }
        FD_SET(sockfd, &rset);
        maxfdp1 = max(fileno(fp), sockfd) + 1;

        select(maxfdp1, &rset, NULL, NULL, NULL);

        if (FD_ISSET(sockfd, &rset)) {
            if ((n = read(sockfd, buf, MAXLINE)) == 0) {
                if (stdineof == 1) {
                    return;
                } else {
                    printf("str_cli: server terminated prenatruely\n");
                    exit(-1);
                }
            }
            write(fileno(stdout), buf, n);
        }

        if (FD_ISSET(fileno(fp), &rset)) {
            if ((n = read(fileno(fp), buf, MAXLINE)) == 0) {
                stdineof = 1;
                shutdown(sockfd, SHUT_WR);
                FD_CLR(fileno(fp), &rset);
                continue;
            }
            write(sockfd, buf, n);
        }
    }
}

int main(int argc, char **argv)
{
    int ret, sockfd;
    struct sockaddr_un servaddr;

    sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_LOCAL;
    strncpy(servaddr.sun_path, UNIX_STREAM_PATH, sizeof(servaddr.sun_path));

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    str_cli(stdin, sockfd);

    return 0;
}

使用数据报模式实现客户/服务器回射程序

服务器端：

#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>

#define MAXLINE 4096
#define UNIX_DGRAM_PATH "/tmp/unix_dgram_path"

void dg_echo(int sockfd, struct sockaddr *pcliaddr, socklen_t clilen)
{
    int n;
    socklen_t len;
    char mesg[MAXLINE];

    while(1) {
        len = clilen;
        n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

        sendto(sockfd, mesg, n, 0, pcliaddr, len);
    }
}

int main(int argc, char **argv)
{ 
    int ret, sockfd;
    struct sockaddr_un cliaddr, servaddr;

    sockfd = socket(AF_LOCAL, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        printf("socket error: %s\n", strerror(errno));
        return -1;
    }

    unlink(UNIX_DGRAM_PATH);
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_LOCAL;
    strncpy(servaddr.sun_path, UNIX_DGRAM_PATH, sizeof(servaddr.sun_path) - 1);

    ret = bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if (ret) {
        printf("bind error: %s\n", strerror(errno));
        return -1;
    }

    dg_echo(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));

}

客户端：

#include <stdio.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>

#define MAXLINE 4096
#define UNIX_DGRAM_PATH "/tmp/unix_dgram_path"

void dg_cli(FILE *fp, int sockfd, const struct sockaddr *pservaddr, socklen_t servlen)
{
    int n;
    char sendline[MAXLINE], recvline[MAXLINE + 1];

    while (fgets(sendline, MAXLINE, fp) != NULL) {
        sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

        n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);

        recvline[n] = 0;
        fputs(recvline, stdout);
    }
}

int main(int argc, char **argv)
{ 
    int ret, sockfd;
    struct sockaddr_un cliaddr, servaddr;

    sockfd = socket(AF_LOCAL, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        printf("socket error: %s\n", strerror(errno));
        return -1;
    }

    bzero(&cliaddr, sizeof(cliaddr));
    cliaddr.sun_family = AF_LOCAL;
    strncpy(cliaddr.sun_path, tmpnam(NULL), sizeof(cliaddr.sun_path) - 1);

    ret = bind(sockfd, (struct sockaddr *)&cliaddr, sizeof(cliaddr));
    if (ret) {
        printf("bind error: %s\n", strerror(errno));
        return -1;
    }

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_LOCAL;
    strncpy(servaddr.sun_path, UNIX_DGRAM_PATH, sizeof(servaddr.sun_path) - 1);

    dg_cli(stdin, sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    return 0;
}