Senden file-Deskriptor von Linux-Buchse

Ich versuche zu senden, einige Datei-Deskriptor von linux-socket, aber es funktioniert nicht. Was mache ich falsch? Wie soll man zum Debuggen so etwas? Ich habe versucht, perror() ist es überall möglich ist, aber Sie behauptet, dass alles ok ist. Hier ist, was ich geschrieben habe:

#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);
    }

}
Ich meinte CMSG_DATA ich weiß nicht, was Sie sind, aber ich denke, dass ich das problem gefunden.
Warum schicken Sie die Wert der Dateideskriptor über einen socket? Was die Empfänger damit machen soll? Wenn der Empfänger nicht im gleichen Prozess wie der Absender, wird der file-Deskriptor wird bedeutungslos sein, um den Empfänger, wie ein Datei-Deskriptor ist Prozess-spezifisch. In jedem Fall, auf der Empfängerseite, bei der Verwendung von recvmsg() müssen Sie eine Schleife durch das empfangen der Nachrichten-Header auf der Suche für die SOL_SOCKET/SCM_RIGHTS header. Jetzt sind Sie unter der Annahme, dass jede Nachricht beginnt mit SCM_RIGHTS, und das ist wahrscheinlich nicht immer der Fall sein.
Nur um zu überprüfen, Sie sind sich bewusst, dass es möglich ist, zu senden (nutzbare) Datei-Deskriptoren, die zwischen Prozessen mit SCM_RIGHTS und AF_UNIX sockets?
Ich ziehe meinen Kommentar über das senden der Wert eines file-descriptor-über Prozessgrenzen hinweg unwirksam. Aber mein Kommentar zu benötigen, um richtig zu Scannen, erhielt recvmsg() Header für SCM_RIGHTS immer noch gilt.
FWIW, Es ist nicht Linux-spezifisch sind (viele, aber ich glaube, nicht alle Unix-Geschmacksrichtungen, die es unterstützen). Aber ich Stimme zu, dass das Scannen der recvmsg() Header ist die beste Praxis 🙂

InformationsquelleAutor Dekakaruk | 2015-01-17

  1. 33

    Stevens (et al) UNIX Network Programming, Vol 1: The Sockets Networking API beschreibt den Prozess der übertragung von Datei-Deskriptoren, zwischen Prozessen, die in Kapitel 15 Unix Domain Protokolle und speziell §15.7 Vorbei Deskriptoren. Es ist fummelig zu beschreiben, in vollem Umfang, aber es muss getan werden, auf einem Unix-domain-socket (AF_UNIX oder AF_LOCAL), und den Absender-Prozess verwendet sendmsg() während der Empfänger verwendet recvmsg().

    Ich habe diese leicht modifiziert (und instrumentiert) version der code aus der Frage für mich zu arbeiten auf Mac OS X 10.10.1 Yosemite mit GCC 4.9.1:

    #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;
}

    Die Ausgabe des instrumentierten, aber lose version von der original-code war:

    $ ./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

    Beachten Sie, dass die Eltern fertig, bevor das Kind, so die Aufforderung erschien in der Mitte der Ausgabe.

    Den Ausgang von der 'festen' code war:

    $ ./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
$

    Den primären signifikante änderungen waren das hinzufügen der struct iovec auf die Daten in der struct msghdr in beiden Funktionen, und bietet Raum für die in der receive-Funktion (odbierz()) für die control-Nachricht. Ich berichtete in einem Zwischenschritt in das debugging, wo ich das struct iovec zu den Eltern und die Eltern "Nachricht zu lang" - Fehler wurde entfernt. Um zu beweisen, es funktioniert (einen Datei-Deskriptor übergeben wurde), fügte ich code Lesen und drucken Sie die Datei aus dem übergebenen file-Deskriptor. Der ursprüngliche code hatte sleep(0.5) aber da sleep() nimmt eine vorzeichenlose Ganzzahl, entspricht nicht schlafen. Ich verwendet C99 zusammengesetzte Literale zu haben, das Kind schlafen für 0,5 Sekunden. Der Elternteil schläft seit 1,5 Sekunden, so dass der Ausgang aus dem Kind abgeschlossen ist, bevor der Elternteil beendet wird. Ich könnte wait() oder waitpid() auch, aber war zu faul das zu tun.

    Ich habe nicht zurück gegangen, und überprüft, dass alle Ergänzungen wurden notwendig.

    Den "stderr.h" header deklariert die err_*() Funktionen. Es ist code, den ich schrieb (erste version vor 1987), um Fehler zu melden prägnant auf den Punkt. Die err_setlogopts(ERR_PID) call-Präfixe werden alle Nachrichten mit der PID. Für timestamps auch err_setlogopts(ERR_PID|ERR_STAMP) würde die Arbeit machen.

    Problemen Ausrichtung

    Nominal Tier schlägt in einem Kommentar:

    Kann ich schlage vor, Sie ändern Sie den code, kopieren Sie den Deskriptor int mit memcpy() statt den Zugriff auf die Daten direkt? Es ist nicht unbedingt richtig ausgerichtet ist — das ist der Grund, warum der Mann Seite Beispiel verwendet auch memcpy() — und es gibt viele Linux-Architekturen, in denen nicht int Zugang Probleme verursacht (bis zu SIGBUS-signal Tötung der Prozess).

    Nicht nur Linux-Architekturen: sowohl SPARC-und Power benötigen ausgerichteten Daten und sind oft Solaris und AIX beziehungsweise. Once upon a time, DEC Alpha erforderlich, dass auch, aber Sie sind selten gesehen in den Bereich in diesen Tagen.

    Den code in die manual-Seite cmsg(3) damit verbunden ist:

    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);

    Die Zuordnung zu fdptr erscheint, anzunehmen, dass CMSG_DATA(cmsg) ist ausreichend gut ausgerichtet, um in eine int * und die memcpy() verwendet wird, auf der Annahme, dass NUM_FD ist nicht nur 1. Mit dieser sagte, es soll zeigen das array buf, und, die möglicherweise nicht ausreichend gut ausgerichtet, wie die Nominalen Tier schlägt, scheint es mir so, dass die fdptr ist nur ein Eindringling, und es wäre besser, wenn das Beispiel verwendet:

    memcpy(CMSG_DATA(cmsg), myfds, NUM_FD * sizeof(int));

    Und der umgekehrte Vorgang am empfangenden Ende wäre dann angemessen. Dieses Programm übergibt nur eine einzige Datei-Deskriptor, so dass der code geändert werden, um:

    memmove(CMSG_DATA(cmsg), &fd, sizeof(fd));  //Send
memmove(&fd, CMSG_DATA(cmsg), sizeof(fd));  //Receive

    Auch ich scheine zu erinnern, historische Themen auf verschiedenen OS w.r.t. zusätzliche Daten mit keine normale Nutzdaten, vermeiden, indem das senden mindestens ein dummy-byte zu, aber ich finde keine Referenzen zu überprüfen, so könnte ich mich erinnere falsch.

    Gegeben, dass Mac OS X (Darwin/BSD-basis) erfordert mindestens einen struct iovec, selbst wenn, der beschreibt, mit der Länge null Nachricht, ich bin bereit zu glauben, dass der code oben gezeigt, umfasst ein 3-byte-Nachricht, ist ein guter Schritt in die richtige Richtung zeigen. Die Nachricht sollte vielleicht ein einzelnes null byte statt 3 Buchstaben.

    Habe ich überarbeitet, den code zu Lesen, wie unten gezeigt. Es nutzt memmove() kopieren der Datei-Deskriptor und von der cmsg Puffer. Es überträgt eine einzelne Nachricht byte, die ein null-byte.

    Es hat auch die parent-Prozess-Lesen (bis zu) 32 bytes der Datei vor der Weitergabe der Datei-Deskriptor für das Kind. Das Kind wird weiterhin Lesen, wo die Eltern aufgehört haben. Dies zeigt, dass der Datei-Deskriptor übertragen enthält die Datei offset.

    Receiver sollte mehr tun, eine Validierung auf der cmsg vor und behandeln Sie es als eine Datei-Deskriptor übergeben-Nachricht.

    #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;
}

    Und eine Probe ausführen:

    $ ./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
$
    Vielen Dank, es funktioniert! Das problem war der Mangel an Puffer für die msg.msg_control in odbierz().
    Froh, dass es für Sie arbeiten. Auf Mac OS X, es scheint, dass die struct iovec Teile benötigt werden, aber die Versand-version kann struct iovec io = { .iov_base = "", .iov_len = 0 }; und das ist OK. Der Empfang war mit char mbuffer[1];, aber nicht ohne die struct iovec.
    Kann ich schlage vor, Sie ändern den code zu kopieren descriptor int mit memcpy() statt den Zugriff auf die Daten direkt? Es ist nicht unbedingt richtig ausgerichtet ist-das ist, warum Sie die man page Beispiel verwendet auch memcpy() - und es gibt viele Linux-Architekturen, in denen unverbunden int Zugriff Probleme verursacht (bis zu SIGBUS-signal Tötung der Prozess). Auch ich scheine zu erinnern, historische Themen auf verschiedenen Betriebssystemen wrt. zusätzliche Daten mit keine normale Nutzdaten, vermeiden, indem das senden mindestens ein dummy-byte zu, aber ich finde keine Referenzen zu überprüfen, so könnte ich erinnere mich falsch.
    Danke — siehe meine aktualisierte Antwort. Das Beispiel auf der man-Seite ist ein bisschen verwirrend mit seinen (unnötigen und unsicheren) nutzen fdptr. Ich denke, was ich geschrieben habe, wird überall unterstützt, dass die grundlegenden Mechanismen (aber ich gestehe, mein Test ist sehr begrenzt). Ich benutze memmove() statt memcpy() denn ich sollte nicht zu kümmern, ob die Dinge sich überschneiden. Da memmove() ist garantiert immer Arbeit und memcpy() ist nicht garantiert immer Arbeit ('Arbeit' Sinn 'arbeiten korrekt, unabhängig von der übergebenen Argumente'), verwende ich memmove(). Das ist eine persönliche Entscheidung.
    Die iovec-Daten scheint erforderlich zu sein, wie folgende Notiz aus der man-page (unix - (7)) heißt es: "pass Dateideskriptoren oder Anmeldeinformationen, die über einen SOCK_STREAM, müssen Sie zum senden oder empfangen von mindestens einem byte nonancillary Daten in der gleichen sendmsg(2) und recvmsg(2) Aufruf."

    InformationsquelleAutor Jonathan Leffler

Schreibe einen Kommentar