how - socket programming in c geeksforgeeks

Socketpair() en C/Unix

Question

Tengo 2 aplicaciones en el mismo sistema que necesito comunicar de ida y vuelta. De mi investigación creo que esto se llama Inter Process Communication y el uso de socketpair () es el mejor método para mi problema.

Me estoy arrancando los pelos (literalmente) tratando de empezar a crear sockets con socketpair () en C. Por lo que entiendo, los sockets son un tema muy complejo y el ser un programador de C novato seguramente no está ayudando a la situación.

Busqué en Google durante las últimas 48 horas, leí tutoriales, etc., pero todavía no puedo obtenerlo. Entiendo el concepto, pero el código es demasiado confuso. He leído este artículo algunas veces: http://beej.us/guide/bgnet/html/single/bgnet.html , pero no es lo suficientemente simple.

¿Alguien puede dar algún ejemplo (tan simple que un niño de 5to grado podría entender) o señalarme un buen tutorial?

Answer 1

Para comunicarse entre dos procesos, sí, Inter Process Communication o IPC es lo que debe buscar. Los sockets son solo uno de los métodos de comunicación y son útiles si tiene que implementar una conexión de uno a muchos. Significa, un proceso de servidor que se comunica con muchos procesos del cliente en una forma de solicitud-respuesta. Como eres un novato en IPC, es comprensible que las direcciones de socket y los detalles involucrados puedan parecer difíciles de comprender. (Aunque los encontrarás fáciles a su debido tiempo :-))

Para su problema, le sugiero que use mecanismos de IPC más simples como Pipe, FIFO, Message Queue. No estoy seguro de cómo llegó a la conclusión de usar socketpair. Como no ha mencionado nada sobre el diseño o el tipo de IPC que necesita Y basado en el nivel de uso, le recomiendo consultar los códigos de muestra de Pipe o FIFO en algún libro o internet. Deberían verse mucho más fáciles de implementar y funcionar más rápido que los sockets.

Answer 2

Use TCP / IP. Si bien hay otros mecanismos de IPC disponibles (como los sockets de dominio de Unix y SYSV IPC), es mejor con TCP / IP por muchas razones. Aquí están algunas:

1. Hay muchos tutoriales y otra información en la web que describe cómo hacer TCP / IP
2. Los sistemas modernos, y especialmente Linux y * BSD, no imponen una penalización significativa por el uso de TCP / IP en comparación con, por ejemplo, sockets de dominio Unix o incluso SYSV IPC.
3. Hay una serie de bibliotecas y marcos que puede utilizar para aplicaciones que se comunican a través de TCP / IP.

El único caso en el que no usaría TCP / IP para comunicarme entre dos "programas" es para el caso en el que realmente son hilos en lugar de programas separados.

Answer 3

socketpair crea un par de sockets anónimos , generalmente unix / sockets locales, que solo son útiles para la comunicación entre un proceso primario y secundario o en otros casos donde los procesos que necesitan usarlos pueden heredar los descriptores de un ancestro común.

Si vas a hacer la comunicación entre procesos no relacionados (en el sentido de paternidad), necesitas usar socket , bind y connect para crear un socket de escucha en un proceso y crear un socket de cliente para conectarlo en el otro proceso. .

Answer 4

Puede usar socketpair solo donde crea ambos procesos, de esta manera:

1. llame al socketpair : ahora tiene dos descriptores de archivos de socket (dos extremos de un solo tubo)
   • nominar un extremo para ser el padre y uno para ser el final del niño . No importa cuál, simplemente haga una elección y apéguese a ella más tarde
2. llamada fork - ahora tienes dos procesos
   1. si el fork devolvió cero, eres el niño. Cierre el descriptor del archivo principal , mantenga el descriptor secundario y úselo como el final del proceso de este proceso
   2. si el fork devuelve un valor distinto de cero, usted es el padre. Cierre el descriptor de archivo secundario , mantenga el principal y úselo como su extremo de la tubería
3. ahora tiene dos procesos, cada uno tiene un descriptor de archivo que representa diferentes extremos del mismo conducto. Tenga en cuenta que ambos procesos están ejecutando el mismo programa, pero siguieron una rama diferente después de llamar al fork . Si el padre llama para write en su socket, el niño podrá leer esa información de su socket, y viceversa

Aquí hay una traducción directa al código:

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 */
}

Tenga en cuenta que esto es solo un código de muestra: he omitido todas las comprobaciones de errores y un protocolo de transmisión de datos sensible.

Si desea que se comuniquen dos programas separados (por ejemplo, si tiene un ejecutable llamado cliente y un servidor llamado), no puede usar este mecanismo. En cambio, puedes:

• utilice conectores UNIX (donde un conducto IPC en un host se identifica por un nombre de archivo; esto solo funciona si el cliente y el servidor se ejecutan en la misma máquina)
• o use conectores TCP / IP (donde una dirección IP y un puerto identifican el conducto, y el cliente y el servidor pueden estar en máquinas diferentes)

Si no necesita enchufes específicamente , y le complace exigir que el cliente y el servidor se ejecuten en la misma máquina, también puede usar memoria compartida o colas de mensajes.