sockets

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> // Para close()

int main() {
    int sockfd;
    struct sockaddr_in address;
    int result;
    char ch[1024];
    char c[1024];
    char ipserver[16]; // Tamaño suficiente para direcciones IPv4
    int puerto;
    int ciclo = 1;

    printf("Ingrese la IP del servidor: ");
    if (scanf("%15s", ipserver) != 1) {
        fprintf(stderr, "Error al leer la IP del servidor.\n");
        return 1;
    }

    printf("Ingrese el puerto de la conexión: ");
    if (scanf("%d", &puerto) != 1) {
        fprintf(stderr, "Error al leer el puerto.\n");
        return 1;
    }

    while (ciclo) {
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd == -1) {
            perror("Error al crear el socket");
            return 1;
        }

        address.sin_family = AF_INET;
        address.sin_addr.s_addr = inet_addr(ipserver);
        address.sin_port = htons(puerto); // Usar htons para la conversión de puerto

        result = connect(sockfd, (struct sockaddr *)&address, sizeof(address));
        if (result == -1) {
            perror("Error en la conexión");
            close(sockfd);
            return 1;
        }

        printf("Conexión establecida.\n");

        // Recibir el primer mensaje del servidor
        memset(ch, 0, sizeof(ch)); // Limpiar el búfer
        if (recv(sockfd, ch, sizeof(ch) - 1, 0) > 0) {
            printf("%s\n", ch);
        } else {
            perror("Error al recibir el mensaje inicial del servidor");
            close(sockfd);
            return 1;
        }

        printf("Ingrese una cadena para enviar al servidor: ");
        memset(c, 0, sizeof(c)); // Limpiar el búfer
        scanf(" %1023[^\n]", c); // Leer hasta el salto de línea, con límite

        if (send(sockfd, c, strlen(c), 0) == -1) {
            perror("Error al enviar datos al servidor");
            close(sockfd);
            return 1;
        }

        memset(ch, 0, sizeof(ch)); // Limpiar el búfer
        if (recv(sockfd, ch, sizeof(ch) - 1, 0) > 0) {
            printf("El servidor dijo: %s\n", ch);
        } else {
            perror("Error al recibir datos del servidor");
            close(sockfd);
            return 1;
        }
        close(sockfd);
    }

    return 0;
}

}
/*servidor*/
#include <stdio.h>
#include <stdlib.h> // Para exit()
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> // Para close()

#define BUFFER_SIZE 1024

int main() {
    int server_sockfd, client_sockfd;
    struct sockaddr_in server_address, client_address;
    socklen_t server_len, client_len;
    char client_message[BUFFER_SIZE], server_message[BUFFER_SIZE];
    int port;

    printf("Dirección del servidor: 127.0.0.1\n\n");
    printf("Ingrese el puerto de escucha:\n\n");
    if (scanf("%d", &port) != 1) {
        fprintf(stderr, "Error: Puerto inválido.\n");
        return 1;
    }

    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sockfd < 0) {
        perror("Error al crear el socket");
        return 1;
    }

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_address.sin_port = htons(port); // Convertir a orden de bytes de red
    server_len = sizeof(server_address);

    if (bind(server_sockfd, (struct sockaddr *)&server_address, server_len) < 0) {
        perror("Error al enlazar el socket");
        close(server_sockfd);
        return 1;
    }

    if (listen(server_sockfd, 5) < 0) {
        perror("Error al escuchar en el socket");
        close(server_sockfd);
        return 1;
    }

    printf("Servidor en espera...\n");

    while (1) {
        client_len = sizeof(client_address);
        client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address, &client_len);
        if (client_sockfd < 0) {
            perror("Error al aceptar la conexión");
            continue; // Continuar con el siguiente cliente
        }

        printf("-------Sesión iniciada-------\n");
        printf("Cliente conectado\n");

        memset(server_message, 0, sizeof(server_message)); // Limpiar el buffer
        strcpy(server_message, "Servidor Conectado\n");
        if (send(client_sockfd, server_message, strlen(server_message), 0) < 0) {
            perror("Error al enviar el mensaje de conexión");
            close(client_sockfd);
            continue;
        }

        memset(client_message, 0, sizeof(client_message)); // Limpiar el buffer
        if (recv(client_sockfd, client_message, BUFFER_SIZE - 1, 0) < 0) {
            perror("Error al recibir el mensaje del cliente");
            close(client_sockfd);
            continue;
        }
        printf("El cliente dijo: %s\n", client_message);

        printf("Ingrese una cadena:\n");
        memset(server_message, 0, sizeof(server_message));
        if (fgets(server_message, BUFFER_SIZE, stdin) == NULL) {
            perror("Error al leer la entrada del usuario");
            close(client_sockfd);
            continue;
        }
        server_message[strcspn(server_message, "\n")] = 0; //remove newline from fgets.

        close(client_sockfd); // Cerrar el socket del cliente
    }

    close(server_sockfd); // Cerrar el socket del servidor (nunca se alcanza en este bucle infinito)
    return 0;
}