Rockingcool/netpong
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Made the sendAll and recvAll functions in sock.cpp use variables set by the children, rather than having the functions pass parameters

Browse Source
This commit is contained in:
Aadhavan Srinivasan
2024-02-21 22:25:52 -05:00
parent 350b51e28b
commit 9954a18171
3 changed files with 58 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
client.cpp
View File

@@ -22,7 +22,7 @@ void Client::create_socket() {
Sock::create_socket();
this->sock_fd = create_remote(this->ip_ver, this->protocol, this->address.data(), this->port, dest);
if (this->sock_fd < 0) {
throw strerror(this->sock_fd * -1);
throw (this->sock_fd * -1);
}
}
@@ -32,12 +32,19 @@ client socket (TCP or UDP) does not have this requirement. Therefore, while both
sendAll methods perform the same actions, they do so using different sockets. */
void Client::sendAll(std::string to_send) {
Sock::sendAll(to_send, this->sock_fd);
this->other_socket = this->sock_fd;
Sock::sendAll(to_send);
}
/* Receives data from peer socket, and returns it. See above for better
explanation of why this method is overriden. */
std::string Client::recvAll() {
return Sock::recvAll(this->sock_fd);
this->other_socket = this->sock_fd;
return Sock::recvAll();
}
/* Returns the type of socket based on the global constants set in sock.hpp */
int Client::get_type() {
return SOCK_CLIENT;
}

50
server.cpp
View File

@@ -4,6 +4,7 @@
#include "includes/server.hpp"
#include "includes/exception_consts.hpp"
#include "includes/easysock.hpp"
#include "includes/connect_code.hpp"
/* Destructor - closes any open sockets */
Server::~Server() {
@@ -16,22 +17,37 @@ base method, because a different socket must be used. In the server's case, the
'peer' socket i.e. the socket returned after calling 'accept', must be used. */
void Server::sendAll(std::string to_send) {
Sock::sendAll(to_send, this->other_socket);
Sock::sendAll(to_send);
}
/* Receives data from socket, and returns it. This function works differently
based on the Transport layer protocol used. For TCP, it calls the parent method
with the peer socket. As mentioned above, this is the socket returned after
calling the accept function. With UDP, there is no concept of a peer socket, and
so the regular server socket (the one created in create_socket() ) is used
instead. */
based on the Transport layer protocol used. For TCP, it sets the 'other_socket' variable (used
by the parent function) to the peer socket. As mentioned above, this is the
socket returned after calling the accept function. With UDP, there is no concept
of a peer socket, and so the regular server socket (the one created in create_socket())
is used instead. This function also sets the 'peer_addr' string to the address of the
peer socket, handling both TCP and UDP. */
std::string Server::recvAll() {
if (this->protocol == 'T') {
return Sock::recvAll(this->other_socket);
} else {
return Sock::recvAll(this->sock_fd);
if (this->protocol == ES_UDP) {
this->other_socket = this->sock_fd;
}
/* Call receive method of parent */
std::string to_return = Sock::recvAll();
/* Set the peer address of the socket */
if (this->ip_ver == 4) {
/* FOR IPv4 */
struct sockaddr_in* temp_struct = (struct sockaddr_in*)this->dest;
/* Convert the s_addr field of the caseted struct to host network-byte, and convert it to a dotted decimal */
peer_addr = connect_code::dec_to_dotted_dec(std::to_string(htonl(temp_struct->sin_addr.s_addr)));
} else {
/* FOR IPv6 */
peer_addr = "IPV6 NOT SUPPORTED YET";
}
return to_return;
}
/* FOR TCP ONLY - Waits for a peer to connect to the server socket. It stores
@@ -40,8 +56,8 @@ nothing if your server socket is a UDP socket. If the accept function fails, the
is thrown as an exception. */
void Server::wait_for_peer() {
if (this->protocol == 'T') {
this->other_socket = accept(this->sock_fd, NULL, NULL);
if (this->protocol == ES_TCP) {
this->other_socket = accept(this->sock_fd, dest, &addrlen);
if (this->other_socket < 0) {
throw errno;
}
@@ -61,9 +77,17 @@ void Server::create_socket() {
if (this->sock_fd < 0) {
throw (this->sock_fd * -1);
}
if (protocol == 'T') {
if (protocol == ES_TCP) {
listen(sock_fd, 10);
}
}
/* Returns the address of the peer socket as a string, can be used for debugging */
std::string Server::get_peer_addr() {
return this->peer_addr;
}
/* Returns the type of socket based on the global constants set in sock.hpp */
int Server::get_type() {
return SOCK_SERVER;
}

21
sock.cpp
View File

@@ -25,7 +25,7 @@ Sock::Sock(int ip_ver, char protocol, const char* address, int port) {
if (port < 1024 || port > 65535) {
throw std::invalid_argument("Invalid port");
}
if (protocol != 'T' && protocol != 'U') {
if (protocol != ES_TCP && protocol != ES_UDP) {
throw std::invalid_argument("Invalid protocol");
}
@@ -40,23 +40,24 @@ Sock::Sock(int ip_ver, char protocol, const char* address, int port) {
}
}
/* This method sends the given data, through the given socket. Client and server
classes extend this method, by calling it with different parameters.
/* This method sends the given data, through the 'other_sockt' variable.. Client
and server classes extend this method, by setting this variable to different values.
This function needs more testing for TCP, as it focuses on UDP right now. */
void Sock::sendAll(std::string to_send, int dest_sock) {
void Sock::sendAll(std::string to_send) {
int str_length = to_send.length();
int num_bytes_sent = 0; /* Number of bytes sent in one call to send */
int total_bytes_sent = 0; /* Total number of bytes sent */
/* For UDP sockets */
if (this->protocol == 'U') {
if (this->protocol == ES_UDP) {
sendto(this->sock_fd, to_send.data(), str_length, 0, dest, addrlen);
}
/* For TCP sockets */
else {
while (total_bytes_sent < str_length) {
num_bytes_sent = send(dest_sock, to_send.substr(total_bytes_sent).data(), str_length - total_bytes_sent, 0);
/* Send the data to the 'other_socket' variable, which should be set by the client and server methods */
num_bytes_sent = send(this->other_socket, to_send.substr(total_bytes_sent).data(), str_length - total_bytes_sent, 0);
if (num_bytes_sent < 0) {
throw errno * -1;
}
@@ -67,24 +68,24 @@ void Sock::sendAll(std::string to_send, int dest_sock) {
return;
}
/* Receives data from given socket into a string, and returns that string. For TCP, the
/* Receives data from 'other_socket' into a string, and returns that string. For TCP, the
'recv' method is called until all the data has been read. For UDP, the 'recvfrom'
method is only called once.
This function also needs more testing for TCP. */
std::string Sock::recvAll(int from_sock) {
std::string Sock::recvAll() {
int num_bytes_received;
std::string string = std::string();
char* buffer = (char *)malloc(100);
bool has_been_read = false;
if (this->protocol == 'U') {
if (this->protocol == ES_UDP) {
recvfrom(this->sock_fd, buffer, 100, 0, dest, &addrlen);
string.append(std::string(buffer));
}
/* For TCP sockets */
else {
while ((num_bytes_received = recv(from_sock, buffer, 100, 0)) != 0) {
while ((num_bytes_received = recv(this->other_socket, buffer, 100, 0)) != 0) {
if ((errno == EAGAIN || errno == EWOULDBLOCK)) {
if (has_been_read) {