server.c

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

#define PORT           9999
#define LISTEN_BACKLOG 10
#define BUFFER_SIZE    1024

volatile sig_atomic_t running = 1;

void handle_sigint(int sig)
{
    running = 0;
}

typedef struct
{
    int socket;
} client_args_t;

void *handle_client(void *arg)
{
    client_args_t *args = (client_args_t *)arg;
    int client_socket = args->socket;
    free(arg);

    pthread_detach(pthread_self());

    char buffer[BUFFER_SIZE];

    while (1)
    {
        memset(buffer, 0, BUFFER_SIZE);

        int bytes_received = read(client_socket, buffer, BUFFER_SIZE - 1);
        if (bytes_received <= 0)
        {
            printf("[!] Client (fd=%d) disconnected unexpectedly\n", client_socket);
            break;
        }

        buffer[bytes_received] = '\0';
        printf("[+] Message from client (fd=%d): %s\n", client_socket, buffer);

        if (strncmp(buffer, "disconnect", strlen("disconnect")) == 0)
        {
            char *message = "Goodbye!";
            if (write(client_socket, "Goodbye!", 8) < 0)
                printf("[!] Error sending goodbye to client (fd=%d)\n", client_socket);

            printf("[+] Client (fd=%d) requested disconnect\n", client_socket);
            break;
        }

        if (strncmp(buffer, "hello", strlen("hello")) == 0)
        {
            char *response = "world";
            if (write(client_socket, response, strlen(response)) < 0)
            {
                printf("[!] Error when sending data to client (fd=%d)\n", client_socket);
                break;
            }
        }
        else
        {
            if (write(client_socket, buffer, bytes_received) < 0)
            {
                printf("[!] Error when sending data to client (fd=%d)\n", client_socket);
                break;
            }
        }
    }

    close(client_socket);
    printf("[+] Connection with client (fd=%d) closed\n", client_socket);
    return NULL;
}

int main()
{
    struct sigaction sa;
    sa.sa_handler = handle_sigint;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0)
    {
        printf("[!] Error when creating a socket!\n");
        exit(EXIT_FAILURE);
    }
    printf("[+] Socket is created\n");

    int opt = 1;
    if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
    {
        printf("[!] Error when setting socket options!\n");
        close(server_socket);
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in server_address;
    server_address.sin_family      = AF_INET;
    server_address.sin_port        = htons(PORT);
    server_address.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) < 0)
    {
        printf("[!] Error when binding a socket!\n");
        exit(EXIT_FAILURE);
    }
    printf("[+] Bind is successful\n");

    if (listen(server_socket, LISTEN_BACKLOG) < 0)
    {
        printf("[!] Error when listening!\n");
        exit(EXIT_FAILURE);
    }
    printf("[+] Listening on port %d\n", PORT);

    while (running)
    {
        struct sockaddr_in client_address;
        socklen_t client_address_len = sizeof(client_address);

        int client_socket = accept(
            server_socket,
            (struct sockaddr *)&client_address,
            &client_address_len
        );

        if (client_socket < 0)
        {
            if (!running)
                break;
            printf("[!] Error when accepting!\n");
            continue;
        }
        printf("[+] Client connected (fd=%d)\n", client_socket);

        client_args_t *args = malloc(sizeof(client_args_t));
        if (args == NULL)
        {
            printf("[!] Error when allocating memory for client args!\n");
            close(client_socket);
            continue;
        }
        args->socket = client_socket;

        pthread_t thread;
        if (pthread_create(&thread, NULL, handle_client, args) != 0)
        {
            printf("[!] Error when creating thread!\n");
            free(args);
            close(client_socket);
            continue;
        }
    }

    printf("\n[+] Shutting down server...\n");
    close(server_socket);
    printf("[+] Server socket closed\n");
    return 0;
}