UDP_Protocol.cpp

#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <regex>
#include <limits>
#include <algorithm>
#include <ctime>
#include <iomanip>

#include <UDP_Protocol.h>

using namespace inaf::oasbo::Receivers;

UDPProtocol::UDPProtocol() :
		UDPProtocol(std::string("localhost"), 9003) {
}

UDPProtocol::UDPProtocol(std::string ip, int port) :
		srv_sock(-1), ip(ip), port(port) {
	memset(&cliaddr, 0, sizeof(cliaddr));
	memset(&srvaddr, 0, sizeof(srvaddr));
	// Filling server information
	srvaddr.sin_family = AF_INET; // IPv4
	srvaddr.sin_addr.s_addr = inet_addr(ip.c_str());
	srvaddr.sin_port = htons(this->port);

}

UDPProtocol::~UDPProtocol() {
	closeConnectionToClient();
}

int UDPProtocol::receiveAtLeastNbytes(uint8_t *buff, int n_bytes,
		int max_size) {
	int bytercv = 0;
	socklen_t len = sizeof(cliaddr);
	while (bytercv < n_bytes && this->checkIncomingPackets) {
		int rcv = recvfrom(srv_sock, &buff[bytercv], max_size + 1, // +1 to recognized if there are more bytes than expected
		0, (struct sockaddr*) &cliaddr, &len);

		bytercv += rcv;
		if (rcv < 0) {
			return -1;
		}
	}
	if (!this->checkIncomingPackets) { // interrupted by closeConnectionToClient before receiving all the N bytes.
		return -1;
	}
	return bytercv;
}

int UDPProtocol::receiveFromClient(Packets::BasePacket &pack) {
	bool headerFlag = false; // tells if the header has been received
	uint headerSize = pack.getHeaderSize();
	uint packSize = pack.getPacketStructureByteSize();
	uint tailSize = pack.getTailSize();
	uint payloadSize = 0;
	uint totPacketSize = 0;
	ssize_t to_be_received = 0;
	uint8_t *buff = new uint8_t[(packSize + headerSize) * headerSize]; // * headerSize to avoid overflow
	int tot_byte_rcv = 0;
	while (this->checkIncomingPackets) {
		while (!headerFlag) { // until the header has not received
			int rcv = receiveAtLeastNbytes(buff, headerSize, packSize); // receive at least headerSize byte, maximum packSize for each udp rcv.
			if (rcv < 0) {
				delete[] buff;
				return -1;
			}
			tot_byte_rcv += rcv;
			pack.copyToMemory(buff, headerSize); //copy the header into packet to be able to read it.
			if (!pack.hasRecognizedHeader()) { // reset buffer and exit
				resetPacket(pack, headerSize);
				delete[] buff;
				return -1;
			}
			headerFlag = true;
			payloadSize = pack.getPayloadSize();
			totPacketSize = headerSize + payloadSize + tailSize;
			to_be_received = totPacketSize - tot_byte_rcv; // Calculate how much is still left to read
		}

		if (to_be_received == 0) { // whole packet has been received, we can return.
			pack.copyToMemory(&buff[headerSize], tot_byte_rcv - headerSize,
					headerSize); // copy the buffer into packet except already copied header
			delete[] buff;
			return tot_byte_rcv;
		}
		if (to_be_received < 0) {// error,received more bytes then expected, we can return.
			resetPacket(pack, tot_byte_rcv);
			delete[] buff;
			return -1;
		}

		// go ahead until the rest of the packet received or connection terminates or another header is received.
		uint8_t *tmp_buff = new uint8_t[packSize + headerSize]; // maximum receivable in receiveAtLeastNBytes
		int rcv = receiveAtLeastNbytes(tmp_buff, headerSize, packSize);
		if (rcv == -1) {
			delete[] buff;
			delete[] tmp_buff;
			resetPacket(pack, tot_byte_rcv);
			return -1;
		}

		// copy the content of the buffer into a vector to check if it is a header. If it is,
		// save it and discard previous data, otherwise append to current buff.
		std::vector<uint8_t> vec;
		std::copy(tmp_buff, tmp_buff + headerSize, std::back_inserter(vec));
		if (pack.isRecognizedHeader(vec)) { //another header received, save it and discard previous data.
			std::memset(buff, 0, tot_byte_rcv);
			std::memcpy(buff, tmp_buff, rcv);
			headerFlag = true;
			pack.copyToMemory(buff, headerSize);
			payloadSize = pack.getPayloadSize();
			totPacketSize = headerSize + payloadSize + tailSize;
			to_be_received = totPacketSize - rcv;
			tot_byte_rcv = rcv;
		} else { // append to current buff
			tot_byte_rcv += rcv;
			std::memcpy(&buff[tot_byte_rcv - rcv], tmp_buff, rcv);
			to_be_received -= rcv;
		}
		delete[] tmp_buff;
	}
	return -1; // connection interrupted by closeConnectionToClient
}

int UDPProtocol::connectToClient() {
	// Creating socket file descriptor
	if ((srv_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t" << "socket creation failed"
				<< std::endl;
		return -1;
	}

	// Set timeout to the socket
	struct timeval tv;
	tv.tv_sec = 1;
	tv.tv_usec = 0;
	if (setsockopt(srv_sock, SOL_SOCKET, SO_RCVTIMEO, (const char*) &tv,
			sizeof tv) < 0) {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t" << "Error setting timeout to socket"
				<< std::endl;
		return -1;
	}

	// Bind the socket with the server address
	if (bind(srv_sock, (const struct sockaddr*) &srvaddr, sizeof(srvaddr))
			< 0) {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t" << "bind failed" << std::endl;
		return -1;
	}

	return srv_sock;

}

int UDPProtocol::closeConnectionToClient() {
	checkIncomingPackets = false;
	if (srv_sock != -1) {
		::close(srv_sock);
		srv_sock = -1;
	}
	return 1;
}

bool UDPProtocol::isConnectedToClient() const {
	return srv_sock != -1;
}

void UDPProtocol::resetPacket(Packets::BasePacket &pack, int bytes) {
	uint8_t *buff = new uint8_t[bytes];
	std::memset(buff, 0, bytes);
	int toBeReset = std::min(
			static_cast<int>(pack.getPacketStructureByteSize()), bytes);
	pack.copyToMemory(buff, toBeReset);
	delete[] buff;
}

std::string UDPProtocol::getHost() {
	return ip + ":" + std::to_string(port);
}

void UDPProtocol::setHost(std::string host) {
	std::string ip = { };
	int port = 0;
	if (split_ip_port(host, ip, port)) {
		setIp(ip);
		setPort(port);
	} else {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t"
				<< "invalid IP address and port format: " << host << std::endl;
	}
}

void UDPProtocol::setIp(std::string ip) {
	std::regex pattern("^[\\w.-]+$");
	// Check if the input string matches the expected format
	bool ok = true;
	if (!std::regex_match(ip, pattern)) {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t" << "invalid IP address: " << ip
				<< ", setting to localhost" << std::endl;
		ok = false;
		this->ip = std::string("localhost");
	}
	if (ok)
		this->ip = ip;

	this->host = this->ip + ":" + std::to_string(this->port);
}
void UDPProtocol::setPort(int port) {
	if (port > 1023 && port < 65535)
		this->port = port;
	else {
		time_t now = time(nullptr);
		std::cerr << "[" << std::put_time(localtime(&now), "%Y-%m-%d %H:%M:%S")
				<< "]\t[UDP Receiver]\t" << "invalid port: " << port
				<< ", setting to 9003" << std::endl;
		this->port = 9003;
	}
	this->host = this->ip + ":" + std::to_string(this->port);
}

bool UDPProtocol::split_ip_port(const std::string &ip_port,
		std::string &ip_address, int &port) {
	// Regex pattern to match IP address and port in the format "xxx.xxx.xxx.xxx:xxxx"
	std::regex pattern("^[\\w.-]+:(\\d{1,5})$");

	// Check if the input string matches the expected format
	if (!std::regex_match(ip_port, pattern)) {
		return false;
	}

	// Split the input string into IP address and port
	int colon_pos = ip_port.find(":");
	ip_address = ip_port.substr(0, colon_pos);
	port = std::stoi(ip_port.substr(colon_pos + 1));
	return true;
}