本地套接字(domain)通信

socket IPC

  socket API原本是为网络通讯设计的,但后来在socket的框架上发展出一种IPC机制,就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯(通过loopback地址127.0.0.1),但是UNIX Domain Socket用于IPC更有效率:不需要经过网络协议栈,不需要打包拆包、计算校验和、维护序号和应答等,只是将应用层数据从一个进程拷贝到另一个进程。这是因为,IPC机制本质上是可靠的通讯,而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口,类似于TCP和UDP,但是面向消息的UNIX Domain Socket也是可靠的,消息既不会丢失也不会顺序错乱。

  UNIX Domain Socket是全双工的,API接口语义丰富,相比其它IPC机制有明显的优越性,目前已成为使用最广泛的IPC机制,比如X Window服务器和GUI程序之间就是通过UNIXDomain Socket通讯的。

  UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同,用结构体sockaddr_un表示,网络编程的socket地址是IP地址加端口号,而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径,这个socket文件由bind()调用创建,如果调用bind()时该文件已存在,则bind()错误返回。

对比网络套接字

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

参数:

  domain:AF_UNIX、 AF_LOCAL

  type:SOCK_STREAM、SOCK_DGRAM

套接字地址结构:

struct sockaddr_in 
{
	__kernel_sa_family_t **sin_family**; 	/* Address family */  地址结构类型
	__be16 **sin_port**;					/* Port number */		端口号
	struct in_addr **sin_addr**;		   /* Internet address */	IP地址
};

struct sockaddr_un 
{
	__kernel_sa_family_t **sun_family**; 	/* AF_UNIX */	地址结构类型
	char **sun_path**[UNIX_PATH_MAX]; 		/* pathname */	socket文件名(含路径)
};
网络套接字本地套接字
函数参数domain:AF_INET
type:SOCK_STREAM、SOCK_DGRAM
domain:AF_UNIX、 AF_LOCAL
type:SOCK_STREAM、SOCK_DGRAM
地址结构sockaddr_insockaddr_un
地址结构初始化struct sockaddr_in srv_addr
srv_addr.sin_family=AF_INET
srv_addr. sin port=htons(8888);
srv_addr.sinaddr.s_addr=htonl(INADDR_ANY)
bind(fd(structsockaddr*)&srv_addr,sizeof(srv_addr))
struct sockaddr_un srv_addr
srv_addr.sun_family=AF_UNIX/ AF_LOCAL
strcpy(srv_addr. sun path,“srv. socket”)
len=brtsetof(struct sockaddr un, sium path+strlen(“srv. socket”)
bind(fd,(struct sockaddr *)& srv_addr,1en)
bind函数调用bind函数bind函数调用成功会创建一个套接字,保证bind绑定成功,在此之前使用unlink函数
客户端依赖“隐式绑定”客户端不能依赖“隐式绑定”,在建立通信过程中创建并初始化两个地址结构。

本地套接字实现通信

通信流程

服务端程序

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#include <ctype.h>
#include <arpa/inet.h>
#include "wrap.h"
using namespace std;

//定义一个端口号
#define SERVER_PORT  9527
//#define BUFSIZ _IO_BUFSIZ
#define SERVER_ADDR "server.socket"

int main (int argc,char *argv[])
{
   
    int link_fd=0;//用于建立连接的文件描述符
    int cfd=0;//用于与服务器进行通信

    int ret,len,size;
    char buf[BUFSIZ];//4096
    //创建套接字
    link_fd=Socket(AF_UNIX,SOCK_STREAM,0);
    //检查返回值,判断是否创建成功
    if(link_fd==-1)
    {
        sys_err("socket error");
    }
    //创建服务端、客户端结构体  初始化成员
    struct sockaddr_un server_addr,client_addr;//引入头文件#include<netinet/in.h>
    //socklen_t client_addrlen;

    bzero(&server_addr,sizeof(server_addr));
    server_addr.sun_family=AF_UNIX;
    strcpy(server_addr.sun_path,SERVER_ADDR);
   
    //求出(本地套接字)绑定地址结构长度(2字节)宏函数求解
    len =offsetof(struct sockaddr_un,sun_path)+strlen(server_addr.sun_path);
    //调用unlink函数保证创建成功
    unlink(SERVER_ADDR);
    //调用bind函数绑定
    ret=bind(link_fd,(struct sockaddr*)&server_addr,len);
    //判断是否绑定成功
    if(ret==-1)
    {
        sys_err("bind error");
    }

    //设置同时与服务器建立连接的上限
    Listen(link_fd,128);

    cout<<("accept...")<<endl;
    while(1)
    {
        len =sizeof(client_addr);
        cfd=accept(link_fd,(struct sockaddr*)&client_addr,(socklen_t*)&len);
        //打印通信的文件名
        len-=offsetof(struct sockaddr_un,sun_path);  //获得文件名的长度的,【需要减去地址结构体前两个字节】
        client_addr.sun_path[len]='\0';
        cout<<"client bind filename "<<client_addr.sun_path<<endl;

        while((size=read(cfd,buf,sizeof(buf)))>0)
        {
            for(int i=0;i<size;i++)
            {
                buf[i]=toupper(buf[i]);
            }
            write(cfd,buf,size);
        }
        close(cfd);
    }
    close(link_fd);
    return 0;
}

客户端程序

#include<iostream>
#include <stdio.h>
#include <unistd.h>       
#include <sys/socket.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>
#include "wrap.h"
using namespace std;

//定义一个端口号(服务端)
#define SERVER_PORT  9527

#define SERVER_ADDR "server.socket"
#define CLIENT_ADDR "client.socket"


int main (int argc,char *argv[])
{
    int  cfd, len;
    struct sockaddr_un servaddr, cliaddr;
    char buf[4096];

    cfd = Socket(AF_UNIX, SOCK_STREAM, 0);

    bzero(&cliaddr, sizeof(cliaddr));
    //客户端地址结构体成员初始化  ,用于创建套接字文件,绑定
    cliaddr.sun_family = AF_UNIX;
    strcpy(cliaddr.sun_path,CLIENT_ADDR);
    //求出首部长度字节加上文件长度
    len = offsetof(struct sockaddr_un, sun_path) + strlen(cliaddr.sun_path);     /* 计算客户端地址结构有效长度 */

    unlink(CLIENT_ADDR);
    bind(cfd, (struct sockaddr *)&cliaddr, len);                                 /* 客户端也需要bind, 不能依赖自动绑定*/

    
    bzero(&servaddr, sizeof(servaddr));
    //服务器地址结构体成员初始化    用于连接                                      /* 构造server 地址 */
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path,SERVER_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);   /* 计算服务器端地址结构有效长度 */

    connect(cfd, (struct sockaddr *)&servaddr, len);

    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        write(cfd, buf, strlen(buf));
        len = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);
    }

    close(cfd);

    return 0;
}

运行结果

服务端:
在这里插入图片描述
客户端:
请添加图片描述

  • 3
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
套接字(Socket)是一种通信机制,它允许不同的进程在同一主机或不同主机之间进行通信Linux下的套接字编程可以使用C语言的套接字接口库函数来实现。 以下是一个简单的Linux套接字编程教程: 1. 创建套接字 使用socket()函数创建一个套接字socket()函数的原型如下: ```c int socket(int domain, int type, int protocol); ``` 其中,domain指定协议族,type指定套接字类型,protocol指定协议。常用的协议族有AF_INET(IPv4)和AF_INET6(IPv6),套接字类型有SOCK_STREAM(TCP)和SOCK_DGRAM(UDP),协议有IPPROTO_TCP和IPPROTO_UDP等。 例如,创建一个TCP协议的套接字: ```c int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); ``` 2. 绑定地址 使用bind()函数将套接字与一个地址绑定。bind()函数的原型如下: ```c int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); ``` 其中,sockfd是要绑定的套接字描述符,addr是一个指向地址结构体的指针,addrlen是地址结构体的长度。 例如,绑定到本地IP地址和指定端口号: ```c struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_ANY); addr.sin_port = htons(8080); int ret = bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)); ``` 3. 监听连接 使用listen()函数将套接字设置为监听状态。listen()函数的原型如下: ```c int listen(int sockfd, int backlog); ``` 其中,sockfd是要监听的套接字描述符,backlog是在内核中排队等待的连接的最大数量。 例如,设置最大排队数量为5: ```c int ret = listen(sockfd, 5); ``` 4. 接受连接 使用accept()函数接受客户端连接请求,并创建一个新的套接字用于与客户端进行通信。accept()函数的原型如下: ```c int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); ``` 其中,sockfd是监听套接字描述符,addr是一个指向地址结构体的指针,用于存储客户端的地址信息,addrlen是地址结构体的长度。 例如,接受客户端连接请求,并创建一个新的套接字描述符: ```c struct sockaddr_in client_addr; socklen_t client_addrlen = sizeof(client_addr); int newfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_addrlen); ``` 5. 发送和接收数据 使用send()函数向对端发送数据,使用recv()函数从对端接收数据。send()和recv()函数的原型如下: ```c ssize_t send(int sockfd, const void *buf, size_t len, int flags); ssize_t recv(int sockfd, void *buf, size_t len, int flags); ``` 其中,sockfd是要发送或接收数据的套接字描述符,buf是要发送或接收的缓冲区,len是缓冲区的长度,flags是可选的标志参数。 例如,发送数据: ```c char msg[] = "Hello World!"; int ret = send(newfd, msg, sizeof(msg), 0); ``` 例如,接收数据: ```c char buf[1024]; int ret = recv(newfd, buf, sizeof(buf), 0); ``` 6. 关闭套接字 使用close()函数关闭套接字。close()函数的原型如下: ```c int close(int fd); ``` 其中,fd是要关闭的套接字描述符。 例如,关闭套接字: ```c close(sockfd); ``` 以上是一个简单的Linux套接字编程教程。套接字编程涉及到许多细节和复杂的操作,需要仔细学习和实践。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值