通过Linux套接字发送文件描述符
我正在尝试通过linux套接字发送一些文件描述符，但是它不起作用。我究竟做错了什么？应该如何调试这样的东西？我尝试将perror（）放到所有可能的地方，但是他们声称一切正常。这是我写的：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <fcntl.h>
void wyslij(int socket, int fd) // send fd by socket
{
struct msghdr msg = {0};
char buf[CMSG_SPACE(sizeof fd)];
msg.msg_control = buf;
msg.msg_controllen = sizeof buf;
struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof fd);
*((int *) CMSG_DATA(cmsg)) = fd;
msg.msg_controllen = cmsg->cmsg_len; // why does example from man need it? isn't it redundant?
sendmsg(socket, &msg, 0);
}
int odbierz(int socket) // receive fd from socket
{
struct msghdr msg = {0};
recvmsg(socket, &msg, 0);
struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
unsigned char * data = CMSG_DATA(cmsg);
int fd = *((int*) data); // here program stops, probably with segfault
return fd;
}
int main()
{
int sv[2];
socketpair(AF_UNIX, SOCK_DGRAM, 0, sv);
int pid = fork();
if (pid > 0) // in parent
{
close(sv[1]);
int sock = sv[0];
int fd = open("./z7.c", O_RDONLY);
wyslij(sock, fd);
close(fd);
}
else // in child
{
close(sv[0]);
int sock = sv[1];
sleep(0.5);
int fd = odbierz(sock);
}
}
问题答案：
史蒂文斯（etal）[UNIX®网络编程，第1卷：套接字网络API描述了在第15章
Unix域协议 （尤其是第15.7节：_传递描述_符）中的过程之间传输文件描述符的过程。对此进行完整描述很麻烦，但是必须在Unix域套接字（AF_UNIX或AF_LOCAL）上完成，发送方进程使用，sendmsg()而接收方使用recvmsg()。
我从问题中得到了经过轻微修改（和检测）的代码版本，可以在带有GCC 4.9.1的Mac OS X 10.10.1 Yosemite上为我工作：
#include "stderr.h"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static
void wyslij(int socket, int fd) // send fd by socket
{
struct msghdr msg = { 0 };
char buf[CMSG_SPACE(sizeof(fd))];
memset(buf, '\0', sizeof(buf));
struct iovec io = { .iov_base = "ABC", .iov_len = 3 };
msg.msg_iov = &io;
msg.msg_iovlen = 1;
msg.msg_control = buf;
msg.msg_controllen = sizeof(buf);
struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
*((int *) CMSG_DATA(cmsg)) = fd;
msg.msg_controllen = CMSG_SPACE(sizeof(fd));
if (sendmsg(socket, &msg, 0) < 0)
err_syserr("Failed to send message\n");
}
static
int odbierz(int socket) // receive fd from socket
{
struct msghdr msg = {0};
char m_buffer[256];
struct iovec io = { .iov_base = m_buffer, .iov_len = sizeof(m_buffer) };
msg.msg_iov = &io;
msg.msg_iovlen = 1;
char c_buffer[256];
msg.msg_control = c_buffer;
msg.msg_controllen = sizeof(c_buffer);
if (recvmsg(socket, &msg, 0) < 0)
err_syserr("Failed to receive message\n");
struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
unsigned char * data = CMSG_DATA(cmsg);
err_remark("About to extract fd\n");
int fd = *((int*) data);
err_remark("Extracted fd %d\n", fd);
return fd;
}
int main(int argc, char **argv)
{
const char *filename = "./z7.c";
err_setarg0(argv[0]);
err_setlogopts(ERR_PID);
if (argc > 1)
filename = argv[1];
int sv[2];
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) != 0)
err_syserr("Failed to create Unix-domain socket pair\n");
int pid = fork();
if (pid > 0) // in parent
{
err_remark("Parent at work\n");
close(sv[1]);
int sock = sv[0];
int fd = open(filename, O_RDONLY);
if (fd < 0)
err_syserr("Failed to open file %s for reading\n", filename);
wyslij(sock, fd);
close(fd);
nanosleep(&(struct timespec){ .tv_sec = 1, .tv_nsec = 500000000}, 0);
err_remark("Parent exits\n");
}
else // in child
{
err_remark("Child at play\n");
close(sv[0]);
int sock = sv[1];
nanosleep(&(struct timespec){ .tv_sec = 0, .tv_nsec = 500000000}, 0);
int fd = odbierz(sock);
printf("Read %d!\n", fd);
char buffer[256];
ssize_t nbytes;
while ((nbytes = read(fd, buffer, sizeof(buffer))) > 0)
write(1, buffer, nbytes);
printf("Done!\n");
close(fd);
}
return 0;
}
已检测但未修复的原始代码版本的输出为：
$ ./fd-passing
fd-passing: pid=1391: Parent at work
fd-passing: pid=1391: Failed to send message
error (40) Message too long
fd-passing: pid=1392: Child at play
$ fd-passing: pid=1392: Failed to receive message
error (40) Message too long
请注意，父级在子级之前完成，因此提示出现在输出的中间。
“固定”代码的输出为：
$ ./fd-passing
fd-passing: pid=1046: Parent at work
fd-passing: pid=1048: Child at play
fd-passing: pid=1048: About to extract fd
fd-passing: pid=1048: Extracted fd 3
Read 3!
This is the file z7.c.
It isn't very interesting.
It isn't even C code.
But it is used by the fd-passing program to demonstrate that file
descriptors can indeed be passed between sockets on occasion.
Done!
fd-passing: pid=1046: Parent exits
$
主要的重大变化是将都添加struct iovec到struct msghdr两个函数中的数据中，并在接收函数（odbierz()）中为控制消息提供了空间。我报告了调试的中间步骤，在该步骤中，我向struct iovec父级提供了，并且父级的“消息过长”错误已消除。为了证明它是有效的（通过了文件描述符），我添加了代码以从传递的文件描述符中读取和打印文件。原始代码具有sleep(0.5)但由于sleep()采用了无符号整数，所以这相当于不hibernate。我用C99复合文字让孩子睡了0.5秒。父级睡眠1.5秒，以便在父级退出之前完成子级的输出。我可以使用wait()或waitpid()
也是如此，但是太懒了。
我没有回去检查所有添加的内容是否必要。
的"stderr.h"报头声明err_*()功能。这是我编写的代码（1987年之前的第一个版本），用于简洁地报告错误。该err_setlogopts(ERR_PID)呼叫在所有消息之前加上PID。对于时间戳，err_setlogopts(ERR_PID|ERR_STAMP)也可以做。
对齐问题
我是否建议您修改代码以使用复制描述符
int，memcpy()而不是直接访问数据？它不一定正确对齐（这就是手册页示例也要使用的原因）memcpy()，并且在许多Linux体系结构中，未对齐的int访问会导致问题（多达SIGBUS信号会杀死进程）。
而且不仅是Linux体系结构：SPARC和Power都需要对齐的数据，并且通常分别运行Solaris和AIX。曾几何时，DEC
Alpha也要求这样做，但如今在现场很少见到它们。
cmsg(3)与此相关的手册页中的代码是：
struct msghdr msg = {0};
struct cmsghdr *cmsg;
int myfds[NUM_FD]; /* Contains the file descriptors to pass. */
char buf[CMSG_SPACE(sizeof myfds)]; /* ancillary data buffer */
int *fdptr;
msg.msg_control = buf;
msg.msg_controllen = sizeof buf;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int) * NUM_FD);
/* Initialize the payload: */
fdptr = (int *) CMSG_DATA(cmsg);
memcpy(fdptr, myfds, NUM_FD * sizeof(int));
/* Sum of the length of all control messages in the buffer: */
msg.msg_controllen = CMSG_SPACE(sizeof(int) * NUM_FD);
对to的赋值fdptr似乎假设它CMSG_DATA(cmsg)已充分对齐以转换为an，int *并且the
memcpy()的使用NUM_FD不只是1
的假设。如此说来，它应该指向数组buf，并且可能不够好按照名义动物的建议排列，因此在我看来，这fdptr只是闯入者，如果使用以下示例会更好：
memcpy(CMSG_DATA(cmsg), myfds, NUM_FD * sizeof(int));
然后在接收端进行相反的处理将是适当的。该程序仅传递单个文件描述符，因此代码可修改为：
memmove(CMSG_DATA(cmsg), &fd, sizeof(fd)); // Send
memmove(&fd, CMSG_DATA(cmsg), sizeof(fd)); // Receive
我似乎也想起了各种操作系统上的历史问题，这些操作系统都带有没有正常有效载荷数据的辅助数据，也通过发送至少一个虚拟字节来避免这种情况，但是我找不到任何可验证的引用，因此我可能会记错。
鉴于Mac OS X（基于Darwin / BSD）至少需要一个struct iovec，即使它描述了零长度的消息，我也愿意相信上面显示的代码（包括3字节消息）是在正确的总体方向上迈出的重要一步。该消息可能应该是一个空字节，而不是3个字母。
我将代码修改为如下所示。它用于memmove()在cmsg缓冲区中复制文件描述符。它传输单个消息字节，即空字节。
在将文件描述符传递给子进程之前，父进程还读取（最多）文件的32个字节。孩子继续在父母离开的地方读书。这证明了传输的文件描述符包括文件偏移量。
接收者应cmsg在将其视为文件描述符传递消息之前对进行更多验证。
#include "stderr.h"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static
void wyslij(int socket, int fd) // send fd by socket
{
struct msghdr msg = { 0 };
char buf[CMSG_SPACE(sizeof(fd))];
memset(buf, '\0', sizeof(buf));
/* On Mac OS X, the struct iovec is needed, even if it points to minimal data */
struct iovec io = { .iov_base = "", .iov_len = 1 };
msg.msg_iov = &io;
msg.msg_iovlen = 1;
msg.msg_control = buf;
msg.msg_controllen = sizeof(buf);
struct cmsghdr * cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
memmove(CMSG_DATA(cmsg), &fd, sizeof(fd));
msg.msg_controllen = CMSG_SPACE(sizeof(fd));
if (sendmsg(socket, &msg, 0) < 0)
err_syserr("Failed to send message\n");
}
static
int odbierz(int socket) // receive fd from socket
{
struct msghdr msg = {0};
/* On Mac OS X, the struct iovec is needed, even if it points to minimal data */
char m_buffer[1];
struct iovec io = { .iov_base = m_buffer, .iov_len = sizeof(m_buffer) };
msg.msg_iov = &io;
msg.msg_iovlen = 1;
char c_buffer[256];
msg.msg_control = c_buffer;
msg.msg_controllen = sizeof(c_buffer);
if (recvmsg(socket, &msg, 0) < 0)
err_syserr("Failed to receive message\n");
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
err_remark("About to extract fd\n");
int fd;
memmove(&fd, CMSG_DATA(cmsg), sizeof(fd));
err_remark("Extracted fd %d\n", fd);
return fd;
}
int main(int argc, char **argv)
{
const char *filename = "./z7.c";
err_setarg0(argv[0]);
err_setlogopts(ERR_PID);
if (argc > 1)
filename = argv[1];
int sv[2];
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) != 0)
err_syserr("Failed to create Unix-domain socket pair\n");
int pid = fork();
if (pid > 0) // in parent
{
err_remark("Parent at work\n");
close(sv[1]);
int sock = sv[0];
int fd = open(filename, O_RDONLY);
if (fd < 0)
err_syserr("Failed to open file %s for reading\n", filename);
/* Read some data to demonstrate that file offset is passed */
char buffer[32];
int nbytes = read(fd, buffer, sizeof(buffer));
if (nbytes > 0)
err_remark("Parent read: [[%.*s]]\n", nbytes, buffer);
wyslij(sock, fd);
close(fd);
nanosleep(&(struct timespec){ .tv_sec = 1, .tv_nsec = 500000000}, 0);
err_remark("Parent exits\n");
}
else // in child
{
err_remark("Child at play\n");
close(sv[0]);
int sock = sv[1];
nanosleep(&(struct timespec){ .tv_sec = 0, .tv_nsec = 500000000}, 0);
int fd = odbierz(sock);
printf("Read %d!\n", fd);
char buffer[256];
ssize_t nbytes;
while ((nbytes = read(fd, buffer, sizeof(buffer))) > 0)
write(1, buffer, nbytes);
printf("Done!\n");
close(fd);
}
return 0;
}
并运行一个示例：
$ ./fd-passing
fd-passing: pid=8000: Parent at work
fd-passing: pid=8000: Parent read: [[This is the file z7.c.
It isn't ]]
fd-passing: pid=8001: Child at play
fd-passing: pid=8001: About to extract fd
fd-passing: pid=8001: Extracted fd 3
Read 3!
very interesting.
It isn't even C code.
But it is used by the fd-passing program to demonstrate that file
descriptors can indeed be passed between sockets on occasion.
And, with the fully working code, it does indeed seem to work.
Extended testing would have the parent code read part of the file, and
then demonstrate that the child codecontinues where the parent left off.
That has not been coded, though.
Done!
fd-passing: pid=8000: Parent exits
$
-
问题内容： 您好，我尝试使用Java中的客户端-服务器类发送文件。由于某种原因，当调用发送文件的方法时，套接字关闭。这是代码： 和来自客户端的代码： 和我得到的错误消息：严重：null java.net.SocketException：套接字已关闭 我对此并没有真正的经验，所以如果有帮助的话会很棒。 问题答案： 该方法返回一个，代表它实际读取的字节数。不能保证从字节数组中读取所需的字节数。它通常会
-
问题内容： 我正在尝试用Python编写一个实现套接字的程序，每个客户端发送一个PDF文件，服务器接收该文件，标题更改为“ file_number.pdf”（即：file_1.pdf）。出现的问题是只有客户端才能成功发送文件。当第二个客户端尝试发送程序时，它确实崩溃了。我在做什么错，我该如何解决我的代码以允许N个客户端（N <20）连接到服务器并传输文件？ 这是服务器代码： 这是客户端代码： 为了
-
问题内容： @cnicutar在此问题上回答了我之后，我尝试将文件描述符从父进程发送到其子进程。基于此示例，我编写了以下代码： 但是不幸的是，我得到了这个错误： 我应该怎么做才能解决这个问题？我是否正确使用该结构？因为在我上面提到的示例中，它们使用和，当我使用它们时遇到了一些错误，因此我不得不使用和。 问题答案： 这是很难做到的。我建议仅使用为您提供帮助的图书馆。最简单的一种是libancilla
-
问题内容： 我正在尝试开发一个非常简单的客户端/服务器，其中客户端将文件转换为字节，将其发送到服务器，然后将字节转换回文件。 当前，程序仅创建一个空文件。我不是一个出色的Java开发人员，因此不胜感激。 这是接收客户端发送的内容的服务器部分。 这是客户端部分 问题答案： 在Java中复制流的正确方法如下： 希望我每次在论坛上发布时都能获得一美元。
-
我正试图通过Java的socket发送一个custome对象。我知道我需要将具有我需要发送的对象的类放在相同的包中，具有相同的serialVersionUID并实现Serializable。我已经这样做了，但我仍然不能通过套接字发送对象。我错在哪里了？ 以下是客户端代码: 客户端中的类用户 发送user类对象的代码： 这里是服务器的代码: user类的代码：与客户端的user完全相同（我从客户端复
-
问题内容： 我有两个脚本，Server.py和Client.py。我有两个目标： 为了能够一次又一次地从客户端向服务器发送数据。 为了能够将数据从服务器发送到客户端。 这是我的Server.py： 这是我的客户： 该函数首次运行（“ e”进入服务器，我返回返回消息），但是如何使它一遍又一遍地发生（类似于聊天应用程序）？该问题在第一次之后开始。消息不会在第一次之后发送。我究竟做错了什么？我是pyth