Server5.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <pthread.h>
#pragma comment(lib, "Ws2_32.lib")

/* Intrusive Linked List Node
 * future proofs as I can add more clients if I want
 */
struct llist_node {
    struct llist_node *next;
};

/* Linked List Head */
struct llist_head {
    struct llist_node *first;
};

/* Macro for Iterating Over the List
 * this saves time as I can reuse this to traverse the list
 * also future proofs as I can add more clients if I want
 */
#define llist_for_each(pos, head) \
    for (struct llist_node *pos = (head)->first; pos != NULL; pos = pos->next)

/* Client Node Structure */
struct client_node {
    struct llist_node node;   /* Intrusive linked list node */
    SOCKET socket;            /* Client socket */
    pthread_t thread;         /* Thread handling this client */
    struct client_node *peer; /* Pointer to the peer client (not strictly needed for broadcasting) */
};

/* Global client list so it can be accessed in thread function */
static struct llist_head client_list = { .first = NULL };

/* Function to broadcast a message to all clients except the sender
 * this for future proofing
 * so in the future  you can add more clients
 */
void broadcast_message(struct llist_head *list, struct client_node *sender, const char *message, size_t length) {
    struct llist_node *pos;
    llist_for_each(pos, list) {
        struct client_node *client = (struct client_node *)pos;
        if (client != sender) { // Skip the sender
            send(client->socket, message, (int)length, 0);
        }
    }
}

/* Function to print all connected clients */
void print_all_clients(struct llist_head *list) {
    printf("[INFO] Currently connected clients:\n");
    struct llist_node *pos;
    llist_for_each(pos, list) {
        struct client_node *client = (struct client_node *)pos;
        printf(" - Socket: %d\n", client->socket);
    }
}

/* Function to count the number of connected clients */
int count_clients(struct llist_head *list) {
    int count = 0;
    struct llist_node *pos;
    llist_for_each(pos, list) {
        count++;
    }
    return count;
}

/* Thread Function to Handle Client Communication */
void *client_thread(void *arg) {
    struct client_node *self = (struct client_node *)arg;
    SOCKET my_sock = self->socket;

    char buffer[1024];
    for (;;) {
        int n = recv(my_sock, buffer, (int)(sizeof(buffer) - 1), 0);
        if (n <= 0) { /* Client disconnected */
            printf("[INFO] Client disconnected (Socket: %d).\n", my_sock);
            closesocket(my_sock);

            /* Optionally: Notify the peer or do any cleanup here.
             * For this example, we just exit the thread.
             */
            pthread_exit(NULL);
        }

        buffer[n] = '\0';
        printf("[MESSAGE] Client (Socket: %d): %s\n", my_sock, buffer);

        /* Broadcast the message to all other clients */
        broadcast_message(&client_list, self, buffer, n);
    }

    return NULL;
}

/* Accept New Client and Add to the Linked List */
struct client_node *accept_client(SOCKET listen_socket, struct llist_head *list) {
    SOCKET client_sock = accept(listen_socket, NULL, NULL);
    if (client_sock == INVALID_SOCKET) {
        fprintf(stderr, "Accept failed: %d\n", WSAGetLastError());
        return NULL;
    }

    printf("[INFO] New client connected (Socket: %d).\n", client_sock);

    /* Allocate and initialize a new client node */
    struct client_node *new_client = calloc(1, sizeof(*new_client));
    if (!new_client) {
        fprintf(stderr, "Out of memory.\n");
        closesocket(client_sock);
        return NULL;
    }

    new_client->socket = client_sock;

    /* Add the new client to the linked list */
    new_client->node.next = list->first;
    list->first = &new_client->node;

    return new_client;
}

int main(void) {
    WSADATA wsa_data;
    if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
        fprintf(stderr, "Failed to initialize WinSock.\n");
        return EXIT_FAILURE;
    }

    /* Create a listening socket */
    SOCKET listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listen_socket == INVALID_SOCKET) {
        fprintf(stderr, "Socket creation failed: %d\n", WSAGetLastError());
        WSACleanup();
        return EXIT_FAILURE;
    }

    /* Configure server address */
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    /* Bind socket */
    if (bind(listen_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
        fprintf(stderr, "Bind failed: %d\n", WSAGetLastError());
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    /* Start listening */
    if (listen(listen_socket, SOMAXCONN) == SOCKET_ERROR) {
        fprintf(stderr, "Listen failed: %d\n", WSAGetLastError());
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    printf("[INFO] Server started. Waiting for two clients...\n");

    /* Accept the first client */
    struct client_node *clientA = accept_client(listen_socket, &client_list);
    if (!clientA) {
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    /* Accept the second client */
    struct client_node *clientB = accept_client(listen_socket, &client_list);
    if (!clientB) {
        closesocket(clientA->socket);
        free(clientA);
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    /* Print all connected clients and their count */
    print_all_clients(&client_list);
    printf("[INFO] Total clients connected: %d\n", count_clients(&client_list));

    /* Create threads for both clients */
    if (pthread_create(&clientA->thread, NULL, client_thread, clientA) != 0) {
        fprintf(stderr, "Failed to create thread for Client A.\n");
        closesocket(clientA->socket);
        closesocket(clientB->socket);
        free(clientA);
        free(clientB);
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    if (pthread_create(&clientB->thread, NULL, client_thread, clientB) != 0) {
        fprintf(stderr, "Failed to create thread for Client B.\n");
        closesocket(clientA->socket);
        closesocket(clientB->socket);
        free(clientA);
        free(clientB);
        closesocket(listen_socket);
        WSACleanup();
        return EXIT_FAILURE;
    }

    /* Wait for both threads to finish */
    pthread_join(clientA->thread, NULL);
    pthread_join(clientB->thread, NULL);

    /* Clean up resources */
    closesocket(listen_socket);
    free(clientA);
    free(clientB);
    WSACleanup();

    printf("[INFO] Server shutdown complete.\n");
    return EXIT_SUCCESS;
}