unix domain socket

Unix domain socket，也称为AF_UNIX socket，是一种在单一系统中进行进程间通信的方式。它使用文件系统中的路径名作为地址，允许同一台主机上的进程间通信而无需网络协议。Unix domain socket比IP socket更高效，因为它不需要进行网络传输。

相关问题

unix domain socket 例子

下面是一个使用 Unix Domain Socket 进行进程间通信的简单例子：

服务端代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/mysocket"

int main(void) {
    int server_fd, client_fd;
    struct sockaddr_un server_addr, client_addr;
    socklen_t client_len;

    // 创建 socket
    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 绑定地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);
    unlink(SOCKET_PATH);
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 监听端口
    if (listen(server_fd, 5) == -1) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    printf("Listening on socket %s\n", SOCKET_PATH);

    while (1) {
        // 接受连接
        client_len = sizeof(client_addr);
        client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
        if (client_fd == -1) {
            perror("accept");
            continue;
        }

        printf("Accepted connection\n");

        // 发送欢迎消息
        if (write(client_fd, "Welcome to my server", 21) == -1) {
            perror("write");
            close(client_fd);
            continue;
        }

        // 关闭连接
        close(client_fd);
    }

    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/mysocket"

int main(void) {
    int server_fd;
    struct sockaddr_un server_addr;
    char buf[1024];
    ssize_t n;

    // 创建 socket
    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 连接到服务端
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);
    if (connect(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect");
        exit(EXIT_FAILURE);
    }

    // 读取欢迎消息
    n = read(server_fd, buf, sizeof(buf));
    if (n == -1) {
        perror("read");
        exit(EXIT_FAILURE);
    }

    printf("Received: %.*s\n", (int)n, buf);

    // 关闭连接
    close(server_fd);

    return 0;
}

以上代码演示了一个简单的 Unix Domain Socket 客户端和服务端的通信过程。服务端创建了一个 Unix Domain Socket 并监听客户端的连接请求，客户端连接到服务端并发送一个请求，服务端收到请求后向客户端发送一个欢迎消息，然后关闭连接。通信过程中使用了 read 和 write 函数进行数据传输。

Golang Unix domain socket

Golang提供了对Unix域套接字（Unix domain）的支持。Unix域套接字是一种在同一台机器上的进程之间进行通信的机制，它不依赖于网络协议栈，而是通过文件系统来实现。

在Golang中，你可以使用net包来创建和操作Unix域套接字。下面是一个简单的例子：

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	// 创建Unix域套接字
	socketPath := "/tmp/mysocket.sock"
	listener, err := net.Listen("unix", socketPath)
	if err != nil {
		fmt.Println("Error listening:", err)
		os.Exit(1)
	}
	defer listener.Close()

	fmt.Println("Listening on", socketPath)

	for {
		// 接受连接
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			os.Exit(1)
		}

		// 处理连接
		go handleConnection(conn)
	}
}

func handleConnection(conn net.Conn) {
	// 在这里处理连接逻辑

	// 关闭连接
	conn.Close()
}

在上面的例子中，我们首先创建了一个Unix域套接字，并监听在指定的路径上。然后我们使用Accept方法来接受连接，并将每个连接都交给handleConnection函数来处理。在handleConnection函数中，你可以处理具体的连接逻辑，然后关闭连接。

这只是一个简单的例子，你可以根据自己的需求进行扩展和修改。希望对你有帮助！