enchufes Berkeley

A medida que la API de sockets de Berkeley evolucionó y finalmente dio lugar a la API de sockets POSIX, ^{[ 2 ]} ciertas funciones fueron descontinuadas o eliminadas y reemplazadas por otras. La API POSIX también está diseñada para ser reentrante y admite IPv6.

The STREAMS-based Transport Layer Interface (TLI) API offers an alternative to the socket API. Many systems that provide the TLI API also provide the Berkeley socket API.

Non-Unix systems often expose the Berkeley socket API with a translation layer to a native networking API. Plan 9^[3] and Genode^[4] use file-system APIs with control files rather than file-descriptors.

La función socket()crea un punto final para la comunicación y devuelve un descriptor de archivo para el socket. Utiliza tres argumentos:

• domain, que especifica la familia de protocolos del socket creado. Por ejemplo:
  • PF_INET para el protocolo de red IPv4 (solo IPv4)
  • PF_INET6 para IPv6 (y en algunos casos, compatible con versiones anteriores de IPv4)
  • PF_UNIX para socket local (usando un nodo de sistema de archivos especial)
• type, uno de:
  • SOCK_STREAM (servicio confiable orientado a flujos o sockets de flujo )
  • SOCK_DGRAM (servicio de datagramas o sockets de datagramas )
  • SOCK_SEQPACKET (servicio confiable de paquetes secuenciados)
  • SOCK_RAW (protocolos sin procesar sobre la capa de red)
• protocolEspecifica el protocolo de transporte que se utilizará. Los más comunes son IPPROTO_TCP , IPPROTO_SCTP , IPPROTO_UDP e IPPROTO_DCCP . Estos protocolos se especifican en el archivo . El valor 0 permite seleccionar un protocolo predeterminado del dominio y tipo seleccionados.<netinet/in.h>

La función devuelve -1 si se produjo un error. En caso contrario, devuelve un número entero que representa el descriptor recién asignado.

bind()asocia un socket con una dirección. Cuando se crea un socket con socket(), solo se le asigna una familia de protocolo, pero no una dirección. Esta asociación debe realizarse antes de que el socket pueda aceptar conexiones de otros hosts. La función tiene tres argumentos:

• sockfd, un descriptor que representa el socket
• my_addr, un puntero a una sockaddrestructura que representa la dirección a la que enlazar.
• addrlen, un campo de tipo socklen_tque especifica el tamaño de la sockaddrestructura.

bind()Devuelve 0 si la operación se realiza correctamente y -1 si se produce un error.

Después de que un socket se ha asociado con una dirección, listen()lo prepara para conexiones entrantes. Sin embargo, esto solo es necesario para los modos de datos orientados a flujo (orientados a conexión), es decir, para los tipos de socket ( SOCK_STREAM, SOCK_SEQPACKET). listen()requiere dos argumentos:

• sockfd, un descriptor de socket válido.
• backlog, un número entero que representa la cantidad de conexiones pendientes que pueden estar en cola en un momento dado. El sistema operativo suele poner un límite a este valor.

Una vez aceptada la conexión, se extrae de la cola. Si la operación es exitosa, se devuelve 0. Si se produce un error, se devuelve -1.

Cuando una aplicación está a la espera de conexiones orientadas a flujo desde otros hosts, se le notifica de dichos eventos (véase select()la función) y debe inicializar la conexión utilizando la función accept(). Esta crea un nuevo socket para cada conexión y elimina la conexión de la cola de escucha. La función tiene los siguientes argumentos:

• sockfd, el descriptor del socket de escucha que tiene la conexión en cola.
• cliaddr, un puntero a una estructura sockaddr para recibir la información de la dirección del cliente.
• addrlen, un puntero a una socklen_tubicación que especifica el tamaño de la estructura de dirección del cliente pasada a accept(). Cuando accept()regresa, esta ubicación contiene el tamaño (en bytes) de la estructura.

accept()Devuelve el nuevo descriptor de socket para la conexión aceptada, o el valor -1 si se produce un error. Toda la comunicación posterior con el host remoto se realizará a través de este nuevo socket.

Los sockets de datagramas no requieren procesamiento, accept()ya que el receptor puede responder inmediatamente a la solicitud utilizando el socket de escucha.

connect()Establece un enlace de comunicación directo con un host remoto específico, identificado por su dirección, a través de un socket, identificado por su descriptor de archivo.

Al utilizar un protocolo orientado a la conexión , se establece una conexión. Algunos tipos de protocolos no requieren conexión, especialmente el Protocolo de Datagramas de Usuario (UDP ). Al utilizarse con protocolos sin conexión, connectse define la dirección remota para enviar y recibir datos, lo que permite el uso de funciones como sendy recv. En estos casos, la función connect impide la recepción de datagramas de otras fuentes.

connect()Devuelve un entero que representa el código de error: 0 representa éxito, mientras que –1 representa un error. Históricamente, en los sistemas derivados de BSD, el estado de un descriptor de socket es indefinido si la llamada a falla (como se especifica en la Especificación Única de Unix ), por lo tanto, las aplicaciones portátiles deben cerrar el descriptor de socket inmediatamente y obtener un nuevo descriptor con , en caso de que la llamada a falle. ^{[ 5 ]}connectsocket()connect()

Las funciones gethostbyname()y gethostbyaddr()se utilizan para resolver nombres de host y direcciones en el sistema de nombres de dominio u otros mecanismos de resolución del host local (por ejemplo, /etc/hostsbúsqueda). Devuelven un puntero a un objeto de tipo struct hostent, que describe un host de protocolo de Internet . Las funciones utilizan los siguientes argumentos:

• nameespecifica el nombre del host.
• addrespecifica un puntero que struct in_addrcontiene la dirección del host.
• lenespecifica la longitud, en bytes, de addr.
• typeespecifica el tipo de familia de direcciones (por ejemplo, AF_INET) de la dirección del host.

Las funciones devuelven un valor en caso de error, en cuyo caso se puede comprobar NULLel entero externo para determinar si se trata de un fallo temporal o de un host no válido o desconocido. De lo contrario, se devuelve un valor válido.h_errnostruct hostent*

Estas funciones no son estrictamente un componente de la API de sockets BSD, pero a menudo se utilizan junto con las funciones de la API para buscar un host. Estas funciones ahora se consideran interfaces heredadas para consultar el sistema de nombres de dominio. Se han definido nuevas funciones que son completamente independientes del protocolo (compatibles con IPv6). Estas nuevas funciones son getaddrinfo() y getnameinfo() , y se basan en una nueva estructura de datos . ^{[ 6 ]}[[addrinfo]]

Este par de funciones apareció al mismo tiempo que la API de sockets BSD propiamente dicha en 4.2BSD (1983), ^{[ 7 ]} el mismo año en que se creó DNS por primera vez. Las primeras versiones no consultaban DNS y solo realizaban búsquedas en /etc/hosts. La versión 4.3BSD (1984) añadió DNS de forma rudimentaria. La implementación actual que utiliza Name Service Switch deriva de Solaris y posteriormente de NetBSD 1.4 (1999). ^{[ 8 ]} Inicialmente definido para NIS+ , NSS hace que DNS sea solo una de las muchas opciones de búsqueda para estas funciones y su uso puede deshabilitarse incluso hoy en día. ^{[ 9 ]}

Los sockets sin procesar proporcionan una interfaz sencilla que evita el procesamiento por parte de la pila TCP/IP del host. Permiten la implementación de protocolos de red en el espacio de usuario y facilitan la depuración de la pila de protocolos. ^{[ 13 ]} Algunos servicios, como ICMP , que operan en la capa de Internet del modelo TCP/IP, utilizan sockets sin procesar .

Para establecer un servidor TCP se siguen los siguientes pasos básicos:

• Creación de un socket TCP con una llamada a socket().
• Vinculación del socket al puerto de escucha bind()después de configurar el número de puerto.
• Preparando el socket para escuchar conexiones (convirtiéndolo en un socket de escucha), con una llamada a listen().
• Aceptando conexiones entrantes ( accept()). Esto bloquea el proceso hasta que se recibe una conexión entrante y devuelve un descriptor de socket para la conexión aceptada. El descriptor inicial permanece como un descriptor de escucha y accept()puede volver a llamarse en cualquier momento con este socket, hasta que se cierre.
• Comunicación con el host remoto mediante las funciones API send()y recv(), así como mediante las funciones de propósito general write()y read().
• Cerrando cada toma que se abrió después de su uso con la funciónclose()

El siguiente programa crea un servidor TCP que escucha en el puerto número 1100:

#include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h>#include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #include <sys/types.h> #include <unistd.h> int main ( void ) { int sockfd = socket ( PF_INET , SOCK_STREAM , IPPROTO_TCP ); if ( sockfd == -1 ) { fprintf ( stderr , "¡Error al crear el socket! \n " ); return EXIT_FAILURE ; } struct sockaddr_in sa = { . sin_family = AF_INET , . sin_port = htons ( 1100 ), . sin_addr . s_addr = htonl ( INADDR_ANY ) }; if ( bind ( sockfd , ( struct sockaddr * ) & sa , sizeof ( sa )) == -1 ) { fprintf ( stderr , "¡Error al enlazar el socket! \n " ); close ( sockfd ); return EXIT_FAILURE ; } if ( listen ( sockfd , 10 ) == -1 ) { fprintf ( stderr , "¡Error al escuchar en el socket! \n " ); close ( sockfd ); return EXIT_FAILURE ; } while ( true ) { int connfd = accept ( sockfd , NULL , NULL ); if ( connfd == -1 ) { fprintf ( stderr , "¡Error al aceptar la conexión! \n " ); close ( sockfd ); returnEXIT_FAILURE ; } // realizar operaciones de lectura y escritura... // read(connfd, buff, size) if ( shutdown ( connfd , SHUT_RDWR ) == -1 ) { fprintf ( stderr , "¡Error al cerrar la conexión! \n " ); close ( connfd ); close ( sockfd ); return EXIT_FAILURE ; } close ( connfd ); }cerrar ( sockfd ); devolver SALIDA_ÉXITA ; }

La programación de una aplicación cliente TCP implica los siguientes pasos:

• Creando un socket TCP.
• Conectarse al servidor ( connect()), pasando una sockaddr_inestructura con el sin_familyvalor establecido en AF_INET , establecido en el puerto en el que el punto final está escuchando (en orden de bytes de red) y establecido en la dirección IP del servidor que escucha (también en orden de bytes de red).sin_portsin_addr
• Comunicación con el host remoto mediante las funciones API send()y recv(), así como mediante las funciones de propósito general write()y read().
• Cerrando cada enchufe que se abrió después de su uso con la función close().

#include <stdio.h> #include <stdlib.h> #include <string.h>#include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #include <sys/types.h> #include <unistd.h> int main ( void ) { int sockfd = socket ( PF_INET , SOCK_STREAM , IPPROTO_TCP ); if ( sockfd == -1 ) { fprintf ( stderr , "¡Error al crear el socket! \n " ); return EXIT_FAILURE ; } struct sockaddr_in sa = { . sin_family = AF_INET , . sin_port = htons ( 1100 ), }; int res = inet_pton ( AF_INET , "192.168.1.3" , & sa . sin_addr );if ( connect ( sockfd , ( struct sockaddr * ) & sa , sizeof ( sa )) == -1 ) { fprintf ( stderr , "¡Error al establecer la conexión! \n " ); close ( sockfd ); return EXIT_FAILURE ; } // realizar operaciones de lectura y escritura... close ( sockfd ); return EXIT_SUCCESS ; }

Una aplicación puede configurar un servidor UDP en el número de puerto 7654de la siguiente manera. El programa contiene un bucle infinito que recibe datagramas UDP con la función recvfrom().

#include <stdbool.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <string.h>#include <netinet/in.h> #include <sys/socket.h> #include <sys/types.h> #include <unistd.h>int main ( void ) { struct sockaddr_in sa = { . sin_family = AF_INET , . sin_addr . s_addr = htonl ( INADDR_ANY ), . sin_port = htons ( 7654 ) }; char buffer [ 1024 ]; ssize_t recsize ; socklen_t fromlen = sizeof ( sa );int sock = socket ( PF_INET , SOCK_DGRAM , IPPROTO_UDP ); if ( bind ( sock , ( struct sockaddr * ) & sa , sizeof ( sa )) == -1 ) { fprintf ( stderr , "¡Error al enlazar el socket! \n " ); close ( sock ); return EXIT_FAILURE ; }while ( true ) { recsize = recvfrom ( sock , ( void * ) buffer , sizeof buffer , 0 , ( struct sockaddr * ) & sa , & fromlen ); if ( recsize < 0 ) { fprintf ( stderr , "%s \n " , strerror ( errno )); return EXIT_FAILURE ; } printf ( "recsize: %d \n " , ( int ) recsize ); sleep ( 1 ); printf ( "datagrama: %.*s \n " , ( int ) recsize , buffer ); } }

El siguiente es un programa cliente para enviar un paquete UDP que contiene la cadena "Hello, world!" a la dirección 127.0.0.1en el puerto número 7654.

#include <errno.h> #include <stdlib.h> #include <stdio.h> #include <string.h>#include <arpa/inet.h> #include <netinet/in.h> #include <sys/socket.h> #include <sys/types.h> #include <unistd.h>int main ( void ) { struct sockaddr_in sa = { // La dirección es IPv4 . sin_family = AF_INET , // Las direcciones IPv4 son un uint32_t, convierte una representación de cadena de los octetos al valor apropiado . sin_addr . s_addr = inet_addr ( "127.0.0.1" ), // Los sockets son shorts sin signo, htons(x) asegura que x esté en orden de bytes de red, establece el puerto en 7654 . sin_port = htons ( 7654 ) }; char buffer [ 200 ]; strcpy ( buffer , "¡Hola, mundo!" );// Crea un socket de datagramas de Internet usando UDP int sock = socket ( PF_INET , SOCK_DGRAM , IPPROTO_UDP ); if ( sock == -1 ) { // Si el socket no se pudo inicializar, salir fprintf ( stderr , "¡Error al crear el socket! \n " ); return EXIT_FAILURE ; }// Enviar mensaje usando sendto() int bytes_sent = sendto ( sock , buffer , strlen ( buffer ), 0 , ( struct sockaddr * ) & sa , sizeof ( sa ));if ( bytes_sent < 0 ) { fprintf ( stderr , "Error al enviar el paquete: %s \n " , strerror ( errno )); return EXIT_FAILURE ; } close ( sock ); // cerrar el socket return 0 ; }

En este código, bufferes un puntero a los datos que se van a enviar y buffer_lengthespecifica el tamaño de los datos.