SERVER

\chip none
\Date 2024-08-13
\version v0.0.1
*********************************************************************************/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "PrintLevel.h"

#define BUFFER_SIZE (1024)
#define MAX_CLIENTS (2)
#define MYPORT (1111)
#define IP ("127.0.0.1")
#define TIMEOUT_MINUTES (1)

enum ErrorType
{
ArgcFault = -3,
BindFail = -2,
ListenSocFail = -1,
Success = 0
};

int server_socket = 0;
int client_sockets[MAX_CLIENTS] = {0};
int client_count = 0;
pthread_mutex_t client_mutex = PTHREAD_MUTEX_INITIALIZER;
int g_PRINTAPI_level = g_PRINTAPI_msg;
bool is_running = true;

/*!
@brisf:handle_signal

*@para[in] const char *message
*@para[in] const char *sender
*@return void:
*/
void handle_signal(int signal)
{
PRINTAPI_trc("Enter handle_signal API\n");
if (signal == SIGINT)
{
printf("\nServer interrupted by user (Ctrl+C). Exiting...\n");
close(server_socket);
exit(EXIT_SUCCESS);
}
else if (signal == SIGTSTP)
{
printf("\nServer suspended by user (Ctrl+Z). Resuming...\n");
close(server_socket);
exit(EXIT_SUCCESS);
}
PRINTAPI_trc("out handle_signal API\n");
}

/*!
@brisf:handle_clien

*@para[in] void *arg

*@return void*:
*/
void *handle_client(void *arg)
{
PRINTAPI_trc("Enter handle_client API\n");
char buffer[BUFFER_SIZE] = {0};
int bytes_read = 0;
if(nullptr == arg)
{
PRINTAPI_err("nullpointer\n");
return NULL;
}
int client_socket = *(int *)arg;
while (is_running)
{
bytes_read = recv(client_socket, buffer, BUFFER_SIZE - 1, 0);
if (bytes_read {
//PRINTAPI_err("recv");
is_running = false;
break;
}
buffer[bytes_read] = '\0';
PRINTAPI_msg("%s\n", buffer);

// brocast news to other clients
pthread_mutex_lock(&client_mutex);
for (int i = 0; i < client_count; i++)
{
if (client_sockets[i] != client_socket)
{
if (send(client_sockets[i], buffer, strlen(buffer), 0) < 0)
{
PRINTAPI_err("senderro");
}
}
}
pthread_mutex_unlock(&client_mutex);
}

if (bytes_read < 0)
{
PRINTAPI_err("recv");
}
else if (0 == bytes_read)
{
PRINTAPI_err("Client %d disconnected\n",client_socket);
}

// remove client from clientlist
pthread_mutex_lock(&client_mutex);
for (int i = 0; i < client_count; i++)
{
if (client_sockets[i] == client_socket)
{
for (int j = i; j < client_count - 1; j++)
{
client_sockets[j] = client_sockets[j + 1];
}
client_count--;
break;
}
}
pthread_mutex_unlock(&client_mutex);

close(client_socket);
PRINTAPI_trc("out handle_client API\n");
return NULL;
}

/*!
@brisf:main

*@para[in]

*@return int:
*\retval -2 If BindFail
*\retval -1 If ListenSocFail
*\retval 0 If success.
*/
int main()
{
PRINTAPI_trc("Enter main API\n");
// create server socket
server_socket = socket(AF_INET, SOCK_STREAM, 0);

// set server address
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;// use IPV4 address
server_addr.sin_addr.s_addr = inet_addr(IP);// ip
server_addr.sin_port = htons(MYPORT); // port

// Register signal handler
struct sigaction sa;
sa.sa_handler = handle_signal;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTSTP, &sa, NULL);

// bind socket to addr
if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
{
PRINTAPI_err("bindSocFail");
close(server_socket);
PRINTAPI_trc("out main API\n");
return BindFail;
}

// listen connect request
if (listen(server_socket, MAX_CLIENTS) < 0)
{
PRINTAPI_err("ListenSocFail");
close(server_socket);
PRINTAPI_trc("out main API\n");
return ListenSocFail;
}

PRINTAPI_msg("Server listening on port %d\n", MYPORT);
while (is_running)
{
// recieive client connect request
int client_socket = accept(server_socket, NULL, NULL);
if (client_socket < 0)
{
PRINTAPI_err("accept");
continue;//enter next loop
}

// add new client to list
pthread_mutex_lock(&client_mutex);
if (client_count < MAX_CLIENTS)
{
client_sockets[client_count++] = client_socket;
PRINTAPI_msg("New client :% d connected\n", client_socket);
}
else
{
PRINTAPI_msg("Maximum number of clients reached\n");
is_running = false;
close(client_socket);
break;
}
pthread_mutex_unlock(&client_mutex);

// creat pthread of client connect
pthread_t client_thread = {};
if (pthread_create(&client_thread, NULL, handle_client, &client_socket) != 0)
{
PRINTAPI_err("pthread_create");
close(client_socket);
continue;
}
pthread_detach(client_thread);
}
PRINTAPI_trc("out main API\n");
return Success;
}