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

Merge pull request #1 from viniciusfdasilva/dev 

[test] Multiple Sockets connections
This commit is contained in:
Vinicius Silva 2023-12-11 15:15:12 -03:00 committed by GitHub
parent 738d8d11ac 7b6c4e7e1e
commit 1fc086766d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 492 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
.gitignore vendored
View File

@ -1,6 +1,8 @@
# Prerequisites # Prerequisites
*.d *.d
*.vscode/settings.json
.vscode/settings.json
# Object files # Object files
*.o *.o
*.ko *.ko
@ -36,6 +38,19 @@
*.x86_64 *.x86_64
*.hex *.hex
# CMake
CMakeLists.txt.user
CMakeCache.txt
CMakeFiles
CMakeScripts
Testing
Makefile
cmake_install.cmake
install_manifest.txt
compile_commands.json
CTestTestfile.cmake
_deps
# Debug files # Debug files
*.dSYM/ *.dSYM/
*.su *.su

12
.vscode/settings.json vendored
View File

@ -1,12 +0,0 @@
{
"files.associations": {
"unistd.h": "c",
"stdio.h": "c",
"in.h": "c",
"time.h": "c",
"signal.h": "c",
"string.h": "c",
"stdlib.h": "c",
"inet.h": "c"
}
}

9
CMakeLists.txt Normal file
View File

@ -0,0 +1,9 @@
cmake_minimum_required(VERSION 2.8)
project(pingpong)
execute_process(
COMMAND mkdir -p bin
)
add_executable(./bin/server ./src/server.c)
add_executable(./bin/client ./src/client.c)

BIN
Transmissão de Buffers entre Cliente e Servidor via Conexão por Socket.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 33 KiB

BIN
bin/client Executable file
View File

Binary file not shown.

BIN
bin/server Executable file
View File

Binary file not shown.

163
client.c
View File

@ -1,163 +0,0 @@
#include <time.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.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 8099 // 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 KB 1024
float times[N];
float send_elapsed_time_ms = 0.00;
float receive_elapsed_time_ms = 0.00;
typedef struct sockaddr_in socket_address;
int init_socket()
{
// AF_INET -> IPV4 Family
// SOCK_STREAM -> TCP Socket initialization
// IPPROTO_TCP -> TCP Explicit protocol
int client_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(client_socket == SOCKET_ERROR_CODE)
{
perror("Socket create failed!\n");
exit(SYSTEM_EXIT_FAILED);
}
return client_socket;
}
socket_address config_server_address()
{
socket_address server_address;
server_address.sin_family = AF_INET; // IPV4 ips family
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = inet_addr(HOST_IP);
return server_address;
}
void connect_to_server(int client_socket, socket_address server_address)
{
struct sockaddr* address = (struct sockaddr*)&server_address;
int connection_response = connect(client_socket,
address,
sizeof(server_address)
);
if(connection_response == SOCKET_ERROR_CODE)
{
perror("Server connection error\n");
close(client_socket);
exit(SYSTEM_EXIT_FAILED);
}
}
int receive_buffer(int client_socket, int buffer_size)
{
ssize_t bytes_read;
int received_buffer[buffer_size];
recv(client_socket, received_buffer, buffer_size, 0);
}
void send_buffer(int client_socket, int buffer[], size_t buffer_size)
{
send(client_socket, buffer, buffer_size, 0);
}
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)
{
perror("Signal create error!");
exit(SYSTEM_EXIT_FAILED);
}
clock_t start_send_time = clock();
send_buffer(client_socket, buffer, buffer_size);
clock_t end_send_time = clock();
clock_t send_difference = (end_send_time - start_send_time);
send_elapsed_time_ms = ((float)send_difference / (CLOCKS_PER_SEC/1000));
clock_t start_receive_time = clock();
receive_buffer(client_socket, buffer_size);
clock_t end_receive_time = clock();
clock_t receive_difference = (end_receive_time - start_receive_time);
receive_elapsed_time_ms = ((float)receive_difference / (CLOCKS_PER_SEC/1000));
}
float calculate()
{
float average_total = 0.00;
for(int i = 0; i < N; i++){
average_total += times[i];
}
return average_total;
}
int main(int argc, char** argv)
{
size_t buffer_size = (int)atoi(argv[1]);
int buffer[buffer_size];
for(int i = 0; i < buffer_size; i++)
{
buffer[i] = (int)(i % 255);
}
int client_socket = init_socket();
socket_address server_address;
server_address = config_server_address();
connect_to_server(client_socket, server_address);
for(int i = 0; i < N; i++){
socket_listen(client_socket, buffer, buffer_size);
times[i] = send_elapsed_time_ms + receive_elapsed_time_ms;
}
float average = calculate();
printf("%lf\n", (float)(average/(float)N));
return SYSTEM_EXIT_SUCCESS;
}

2
graphic.py → data/graphic.py
View File

@ -69,6 +69,8 @@ categorias = ["0,064KB","0,128KB","0,256KB","0,512KB","1KB","2KB","4KB","8KB"]
plt.bar(categorias, valores, color='purple', width=0.8) plt.bar(categorias, valores, color='purple', width=0.8)
plt.yscale('log')
plt.xlabel('Tamanho do buffer em (KB)') plt.xlabel('Tamanho do buffer em (KB)')
plt.ylabel('Tempo de execução em (ms)') plt.ylabel('Tempo de execução em (ms)')
plt.title('Transmissão de Buffers entre Cliente e Servidor via Conexão por Socket') plt.title('Transmissão de Buffers entre Cliente e Servidor via Conexão por Socket')

11
data/main.py Normal file
View File

@ -0,0 +1,11 @@
import pylab
import matplotlib.pyplot as plt
a = [pow(10, i) for i in range(10)]
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1)
line, = ax.plot(a, color='blue', lw=2)
ax.set_yscale('log')
pylab.show()

0
requirements.txt → data/requirements.txt
View File

22
makefile
View File

@ -1,22 +0,0 @@
CC=gcc
all:
@$(CC) client.c -o client
@$(CC) server.c -o server
@./server $(buffer_size)&
@./client $(buffer_size)
clean:
@rm server client
run_client:
@$(CC) client.c -o client
@./client $(buffer_size)
@rm server client
run_server:
@$(CC) server.c -o server
@./server $(buffer_size)&
graphic:
@python graphic.py

142
server.c
View File

@ -1,142 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.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 8099 // Server port
#define MAX_CONNECTIONS 10 // 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 KB 1024
typedef struct sockaddr_in socket_address;
int create_socket()
{
int server_socket;
server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(server_socket == SOCKET_ERROR_CODE)
{
perror("Socket create failed!");
exit(SYSTEM_EXIT_FAILED);
}
return server_socket;
}
socket_address config_server_address()
{
socket_address server_address;
server_address.sin_family = AF_INET; // IPV4 ips family
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = inet_addr(HOST_IP);
return server_address;
}
void bind_server(int server_socket, socket_address server_address)
{
struct sockaddr* address = (struct sockaddr*)&server_address;
int server_bind_response = bind(server_socket, address, sizeof(server_address));
if(server_bind_response == SOCKET_ERROR_CODE)
{
perror("Bind server error");
close(server_socket);
exit(SYSTEM_EXIT_FAILED);
}
}
int accept_connection(int client_socket, int server_socket, socket_address client_address, socklen_t client_addr_len)
{
struct sockaddr *address = (struct sockaddr*)&client_address;
client_socket = accept(server_socket, address, &client_addr_len);
if(client_socket == SYSTEM_EXIT_FAILED)
{
perror("Accept connection error!");
exit(SYSTEM_EXIT_FAILED);
}else{
return client_socket;
}
}
void send_buffer(int client_socket, int buffer[], int buffer_size)
{
send(client_socket, buffer, buffer_size, 0);
}
int receive_buffer(int client_socket, int buffer_size)
{
ssize_t bytes_read;
int received_buffer[buffer_size];
while((bytes_read = recv(client_socket, received_buffer, buffer_size, 0)) > 0)
{
received_buffer[bytes_read] = '\0';
send_buffer(client_socket, received_buffer, buffer_size);
}
}
void controlc_handler()
{
printf("\nProgram finished!\n");
exit(SYSTEM_EXIT_SUCCESS);
}
void server_listen(int client_socket, int server_socket, socket_address client_address, socklen_t client_addr_len, int buffer_size)
{
if (listen(server_socket, MAX_CONNECTIONS) == SOCKET_ERROR_CODE)
{
perror("Listening mode error");
close(server_socket);
exit(SYSTEM_EXIT_FAILED);
}
printf("[SERVER] - Server TCP listening on port %d...\n", SERVER_PORT);
client_socket = accept_connection(client_socket, server_socket, client_address, client_addr_len);
receive_buffer(client_socket, buffer_size);
}
int main(int argc, char** argv)
{
size_t buffer_size = 8192;
int buffer[buffer_size];
int server_socket, client_socket;
server_socket = create_socket();
socket_address server_address, client_address;
socklen_t client_addr_len = sizeof(client_address);
server_address = config_server_address();
bind_server(server_socket, server_address);
server_listen(client_socket, server_socket, client_address, client_addr_len, buffer_size);
}

231
src/client.c Normal file
View File

@ -0,0 +1,231 @@
#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;
}

224
src/server.c Normal file
View File

@ -0,0 +1,224 @@
#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;
}