server.c

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

#define MAX_CLIENTS 10

int createTCPIpv4Socket() {
    return socket(AF_INET, SOCK_STREAM, 0);
}

struct sockaddr_in* createIpv4Address(char *ip, int port) {
    struct sockaddr_in *address = malloc(sizeof(struct sockaddr_in));
    address->sin_family = AF_INET;
    address->sin_port = htons(port);

    if (strlen(ip) == 0) {
        address->sin_addr.s_addr = INADDR_ANY;
    } else {
        inet_pton(AF_INET, ip, &address->sin_addr.s_addr);
    }

    return address;
}

struct AcceptedSocket {
    int acceptedSocketFD;
    struct sockaddr_in address;
    int error;
    bool acceptedSuccessfully;
};

struct AcceptedSocket* acceptedSockets[MAX_CLIENTS];
int acceptedSocketsCount = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

struct AcceptedSocket* acceptIncomingConnection(int serverSocketFD) {
    struct sockaddr_in clientAddress;
    socklen_t clientAddressSize = sizeof(struct sockaddr_in);

    int clientSocketFD = accept(serverSocketFD, (struct sockaddr*)&clientAddress, &clientAddressSize);

    struct AcceptedSocket* acceptedSocket = malloc(sizeof(struct AcceptedSocket));
    acceptedSocket->address = clientAddress;
    acceptedSocket->acceptedSocketFD = clientSocketFD;
    acceptedSocket->acceptedSuccessfully = clientSocketFD >= 0;

    if (!acceptedSocket->acceptedSuccessfully) {
        acceptedSocket->error = clientSocketFD;
    }

    return acceptedSocket;
}

void sendReceivedMessageToOtherClients(char* buffer, int senderSocketFD) {
    pthread_mutex_lock(&lock);
    for (int i = 0; i < acceptedSocketsCount; i++) {
        int receiverSocketFD = acceptedSockets[i]->acceptedSocketFD;
        if (receiverSocketFD != senderSocketFD) {
            send(receiverSocketFD, buffer, strlen(buffer), 0);
        }
    }
    pthread_mutex_unlock(&lock);
}

void* receiveAndPrintIncomingMessages(void* arg) {
    int clientSocketFD = *((int*)arg);
    free(arg);

    char buffer[1024];

    while (true) {
        ssize_t byteReceived = recv(clientSocketFD, buffer, sizeof(buffer) - 1, 0);
        if (byteReceived > 0) {
            buffer[byteReceived] = '\0';
            printf("Message from %d: %s\n", clientSocketFD, buffer);
            sendReceivedMessageToOtherClients(buffer, clientSocketFD);
        } else if (byteReceived <= 0) {
            break;
        }
    }

    close(clientSocketFD);
    pthread_exit(NULL);
}

void receiveAndPrintIncomingMessagesInSeperateThread(struct AcceptedSocket* pSocket) {
    pthread_t id;
    int* socketCopy = malloc(sizeof(int));
    *socketCopy = pSocket->acceptedSocketFD;
    pthread_create(&id, NULL, receiveAndPrintIncomingMessages, socketCopy);
    pthread_detach(id);
}

void startAcceptingIncomingConnections(int serverSocketFD) {
    while (true) {
        struct AcceptedSocket* clientSocket = acceptIncomingConnection(serverSocketFD);
        if (!clientSocket->acceptedSuccessfully) {
            perror("Failed to accept connection");
            free(clientSocket);
            continue;
        }

        pthread_mutex_lock(&lock);
        if (acceptedSocketsCount < MAX_CLIENTS) {
            acceptedSockets[acceptedSocketsCount++] = clientSocket;
            receiveAndPrintIncomingMessagesInSeperateThread(clientSocket);
        } else {
            printf("Max clients reached. Rejecting connection.\n");
            close(clientSocket->acceptedSocketFD);
            free(clientSocket);
        }
        pthread_mutex_unlock(&lock);
    }
}

int main() {
    int serverSocketFD = createTCPIpv4Socket();
    struct sockaddr_in* serverAddress = createIpv4Address("", 8000);

    int result = bind(serverSocketFD, (struct sockaddr*)serverAddress, sizeof(*serverAddress));
    if (result == 0) {
        printf("Socket was bound successfully\n");
    } else {
        perror("Bind failed");
        exit(EXIT_FAILURE);
    }

    int listenResult = listen(serverSocketFD, MAX_CLIENTS);
    if (listenResult != 0) {
        perror("Listen failed");
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port 8000...\n");
    startAcceptingIncomingConnections(serverSocketFD);

    shutdown(serverSocketFD, SHUT_RDWR);
    close(serverSocketFD);
    free(serverAddress);
    return 0;
}