En esta publicación de blog, exploraremos cómo crear un servidor TCP simple en C que pueda servir archivos HTML. Desglosaremos el código, explicaremos cómo funciona y discutiremos planes futuros para mejorar este proyecto. ¡Este es un excelente ejemplo de cómo puedes "simplemente hacer cosas" en C sin complicar demasiado el proceso!

Descripción general del proyecto

El objetivo de este proyecto es implementar un servidor TCP básico que escuche las conexiones del cliente y proporcione archivos HTML a pedido. El servidor manejará las solicitudes de los clientes, leerá el archivo HTML especificado y enviará el contenido al cliente como una respuesta HTTP.

? Mantenga la conversación en Twitter(X): @trish_07

? Repositorio de GitHub: Explore el repositorio de proyectos del servidor TCP

Estructura del proyecto

Para organizar nuestro código, estructuraremos el proyecto de la siguiente manera:

tcp_server_c/
├── CMakeLists.txt             # Build configuration
├── include/
│   ├── server.h               # Main server header file
│   ├── html_serve.h           # Header for serve_html function
│   ├── request_handler.h      # Header for handle_client function
│   └── socket_utils.h         # Header for socket utility functions
├── src/
│   ├── server.c               # Main server program
│   ├── html_serve.c           # serve_html function
│   ├── request_handler.c      # handle_client function
│   └── socket_utils.c         # Utility functions for socket operations
└── README.md                  # Project documentation

Desglose del código

1. Utilidades de enchufe

Primero, creemos un archivo de utilidad para manejar la inicialización del socket. Esto asegurará que el código de nuestro servidor principal permanezca limpio y enfocado.

incluir/socket_utils.h

#ifndef SOCKET_UTILS_H
#define SOCKET_UTILS_H

#include 

int initialize_server(struct sockaddr_in* address);

#endif

src/socket_utils.c

#include "socket_utils.h"
#include 
#include 
#include 
#include 

#define PORT 8080

int initialize_server(struct sockaddr_in* address) {
    int server_fd;
    int opt = 1;

    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("Socket failed!");
        return -1;
    }

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
        perror("setsockopt failed");
        close(server_fd);
        return -1;
    }

    address->sin_family = AF_INET;
    address->sin_addr.s_addr = INADDR_ANY;
    address->sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)address, sizeof(*address)) 




  
  
  2. Funcionalidad de publicación HTML


A continuación, crearemos una función para servir archivos HTML. Esta función leerá el contenido de un archivo HTML y se lo devolverá a la persona que llama.

incluir/html_server.h



#ifndef HTML_SERVER_H
#define HTML_SERVER_H

char* serve_html(const char* filename);

#endif




src/html_server.c



#include "html_server.h"
#include 
#include 
#include 

char* serve_html(const char* filename) {
    FILE* file = fopen(filename, "r");
    if (!file) {
        perror("Error opening file");
        return NULL;
    }

    fseek(file, 0, SEEK_END);
    long length = ftell(file);
    fseek(file, 0, SEEK_SET);

    char* buffer = malloc(length   1);
    if (!buffer) {
        perror("Error allocating memory");
        fclose(file);
        return NULL;
    }

    fread(buffer, 1, length, file);
    buffer[length] = '\0'; // Null-terminate the buffer

    fclose(file);
    return buffer;
}





  
  
  3. Manejo de solicitudes de clientes


Ahora, implementemos la lógica para manejar las solicitudes entrantes de los clientes.

incluir/request_handler.h



#ifndef REQUEST_HANDLER_H
#define REQUEST_HANDLER_H

#include 

void handle_client(int new_socket);

#endif




src/request_handler.c



#include "request_handler.h"
#include "html_server.h"
#include 
#include 
#include 

#define BUFFER_SIZE 1024

void handle_client(int new_socket) {
    char buffer[BUFFER_SIZE] = { 0 };
    read(new_socket, buffer, BUFFER_SIZE);

    // Serve the HTML file
    char* html_content = serve_html("../html/index.html");
    if (html_content) {
        write(new_socket, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n", 48);
        write(new_socket, html_content, strlen(html_content));
    } else {
        const char* not_found_response = "HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\n\r\n
404 Not Found
";
        write(new_socket, not_found_response, strlen(not_found_response));
    }

    free(html_content);
    close(new_socket); // Close the connection with the current client
}





  
  
  4. Lógica del servidor principal


Finalmente, juntemos todo en el archivo principal.

src/main.c



#include 
#include 
#include 
#include 
#include 
#include "socket_utils.h"
#include "request_handler.h"

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);

    server_fd = initialize_server(&address);
    if (server_fd == -1) {
        return EXIT_FAILURE;
    }

    printf("Server listening on port: 8080\n");

    while (1) {
        if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) 




  
  
  Planes futuros


En el futuro, hay varias mejoras y características que planeamos implementar:



Soporte de subprocesos múltiples: para manejar múltiples conexiones de clientes simultáneamente, introduciremos capacidades de subprocesos para mejorar la eficiencia del servidor.

Servicio de contenido dinámico: implemente una funcionalidad para ofrecer contenido dinámico mediante la integración con un motor de plantillas liviano.

Registro: agregue un mecanismo de registro para realizar un seguimiento de las solicitudes, los errores y el rendimiento del servidor.

Funciones de seguridad: explore cómo agregar compatibilidad con HTTPS y validación de entrada para mejorar la seguridad.

Manejo de errores mejorado: implemente un mejor manejo de errores para varios escenarios, como archivo no encontrado, sobrecarga del servidor, etc.



  
  
  Conclusión


Este sencillo proyecto de servidor TCP sirve como ejemplo fundamental de cómo crear un servidor web en C, lo que demuestra el poder y la simplicidad del lenguaje. Al aprovechar esta base, podemos desarrollar funciones más sofisticadas y mejorar el rendimiento, convirtiéndola en una solución sólida para ofrecer contenido web.

Puedes encontrar el código fuente completo y contribuir al proyecto en GitHub: Enlace al repositorio de GitHub. 

¡No dudes en enviarnos comentarios, hacer preguntas o contribuir con tus ideas para futuras mejoras!