Introducción a los Sockets con C

Cuando hablamos de programación de redes, es común que nos refiramos a los sistemas distribuidos. En Unix estos sistemas estan basados en Sockets.

La siguiente cita redacta los fundamentos de la programación de Sockets. Después yo les dejo un ejemplo pequeño con el código completo y su explicación.

Los sockets son la interfaz más difundida que hay para la comunicación de procesos. En este artículo vamos a ver una introducción a estos, explicando sus ventajas, desventajas, el modelo de BSD sockets y un ejemplo en C con sockets TCP.

— Just Sherekan

gcc -o servidor servidor.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

int port = 8000;

int main(void)
{
    struct sockaddr_in sin;
    struct sockaddr_in pin;

    int sock_descriptor;
    int temp_sock_descriptor;
    int address_size;

    char buf[16384];
    int i, len;

    sock_descriptor= socket(AF_INET, SOCK_STREAM, 0);
    if (sock_descriptor == -1)
    {
        perror("Llamando a Socket");
        exit(1);
    }

    bzero(&sin, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);

    if (bind(sock_descriptor, (struct sockaddr *)&sin, sizeof(sin)) == -1)
    {
        perror("Llamada para comunicar");
        exit(1);
    }

    if (listen(sock_descriptor, 20) == -1)
    {
        perror("Llamada para escuchar");
        exit(1);
    }

    printf("Aceptar la conexion... n");

    while(1)
    {
        temp_sock_descriptor = accept(sock_descriptor,
            (struct sockaddr *)&pin, &address_size);

        if (temp_sock_descriptor == -1)
        {
            perror("Llamada para aceptar");
            exit(1);
        }

        if (recv(temp_sock_descriptor, buf, 16384, 0) == -1)
        {
            perror("Llamada para recibir");
            exit(1);
        }

        printf("Recibido del cliente: %sn", buf);

        len = strlen(buf);
        for (i=0; i<len; i++) buf[i] = toupper(buf[i]);

        if (send(temp_sock_descriptor, buf, len, 0) == -1)
        {
            perror("Llamada para enviar");
            exit(1);
        }

        close(temp_sock_descriptor);
    }
}

gcc -o cliente cliente.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

char * host_name = "127.0.0.1";
int port = 8000;

int main(int argc, char *argv[])
{
    char buf[8192];
    char message[256];
    int socket_descriptor;
    struct sockaddr_in pin;
    struct hostent *server_host_name;

    char * str = "Una cadena";

    if (argc < 2)
    {
        printf("Usage:'test "Una cadena de comprobacion"n");
        printf("Enviaremos una cadenan");
    }
    else
    {
        str = argv[1];
    }

    if ((server_host_name = gethostbyname(host_name)) == 0)
    {
        perror("Error al resolver el host local");
        exit(1);
    }

    bzero(&pin, sizeof(pin));
    pin.sin_family = AF_INET;
    pin.sin_addr.s_addr = htonl(INADDR_ANY);
    pin.sin_addr.s_addr = ((struct in_addr *)(server_host_name->h_addr))->s_addr;
    pin.sin_port = htons(port);

    if((socket_descriptor = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("Error al abrir al socketn");
        exit(1);
    }

    if (connect(socket_descriptor, (void *)&pin, sizeof(pin)) == -1)
    {
        perror("Error de conexion con el socketn");
        exit(1);
    }

    printf("Enviando mensaje %s al servidor...n", str);

    if (send(socket_descriptor, str, strlen(str), 0) == -1)
    {
        perror("Error en sendn");
        exit(1);
    }

    printf("Mensaje enviado... espero respuesta...n");

    if (recv(socket_descriptor, buf, 8192, 0) == -1)
    {
        perror("Error al recibir la respuestan");
        exit(1);
    }

    printf("nRespuesta del servidor nn%sn", buf);

    close(socket_descriptor);
}