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

master
Aadhavan Srinivasan 10 months ago
parent 350b51e28b
commit 9954a18171

@ -22,7 +22,7 @@ void Client::create_socket() {
Sock::create_socket(); Sock::create_socket();
this->sock_fd = create_remote(this->ip_ver, this->protocol, this->address.data(), this->port, dest); this->sock_fd = create_remote(this->ip_ver, this->protocol, this->address.data(), this->port, dest);
if (this->sock_fd < 0) { 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. */ sendAll methods perform the same actions, they do so using different sockets. */
void Client::sendAll(std::string to_send) { 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 /* Receives data from peer socket, and returns it. See above for better
explanation of why this method is overriden. */ explanation of why this method is overriden. */
std::string Client::recvAll() { 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;
} }

@ -4,6 +4,7 @@
#include "includes/server.hpp" #include "includes/server.hpp"
#include "includes/exception_consts.hpp" #include "includes/exception_consts.hpp"
#include "includes/easysock.hpp" #include "includes/easysock.hpp"
#include "includes/connect_code.hpp"
/* Destructor - closes any open sockets */ /* Destructor - closes any open sockets */
Server::~Server() { 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. */ 'peer' socket i.e. the socket returned after calling 'accept', must be used. */
void Server::sendAll(std::string to_send) { 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 /* 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 based on the Transport layer protocol used. For TCP, it sets the 'other_socket' variable (used
with the peer socket. As mentioned above, this is the socket returned after by the parent function) to the peer socket. As mentioned above, this is the
calling the accept function. With UDP, there is no concept of a peer socket, and socket returned after calling the accept function. With UDP, there is no concept
so the regular server socket (the one created in create_socket() ) is used of a peer socket, and so the regular server socket (the one created in create_socket())
instead. */ 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() { std::string Server::recvAll() {
if (this->protocol == 'T') { if (this->protocol == ES_UDP) {
return Sock::recvAll(this->other_socket); 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 { } else {
return Sock::recvAll(this->sock_fd); /* 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 /* 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. */ is thrown as an exception. */
void Server::wait_for_peer() { void Server::wait_for_peer() {
if (this->protocol == 'T') { if (this->protocol == ES_TCP) {
this->other_socket = accept(this->sock_fd, NULL, NULL); this->other_socket = accept(this->sock_fd, dest, &addrlen);
if (this->other_socket < 0) { if (this->other_socket < 0) {
throw errno; throw errno;
} }
@ -61,9 +77,17 @@ void Server::create_socket() {
if (this->sock_fd < 0) { if (this->sock_fd < 0) {
throw (this->sock_fd * -1); throw (this->sock_fd * -1);
} }
if (protocol == 'T') { if (protocol == ES_TCP) {
listen(sock_fd, 10); 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;
}

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

Loading…
Cancel
Save