板凳--------57.Linux/Unix 系统编程手册(下) -- SOCKET : Unix domain

https://blog.51cto.com/u_15567199/5204540

【linux网络编程】容错处理文件 wrap.h、wrap.c_wx623c6c9.

// 容错处理 wrap.h
#ifndef _WRAP_H_
#define _WRAP_H_

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <error.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>

void perr_exit(const char *str);
int Socket(int domain, int type, int protocol);
int Bind(int sockfd, const struct sockaddr *addr,
         socklen_t addrlen);
int Listen(int sockfd, int backlog);
int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int Connect(int sockfd, const struct sockaddr *addr,
            socklen_t addrlen);
ssize_t Read(int fd, void *buf, size_t count);
ssize_t Write(int fd, const void *buf, size_t count);

int Close(int fd);
#endif


//  wrap.c
#include "wrap.h"

void perr_exit(const char *str)
{
    perr_exit(str);
    exit(1);
}

int Socket(int domain, int type, int protocol)
{
    int n;
    if ((n = socket(domain, type, protocol)) < 0)
    {
        perr_exit("socket error");
    }

    return n;
}

int Bind(int sockfd, const struct sockaddr *addr,
         socklen_t addrlen)
{
    int n;
    if ((n = bind(sockfd, addr, addrlen)) < 0)
    {
        perr_exit("bind error");
    }
    return n;
}

int Listen(int sockfd, int backlog)
{
    int n;
    if ((n = listen(sockfd, backlog)) < 0)
    {
        perr_exit("listen error");
    }
    return n;
}
int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
    int n;
again:
    if ((n = accept(sockfd, addr, addrlen)) < 0)
    {
        if ((errno == ECONNABORTED) || (errno == EINTR))
        {
            goto again;
        }
        else
        {
            perr_exit("accept error");
        }
    }
    return n;
}
int Connect(int sockfd, const struct sockaddr *addr,
            socklen_t addrlen)
{
    int n;
    if ((n = connect(sockfd, addr, addrlen)) < 0)
    {
        perr_exit("connect error");
    }
    return n;
}
ssize_t Read(int fd, void *buf, size_t count)
{
    ssize_t n;
again:
    if ((n = read(fd, buf, count)) == -1)
    {
        if (errno == EINTR)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }
    return n;
}
ssize_t Write(int fd, const void *buf, size_t count)
{
    ssize_t n;
again:
    if ((n = write(fd, buf, count)) == -1)
    {
        if (errno == EINTR)
        {
            goto again;
        }
        else
        {
            return -1;
        }
    }
    return n;
}
int Close(int fd)
{
    int n;
    if ((n = close(fd)) == -1)
    {
        perror("close error");
    }

    return n;
}

// 读取N个字节
ssize_t Readn(int fd, void *vptr, size_t n)
{
    size_t nleft;  // unsigned int 剩余未读取的字节数
    ssize_t nread; // int 实际读取的字节数

    char *ptr;

    ptr = vptr;

    nleft = n; // 未读取字节数

    while (nleft > 0)
    {
        if ((nread = read(fd, ptr, nleft)) < 0)
        {
            // 处理系统中断错误
            if (errno == EINTR)
            {
                nread = 0;
            }
            else
            {
                return -1;
            }
        }
        else if (nread == 0)
        {
            break;
        }

        nleft -= nread;
        ptr += nread;
    }
    return n - nleft;
}

// 写N个字节
ssize_t writen(int fd, const void *vptr, size_t n)
{
    // 剩余字节数
    size_t nleft;
    // 已经写出字节数
    ssize_t nwritten;
    // 指向待写数据
    const char *ptr;

    ptr = vptr;
    nleft = n; // 起始，剩余n

    while (nleft > 0)
    {
        // 开始写入
        if ((nwritten = write(fd, ptr, nleft)) < 0)
        {
            if (nwritten < 0 && errno == EINTR)
            {
                nwritten = 0;
            }
            else
            {
                return -1;
            }
        }
        nleft -= nwritten;
        ptr += nwritten;
    }
    return n;
}

static ssize_t my_read(int fd, char *ptr)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buf[100];

    if (read_cnt <= 0)
    {
    again:
        if ((read_cnt = (read(fd, read_buf, sizeof(read_buf)))) < 0)
        {
            if (errno == EINTR)
            {
                goto again;
            }
            return -1;
        }
        else if (read_cnt == 0)
        {
            return 0;
        }

        read_ptr = read_buf;
    }
    read_cnt--;
    *ptr = *read_ptr++;

    return 1;
}

// ssize_t Readline(int fd, void *vptr, size_t maxlen)
// {
//     ssize_t n, rc;

//     char c, *ptr;

//     ptr = vptr;

//     for (n = 1; n < maxlen; n++)
//     {
//         if ((rc = my_read(fd, &c)) == -1)
//         {
//             *ptr++ = c;
//             if (c == '\n')
//             {
//                 break;
//             }
//         }
//         else if (rc == 0)
//         {

//             *ptr = 0;
//             return n - 1;
//         }
//     }
//     *ptr = 0;
//     return n;
// }

// 读取一行
/*readline --- fgets*/
//传出参数 vptr
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
    ssize_t n, rc;
    char c, *ptr;
    ptr = vptr;

    for (n = 1; n < maxlen; n++)
    {
        if ((rc = my_read(fd, &c)) == 1)
        { // ptr[] = hello\n
            *ptr++ = c;
            if (c == '\n')
                break;
        }
        else if (rc == 0)
        {
            *ptr = 0;
            return n - 1;
        }
        else
            return -1;
    }
    *ptr = 0;

    return n;
}




防止僵尸进程，捕捉SIGCHLD信号
 			1、socket()  创建监听套接字 lfd : listen socket
			 2、bind() 绑定地址结构  struct sockaddr_in addr;
			 3、Listen()
			  4、while(1)
     		   cfd = Accept() 接受客户端连接请求
    		    pid = fork() 产生子进程
      		  if(pid == 0) // 子进程 (既有cfd ，又有 lfd)
         	   close(lfd); // 关闭用于建立连接的套接字
         	   read(cfd)
      	      小写-->大写
       	     write(cfd)
    	 	   else if(pid>0) // 父进程 （既有 cfd,又有 lfd）
    	        close(cfd); // 关闭用于和客户端建立连接的套接字 cfd

            waitpid(0,NULL,WNOHANG);
            continue;
5、 子进程：
        close(lfd)
        read(cfd)
        ???? --》 ????
        write()

    父进程：
        close(cfd);
        注册信号捕捉函数 ： SIGCHLD
        在回调函数中，完成子进程回收： while(waitpid());


#include <ctype.h>
#include <strings.h>
#include <signal.h>
#include <sys/wait.h>

#include "wrap.c"

#define PORT 9090

void catch_child(int num){
	pid_t pid;
	while(1){
		pid = waitpid(-1, NULL, WNOHANG);
		if(pid <= 0){//没有回收到， 或还在运行，就跳出
			
			break;
		}else if(pid > 0){//回收，就继续
			printf("child process %d\n", pid);
			continue;
		}
	}
}


int main(int arg, char argv[])
{
    int lfd, cfd;
    int i, ret;
    int pid;
    socklen_t serv_addr_len;
    char buf[BUFSIZ];

    lfd = Socket(AF_INET, SOCK_STREAM, 0);

    // 服务端地址结构、客户端地址结构
    struct sockaddr_in serv_addr, clit_addr;
    socklen_t clit_addr_len;
    clit_addr_len = sizeof(clit_addr_len);
    // 清空地址空间
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr_len = sizeof(serv_addr);
    // 绑定
    ret = Bind(lfd, (struct sockaddr *)&serv_addr, serv_addr_len);
    // 监听
    ret = Listen(lfd, 128);

    // 回收子进程，设置信号捕捉
    // 子进程状态发生变化时给父进程发送信号
    struct sigaction act;
    act.sa_handler = catch_child;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, NULL);

    while (1)
    {
        cfd = Accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
        pid = fork();
        if (pid == 0) // 子进程
        {
            ret = Close(lfd);
            break;
        }
        else if (pid > 0) // 父进程
        {
            Close(cfd);
        }
        else
        {
            perror("fork error");
        }
    }

    // 子进程单独抠出来
    if (pid == 0)
    {
        while (1)
        {
            ret = Read(cfd, buf, sizeof(buf));
            if (ret == 0)
            {
                close(cfd);
                exit(1);
            }
            for (i = 0; i < ret; i++)
            {
                buf[i] = toupper(buf[i]);
            }
            // 写到屏幕
            write(STDOUT_FILENO, buf, ret);
            write(cfd, buf, ret);
        }
    }

    return 0;
}


	使用线程分离

1、Socket()
2、Bind()
3、Listen()
4、while(1)
  		cfd = Accept(lfd);
		pthread_create(&tid,NULL,tfn,NULL);
    	pthread_detach(tid); // 设置子线程分离,不能获得子线程退出的状态
    	// pthread_join(tid,void **); //可以回收子线程退出的状态，但是会产生阻塞。可以创建新线程，用于回收子线程（兄弟线程之间可以相互回收）
5、 子线程：
       void  *tfn(void *arg){
            close(lfd)
            read(cfd)
            ???? --》 ????
            write(cfd)
            pthread_exit(10); // 设置退出状态
       }


#include <pthread.h>
#include <ctype.h>
#include <strings.h>
#include "wrap.c"
#define SERV_PORT 8000

#define MAXLINE 8192

// 将地址结构跟cfd绑定
struct s_info
{
    struct sockaddr_in clit_addr;
    int cfd;
};

void *tfn(void *arg)
{

    int n, i;
    struct s_info *ts = (struct s_info *)arg;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN]; // 定义为 16
    while (1)
    {
        n = Read(ts->cfd, buf, MAXLINE);
        // 读取客户端
        if (n == 0) // 没有读到数据，说明客户端已经关闭
        {
            printf("the client %d closed ... \n", ts->cfd);
            break;
        }
        printf("received from %s at PORT %d\n",
               inet_ntop(AF_INET, &(*ts).clit_addr.sin_addr.s_addr, str, sizeof(str)),
               ntohs((*ts).clit_addr.sin_port));
        for (i = 0; i < n; i++)
        {
            buf[i] = toupper(buf[i]);
        }

        Write(STDOUT_FILENO, buf, n);
        Write(ts->cfd, buf, n);
    }
    Close(ts->cfd);

    return (void *)0;
}

int main()
{
    int lfd, cfd;
    int ret;
    struct s_info ts[256]; // 创建结构体数组
    int i = 0;
    pthread_t tid;

    struct sockaddr_in serv_addr, clit_addr;
    socklen_t serv_addr_len, clit_addr_len;

    serv_addr_len = sizeof(serv_addr);
    lfd = Socket(AF_INET, SOCK_STREAM, 0); // 创建一个 socket ，得到 listen_fd

    int opt = 1; //设置可以复用
    setsockopt(lfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    // 地址结构清零
    bzero(&serv_addr, serv_addr_len);

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 指定本地任意IP
    serv_addr.sin_port = htons(SERV_PORT);         // 指定端口号

    ret = Bind(lfd, (struct sockaddr *)&serv_addr, serv_addr_len);
    ret = Listen(lfd, 128); // 设置同一时刻连接服务器的上限数

    printf("Accepting client connect ... \n");
    while (i < 10)
    {
        clit_addr_len = sizeof(clit_addr);

        cfd = Accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len);
        ts[i].clit_addr = clit_addr;
        ts[i].cfd = cfd;

        pthread_create(&tid, NULL, tfn, (void *)&ts[i]);
        // 设置子线程分离，防止僵尸线程产生
        pthread_detach(tid);
        i++;
    }
    return 0;
}

https://blog.csdn.net/u010783439/article/details/130275301
允许位于同一主机系统上的进程之间相互通信的UNIX domain socket

57.1 UNIX domain socket地址：struct sockaddr_un

 在UNIX domain 中，socket地址以路径名来表示，domain特定的cocket地址结构的定义
struct sockaddr_un{
    sa_family_t sun_family;   
    char sun_path[108];       
}

为一个UNIX domain socket 绑定到一个地址上，需要初始化一个sockaddr_un结构，然后指向这个结构的一个（转换）指针作为addr参数传入bind()并将addrlen指定为这个结构的大小。

#include <stdio.h>
    #include <sys/un.h>
    #include <sys/socket.h>
     
    #define SV_SOCK_PATH "/tmp/us_xfr"
     
    int main(int argc,char *argv[])
    {
        struct sockaddr_un addr;
        int sfd,cfd;
        ssize_t numRead;
        char buf[512];
        sfd = socket(AF_UNIX,SOCK_STREAM,0)
        if(sfd == -1)
        {
            perror("socket");
        }
        /*Construct server Socket address,bind socket to it,and make this a listening socket*/
        if(remove(SV_SOCK_PATH) == -1 && errno != ENOENT)
            printf("remove-%s",SV_SOCK_PATH );
        memset(&addr,0,sizeof(struct sockaddr_un));
        addr.un_family = AF_UNIX;
        strncpy(addr.sun_path,SV_SOCK_PATH,sizeof(addr.sun_path)-1);
        if(bind(sfd,(struct sockaddr *)&addr,sizeof(struct sockaddr_un)) == -1)
        {
            perror("bind");
        }
        if(listen(sfd,BACKLOG) == -1)
        {
            perror("listen")
        }
        for(;;;)  /*handle client connections iteratively*/
        {
            /*Accept a connection.The connection is returned on a new socket,'cfd';the         listening socket ,'cfd';the listening socket('sfd') remains open and can be used accept     further connections.*/
            cfd = accept(sfd,NULL,NULL);
            if(cfd == -1)
            {
                perror("accept");
            }
            /*Transfer datd from connected socket to stdout until EOF*/
            while((numRead = read(cfd,buf,BUF_SIZE))>0)
            {
                if(write(STDOUT_FILENO,buf,numRead)!=numRead)
                {
                    perror("partial/failed write");
                }
            }
            if(numRead == -1)
            {
                perror("read");
            }
            if(close(cfd) == -1)
            {
                perror("close");
            }
        }
     
    }

一个简单的UNIX domain 流socket客户端

   #include <sys/un.h>
    #include <sys/socket.h>
     
    #define SV_SOCK_PATH "tmp/us_xfr"
    #define BUF_SIZE 100
     
    int main(int argc, char *argv[])
    {
        struct sockaddr_un addr;
        int sfd;
        ssize_t numRead;
        char buf[BUF_SIZE];
        sfd = socket(AF_UNIX,SOCK_STREAM,0);   /*create client socket*/
        if(sfd == -1)
        {
            perror("socket");
        }
        /*Construct server address*/
        memset(&addr,0,sizeof(struct sockaddr_un));
        strncpy(addr.sun_path,SV_SOCK_PATH,sizeof(addr.sun_path)-1);
        if(connect(sfd,(struct sockaddr *)&addr),sizeof(struct sockaddr_un))==-1)
        {
            perror("connect");
        }
        /*Copy stdin to socket*/
        while((numRead = read(STD_FILENO,buf,BUF_SIZE))>0)
        {
            if(write(sfd,buf,numRead)!=numRead)
            {
                printf("partial/failed wrote");
            }
        }
        if(numRead == -1)
        {
            perror("read");
        }
     
        return 0;
    }

这个服务器执行了下列任务。
1. 创建一个socket.
2. 删除所有与路径名一致的既有文件，这样就能将socket绑定到这个路径名上为服务器socket构建一个地址结构，将socket绑定到该地址上，将这个socket标记为监听socket
3. 执行一个无限循环来处理进入的客户请求，每次循环迭代下列任务。
a. 接受一个连接，为该链接获取一个新socket cfd.
b. 从已连接的socket读取所有数据并将这些数据写入标准输出中
c. 关闭已连接的socket cfd

服务器程序必须手动终止（如向其发送一个信号）

客户端程序（程序清单）执行下列任务
1. 创建一个socket.
2. 为服务器socket构建一个地址结构并连接到改地址处的socket
执行一个循环将其标准输入复制到socket连接上。当遇到标准输入中的文件结尾时客户端就终止，其结果是客户端socket将会被关闭并且服务器在从连接的另一端的socket数据时就会看到问价结束

在后台运行服务器:
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ gcc us_xfr_sv.c -o us_xfr_sv error_functions.c
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ gcc us_xfr_cl.c -o us_xfr_cl error_functions.c
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ./us_xfr_sv > b &
[1] 7275
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ls -lF /tmp/us_xfr
srwxr-xr-x 1 wannian07 wannian07 0 6月 15 15:36 /tmp/us_xfr=
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ cat *.c > a
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ./us_xfr_cl < a
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ kill %1
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ diff a b
[1]+ 已终止 ./us_xfr_sv > b

diff命令并没有产生任何输出，表明输入和输出文件是一致的。
注意在服务器终止之后，socket路径名会继续存在。
这就是为何服务器在调用bind()之前使用remove()删除socket路径名的所有既有实例。
如果没有这样做，那么bind()调用在上一次调用服务器时创建了这个socket路径名时就会失败。

57.3 UNIX domain中的数据报 socket

通过网络传输的数据报，使用数据报socket的通信是不可靠的。
对于UNIX domain socket来讲，数据报的传输是在内核中发生的并且也是可靠的。所有消息都会按序被递送并且也不会发生重复的状况。
没有规定，UNIX domain 数据报socket能传输的数据报的最大大小
Linux其限制是通过SO_SNDBUF socket选项和/proc 文件来控制

一个简单的 UNIX domain 数据报服务器

   #include <sys/un.h>
    #include <sys/socket.h>
    #include <stype.h>
    #define BUF_SIZE 10 /*MAXmum sizeof messages exchanged between client toserver*/
     
    #define SV_SOCK_PATH "/tmp/ud_ucase"
     
    int main(int argc char *argv[])
    {
        struct sockaddr_un svaddr,claddr;
        int sfd j;
        ssize_t numBytes;
        socklen_t len;
        char buf[BUF_SIZE];
        
        sfd = socket(AF_UNIX,SOCK_DGRAM,0)      /*Create server socket*/
        if(sfd == -1)
        {
            perror("socket");
        }
        /*Construct well-known address and bind server socket to it*/
        if(remove(SV_SOCK_PATH)==-1 && errno !=ENOENT)
        {
            printf("remove -%s",SV_SOCK_PATH);
        }
        memset(&svaddr,0,sizeof(struct sockaddr_un));
        svaddr.sun_family = AF_UNIX;
        strncpy(svaddr.sun_path,SV_SOCK_PATH,sizeof(svaddr.sun_path)-1);
     
        if(bind(sfd,(struct sockaddr *)&svaddr,sizeof(struct sockaddr_un)) ==-1)
        {
            perror("bind");
        }
        for(;;;)
        {
            len = sizeof(struct sockaddr_un);
            numBytes = recvfrom(sfd,buf,BUF_SIZE,0,(struct sockaddr *)&claddr,&len);
            if(numBytes == -1)
            {    
                perror("recvfrom");
            }
            printf("Server received %ld bytes from %s\n",(long)numBytes,claddr.sun_path);
            for(j=0;j<numBytes;j++)
            {
                buf[j] = toupper((unsigned char)buf[j]);
            }
            if(sendto(sfd,buf,numBytes,0,(struct sockaddr *)&claddr,len) != numBytes)
            {
                perror("sendto");
            }
        }
    }

一个简单的UNIX domain 数据报客户端

    #include <sys/un.h>
    #include <sys/socket.h>
    #include <stype.h>
    #define BUF_SIZE 10 /*MAXmum sizeof messages exchanged between client toserver*/
     
    #define SV_SOCK_PATH "/tmp/ud_ucase"
    int main(int argc，char *argv[])
    {
        struct sockaddr_un svaddr,claddr;
        int sfd, j;
        size_t msgLen;
        ssize_t numBytes;
        char resp[BUF_SIZE];
        if(argc <2 || strcmp(argv[1],"--help") == 0)
        {
            printf("%s msg...\n",argv[0]);
        }
        /*create client socket;bind to unique pathname(based on PID)*/
        sfd = socket(AF_UNIX,SOCK_DGRAM,0);
        if(sfd == -1)
        {
            perror("socket");
        }
        memset(&claddr,0,sizeof(struct sockaddr_un));
        claddr.sun_family = AF_UNIX;
        snprintf(claddr.sun_path,sizeof(claddr.sun_path),"tmp/ud_ucase_cl.%ld",(long)getpid());
        if(bind(sfd,(struct sockaddr *)&claddr,sizeof(struct sockaddr_un)) == -1)
        {
            perror("bind");
        }
     
        /*Construct address of server*/
        memset(&svaddr,0,sizeof(struct sockaddr_un));
        svaddr.sun_family = AF_UNIX;
        strncpy(svaddr.sun_path,SV_SOCK_PATH,sizeof(svaddr.sun_path)-1);
        /*Send messages to server;echo response on stdout*/
        for(j=1;j<argc;j++)
        {
            msgLen = strlen(argv[j]);   //may be longer than BUF_SIZE
            if(sendto(sfd,argv[j],magLen,0,(struct sockaddr *)&svaddr,sizeof(struct sockaddr_un)) != msgLen)
            {
                perror("sendto");
            }
            numBytes = recvfrom(sfd,resp,BUF_SIZE,0,NULL,NULL);
            if(numBytes == -1)
            {
                perror("recvfrom");
            }
            printf("response %d:%.*s\n",j,(int)numBytes,resp);
        }
        remove(claddr.sun.path);     /*Remove client socket pathname*/
        exit(0);
        
    }

使用服务器和客户端程序：

(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ gcc ud_ucase_sv.c -o ud_ucase_sv error_functions.c
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ gcc ud_ucase_cl.c -o ud_ucase_cl error_functions.c
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ./ud_ucase_sv &
[1] 7398
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ./ud_ucase_cl hello world
Server received 5 bytes from /tmp/ud_ucase_cl.7402
Response 1: HELLO
Server received 5 bytes from /tmp/ud_ucase_cl.7402
Response 2: WORLD
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ ./ud_ucase_cl ‘long message’
Server received 10 bytes from /tmp/ud_ucase_cl.7403
Response 1: LONG MESSA
(base) wannian07@wannian07-PC:~/Desktop/std/linux prog_interface$ kill %1

对客户端程序的第二个调用有意在recvfrom()调用中指定了一个比消息更小的elength值已说明消息会被静默的阶段。读者可以看出这种阶段确实发生了，因为服务器打印出了一条消息生成他只收到了10个字节，而客户端发送的消息则由12个字节构成。

57.4 UNIX domain socket 权限

socket文件的所有权个权限决定了哪些进程能够与这个socket进行通信
要连接一个UNIX domain流socket需要在该socket文件上拥有写权限。
要通过一个UNIX domain数据报socket发送一个数据报需要在该socket文件上拥有写权限。
此外，需要在存放socket路径名的所有目录上都拥有执行（搜索）权限。

在默认情况下，创建socket(通过bind()）时会给所有者（用户），组以及other用户赋予所有的权限。要改变这种行为可以在调用bind（）之前先调用unmask()来禁用不希望赋予的权限。

57.5 创建互联socket对：sockpair()

单个进程创建一对socket并将他们连接起来时比较有用的。
用两个socket()调用和一个bind()调用：
1、对listen()、connect()、accept()（用于流socket）的调用
2、对connect()（用于数据报socket）的调用来完成。
socketpair()系统调用则为这个操作提供了一个快捷方式
#include <sys/socket.h>
int socketpair(int sdomain,int type,int protocol,int sockfd[2]);
socketpair()系统调用只能用在UNIX domain中，即domain参数必须指定为AF_UNIX。(因为这一对socket是创建于单个主机系统上的。)
socket的type可以被指定为SOCK_DGRAM或SOCK_STREAM。
protocol参数必须为0。
sockfd数组返回了引用这两个相互连接的socket的文件描述符。
将type指定为SOCK_STREAM相当于创建一个双向管道（也被称为流管道）。
每个socket都可以用来读取和写入，并且这两个socket之间每个方向上的数据信道是分开的。

socket对的使用方式与管道的使用方式类似。在调用完socketpair（）之后，进程会使用fork（）创建一个子进程。子进程会继承父进程的文件描述符的副本，包括引用socket对的描述符。因此父进程和子进程就可以使用这一对socket来进行IPC进程通信了。

使用socketpair()创建一对socket
手工创建一对相互连接的socket
差别在于上面一对socket不会被绑定在任意地址上。能够避免一类安全问题了。因为这一对socket是对其它进程不可见的。

57.6 Linux 抽象socket名空间

所谓的抽象路径名空间是Linux特有的一项特性。它允许将一个UNIX domain socket绑定到一个名字上但不会在文件系统上创建该名字。
优势：
1、无需担心与文件系统中的既有名字发生冲突。没有必要在使用完socket之后删除socket路径名。当socket被关闭之后会自动删除这个抽象名。
2、无需为socket创建一个文件系统路径名了。这对于chroot环境以及在不具备文件系统上的写权限时是比较有用的。
要创建一个抽象绑定就需要将sun_path字段的第一个字节指定为null字节(\0)。
将抽象socket名字与传统的UNIX domain socket路径名区分开来。
因为传统的名字是由一个或多个非空字节以及一个终止null字节构成的字符串。sun_path字段的余下的字节为socket顶底了抽象名字。
在解释这个名字时需要用到全部字节，而不是将其看成一个以null结尾的字符串。

创建一个抽象socket绑定

  #include <sys/socket.h>
     
    memset(&addr,0,sizeof(struct sockaddr_un)); /*Clear address structure*/
    addr.sun_family = AF_UNIX;                 //UNIX domain address
    /*addr.sun_path[0] has already been set to 0 by memset*/
    strncpy(&addr.sun_path[1],"xyz",sizeof(addr.sun_path)-1);
        /*Abstract name is "xyz " followed by null bytes*/
    sockfd = socket(AF_UNIX,SOCK_STREAM,0);
    if(sockfd == -1)
    {
        perror("socket");
    }
     
    if(bind(sockfd,(struct sockaddr *)&addr,sizeof(struct sockaddr_un)) == -1)
    {
        perror("bind");
    }

使用一个初始null字节来区分抽象socket名、传统的socket名。
假设变量name正好指向了一个长度为零的字符串并将一个UNIX domain socket绑定到一个按照下列方式初始化sun_path的名字上。
strncpy(addr.sun_path,name,sizeof(addr.sun_path)-1);
在linux上，就会在无意中创建了一个抽象socket绑定。

57.7 总结

原文链接：https://blog.csdn.net/u010783439/article/details/130275301