• UNIX 域协议(本地通信协议)

    概述

            Unix 域协议并不是一个实际的协议族，而是在单个主机上执行客户/服务通信的一种方式。是进程间通信（IPC）的一种方式。
            它提供了两类套接字：字节流套接字 SOCK_STREAM（有点像 TCP）和数据报套接字 SOCK_DGRAM（有点像 UDP）
            UNIX 域数据报服务是可靠的，不会丢失消息，也不会传递出错。
            IP 协议标识客户服务器是通过 IP 地址和端口号实现的，UNIX 域协议中用于标识客户机和服务器的协议地址的是普通文件系统中的路径名。
    UNIX 域协议的特点：
            1.UNIX 域套接字域 TCP 套接字相比，在同一台主机的传输速度前者是后者的两倍 。UNIX 域套接字仅仅复制数据，并不执行协议处理，不需要添加或删除网络报头，无需计算校验和，不产
    生顺序号，也不需要发送确认报文
            2.UNIX 域套接字可以在同一台主机上各进程之间传递文件描述符
            3.UNIX 域套接字域传统套接字的区别是用路径名表示协议族的描述
    UNIX 域协议地址 
    1. #define UNIX_PATH_MAX 108
    2. struct sockaddr_un
    3. {
    4.     __kernel_sa_family_t sun_family; /* 通信协议 AF_UNIX / AF_LOCAL */
    5.     char sun_path[UNIX_PATH_MAX]; /* pathname */
    6.     //UNIX 域协议的地址,是以'\0'结束的本地文件系统中的绝对路径名
    7.     //会自动的创建不需要提前创建
    8. };
    UNIX 域协议用于本地进程间通信的编程流程和 TCP/UDP 一样,只不过具体的协议地址是使
    用文件路径名
            Server：先创建套接字 -> 绑定地址 -> 监听 -> accept 客户端连接 -> 连接成功开始通信 -> 关闭套接字
            Client：先创建套接字 ->绑定地址-> 连接 server -> 开始通信 -> 关闭套接字。

    UNIX 域协议之进程间通信方式一：socketpair 函数

    【头文件】 
    1. #include 
    2. #include
    【函数原型】 
    int socketpair(int domain, int type, int protocol, int sv[2]);
    【函数功能】
            此函数只用于 Unix 域套接口，它的 domain 必须是 AF_LOCAL,protocol 参数必须为 0，type 可以是 SOCK_STREAM 也可以是 SOCK_DGRAM，它与调用 pipe 创建的普通管道类似，差别在 于普通管道只能进行单向读或单向写，而该管道是全双工的，可以单向读写。
    【参数含义】
            [domain]: 表示协议族，在 Linux 下只能为 AF_LOCAL 或者 AF_UNIX 。（自从 Linux 2.6.27 后也支持 SOCK_NONBLOCK 和 SOCK_CLOEXEC）
            [type]: 表示协议，可以是 SOCK_STREAM 或者 SOCK_DGRAM。SOCK_STREAM 是基于TCP 的，而 SOCK_DGRAM 是基于 UDP 的
            [protocol]: 表示类型，只能为 0
            [sv]: 套节字柄对，该两个句柄作用相同，均能进行读写双向操作
    【返回值】
            
            0 为创建成功，-1 为创建失败，并且 errno 来表明特定的错误号，具体错误号如下所述：
            EAFNOSUPPORT:本机上不支持指定的 address。 EFAULT： 地址 sv 无法指向有效的进程地址空间内。
            EMFILE： 已经达到了系统限制文件描述符，或者该进程使用过量的描述符。
            EOPNOTSUPP：指定的协议不支持创建套接字对。
            EPROTONOSUPPORT：本机不支持指定的协议。
    【备注】
            1、该函数只能用于 UNIX 域（ LINUX ）下。
            2、只能用于有亲缘关系的进程（或线程）间通信。
            3、所创建的套节字对作用是一样的，均能够可读可写（而管道 PIPE 只能进行单向读写）。
            4、在读的时候，管道内必须有内容，否则将会阻塞；简而言之，该函数是阻塞的。
    【示例代码】 
    1. /*socketpair1.c*/
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. int main ()
    7. {
    8.     int sv[2];
    9.     int result = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
    10.     if (result < 0){
    11.         exit(1);
    12.     }
    13.     printf("sv[0] is : %d \n", sv[0]); //这两个套节字句柄并不相同，但作用是一样的
    14.     printf("sv[1] is : %d \n", sv[1]);
    15.     if (fork())
    16.     { 
    17.         /* 父进程 */
    18.         int val = 0;
    19.         pid_t pid = getpid(); 
    20.         close(sv[1]); //父进程关闭 sv[1]的读写权限
    21.         while (1)
    22.         { 
    23.             ++val;
    24.             printf("%d send message: %d\n", pid, val); 
    25.             write(sv[0], &val, sizeof(val)); //父进程向管道里写数据
    26.             //也可以去读
    27.             // read(sv[0], &val, sizeof(val)); //如果字进程不写数据，将会导致此处堵塞
    28.             //printf("%d receive message: %d\n", pid, val);
    29.             sleep(1);
    30.         }
    31.     }
    32.     else
    33.     { 
    34.         /*子进程*/
    35.         int val = 0;
    36.         close(sv[0]); //字进程关闭 sv[0]的读写权限
    37.         pid_t pid = getpid(); 
    38.         while(1)
    39.         {
    40.             read(sv[1], &val, sizeof(val)); //字进程从管道中取数据
    41.             printf("%d receive message: %d\n", pid, val);
    42.             // printf("%d receive message: %d\n", pid, val); 
    43.             //也可以写
    44.             // write(sv[1], &val, sizeof(val));
    45.         }
    46.     }
    47. }

    UNIX 域协议之进程间通信方式二：套接字通信方式

            UNIX 域协议进行本地通信的方式和 TCP、UDP 很类似，下面就以 UNIX 域协议的流式套接字来写一个客户端和服务器间通信的例子，使用流式套接字，则本地间的通信方式就要类似于 TCP,这样的通信方式同时也具有 TCP 通信的特点。
    客户端示例程序： 
    1. #include
    2. #include
    3. #include  /* See NOTES */
    4. #include 
    5. #include 
    6. #include 
    7. #include //为了使用 IPV4 地址结构体
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define UNIX_PATH_PS "/home/china/sockp1" //连接的套接字地址
    13. #define UNIX_PATH_PC "/home/china/sockp2" //绑定的套接字地址
    14.  
    15. int main(int argc,char *argv[])
    16. {
    17.     system("rm /home/china/sockp2"); //防止文件重名
    18.  
    19.     //1.创建一个套接字
    20.     int sockfd = socket(AF_UNIX, SOCK_STREAM,0); //创建一个本地通信 UNIX 流式套接字
    21.     if(-1 == sockfd)
    22.     {
    23.         perror("create socket failed");
    24.         exit(-1);
    25.     }
    26.  
    27.     //2.绑定一个通信地址(让服务器能看到我)，可不绑定
    28.     struct sockaddr_un local; 
    29.     memset(&local,0,sizeof(struct sockaddr_un)); //清空结构体
    30.     local.sun_family = AF_UNIX;
    31.     strcpy(local.sun_path,UNIX_PATH_PC);
    32.     int ret = bind(sockfd,(struct sockaddr*)&local,sizeof(local));
    33.     if(ret == -1)
    34.     {
    35.         perror("bind error");
    36.         exit(-1);
    37.     }
    38.     printf("bind success\n");
    39.     //连接目标服务器
    40.     struct sockaddr_un saddr; //保存目标服务器的地址(本地的文件名)
    41.     memset(&saddr,0,sizeof(struct sockaddr_un)); //清空结构体
    42.     saddr.sun_family = AF_UNIX;
    43.     strcpy(saddr.sun_path,UNIX_PATH_PS);
    44.     ret = connect(sockfd, (struct sockaddr*)&saddr,sizeof(saddr)); //请求连接目标服务器
    45.     if(ret == -1)
    46.     {
    47.         perror("connect error");
    48.         exit(-1);
    49.     }
    50.     printf("connect success\n");
    51.     char buf[1024] = {0};
    52.     //读取信息
    53.     ret = recv(sockfd,buf,1024, 0);
    54.     if(ret == -1)
    55.     {
    56.         perror("recv error");
    57.     }
    58.     printf("recv size:%d,recv data:%s\n",ret,buf);
    59.     //发送信息
    60.     ret = sendto(sockfd,"byebye",6,0,NULL,0);
    61.     if(ret == -1)
    62.     {
    63.         perror("sendto error");
    64.     }
    65.     printf("sendto size:%d\n",ret);
    66.     //关闭套接字
    67.     shutdown(sockfd,SHUT_RDWR);
    68.     close(sockfd);
    69.     return 0;
    70. }
    服务器程序示例： 
    1. #include
    2. #include
    3. #include  /* See NOTES */
    4. #include 
    5. #include 
    6. #include 
    7. #include //为了使用 IPV4 地址结构体
    8. #include 
    9. #include 
    10. #include 
    11. #define UNIX_PATH_PS "/home/china/sockp1"
    12.  
    13. int main(int argc,char *argv[])
    14. {
    15.     system("rm /home/china/sockp1"); //保证该文件没有被使用
    16.  
    17.     //1.创建一个套接字
    18.     int sockfd = socket(AF_UNIX, SOCK_STREAM,0); //创建一个本地通信UNIX 流式套接字
    19.     if(-1 == sockfd)
    20.     {
    21.         perror("create socket failed");
    22.         exit(-1);
    23.     }
    24.  
    25.     //2.绑定一个通信地址(作为服务器本身的地址)
    26.     struct sockaddr_un local; //保存服务器的地址(文件名)
    27.     memset(&local,0,sizeof(struct sockaddr_un)); //清空结构体
    28.     local.sun_family = AF_UNIX;
    29.     strcpy(local.sun_path,UNIX_PATH_PS);
    30.     int ret = bind(sockfd,(struct sockaddr*)&local,sizeof(local)); //绑定服务器的地址
    31.     if(ret == -1)
    32.     {
    33.         perror("bind error");
    34.         exit(-1);
    35.     }
    36.     printf("bind success\n");
    37.  
    38.     //3.开启对一个套接字的监听
    39.     listen(sockfd,250);
    40.  
    41.     //4.等待客户端的连接
    42.     while(1)
    43.     {
    44.         struct sockaddr_un caddr; //保存客户端的地址(文件名)
    45.         socklen_t len = sizeof(caddr);
    46.         int confd = accept(sockfd,(struct sockaddr*)&caddr,&len); //阻塞等待客户端连接
    47.         if(confd > 0) //客户端连接成功,返回一个连接套接字专门用来和客户端通信
    48.         {
    49.             //一个客户端连接成功.开一个进程/线程去处理这个连接
    50.             printf("client path:%s\n",caddr.sun_path);
    51.             ret = sendto(confd,"nishiliangzaima?",20,0,NULL,0); //发送消息
    52.             if(ret == -1)
    53.             {
    54.                 perror("sendto error");
    55.             }
    56.             char buf[1024] = {0};
    57.             ret = read(confd,buf,1024); //接收消息
    58.             if(ret <= 0)
    59.             {
    60.                 perror("recv error");
    61.             }
    62.             printf("recv size:%d,recv data:%s\n",ret,buf);
    63.             close(confd);//关闭连接套接字
    64.         }
    65.     }
    66.     //关闭套接字
    67.     shutdown(sockfd,SHUT_RDWR);
    68.     close(sockfd);
    69.     return 0;
    70. }

  • 相关阅读:
    Redis从基础到进阶篇（三）----架构原理与集群演变
    说说 Redis 事务
    数据结构与算法----详解二叉树的遍历(迭代、递归)
    PS制作文字扫光gif
    Golang | Leetcode Golang题解之第200题岛屿数量
    【观察】软通动力：以数智化技术创新，赋能每一个降碳场景
    开源大赛的种种收获
    python办公自动化（九）os模块统计文件名、批量重命名、文件压缩
    计算机网络总结笔记
    陪诊小程序|陪诊系统让就医服务更加人性化
  • 原文地址：https://blog.csdn.net/jiu_yue_ya/article/details/134049796