silva
/
pingpong
mirror of https://github.com/viniciusfdasilva/pingpong.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into dev

This commit is contained in:
Vinicius 2023-12-17 20:33:27 -03:00
parent 400953796e e07823c64a
commit 31b1504531
11 changed files with 409 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CMakeLists.txt
View File

@ -5,19 +5,5 @@ execute_process(
COMMAND mkdir -p bin COMMAND mkdir -p bin
) )
#set(CMAKE_CXX_FLAGS "-Wall -Wextra") add_executable(./bin/server ./include/socket.h ./include/utils.h ./src/socket.c ./src/utils.c ./src/main_server.c)
#set(CMAKE_CXX_FLAGS_DEBUG "-g") add_executable(./bin/client ./include/socket.h ./include/utils.h ./src/socket.c ./src/utils.c ./src/main_client.c)
#set(CMAKE_CXX_FLAGS_RELEASE "-O3")
# Set warning level for GCC or Clang
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
set(CMAKE_CXX_FLAGS_DEBUG "-g")
set(CMAKE_CXX_FLAGS_RELEASE "-O3")
# Set warning level for MSVC
if(MSVC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
endif()
add_executable(./bin/server ./src/server.c)
add_executable(./bin/client ./src/client.c)

BIN
bin/client
View File

Binary file not shown.

BIN
bin/server
View File

Binary file not shown.

26
include/socket.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef __SOCKET_H__
#define SOCKET_ERROR_CODE -1 // Socket create, Connection server, Receive buffer to server code error
#define SYSTEM_EXIT_FAILED 1 // Operating System program error response
#define HOST_IP "127.0.0.1" // IPV4 loopback address
#define SERVER_PORT 8481 // Server port
#define UNIXDOAMIN_ADDRESS "pingpong.socket"
#define MAX_CONNECTIONS 1 // Num max client connected simultaneously
#define NUM_OF_ARGUMENTS 3
#define TCP_SOCKET_FLAG 1
#define UDP_SOCKET_FLAG 2
#define UNIX_SOCKET_FLAG 3
typedef struct sockaddr_in socket_address_ipv4;
typedef struct sockaddr_un socket_address_unix;
typedef struct sockaddr_in socket_address;
extern int create_socket(int sin_family, int sock);
extern socket_address_unix config_unixdomain_server_address();
extern socket_address_ipv4 config_tcp_upd_server_address();
extern void connect_to_server(void* server_address, int client_socket);
extern void bind_server(void* server_address, int socket_type, int server_socket);
extern int accept_connection(int client_socket, void* client_address, int server_socket);
#endif // __SOCKET_H__

21
include/utils.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef __UTILS_H__
#include <time.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/un.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define SYSTEM_EXIT_SUCCESS 0 // Operating System program success response
#define SYSTEM_EXIT_FAILURE 1 // Operating System program error response
#define TRUE 1
#define FALSE 0
extern void panic(char* message);
extern int* get_init_buffer(int buffer_size);
#endif // __UTILS_H__

231
src/client.c
View File

@ -1,231 +0,0 @@
#include <time.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/un.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define N 10000
#define TRUE 1
#define FALSE 0
#define HOST_IP "127.0.0.1" // IPV4 loopback address
#define SERVER_PORT 8481 // Server port
#define PORT_USED_CODE 256
#define SOCKET_ERROR_CODE -1 // Socket create, Connection server, Receive buffer to server code error
#define SYSTEM_EXIT_FAILED 1 // Operating System program error response
#define SYSTEM_EXIT_SUCCESS 0 // Operating System program success response
#define NUM_OF_ARGUMENTS 3
#define TCP_SOCKET_FLAG 1
#define UDP_SOCKET_FLAG 2
#define UNIX_SOCKET_FLAG 3
float times[N];
int num_of_read_bytes = 0;
typedef struct sockaddr_in socket_address_ipv4;
typedef struct sockaddr_un socket_address_unix;
typedef union socketaddr_t
{
socket_address_ipv4 socket_ipv4;
socket_address_unix socket_unix;
} socketaddr_t;
socketaddr_t server_address;
size_t buffer_size;
int socket_type;
int domain, type, protocol;
float elapsed_time_ms = 0.00;
char* address;
int domain, type, protocol, sin_family, sock;
typedef struct sockaddr_in socket_address;
void panic(char* message)
{
perror(message);
exit(SYSTEM_EXIT_FAILED);
}
int init_socket()
{
int client_socket = socket(sin_family, sock, -1);
if(client_socket == SOCKET_ERROR_CODE)
{
panic("Socket create failed!\n");
}
return client_socket;
}
socketaddr_t config_server_address()
{
if(socket_type == UNIX_SOCKET_FLAG)
{
server_address.socket_ipv4.sin_family = sin_family;
server_address.socket_ipv4.sin_port = htons(SERVER_PORT);
server_address.socket_ipv4.sin_addr.s_addr = inet_addr(address);
}else{
server_address.socket_unix.sun_family = AF_UNIX;
strcpy(server_address.socket_unix.sun_path, address);
unlink(address);
}
}
void connect_to_server(int client_socket)
{
struct sockaddr* address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&server_address.socket_unix : (struct sockaddr*)&server_address.socket_ipv4;
int connection_response = connect(client_socket,
address,
socket_type == UNIX_SOCKET_FLAG ? (socklen_t)sizeof(server_address.socket_unix) : (socklen_t)sizeof(server_address.socket_ipv4)
);
if(connection_response == SOCKET_ERROR_CODE)
{
close(client_socket);
panic("Server connection error\n");
}
}
int receive_buffer(int client_socket, int buffer_size)
{
int received_buffer[buffer_size];
if(socket_type == TCP_SOCKET_FLAG) recv(client_socket, received_buffer, buffer_size, 0);
else
{
struct sockaddr* address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&server_address.socket_unix : (struct sockaddr*)&server_address.socket_ipv4;
socklen_t* server_addr_size = socket_type == UNIX_SOCKET_FLAG ? (socklen_t*)sizeof(server_address.socket_unix) : (socklen_t*)sizeof(server_address.socket_ipv4);
recvfrom(client_socket, received_buffer, buffer_size, 0, address, server_addr_size);
}
}
void send_buffer(int client_socket, int* buffer, size_t buffer_size)
{
struct sockaddr* address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&server_address.socket_unix : (struct sockaddr*)&server_address.socket_ipv4;
socklen_t server_addr_size = socket_type == UNIX_SOCKET_FLAG ? (socklen_t)sizeof(server_address.socket_unix) : (socklen_t)sizeof(server_address.socket_ipv4);
if(socket_type == TCP_SOCKET_FLAG) send(client_socket, buffer, buffer_size, 0);
else sendto(client_socket, buffer, buffer_size, 0, address, server_addr_size);
receive_buffer(client_socket, buffer_size);
}
void controlc_handler()
{
printf("\nProgram finished!\n");
exit(SYSTEM_EXIT_SUCCESS);
}
void socket_listen(int client_socket, int* buffer, size_t buffer_size)
{
if(signal(SIGINT, controlc_handler) == SIG_ERR)
{
panic("Signal create error!");
}
clock_t start_time = clock();
send_buffer(client_socket, buffer, buffer_size);
clock_t end_time = clock();
elapsed_time_ms = ((float)(end_time - start_time) / (CLOCKS_PER_SEC/1000));
}
void attribuite_socket_type(int socket_type)
{
switch (socket_type)
{
case TCP_SOCKET_FLAG: // TCP SOCKET
sin_family = AF_INET;
address = HOST_IP;
sock = SOCK_STREAM;
break;
case UDP_SOCKET_FLAG: // UDP SOCKET
sin_family = AF_INET;
address = HOST_IP;
sock = SOCK_DGRAM;
break;
case UNIX_SOCKET_FLAG: // UNIXDOMAIN SOCKET
sin_family = AF_UNIX;
address = "pingpong.socket";;
sock = SOCK_DGRAM;
break;
default:
panic("Value error!");
break;
}
}
void get_args(int argc, char** argv)
{
if(argc > NUM_OF_ARGUMENTS)
{
buffer_size = (int)atoi(argv[1]);
num_of_read_bytes = (int)atoi(argv[2]);
socket_type = (int)atoi(argv[3]);
}else
{
panic("Argument is missing!");
}
}
int main(int argc, char** argv)
{
get_args(argc, argv);
attribuite_socket_type(socket_type);
int* buffer = (int*)malloc(buffer_size*sizeof(int));
for(int i = 0; i < buffer_size; i++)
{
buffer[i] = (int)(i % 255);
}
int client_socket = init_socket();
server_address = config_server_address();
connect_to_server(client_socket);
for(int i = 0; i < num_of_read_bytes; i++)
{
socket_listen(client_socket, buffer, buffer_size);
printf("%lf\n", (float)(elapsed_time_ms));
}
return SYSTEM_EXIT_SUCCESS;
}

125
src/main_client.c Normal file
View File

@ -0,0 +1,125 @@
#include "../include/socket.h"
#include "../include/utils.h"
#define N 10000
float times[N];
int num_of_read_bytes = 0;
int client_socket;
int* buffer;
size_t buffer_size;
int socket_type;
socket_address_ipv4 ipv4_server_address;
socket_address_unix unix_server_address;
float elapsed_time_ms = 0.00;
int receive_buffer(void *server_address)
{
int received_buffer[buffer_size];
if(socket_type == TCP_SOCKET_FLAG) recv(client_socket, received_buffer, buffer_size, 0);
else
{
struct sockaddr* address = (struct sockaddr*)&server_address;
socklen_t* server_addr_size = (socklen_t*)sizeof(server_address);
recvfrom(client_socket, received_buffer, buffer_size, 0, address, server_addr_size);
}
}
void send_buffer(void *server_address)
{
struct sockaddr* address = (struct sockaddr*)&server_address;
socklen_t server_addr_size = (socklen_t)sizeof(server_address);
if(socket_type == TCP_SOCKET_FLAG) send(client_socket, buffer, buffer_size, 0);
else sendto(client_socket, buffer, buffer_size, 0, address, server_addr_size);
receive_buffer(socket_type == UNIX_SOCKET_FLAG ? (void*)&unix_server_address : (void*)&ipv4_server_address);
}
void controlc_handler()
{
printf("\nProgram finished!\n");
exit(SYSTEM_EXIT_SUCCESS);
}
void socket_listen()
{
if(signal(SIGINT, controlc_handler) == SIG_ERR)
{
panic("Signal create error!");
}
clock_t start_time = clock();
send_buffer(socket_type == UNIX_SOCKET_FLAG ? (void*)&unix_server_address : (void*)&ipv4_server_address);
clock_t end_time = clock();
elapsed_time_ms = ((float)(end_time - start_time) / (CLOCKS_PER_SEC/1000));
}
void attribuite_and_init_socket(int socket_type)
{
switch (socket_type)
{
case TCP_SOCKET_FLAG: // TCP SOCKET
client_socket = create_socket(AF_INET, SOCK_STREAM);
ipv4_server_address = config_tcp_upd_server_address();
connect_to_server((void*)&ipv4_server_address,client_socket);
break;
case UDP_SOCKET_FLAG: // UDP SOCKET
client_socket = create_socket(AF_INET, SOCK_STREAM);
ipv4_server_address = config_tcp_upd_server_address();
connect_to_server((void*)&ipv4_server_address,client_socket);
break;
case UNIX_SOCKET_FLAG: // UNIXDOMAIN SOCKET
client_socket = create_socket(AF_UNIX, SOCK_DGRAM);
unix_server_address = config_unixdomain_server_address();
connect_to_server((void*)&unix_server_address,client_socket);
break;
default:
panic("Value error!");
break;
}
}
void get_args(int argc, char** argv)
{
if(argc > NUM_OF_ARGUMENTS)
{
buffer_size = (int)atoi(argv[1]);
num_of_read_bytes = (int)atoi(argv[2]);
socket_type = (int)atoi(argv[3]);
}else
{
panic("Argument is missing!");
}
}
int main(int argc, char** argv)
{
get_args(argc, argv);
attribuite_and_init_socket(socket_type);
buffer = get_init_buffer(buffer_size);
for(int i = 0; i < num_of_read_bytes; i++)
{
socket_listen();
printf("%lf\n", (float)(elapsed_time_ms));
}
return SYSTEM_EXIT_SUCCESS;
}

119
src/main_server.c Normal file
View File

@ -0,0 +1,119 @@
#include "../include/socket.h"
#include "../include/utils.h"
int num_of_read_bytes = 0;
socklen_t client_addr_len;
int server_socket, client_socket;
socket_address client_address, server_address;
size_t buffer_size;
int socket_type;
char* address;
int domain, type, protocol, sin_family, sock;
void send_buffer(int* buffer)
{
socklen_t client_addr_len = socket_type == sizeof(client_address);
struct sockaddr *address = (struct sockaddr*)&client_address;
if(socket_type == TCP_SOCKET_FLAG) send(client_socket, buffer, buffer_size, 0);
else sendto(client_socket, buffer, buffer_size, 0, address, client_addr_len);
}
int receive_buffer()
{
ssize_t bytes_read;
socklen_t* client_addr_len = (socklen_t *)sizeof(client_address);
struct sockaddr *address = (struct sockaddr*)&client_address;
int received_buffer[buffer_size];
while((bytes_read = socket_type == UNIX_SOCKET_FLAG ? recv(client_socket, received_buffer, buffer_size, 0) : recvfrom(client_socket, received_buffer, buffer_size, 0, address, client_addr_len)) > 0)
{
send_buffer(received_buffer);
}
}
void controlc_handler()
{
exit(SYSTEM_EXIT_SUCCESS);
}
void server_listen()
{
if (listen(server_socket, MAX_CONNECTIONS) == SOCKET_ERROR_CODE)
{
close(server_socket);
panic("Listening mode error");
}
client_socket = accept_connection(client_socket, (void*)&client_address, server_socket);
receive_buffer();
}
void attribuite_socket_type(int socket_type)
{
switch (socket_type)
{
case TCP_SOCKET_FLAG: // TCP SOCKET
server_socket = create_socket(AF_INET, SOCK_STREAM);
config_tcp_upd_server_address();
break;
case UDP_SOCKET_FLAG: // UDP SOCKET
server_socket = create_socket(AF_INET, SOCK_DGRAM);
config_tcp_upd_server_address();
break;
case UNIX_SOCKET_FLAG: // UNIXDOMAIN SOCKET
server_socket = create_socket(AF_UNIX, SOCK_DGRAM);
config_unixdomain_server_address();
break;
default:
panic("Value error!");
break;
}
}
void get_args(int argc, char** argv)
{
if(argc > NUM_OF_ARGUMENTS)
{
buffer_size = (int)atoi(argv[1]);
num_of_read_bytes = (int)atoi(argv[2]);
socket_type = (int)atoi(argv[3]);
}else
{
panic("Argument is missing!");
}
}
int main(int argc, char** argv)
{
get_args(argc, argv);
attribuite_socket_type(socket_type);
int* buffer = (int*)malloc(buffer_size*sizeof(int));
bind_server((void*)&server_address, socket_type, server_socket);
for(int i = 0; i < num_of_read_bytes; i++)
{
server_listen();
}
return SYSTEM_EXIT_SUCCESS;
}

224
src/server.c
View File

@ -1,224 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define FALSE 0
#define TRUE 1
#define HOST_IP "127.0.0.1" // IPV4 loopback address
#define SERVER_PORT 8481 // Server port
#define MAX_CONNECTIONS 1 // Num max client connected simultaneously
#define SOCKET_ERROR_CODE -1 // Socket create, Connection server, Receive buffer to server code error
#define SYSTEM_EXIT_FAILED 1 // Operating System program error response
#define SYSTEM_EXIT_SUCCESS 0 // Operating System program success response
#define NUM_OF_ARGUMENTS 3
#define TCP_SOCKET_FLAG 1
#define UDP_SOCKET_FLAG 2
#define UNIX_SOCKET_FLAG 3
int num_of_read_bytes = 0;
typedef struct sockaddr_in socket_address_ipv4;
typedef struct sockaddr_un socket_address_unix;
socklen_t client_addr_len;
typedef union socketaddr_t
{
socket_address_ipv4 socket_ipv4;
socket_address_unix socket_unix;
} socketaddr_t;
socketaddr_t client_address;
socketaddr_t server_address;
size_t buffer_size;
int socket_type;
char* address;
int domain, type, protocol, sin_family, sock;
void panic(char* message)
{
perror(message);
exit(SYSTEM_EXIT_FAILED);
}
int create_socket()
{
int server_socket;
server_socket = socket(sin_family, sock, -1);
if(server_socket == SOCKET_ERROR_CODE)
{
panic("Socket create failed!");
}
return server_socket;
}
void config_server_address()
{
if(socket_type == UNIX_SOCKET_FLAG)
{
server_address.socket_ipv4.sin_family = sin_family;
server_address.socket_ipv4.sin_port = htons(SERVER_PORT);
server_address.socket_ipv4.sin_addr.s_addr = inet_addr(address);
}else{
server_address.socket_unix.sun_family = AF_UNIX;
strcpy(server_address.socket_unix.sun_path, address);
unlink((const char*)address);
}
}
void bind_server(int server_socket)
{
struct sockaddr* address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&server_address.socket_unix : (struct sockaddr*)&server_address.socket_ipv4;
int server_bind_response = bind(server_socket, address, socket_type == UNIX_SOCKET_FLAG ? sizeof(server_address.socket_unix) : sizeof(server_address.socket_ipv4));
if (socket_type == UNIX_SOCKET_FLAG) unlink((const char*)address);
if(server_bind_response == SOCKET_ERROR_CODE)
{
close(server_socket);
panic("Bind server error");
}
}
int accept_connection(int client_socket, int server_socket)
{
socklen_t client_addr_len = socket_type == UNIX_SOCKET_FLAG ? sizeof(client_address.socket_ipv4) : sizeof(client_address.socket_unix);
struct sockaddr *address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&client_address.socket_unix : (struct sockaddr*)&client_address.socket_ipv4;
client_socket = accept(server_socket, address, &client_addr_len);
if(client_socket == SYSTEM_EXIT_FAILED)
{
panic("Accept connection error!");
}else{
return client_socket;
}
}
void send_buffer(int client_socket, int* buffer, int buffer_size)
{
socklen_t client_addr_len = socket_type == UNIX_SOCKET_FLAG ? sizeof(client_address.socket_ipv4) : sizeof(client_address.socket_unix);
struct sockaddr *address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&client_address.socket_unix : (struct sockaddr*)&client_address.socket_ipv4;
if(socket_type == TCP_SOCKET_FLAG) send(client_socket, buffer, buffer_size, 0);
else sendto(client_socket, buffer, buffer_size, 0, address, client_addr_len);
}
int receive_buffer(int client_socket, int buffer_size)
{
ssize_t bytes_read;
socklen_t* client_addr_len = socket_type == UNIX_SOCKET_FLAG ? (socklen_t *)sizeof(client_address.socket_ipv4) : (socklen_t *)sizeof(client_address.socket_unix);
struct sockaddr *address = socket_type == UNIX_SOCKET_FLAG ? (struct sockaddr*)&client_address.socket_unix : (struct sockaddr*)&client_address.socket_ipv4;
int received_buffer[buffer_size];
while((bytes_read = socket_type == UNIX_SOCKET_FLAG ? recv(client_socket, received_buffer, buffer_size, 0) : recvfrom(client_socket, received_buffer, buffer_size, 0, address, client_addr_len)) > 0)
{
send_buffer(client_socket, received_buffer, buffer_size);
}
}
void controlc_handler()
{
exit(SYSTEM_EXIT_SUCCESS);
}
void server_listen(int client_socket, int server_socket, int buffer_size)
{
if (listen(server_socket, MAX_CONNECTIONS) == SOCKET_ERROR_CODE)
{
close(server_socket);
panic("Listening mode error");
}
client_socket = accept_connection(client_socket, server_socket);
receive_buffer(client_socket, buffer_size);
}
void attribuite_socket_type(int socket_type)
{
switch (socket_type)
{
case TCP_SOCKET_FLAG: // TCP SOCKET
sin_family = AF_INET;
address = HOST_IP;
sock = SOCK_STREAM;
break;
case UDP_SOCKET_FLAG: // UDP SOCKET
address = HOST_IP;
sock = SOCK_DGRAM;
break;
case UNIX_SOCKET_FLAG: // UNIXDOMAIN SOCKET
sin_family = AF_UNIX;
address = "pingpong.socket";
sock = SOCK_DGRAM;
break;
default:
panic("Value error!");
break;
}
}
void get_args(int argc, char** argv)
{
if(argc > NUM_OF_ARGUMENTS)
{
buffer_size = (int)atoi(argv[1]);
num_of_read_bytes = (int)atoi(argv[2]);
socket_type = (int)atoi(argv[3]);
}else
{
panic("Argument is missing!");
}
}
int main(int argc, char** argv)
{
get_args(argc, argv);
attribuite_socket_type(socket_type);
int* buffer = (int*)malloc(buffer_size*sizeof(int));
int server_socket, client_socket;
server_socket = create_socket();
config_server_address();
bind_server(server_socket);
for(int i = 0; i < num_of_read_bytes; i++)
{
server_listen(client_socket, server_socket, buffer_size);
}
return SYSTEM_EXIT_SUCCESS;
}

93
src/socket.c Normal file
View File

@ -0,0 +1,93 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "../include/socket.h"
#include "../include/utils.h"
int create_socket(int sin_family, int sock)
{
int server_socket;
server_socket = socket(sin_family, sock, -1);
if(server_socket == SOCKET_ERROR_CODE)
{
panic("Socket create failed!");
}
return server_socket;
}
socket_address_unix config_unixdomain_server_address()
{
socket_address_unix server_address;
server_address.sun_family = AF_UNIX;
strcpy(server_address.sun_path, UNIXDOAMIN_ADDRESS);
unlink(UNIXDOAMIN_ADDRESS);
return server_address;
}
socket_address_ipv4 config_tcp_upd_server_address()
{
socket_address_ipv4 server_address;
server_address.sin_family = AF_INET;
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = inet_addr(HOST_IP);
return server_address;
}
void connect_to_server(void *server_address, int client_socket)
{
struct sockaddr* address = (struct sockaddr*)&server_address;
int connection_response = connect(client_socket,
address,
(socklen_t)sizeof(server_address)
);
if(connection_response == SOCKET_ERROR_CODE)
{
close(client_socket);
panic("Server connection error\n");
}
}
void bind_server(void *server_address, int socket_type, int server_socket)
{
struct sockaddr* address = (struct sockaddr*)&server_address;
int server_bind_response = bind(server_socket, address, sizeof(server_address));
if (socket_type == UNIX_SOCKET_FLAG) unlink((const char*)address);
if(server_bind_response == SOCKET_ERROR_CODE)
{
close(server_socket);
panic("Bind server error");
}
}
int accept_connection(int client_socket, void *client_address, int server_socket)
{
socklen_t client_addr_len = sizeof(client_address);
struct sockaddr *address = (struct sockaddr*)&client_address;
client_socket = accept(server_socket, address, &client_addr_len);
if(client_socket == SYSTEM_EXIT_FAILED)
{
panic("Accept connection error!");
}else{
return client_socket;
}
}

23
src/utils.c Normal file
View File

@ -0,0 +1,23 @@
#include <stdio.h>
#include <stdlib.h>
#include "../include/utils.h"
void panic(char* message)
{
printf("%s\n",message);
exit(SYSTEM_EXIT_FAILURE);
}
int* get_init_buffer(int buffer_size)
{
int *buffer = (int*)malloc(buffer_size*sizeof(int*));
for(int i = 0; i < buffer_size; i++)
{
buffer[i] = (int)(i % 255);
}
return buffer;
}