2023年6月26日 17:29:00go评论66阅读模式

英文:

Linux kernel module communicate with user space through UNIX socket

问题

我正在尝试使用UNIX套接字使内核模块能够与用户空间通信，其中内核模块充当客户端，而用户空间程序充当服务器。

我注意到UNIX套接字有三种类型的地址（参考"man 7 unix"）。

当我使用路径名类型的地址时，它正常工作。但是当我使用抽象类型的地址时，内核模块无法连接到服务器。它返回-ECONNREFUSED。

我的代码有什么问题吗？

内核代码

    struct sockaddr_un s_addr;

    ret = sock_create_kern(&init_net, AF_LOCAL, SOCK_STREAM, 0, &cl_sock);
    if (ret < 0) {
        /*...*/
    }

    memset(&s_addr, 0, sizeof(struct sockaddr_un));
    s_addr.sun_family = AF_LOCAL;
    s_addr.sun_path[0] = 0;
    strncpy(s_addr.sun_path + 1, "my_test", sizeof(s_addr.sun_path) - 1);

    ret = cl_sock->ops->connect(cl_sock, (struct sockaddr *)&s_addr, sizeof(s_addr), 0);
    if (ret < 0) {
        /*...*/
    }

服务器代码

 server_socket = socket_local_server("my_test", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
 if (server_socket < 0) {
 	/*...*/
 }
 accept(server_socket , NULL, NULL);

我期望使用抽象类型的地址连接到服务器。

英文:

I'm trying to use UNIX socket to make kernel module can communicate with user space which the kernel module act as client while the user space program act as server.

I have noticed that UNIX socket has three types of address(refer to "man 7 unix").

When I use the pathname type address, it works normally. But when I use abstract type address, the kernel module cannot connect to the server. It returns -ECONNREFUSED.

Is there anything wrong with my code?

Kernel code

    struct sockaddr_un s_addr;

    ret = sock_create_kern(&amp;init_net, AF_LOCAL, SOCK_STREAM, 0, &amp;cl_sock);
    if (ret &lt; 0) {
        /*...*/
    }

    memset(&amp;s_addr, 0, sizeof(struct sockaddr_un));
    s_addr.sun_family = AF_LOCAL;
    s_addr.sun_path[0] = 0;
    strncpy(s_addr.sun_path + 1, &quot;my_test&quot;, sizeof(s_addr.sun_path) - 1);

    ret = cl_sock-&gt;ops-&gt;connect(cl_sock, (struct sockaddr *)&amp;s_addr, sizeof(s_addr), 0);
    if (ret &lt; 0) {
        /*...*/
    }

server code

 server_socket = socket_local_server(&quot;my_test&quot;, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
 if (server_socket &lt; 0) {
 	/*...*/
 }
 accept(server_socket , NULL, NULL);

I expect to use abstract type address to connect to server.

答案1

得分: 1

Here is the translation of the provided code and text:

尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
my_test尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
"`和`"/tmp/my_test尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
尝试这个：

        socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                        strlen("my_test");
        ret = cl_sock->ops->connect(cl_sock,
                                    (struct sockaddr *)&s_addr,
                                    len, // <-- 不是sizeof(s_addr)
                                    0);


在抽象命名空间中，您必须计算_sun_path_中地址的确切长度作为_sockaddr_大小的一部分。您所需的地址是`"\0my_test"`，但您传入了完整的`sizeof(s_addr)`，这意味着指定的地址类似于`"\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..."` —— 一个不同的套接字。

（相比之下，路径名本地套接字被理解为具有终止的空字节。`"/tmp/my_test\0"`和`"/tmp/my_test\0\0\0\0..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。
..."`都指的是套接字文件`/tmp/my_test`。）

Linux [unix套接字手册页](https://www.man7.org/linux/man-pages/man7/unix.7.html)在处理AF_UNIX地址格式时涉及到了这一点，尽管也许不像匆忙的程序员希望的那么清晰。

英文:

Try this:

    socklen_t len = offsetof(struct sockaddr_un, sun_path) + 1 +
                    strlen(&quot;my_test&quot;);
    ret = cl_sock-&gt;ops-&gt;connect(cl_sock,
                                (struct sockaddr *)&amp;s_addr,
                                len, // &lt;-- not sizeof(s_addr)
                                0);

In the abstract namespace, you must compute the exact length of the address in sun_path as part of the size of the sockaddr. Your desired address is "\0my_test", but you pass in the full sizeof(s_addr), which means the address as specified is something like "\0my_test\0\0\0\0\0\0\0\0\0\0\0\0\0..." — a different socket.

(By contrast, pathname local sockets are understood to have a terminating null byte. Both "/tmp/my_test\0" and "/tmp/my_test\0\0\0\0..." refer to the socket file /tmp/my_test.)

The Linux man page for unix sockets addresses this in its treatment of AF_UNIX address formats, though perhaps not as clearly as the hurried programmer would like.

通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。

Linux内核模块通过UNIX套接字与用户空间通信

问题

内核代码

服务器代码

Kernel code

server code

答案1

如何在Go语言中创建客户端服务器？

使用sed打印每行中与模式匹配后的剩余部分的方法是：

golang get udp socket buffer size

Map(Y) => Set(x), socket.io

What's the correct way to type hint an empty list as a literal in python?

如何在Highcharts Gantt中更改本地化的星期名称

如何在同一个流中使用多个过滤器和映射函数？

如何使用Map/Set来将代码优化到O(n)？

.NET MAUI Android在GitHub Actions上构建失败，错误代码为1。

如何在Playwright视觉比较中屏蔽多个定位器？

在C++中，可以使用可变模板参数来检索类型的内部类型。

selenium.common.exceptions.StaleElementReferenceException: Message: stale element reference: stale element not found

Creating and opening a URL to log in to Website via Basic Auth with Robot Framework/Selenium (Python)

AG Grid 在上下文菜单中以大文本形式打开

发表评论