Socketpair () en C/Unix

Vous pouvez utiliser {[1] } uniquement lorsque vous créez les deux processus, comme ceci:

1. call socketpair - Maintenant, vous avez deux descripteurs de fichier socket (deux extrémités d'un seul tuyau)
   • désigner un bout à l' parent, à la child fin. Peu importe qui, il suffit de faire un choix et de s'y tenir plus tard
2. appelez fork - Maintenant vous avez deux processus
   1. Si fork renvoie zéro, vous êtes l'enfant. Fermez le fichier parent descripteur, gardez leenfant descripteur, et l'utiliser comme fin de ce processus du tuyau
   2. Si fork renvoyé non nul, vous êtes le parent. Fermez le descripteur de fichierenfant , conservez le parent et utilisez-le comme fin du tuyau
3. Vous avez maintenant deux processus, chacun a un descripteur de fichier représentant différentes extrémités du même canal. Notez que les deux processus exécutent le même programme, mais ils ont suivi une branche différente après j'appelle fork. Si parent appelle write sur son socket, enfant pourra lire ces données depuis son socket , et vice-versa

Voici une traduction directe en code:

void child(int socket) {
    const char hello[] = "hello parent, I am child";
    write(socket, hello, sizeof(hello)); /* NB. this includes nul */
    /* go forth and do childish things with this end of the pipe */
}

void parent(int socket) {
    /* do parental things with this end, like reading the child's message */
    char buf[1024];
    int n = read(socket, buf, sizeof(buf));
    printf("parent received '%.*s'\n", n, buf);
}

void socketfork() {
    int fd[2];
    static const int parentsocket = 0;
    static const int childsocket = 1;
    pid_t pid;

    /* 1. call socketpair ... */
    socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);

    /* 2. call fork ... */
    pid = fork();
    if (pid == 0) { /* 2.1 if fork returned zero, you are the child */
        close(fd[parentsocket]); /* Close the parent file descriptor */
        child(fd[childsocket]);
    } else { /* 2.2 ... you are the parent */
        close(fd[childsocket]); /* Close the child file descriptor */
        parent(fd[parentsocket]);
    }
    exit(0); /* do everything in the parent and child functions */
}

Veuillez noter que ce n'est qu'un exemple de code: j'ai omis toute vérification des erreurs et un protocole de flux sensible.

Si vous voulez Deux programmes séparés pour communiquer (par exemple. vous avez un exécutable appelé client, et un appelé serveur), vous ne pouvez pas utiliser ce mécanisme. Au lieu de cela, vous pourriez:

• utilisez des sockets UNIX (où un tube IPC sur un hôte est identifié par un nom de fichier - cela ne fonctionne que si client et serveur fonctionnent sur la même machine)
• ou utilisez des sockets TCP/IP (où une adresse IP et un port identifient le tuyau, et le client et le serveur peuvent être sur des machines différentes)

Si vous n'avez pas spécifiquement besoin de sockets, et vous êtes heureux d'exiger que les clients et serveur exécuter sur la même machine, vous pouvez également utiliser la mémoire partagée, ou les files d'attente de messages.