Comunicación vía sockets: ejecución

Clase 36 de 37 • Curso de Introducción a C 2019

David Felipe Bohórquez

student•

Todo me funcionó perfecto. Está genial. Voy a intentarlo con máquinas remotas.

Por cierto, ese comando de vim está genial! Platzi debería considerar hacer un curso de vim, es un editor muuy completo :O

Eduardo Sebastián Sandoval Jiménez

student•

Si!!!! Por favor un curso de Vim.

marco antonio

student•

no se imagina por la cantidad de problemas para que esto funcionara y aunque el código del profe en linux es parecido al que yo escribí en windows realmente la sufri ya que casi no hay mucha info al menos en español pero he aquí vivito y coleando ![](

una advertencia Primero cuando compiles tienes que enlasar la libreria winsock de la siguiente forma

Segundo cuando se ejecute salta el sistema de proteccion de windows pero solo hay que darle en aceptar y listo aqui dejo los dos codigos, PD: recientemente instale la terminal del windiws system for linux asi que repetiré los ejercicios pero con el reto de comunicar un programa corriendo en windows y otro en linux jeje XD

/***********************SERVIDOR********************************/

#include <winsock2.h>
#include <winsock.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    if(argc < 2){
        printf("indica un puerto");
        return -1;}

    WSADATA wsaData = {0};
    SOCKET socket_servidor;
    WORD PuertoW = (WORD)atoi( argv[1] );

    SOCKADDR_IN Servidor = {0};
    SOCKADDR_IN Cliente = {0};

    Servidor.sin_family = AF_INET;
    Servidor.sin_port = htons(PuertoW);
    Servidor.sin_addr.s_addr = INADDR_ANY;

    WSAStartup(MAKEWORD(2,2),&wsaData);

    if((socket_servidor = socket(AF_INET, SOCK_STREAM,IPPROTO_IP)) == SOCKET_ERROR){
        printf("_ERROR_ : No se pudo abir el Socket");
        return -2;}

    if( bind( socket_servidor ,(SOCKADDR *)&Servidor,sizeof(Servidor)) == SOCKET_ERROR ){
        printf("Error : al abrir %s",argv[1]);
        closesocket(socket_servidor);
        return -3; }

    printf("Esperando clientes\n");

    listen(socket_servidor , 5);


    int Longitud = sizeof(SOCKADDR_IN);

    SOCKET socket_cliente = accept(socket_servidor, (SOCKADDR *)&socket_cliente, &Longitud);

    if(socket_cliente == SOCKET_ERROR){
        printf("no pudimos aceptar la coneccion\n");
        return  -4;}

    char buff[100];

    printf("Conectando [%s,%d] : %s",inet_ntoa( Cliente.sin_addr),htons(Cliente.sin_port),buff);
    send(socket_cliente,"Bienvenido a mi servidor.\n",26,0);
    printf("el saludo fue enviado\n");
    closesocket(socket_cliente);

    closesocket(socket_servidor);
    WSACleanup();
    return 0;
}

/*************************CLIENTE********************************/

#include <winsock2.h>
#include <windows.h>
#include <stdio.h>

int main(int argc, char ** argv)
{
    if(argc != 3) {
        printf(" introduce: la IP del Cliente y el PUERTO del servidor");
        return -1;}

    WSADATA wsaData = {0};
    SOCKET socket_cliente;
    SOCKADDR_IN Servidor = {0};

    WSAStartup(MAKEWORD(2,2),&wsaData);

    printf("abriendo el socket del cliente\n");

    if((socket_cliente = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR){
        printf("no se pudo abrir el socket\n");
        return -2;}

    Servidor.sin_family = AF_INET;
    Servidor.sin_port = htons((WORD)atoi( argv[2] ));
    Servidor.sin_addr.s_addr = inet_addr(argv[1]);

    printf("conectando %s con %s\n",argv[1],argv[2]);

    if(connect(socket_cliente,(SOCKADDR *)&Servidor,sizeof(Servidor)) == SOCKET_ERROR){
        printf("no pude conectarma al servidor\n");
        return -3;}

    printf("Resibiendo...\n");

    int Envio;
    char buff [100];

    if((Envio = recv(socket_cliente,buff,100, 0)) == -1){
        printf("Error en la lectura\n");
        return -4;}
    buff[Envio] = '\0';
    printf("Elservidor envio el mensaje : '%s'\n",buff);

    closesocket(socket_cliente);
    WSACleanup();
    return 0;
}

Reinaldo Mendoza

student•

Yo espero entenderlo con los próximos que tomare mas adelante y volvere para entender realmente este

Reinaldo Mendoza

student•

Fue muy complicado seguir el paso, felicitaciones por haberlo logrado

Breider Alexander Santacruz Reinoso

student•

El mejor ejercicio del curso! 💪🏽

marco antonio

student•

Como lo prometido es deuda logre hacer una comunicación entre un programa corriendo en linux con un programa corriendo en windows muajajaj el mundo sera mio XD ![](

SOLO unas recomendaciones cuando hayan ejecutado el servidor abran el cmd si están en windows y escriban netstat -ano | findstr :9080 que es el puerto que usamos para este ejemplo ahi veran como el programa realmente abrió el puerto ahora si una vez que haya finalizado su programa escriben denuevo eso y no a cambiado PRIMERO tienen un error en el codigo y toca checarlo y SEGUNDO toca cerrar el puerto de forma manual asi ![](

Bien eso seria todo abajo de este comentario deje el código para hacer este ejercicio en windows y así lo tengan para las dos versiones "de nada" XD

Sebastian Andree Lopera Quevedo

student•

luche un poco para ver algunos errores, no me compilaba. Al final vi lo que mis compañeros dejaron y vi la logica de mi código porque el error no era de sintaxis. Gracias a mis compañeros de curso logre ver que me faltaron paréntesis por algun lado jaja tengan cuidado. Les dejo mi código por si quieren comparar si tienen problemas:

SERVIDOR

//libraries with the needed definitions:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*
struct sockaddr_in
{
  short int sin_family;
  unsigned short int sin_port;
  struct in_addr sin_addr;
  unsigned char sin_zero[8];
};

struct sockaddr
{
  unsigned short sa_family;
  char sa_data[14];
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *myaddr, int addrlen);

int listen(int s, int backlog);

int accept(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

ssize_t recv(int sockfd,       void *buf, size_t len, int flags);

int shotdown();
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
  //the first argument will be the port of communication
  if (argc > 1)
  {
    //the needed variables
    int server_socket, client_socket, longitud_cliente, port;

    //casting the argument to an integer
    port = atoi(argv[1]);

    //defining the n-points
    struct sockaddr_in server;
    struct sockaddr_in client;

    // server variables
    server.sin_family = AF_INET;//protocol type (TCP-IP)
    server.sin_port = htons(port);//the integer with the port number gets transformed to the needed structure
    server.sin_addr.s_addr = INADDR_ANY;//any client could get connected
    bzero(&(server.sin_zero), 8);//this function fulls a string with 0's

    if ((server_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    //a socket is created for the server (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el socket\n");//printed in case of opening error

      return 1;
    }
    if (bind(server_socket, (struct sockaddr *) &server, sizeof(struct sockaddr)) == -1)
    //the server socket is associated to a port (the scoket, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el puerto %s y asociarlo con el socket\n", argv[1]);//this could happen if the port is already opened by other application

      return 2;
    }

    if (listen(server_socket, 5) == -1)
    //the port now is listening for only 5 clients
    //if the function goes right returns a value different of -1
    {
      printf("no pude ponerme en modo escucha\n");

      return 3;
    }

    //accepting clients
    printf("Todo listo! Aceptando clientes...\n");
    longitud_cliente = sizeof(struct sockaddr_in);
    if ((client_socket = accept(server_socket, (struct sockaddr *) &client, &longitud_cliente)) == -1)
    //accepts the first client waiting for service (the server_socket accepts the conection, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("No se pudo establecer conección con \n");

      return 4;
    }

    //at this point the conection has been established

    //in order to see the client's direction...
    char str[INET_ADDRSTRLEN];
    //...transforms a direction to a string (protocol, direction to trasform, pointer to a buffer where the address is going to be saved, max size of the buffer)
    inet_ntop(AF_INET, &(client.sin_addr), str, INET_ADDRSTRLEN);

    //it advice the client connected, his IP and port
    printf("Se conectó un cliente desde la IP: %s, desde el puerto: %d\tlo saludo\n", str, port);

    //send a message to the client (to who, message, size of the message, modificators bit to bit (0 for no one))
    send(client_socket, "Bienvenido a mi pedilecto, sublime y elegante servidor.", 55, 0);

    //advice that the graet has been sent
    printf("Saludo enviado!\n");

    //closing the communication(closing socket, how it gonna be closed (2 for be closed completly))
    shutdown(client_socket, 2);
    shutdown(server_socket, 2);
  }
  else
  //if the port has not been passed by the command parameter
  {
    printf("No se indicó el puerto\n");

    return 5;
  }

  return 0;
}

CLIENTE

//libraries with the needed definitions:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*
struct sockaddr_in
{
  short int sin_family;
  unsigned short int sin_port;
  struct in_addr sin_addr;
  unsigned char sin_zero[8];
};

struct sockaddr
{
  unsigned short sa_family;
  char sa_data[14];
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *myaddr, int addrlen);

int listen(int s, int backlog);

int accept(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

ssize_t recv(int sockfd,       void *buf, size_t len, int flags);

int shotdown();
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
  //the first argument will be the server IP
  //the second argument will be the communication port
  if (argc > 2)
  {
    //a string that holds the server IP
    const char *ip;
    //a socket for the client, the amount of bytes that will be recieved or sent, the port
    int client_socket, numbytes, port;

    char buff[100];//pff it's a buffer

    //giving the respective values to the IP and port
    ip = argv[1];
    port = atoi(argv[2]);
    //server information
    struct sockaddr_in server;

    if (inet_pton(AF_INET, ip, &server.sin_addr) <= 0)
    //convert the argument to an IP address (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    ////if the function goes right returns a value different of -1
    {
      printf("la IP %s no es valida\n", ip);

      return 1;
    }

    //creating the client socket
    printf("Abriendo el socket del cliente...\n");
    if ((client_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    //a socket is created for the client (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el socket\n");

      return 2;
    }

    //server variables to especify which server to connect to
    server.sin_family = AF_INET;//protocol type (TCP-IP)
    server.sin_port = htons(port);//the integer with the port number gets transformed to the needed structure
    bzero(&(server.sin_zero), 8);//this function fulls a string with 0's

    //trying to get connected
    printf("Conectando a IP: %s, desde el puerto: %d\n", ip, port);
    if (connect(client_socket, (struct sockaddr *) &server, sizeof(struct sockaddr)) == -1)
    //the client socket is connecting to a server (the scoket, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("no pude conectarme al servidor\n");

      return 3;
    }

    //recieving message and printing it
    printf("Recibiendo...\n");////////////////
    if ((numbytes = recv(client_socket, buff, 100, 0)) == -1)
    //recieve a message from the server (///////////to who, a pointer to the buffer where the message is gonna be saved, size of the buffer, modificators bit to bit (0 for no one))
    //if the function goes right returns a value different of -1
    {
      printf("no se recibio el mensaje\n");

      return 4;
    }
    buff[numbytes] = '\0';
    printf("El servidor envia:\t'%s'\n", buff);

    //closing the communication(closing socket, how it gonna be closed (2 for be closed completly))
    shutdown(client_socket, 2);
  }
  else
  //if the port has not been passed by the command parameter
  {
    printf("No se indico la IP o el puerto\n");

    return 5;
  }

  return 0;
}```


Todo está bastante bien comentado en inglés asi que espero les sirva.

Luis Gabriel Delgado Sanchez

student•

No encuentro el motivo por el cual mi programa cliente, no conecta con el servidor, valide el codigo y no encuetro el error :|

Alguien puede darme una idea ?

Franz Pool Nuñez Villazana

student•

al momento de correr el programa me va todo bien pero el servidor no envia el mensaje (bienvenido a mi servidor) a mi cliente alguien que pueda encontrar un error en mi codigo

ESTE ES EL CODIGO DE MI SERVIDOR

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

int main(int argc, const char * argv[] )
{
        if(argc > 1){
                int server_socket, client_socket, longitud_cliente, puerto;

                puerto = atoi( argv[1] );

                struct sockaddr_in server;
                struct sockaddr_in client;

                server.sin_family = AF_INET;                                                                                                                                            server.sin_port = htons( puerto );                                                                                                                                      server.sin_addr.s_addr = INADDR_ANY;                                                                                                                                    bzero( &(server.sin_zero), 8);                                                                                                                                                                                                                                                                                                                  if ( ( server_socket = socket( AF_INET, SOCK_STREAM, 0) ) == -1 ){                                                                                                              printf("No pude abrir el socket\n");                                                                                                            
                        return -1;
                }
                if ( bind( server_socket, (struct sockaddr *) &server, sizeof(struct sockaddr) ) == -1 ){

                        printf( "No puede abrir el puerto %s\n", argv[1]);

                        return -2;
                }
                if( listen( server_socket, 5) == -1 ){
                        printf("No pude ponerme en modo escucha\n");

                        return -3;
                }

                longitud_cliente  = sizeof( struct sockaddr );

                printf("esperando clientes.....\n");

                if( ( client_socket == accept( server_socket, (struct sockaddr*) &client, &longitud_cliente ) ) == -1 ){

                        printf("No pudimos aceptar una conexion\n");

                        return -4;
                }
                char str[ INET_ADDRSTRLEN ];
                inet_ntop( AF_INET, &(client.sin_addr), str, INET_ADDRSTRLEN );

                printf("se conecto el cliente desde %s:%d. lo saludo\n", str, client.sin_port );
                send( client_socket, "Bienvenido a mi servidor.\n", 26, 0);

                printf("saludo enviado\n" );
                shutdown( client_socket, 2 );
                shutdown( server_socket, 2 );

        }else{
                printf( "Por favor indique el puerto\n" );

                return -5;
        }
}

**este es el codigo de mi cliente **

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


int main( int argc, const char * argv[] )
{
        if( argc > 2){
                const char *ip;
                int client_socket, numbytes, puerto;
                char buff[100];
                puerto = atoi( argv[2]);                                                                                                                                                ip = argv[1];                                                                                                                                                                                                                                                                                                                                   struct sockaddr_in server;                                                                                                                                                                                                                                                                                                                      if( inet_pton( AF_INET,argv[1], &server.sin_addr ) <= 0 ){                                                                                                                      printf("la ip %s no es valida\n", ip );                                                                                                                                                                                                                                                                                                         return -1;                                                                                                                                                      }
                printf("abriendo el socket\n");

                if( ( client_socket = socket( AF_INET, SOCK_STREAM, 0) ) == -1 ){
                        printf("No pude abrir el socket\n");

                        return -2;
                }
                server.sin_family = AF_INET;
                server.sin_port = htons( puerto );
                bzero( &(server.sin_zero ), 8 );

                printf("conectando a %s:%s\n", argv[1], argv[2]);

                if( connect( client_socket, (struct sockaddr *)&server, sizeof( struct sockaddr ) ) == -1 ){
                        printf("No pude conectarme con el servidor\n");

                        return -3;
                }

                printf("Recibiendo...\n");

                if( ( numbytes = recv( client_socket, buff, 100, 0 )) == -1 ){
                        printf("Error en la lectura\n");

                        return -4;
               }
                buff[numbytes] = '\0';

                printf( "El servidor envio el mensaje '%s'\n", buff );

                shutdown( client_socket, 2 );

        }else{
                printf( "Por favor, indique el ip del servidor y puerto\n" );

                return -5;
        }
}

en la terminal de mi cliente me sale esto

abriendo el socket
conectando a 127.0.0.1:9087
Recibiendo...
El servidor envio el mensaje ''

Miqueas Gamero

student•

Muchos de estos errores ya los había visto anteriormente, pero por dar por hecho lo que el profesor decía se colaron en el código.¡Nunca está demás cuestionarse!!

Diego Lozano Paz

student•

Gracias!

Juan Fernando Romero Ortega

student•

Saludos,

Muchas gracias por el curso. Respecto al modulo de comunicación entre procesos, en windows 10 falta explicación sobre algunos archivo que se deben instalar, pues las librerias de sockets no las encuentra el programa, y esto hace que falle la compilación

Jesus Alexis Garcia Perez

student•

hola disculpe la molestia hay que descargar algun programa o librerias para que funcione el socket

marco antonio

student•

yo lo resolví con windows.h y winsock2.h así que pueden checar el codigo que hice en cada clase lo deje todo ahi

Julián David Cubillos Ortegón

student•

Excelente aplicación de sockets funciono a la perfección, muchas gracias.

David Barreto

student•

Esta tarea de revisar el código me gusta yo lo hago siempre antes de compilarlo.

Carlos Nassif Trejo Garcia

student•

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;

int main(int argc, char const *argv[]) {

  // Direccion ip del server, puerto
  if ( argc &gt; 2) {
      const char *ip;
      int client_socket, numbytes, puerto;
      char buff[100];

      ip = argv[1];
      puerto = atoi( argv[2] );

      // Server al que nos queremos conectar
      struct sockaddr_in server;

      // Convertir el argumento a direccion ip
      if ( inet_pton(AF_INET, ip, &amp;server.sin_addr ) &lt;= 0 ) {
        printf(&quot;La ip %s no es valida\n&quot;, ip);
        return -1;
      }

      printf(&quot;Abriendo el socket&quot;);

      // Abrir el socket del cliente
      if ( ( client_socket = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 ) {
        printf(&quot;No pude abrir el socket\n&quot;);
        return -2;
      }

      // A que server nos vamos a conectar?
      server.sin_family = AF_INET;
      server.sin_port = htons( puerto ); // COnvertir a estrctura
      bzero( &amp;(server.sin_zero), 8 );

      // Intentar la conexion
      printf(&quot;Conectando a %s:%d&quot;, ip, puerto);

      if ( connect( client_socket, (struct sockaddr *) &amp;server, sizeof ( struct sockaddr ) ) == -1 ) {
        printf(&quot;No pude conectarme al servidor\n&quot;);
        return -3;
      }

      // Recibir info del server
      printf(&quot;Recibiendo...\n&quot;);

      if ( ( numbytes = recv ( client_socket, buff, 100, 0 ) ) == -1 ) {
        printf(&quot;Error en la lectura&quot;);
        return -4;
      }

      // Termina
      buff[numbytes] = '\0';

      printf(&quot;El servidor envio el mensaje: %s\n&quot;, buff);
      shutdown( client_socket, 2 );
  }

  // EL usuario no ingreso el puerto por la linea de comandos
  else {
    printf(&quot;Porfavor indique ip del server y el puerto\n&quot;);
    return -5;
  }
  return 0;
}

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;

int main(int argc, char const *argv[]) {

  if ( argc &gt; 1) {
      int server_socket, client_socket, longitud_cliente, puerto;

      puerto = atoi( argv[1] );


      struct sockaddr_in server;
      struct sockaddr_in client;

      // Variables del server
      server.sin_family = AF_INET; // Protocolo TCP/IP
      server.sin_port = htons( puerto ); // Puerto
      server.sin_addr.s_addr = INADDR_ANY; // Firewall (todos se puede conectar)
      bzero( &amp;(server.sin_zero), 8 ); // 8 posiciones llenadas con zeros

      // Crear socket del servidor en modo escucha
      // Familia de Protocolo, protocolo, auto
      if ( ( server_socket = socket( AF_INET, SOCKET_STREAM, 0 ) ) == -1 ) {
        printf(&quot;No puede abrir el socket\n&quot;);
        return -1;
      }

      //Conectar socket a un puerto
      // Guardar config en server
      if ( bind( server_socket, (struct sockaddr *) &amp;server, sizeof( sockaddr ) ) == -1 ) {
        printf(&quot;No pude abrir el puerto %s\n&quot;, argv[1] );
        return -2;
      }

      // Poner el socket en modo escucha definiendo lim de cola
      if ( listen( server_socket, 5) == -1 ) {
        printf(&quot;No pude ponerme en modo escucha&quot;);
        return -3;
      }

      longitud_cliente = sizeof( struct sockaddr_in );

      printf(&quot;Espernaod clientes...\n&quot;);

      // Intentar recibir el primer cliente
      if ( (client_socket = accept( server_socket, (struct sockaddr *) &amp;client, &amp;longitud_cliente ) ) == -1 ) {
        printf(&quot;No pudimos aceptar una conexion\n&quot;);
        return -4;
      }

      char str[INET_ADDRSTRLEN];
      // Priemara conexion a str
      inet_ntop( AF_INET, &amp;(cliente.sin_addr), str, INET_ADDRSTRLEN );
      printf(&quot;Se conecto un cliente desde la ip %s:%d. Lo saludo\n&quot;, str, client.sin_port)

      // Mandando mensaje a la conexion
      send( client_socket, &quot;Bienvenido a mi servidor\n&quot;, 26, 0 );
      printf(&quot;El saludo fue enviado\n&quot;);

      // Cerrar por completo
      shutdown( client_socket, 2 );
      shutdown( server_socket, 2 );

  }

  // EL usuario no ingreso el puerto por la linea de comandos
  else {
    printf(&quot;Porfavor indique el puerto\n&quot;);
    return -5;
  }
  return 0;
}

Jesús Joel Sarabia Félix

student•

Wow GENIAL!

Victor Muchica Farfan

student•

Funciono en el WSL Linux de windows

Christian De León

student•

fue interesante el curso en general, deberia haber una mayor cantidad de cursos del profe Mauro, ya que es un buen profesor (desde mi punto de vista).

Uzi Jonadab Rodríguez

student•

en mi caso lo estuve haciendo en MAC y solo me saltó un error como este:

warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign] if((client_socket = accept(server_socket, (struct sockaddr *) &client, &longitud_cliente)) == -1) { ^~~~~~~~~~~~~~~~~ /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include/sys/socket.h:686:73: note: passing argument to parameter here int accept(int, struct sockaddr * __restrict, socklen_t * __restrict)

La solución fue declarar la variable longitud_cliente como unsigned int:

/***********************SERVIDOR********************************/

#include <winsock2.h>
#include <winsock.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    if(argc < 2){
        printf("indica un puerto");
        return -1;}

    WSADATA wsaData = {0};
    SOCKET socket_servidor;
    WORD PuertoW = (WORD)atoi( argv[1] );

    SOCKADDR_IN Servidor = {0};
    SOCKADDR_IN Cliente = {0};

    Servidor.sin_family = AF_INET;
    Servidor.sin_port = htons(PuertoW);
    Servidor.sin_addr.s_addr = INADDR_ANY;

    WSAStartup(MAKEWORD(2,2),&wsaData);

    if((socket_servidor = socket(AF_INET, SOCK_STREAM,IPPROTO_IP)) == SOCKET_ERROR){
        printf("_ERROR_ : No se pudo abir el Socket");
        return -2;}

    if( bind( socket_servidor ,(SOCKADDR *)&Servidor,sizeof(Servidor)) == SOCKET_ERROR ){
        printf("Error : al abrir %s",argv[1]);
        closesocket(socket_servidor);
        return -3; }

    printf("Esperando clientes\n");

    listen(socket_servidor , 5);


    int Longitud = sizeof(SOCKADDR_IN);

    SOCKET socket_cliente = accept(socket_servidor, (SOCKADDR *)&socket_cliente, &Longitud);

    if(socket_cliente == SOCKET_ERROR){
        printf("no pudimos aceptar la coneccion\n");
        return  -4;}

    char buff[100];

    printf("Conectando [%s,%d] : %s",inet_ntoa( Cliente.sin_addr),htons(Cliente.sin_port),buff);
    send(socket_cliente,"Bienvenido a mi servidor.\n",26,0);
    printf("el saludo fue enviado\n");
    closesocket(socket_cliente);

    closesocket(socket_servidor);
    WSACleanup();
    return 0;
}

/*************************CLIENTE********************************/

#include <winsock2.h>
#include <windows.h>
#include <stdio.h>

int main(int argc, char ** argv)
{
    if(argc != 3) {
        printf(" introduce: la IP del Cliente y el PUERTO del servidor");
        return -1;}

    WSADATA wsaData = {0};
    SOCKET socket_cliente;
    SOCKADDR_IN Servidor = {0};

    WSAStartup(MAKEWORD(2,2),&wsaData);

    printf("abriendo el socket del cliente\n");

    if((socket_cliente = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR){
        printf("no se pudo abrir el socket\n");
        return -2;}

    Servidor.sin_family = AF_INET;
    Servidor.sin_port = htons((WORD)atoi( argv[2] ));
    Servidor.sin_addr.s_addr = inet_addr(argv[1]);

    printf("conectando %s con %s\n",argv[1],argv[2]);

    if(connect(socket_cliente,(SOCKADDR *)&Servidor,sizeof(Servidor)) == SOCKET_ERROR){
        printf("no pude conectarma al servidor\n");
        return -3;}

    printf("Resibiendo...\n");

    int Envio;
    char buff [100];

    if((Envio = recv(socket_cliente,buff,100, 0)) == -1){
        printf("Error en la lectura\n");
        return -4;}
    buff[Envio] = '\0';
    printf("Elservidor envio el mensaje : '%s'\n",buff);

    closesocket(socket_cliente);
    WSACleanup();
    return 0;
}

//libraries with the needed definitions:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*
struct sockaddr_in
{
  short int sin_family;
  unsigned short int sin_port;
  struct in_addr sin_addr;
  unsigned char sin_zero[8];
};

struct sockaddr
{
  unsigned short sa_family;
  char sa_data[14];
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *myaddr, int addrlen);

int listen(int s, int backlog);

int accept(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

ssize_t recv(int sockfd,       void *buf, size_t len, int flags);

int shotdown();
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
  //the first argument will be the port of communication
  if (argc > 1)
  {
    //the needed variables
    int server_socket, client_socket, longitud_cliente, port;

    //casting the argument to an integer
    port = atoi(argv[1]);

    //defining the n-points
    struct sockaddr_in server;
    struct sockaddr_in client;

    // server variables
    server.sin_family = AF_INET;//protocol type (TCP-IP)
    server.sin_port = htons(port);//the integer with the port number gets transformed to the needed structure
    server.sin_addr.s_addr = INADDR_ANY;//any client could get connected
    bzero(&(server.sin_zero), 8);//this function fulls a string with 0's

    if ((server_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    //a socket is created for the server (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el socket\n");//printed in case of opening error

      return 1;
    }
    if (bind(server_socket, (struct sockaddr *) &server, sizeof(struct sockaddr)) == -1)
    //the server socket is associated to a port (the scoket, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el puerto %s y asociarlo con el socket\n", argv[1]);//this could happen if the port is already opened by other application

      return 2;
    }

    if (listen(server_socket, 5) == -1)
    //the port now is listening for only 5 clients
    //if the function goes right returns a value different of -1
    {
      printf("no pude ponerme en modo escucha\n");

      return 3;
    }

    //accepting clients
    printf("Todo listo! Aceptando clientes...\n");
    longitud_cliente = sizeof(struct sockaddr_in);
    if ((client_socket = accept(server_socket, (struct sockaddr *) &client, &longitud_cliente)) == -1)
    //accepts the first client waiting for service (the server_socket accepts the conection, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("No se pudo establecer conección con \n");

      return 4;
    }

    //at this point the conection has been established

    //in order to see the client's direction...
    char str[INET_ADDRSTRLEN];
    //...transforms a direction to a string (protocol, direction to trasform, pointer to a buffer where the address is going to be saved, max size of the buffer)
    inet_ntop(AF_INET, &(client.sin_addr), str, INET_ADDRSTRLEN);

    //it advice the client connected, his IP and port
    printf("Se conectó un cliente desde la IP: %s, desde el puerto: %d\tlo saludo\n", str, port);

    //send a message to the client (to who, message, size of the message, modificators bit to bit (0 for no one))
    send(client_socket, "Bienvenido a mi pedilecto, sublime y elegante servidor.", 55, 0);

    //advice that the graet has been sent
    printf("Saludo enviado!\n");

    //closing the communication(closing socket, how it gonna be closed (2 for be closed completly))
    shutdown(client_socket, 2);
    shutdown(server_socket, 2);
  }
  else
  //if the port has not been passed by the command parameter
  {
    printf("No se indicó el puerto\n");

    return 5;
  }

  return 0;
}

//libraries with the needed definitions:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*
struct sockaddr_in
{
  short int sin_family;
  unsigned short int sin_port;
  struct in_addr sin_addr;
  unsigned char sin_zero[8];
};

struct sockaddr
{
  unsigned short sa_family;
  char sa_data[14];
};

int socket(int domain, int type, int protocol);

int bind(int sockfd, const struct sockaddr *myaddr, int addrlen);

int listen(int s, int backlog);

int accept(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

ssize_t recv(int sockfd,       void *buf, size_t len, int flags);

int shotdown();
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
  //the first argument will be the server IP
  //the second argument will be the communication port
  if (argc > 2)
  {
    //a string that holds the server IP
    const char *ip;
    //a socket for the client, the amount of bytes that will be recieved or sent, the port
    int client_socket, numbytes, port;

    char buff[100];//pff it's a buffer

    //giving the respective values to the IP and port
    ip = argv[1];
    port = atoi(argv[2]);
    //server information
    struct sockaddr_in server;

    if (inet_pton(AF_INET, ip, &server.sin_addr) <= 0)
    //convert the argument to an IP address (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    ////if the function goes right returns a value different of -1
    {
      printf("la IP %s no es valida\n", ip);

      return 1;
    }

    //creating the client socket
    printf("Abriendo el socket del cliente...\n");
    if ((client_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    //a socket is created for the client (protocol family, specific protocol (TCP/IP), configuration (0 for automatic configuration))
    //if the function goes right returns a value different of -1
    {
      printf("no pude abrir el socket\n");

      return 2;
    }

    //server variables to especify which server to connect to
    server.sin_family = AF_INET;//protocol type (TCP-IP)
    server.sin_port = htons(port);//the integer with the port number gets transformed to the needed structure
    bzero(&(server.sin_zero), 8);//this function fulls a string with 0's

    //trying to get connected
    printf("Conectando a IP: %s, desde el puerto: %d\n", ip, port);
    if (connect(client_socket, (struct sockaddr *) &server, sizeof(struct sockaddr)) == -1)
    //the client socket is connecting to a server (the scoket, a pointer to a socket address structure for the configuration, size of the structure)
    //if the function goes right returns a value different of -1
    {
      printf("no pude conectarme al servidor\n");

      return 3;
    }

    //recieving message and printing it
    printf("Recibiendo...\n");////////////////
    if ((numbytes = recv(client_socket, buff, 100, 0)) == -1)
    //recieve a message from the server (///////////to who, a pointer to the buffer where the message is gonna be saved, size of the buffer, modificators bit to bit (0 for no one))
    //if the function goes right returns a value different of -1
    {
      printf("no se recibio el mensaje\n");

      return 4;
    }
    buff[numbytes] = '\0';
    printf("El servidor envia:\t'%s'\n", buff);

    //closing the communication(closing socket, how it gonna be closed (2 for be closed completly))
    shutdown(client_socket, 2);
  }
  else
  //if the port has not been passed by the command parameter
  {
    printf("No se indico la IP o el puerto\n");

    return 5;
  }

  return 0;
}```


Todo está bastante bien comentado en inglés asi que espero les sirva.

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

int main(int argc, const char * argv[] )
{
        if(argc > 1){
                int server_socket, client_socket, longitud_cliente, puerto;

                puerto = atoi( argv[1] );

                struct sockaddr_in server;
                struct sockaddr_in client;

                server.sin_family = AF_INET;                                                                                                                                            server.sin_port = htons( puerto );                                                                                                                                      server.sin_addr.s_addr = INADDR_ANY;                                                                                                                                    bzero( &(server.sin_zero), 8);                                                                                                                                                                                                                                                                                                                  if ( ( server_socket = socket( AF_INET, SOCK_STREAM, 0) ) == -1 ){                                                                                                              printf("No pude abrir el socket\n");                                                                                                            
                        return -1;
                }
                if ( bind( server_socket, (struct sockaddr *) &server, sizeof(struct sockaddr) ) == -1 ){

                        printf( "No puede abrir el puerto %s\n", argv[1]);

                        return -2;
                }
                if( listen( server_socket, 5) == -1 ){
                        printf("No pude ponerme en modo escucha\n");

                        return -3;
                }

                longitud_cliente  = sizeof( struct sockaddr );

                printf("esperando clientes.....\n");

                if( ( client_socket == accept( server_socket, (struct sockaddr*) &client, &longitud_cliente ) ) == -1 ){

                        printf("No pudimos aceptar una conexion\n");

                        return -4;
                }
                char str[ INET_ADDRSTRLEN ];
                inet_ntop( AF_INET, &(client.sin_addr), str, INET_ADDRSTRLEN );

                printf("se conecto el cliente desde %s:%d. lo saludo\n", str, client.sin_port );
                send( client_socket, "Bienvenido a mi servidor.\n", 26, 0);

                printf("saludo enviado\n" );
                shutdown( client_socket, 2 );
                shutdown( server_socket, 2 );

        }else{
                printf( "Por favor indique el puerto\n" );

                return -5;
        }
}

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


int main( int argc, const char * argv[] )
{
        if( argc > 2){
                const char *ip;
                int client_socket, numbytes, puerto;
                char buff[100];
                puerto = atoi( argv[2]);                                                                                                                                                ip = argv[1];                                                                                                                                                                                                                                                                                                                                   struct sockaddr_in server;                                                                                                                                                                                                                                                                                                                      if( inet_pton( AF_INET,argv[1], &server.sin_addr ) <= 0 ){                                                                                                                      printf("la ip %s no es valida\n", ip );                                                                                                                                                                                                                                                                                                         return -1;                                                                                                                                                      }
                printf("abriendo el socket\n");

                if( ( client_socket = socket( AF_INET, SOCK_STREAM, 0) ) == -1 ){
                        printf("No pude abrir el socket\n");

                        return -2;
                }
                server.sin_family = AF_INET;
                server.sin_port = htons( puerto );
                bzero( &(server.sin_zero ), 8 );

                printf("conectando a %s:%s\n", argv[1], argv[2]);

                if( connect( client_socket, (struct sockaddr *)&server, sizeof( struct sockaddr ) ) == -1 ){
                        printf("No pude conectarme con el servidor\n");

                        return -3;
                }

                printf("Recibiendo...\n");

                if( ( numbytes = recv( client_socket, buff, 100, 0 )) == -1 ){
                        printf("Error en la lectura\n");

                        return -4;
               }
                buff[numbytes] = '\0';

                printf( "El servidor envio el mensaje '%s'\n", buff );

                shutdown( client_socket, 2 );

        }else{
                printf( "Por favor, indique el ip del servidor y puerto\n" );

                return -5;
        }
}

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;

int main(int argc, char const *argv[]) {

  // Direccion ip del server, puerto
  if ( argc &gt; 2) {
      const char *ip;
      int client_socket, numbytes, puerto;
      char buff[100];

      ip = argv[1];
      puerto = atoi( argv[2] );

      // Server al que nos queremos conectar
      struct sockaddr_in server;

      // Convertir el argumento a direccion ip
      if ( inet_pton(AF_INET, ip, &amp;server.sin_addr ) &lt;= 0 ) {
        printf(&quot;La ip %s no es valida\n&quot;, ip);
        return -1;
      }

      printf(&quot;Abriendo el socket&quot;);

      // Abrir el socket del cliente
      if ( ( client_socket = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 ) {
        printf(&quot;No pude abrir el socket\n&quot;);
        return -2;
      }

      // A que server nos vamos a conectar?
      server.sin_family = AF_INET;
      server.sin_port = htons( puerto ); // COnvertir a estrctura
      bzero( &amp;(server.sin_zero), 8 );

      // Intentar la conexion
      printf(&quot;Conectando a %s:%d&quot;, ip, puerto);

      if ( connect( client_socket, (struct sockaddr *) &amp;server, sizeof ( struct sockaddr ) ) == -1 ) {
        printf(&quot;No pude conectarme al servidor\n&quot;);
        return -3;
      }

      // Recibir info del server
      printf(&quot;Recibiendo...\n&quot;);

      if ( ( numbytes = recv ( client_socket, buff, 100, 0 ) ) == -1 ) {
        printf(&quot;Error en la lectura&quot;);
        return -4;
      }

      // Termina
      buff[numbytes] = '\0';

      printf(&quot;El servidor envio el mensaje: %s\n&quot;, buff);
      shutdown( client_socket, 2 );
  }

  // EL usuario no ingreso el puerto por la linea de comandos
  else {
    printf(&quot;Porfavor indique ip del server y el puerto\n&quot;);
    return -5;
  }
  return 0;
}

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;

int main(int argc, char const *argv[]) {

  if ( argc &gt; 1) {
      int server_socket, client_socket, longitud_cliente, puerto;

      puerto = atoi( argv[1] );


      struct sockaddr_in server;
      struct sockaddr_in client;

      // Variables del server
      server.sin_family = AF_INET; // Protocolo TCP/IP
      server.sin_port = htons( puerto ); // Puerto
      server.sin_addr.s_addr = INADDR_ANY; // Firewall (todos se puede conectar)
      bzero( &amp;(server.sin_zero), 8 ); // 8 posiciones llenadas con zeros

      // Crear socket del servidor en modo escucha
      // Familia de Protocolo, protocolo, auto
      if ( ( server_socket = socket( AF_INET, SOCKET_STREAM, 0 ) ) == -1 ) {
        printf(&quot;No puede abrir el socket\n&quot;);
        return -1;
      }

      //Conectar socket a un puerto
      // Guardar config en server
      if ( bind( server_socket, (struct sockaddr *) &amp;server, sizeof( sockaddr ) ) == -1 ) {
        printf(&quot;No pude abrir el puerto %s\n&quot;, argv[1] );
        return -2;
      }

      // Poner el socket en modo escucha definiendo lim de cola
      if ( listen( server_socket, 5) == -1 ) {
        printf(&quot;No pude ponerme en modo escucha&quot;);
        return -3;
      }

      longitud_cliente = sizeof( struct sockaddr_in );

      printf(&quot;Espernaod clientes...\n&quot;);

      // Intentar recibir el primer cliente
      if ( (client_socket = accept( server_socket, (struct sockaddr *) &amp;client, &amp;longitud_cliente ) ) == -1 ) {
        printf(&quot;No pudimos aceptar una conexion\n&quot;);
        return -4;
      }

      char str[INET_ADDRSTRLEN];
      // Priemara conexion a str
      inet_ntop( AF_INET, &amp;(cliente.sin_addr), str, INET_ADDRSTRLEN );
      printf(&quot;Se conecto un cliente desde la ip %s:%d. Lo saludo\n&quot;, str, client.sin_port)

      // Mandando mensaje a la conexion
      send( client_socket, &quot;Bienvenido a mi servidor\n&quot;, 26, 0 );
      printf(&quot;El saludo fue enviado\n&quot;);

      // Cerrar por completo
      shutdown( client_socket, 2 );
      shutdown( server_socket, 2 );

  }

  // EL usuario no ingreso el puerto por la linea de comandos
  else {
    printf(&quot;Porfavor indique el puerto\n&quot;);
    return -5;
  }
  return 0;
}

Comunicación vía sockets: ejecución

Comprender qué es el lenguaje C

¿Dónde aprender C?

Introducción al curso

Herramientas para programar en C

Aprender los conceptos iniciales del lenguaje C

Compilación y ejecución de un programa en C

Tipos de datos

Definición de variables

Control de flujos

Uso y definición de funciones

Directivas de pre-compilador

Conceptos esenciales

Entender conceptos más profundos del lenguaje C

Punteros

Usos prácticos de los punteros

Aritmética de punteros

Arreglos

Strings

Strings y memoria

Parámetros de línea de comandos

Definición de tipos de datos estructurados

Alias de tipos de datos

Crear bibliotecas propias

Comprender los desafìos de la administración de la memoria

Manejo dinámico de la memoria

Cómo instalar Valgrind

Memory leaks y Garbage Collectors

Listas enlazadas

Ejercicio práctico de listas enlazadas

Liberando las listas enlazadas

Reto: Modifica el programa para que permita eliminar los nodos en los que se encuentre un determinado número

Usos prácticos

Cálculos complejos

Manejo de archivos de texto

Manejo de archivos binarios

Paralelismo

Comunicación entre procesos

Pipes

Sockets

Sockets: Código del servidor

Sockets: código de cliente

Comunicación vía sockets: ejecución

Conclusiones

Conclusiones