Tutoriales

Programación de sockets C++

La programación de sockets se ha convertido en un tema importante en el campo de las redes informáticas. Se trata de establecer una conexión entre dos nodos, servidor y cliente, para comunicarse entre sí sin interrupción. El servidor actúa como escucha en el canal de comunicación y escucha a los clientes en un puerto específico en una dirección IP. El cliente, por su parte, actúa como comunicador en el canal de comunicación. El cliente se pone en contacto con el servidor para establecer una conexión y establecer contacto con el servidor. Este artículo tiene como objetivo proporcionar una guía completa y detallada para la programación de sockets en C++, cubriendo los conceptos básicos, brindando ejemplos prácticos y explicaciones detalladas del código.

Crear un modelo cliente-servidor

La programación de sockets es el proceso de utilizar sockets para establecer un canal de comunicación entre un servidor y un cliente. En el siguiente código de ejemplo, un cliente inicia contacto con el servidor y el servidor está configurado para aceptar conexiones de clientes. Aprendamos sobre los fragmentos de servidor y cliente demostrando su trabajo principal en la comunicación de red. A continuación se muestra el código del lado del servidor. Primero veamos el código y luego expliquemos el código en detalle punto por punto.

1. Lado del servidor

El código para el lado del servidor del modelo se proporciona a continuación. Veamos qué está pasando en el código:

#incluir
#incluir
#incluir
#incluir

usar espacio de nombres estándar;

#definicionport8080
#definir MAX_BUF_SIZE 1024

entero principal() {
entero ser_socket, cli_socket;
Estructura sockaddr_in ser_address, cli_address;
personaje buffer[MAX_BUF_SIZE] = {};

si ((ser_socket = enchufe(AF_INET, SOCK_STREAM, )) == 1) {
error(«Error al crear el socket»);
salida(Salida fallida);
}

dirección_ser.familia de pecado = AF_INET;
dirección_ser.dirección acusada.s_dirección = INADDR_ANY;
dirección_ser.puerto del pecado = Hutton(puerto);

si (vinculante(ser_socket, (Estructura dirección de socket*)&dirección_ser, tamaño(Dirección de Servicio)) == 1) {
error(«Error de enlace»);
salida(Salida fallida);
}

si (escuchar(ser_socket, 3) == 1) {
error(“No entendí”);
salida(Salida fallida);
}

kut < «Puerto de escucha del servidor» < puerto < «…\norte«;

socklen_t cli_address_len = tamaño(dirección_cli);
si ((cli_socket = aceptar(ser_socket, (Estructura dirección de socket*)&dirección_cli, &cli_address_len)) == 1) {
error(«No se puede aceptar»);
salida(Salida fallida);
}

leer(cli_socket,buf,MAX_BUF_SIZE);
kut < «El mensaje del cliente es:» < buffer <endel;

transmitir(cli_socket, «Mensaje del servidor», Strom(«Mensaje del servidor»), );

cierre(cli_socket);
cierre(ser_socket);

devolver ;
}

El ejemplo dado es el código del lado del servidor de un programa C++. Este código es para un servidor TCP simple que escucha conexiones en un único puerto específico. Una vez que la conexión se establezca correctamente, el servidor recibirá el mensaje enviado por el cliente. Luego lo imprime en la consola y envía un mensaje de respuesta al cliente. Entendamos cada línea de código.

El programa contiene primero las siguientes bibliotecas de funciones: «iostream» para definiciones estándar de entrada/salida, «cstring» para funciones de procesamiento de cadenas, «unistd.h» para proporcionar acceso a la API del sistema operativo POSIX, «arpa/inet. h» es se utiliza para proporcionar acceso a la API del sistema operativo POSIX. Realizar operaciones de Internet. La declaración «#define PORT 8080» significa que define el número de puerto 8080 en el que escuchará el servidor. «#define MAX_BUF_SIZE 1024» significa que el tamaño máximo del búfer de datos entrantes es 1024.

En la función principal, se inicializan dos variables «ser_socket» y «cli_socket», que representan el servidor y el cliente respectivamente. Las otras tres variables «sockaddr_in», «ser_address» y «cli_address» de tipo «struct» se inicializan en las estructuras de direcciones del servidor y del cliente. Luego, se inicializa un búfer llamado «buf» para almacenar datos del cliente.

La función socket() en la condición «if» establecerá un nuevo socket TCP. AF_INET representa IPv4, SOCK_STREAM representa un socket TCP confiable orientado a la conexión, el último parámetro es 0 para seleccionar el protocolo TCP predeterminado, INADDR_ANY acepta conexiones en cualquier dirección IP, htons (PORT) cambia el número de puerto de conexión del orden de bytes del host a la red orden de bytes.

Ahora que todo está correctamente definido, el siguiente paso es configurar el servidor para que liste en un puerto determinado y acepte conexiones desde cualquier interfaz de red. A través del método bind(), el socket viene dado por la información en «ser_address». Si la vinculación falla, imprimimos un error y finalizamos el proceso. La función aceptar() abre un nuevo socket para conectarse al cliente, mientras que la función escuchar() le indica al servidor que espere las conexiones entrantes. Si la función aceptar() falla, se imprimirá un mensaje de error y la función se cerrará.

A continuación, el servidor utiliza la función read() para leer el mensaje del cliente en el búfer «buf» y luego lo imprime en la consola. El servidor utiliza la función send() para enviar mensajes en respuesta al cliente. Finalmente, usando close(), el servidor cierra el socket del cliente y finaliza el programa para que todas las conexiones se cierren correctamente y no haya posibilidad de fuga de datos.

2. Cliente

Ahora, veamos qué sucede en el modelo de cliente:

#incluir
#incluir
#incluir
#incluir

#definicionport8080
#Definir SERVER_IP «127.0.0.1»

entero principal() {
entero cli_socket;
Estructura sockaddr_in ser_address;
constante personaje* información = “¡Los clientes envían saludos!”;

si ((cli_socket = enchufe(AF_INET, SOCK_STREAM, )) == 1) {
error(«Error al crear el socket»);
salida(Salida fallida);
}

dirección_ser.familia de pecado = AF_INET;
dirección_ser.puerto del pecado = Hutton(puerto);

si (nate_pton(AF_INET, servidor_IP, &dirección_ser.dirección acusada) <= ) {
error(«dirección incorrecta»);
salida(Salida fallida);
}

si (conectar(cli_socket, (Estructura dirección de socket*)&dirección_ser, tamaño(Dirección de Servicio)) == 1) {
error(«La conexión falló»);
salida(Salida fallida);
}
transmitir(cli_socket, mensaje, Strom(información), );

personaje buffer[1024] = {};
leer(cli_socket, buf, tamaño(buffer));
estándar::kut < «Respuesta del servidor:» < buffer < estándar::endel;

cierre(cli_socket);
devolver ;
}

Veamos cada línea de código para comprender cómo funciona el programa.

El cliente también contiene las mismas cuatro bibliotecas: iostream, cstring, unistd.h y arpa/inet.h. El número de puerto también se define junto con la dirección IP local de 127.0.0.1. Da el mensaje que se debe pasar al servidor. El cliente y el servidor deben establecer una conexión. Los pasos son los siguientes:

«if ((client_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1);» Establezca un socket IPv4 utilizando el tipo de flujo y el protocolo predeterminado TCP. Si la función socket() no puede establecer la conexión y sale del programa, perror() imprimirá los detalles del error.

«server_address.sin_port = htons(PORT);» Establezca el número de puerto convertido al orden de bytes de la red. Después de eso, aquí se muestra otro mensaje de error, que es «Dirección incorrecta», y si hay un problema con la dirección, se imprime este mensaje. Al ubicar la dirección en «ser_address», el cliente se conectará al servidor. Si la conexión falla, se imprimirán los detalles del error. La función send() envía el mensaje al servidor, asegurándose de que no contenga ninguna bandera.

Para recibir y almacenar respuestas del servidor, es necesario inicializar un búfer llamado «buf» de tipo «char». La función read() lee la respuesta del servidor en un búfer. Finalmente, la respuesta del servidor se imprime en la consola. Finalmente, el socket finaliza cerrando la conexión usando la instrucción close(). El siguiente es el resultado del programa:

en conclusión

La programación de sockets es una parte importante de la comunicación de redes en informática. Admite el desarrollo de aplicaciones que pueden comunicarse a través de una red, lo que permite una amplia gama de posibilidades, desde arquitecturas simples cliente-servidor hasta sistemas distribuidos estructurados. Cuando se crea un socket en un contexto de programación, el programa debe configurar las características de su punto final, como el protocolo, TCP o UDP, y la dirección de red (como la dirección IP y el número de puerto). Estos sockets permiten al servidor enviar y recibir datos. Este artículo muestra un ejemplo práctico de cómo funciona el modelo cliente-servidor en la programación de sockets.

LEER  Punteros de función miembro de C++

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba