socket/socketio.hpp

#include <string>
#include <cstring>
#include <vector>
#include <iostream>
#include <exception>
#include <cmath>
#include <stdexcept>

#include <stdio.h> 
#include <sys/socket.h> 
#include <stdlib.h> 
#include <netinet/in.h> 
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>

struct socket_exception : public std::exception{
	std::string msg;
	socket_exception(std::string&& _msg){
		msg = std::move(_msg);
	}
	const char* what() const throw (){
    	return msg.length() == 0 ? "Connection creation failure" : msg.c_str();
    }
};
class cppsocket{
private:
	struct sockaddr_in serv_addr;
	int sock;
	std::vector<char> buffer;
public:
	const static constexpr unsigned int buffersize = 16;
	cppsocket(sockaddr_in _serv_addr,int _sock) : sock(_sock), serv_addr(_serv_addr){
		buffer = std::vector<char>(buffersize + 1,0);
	}
	cppsocket(){};
	cppsocket(const std::string& addr, unsigned int PORT){
		struct sockaddr_in address; 
		sock = 0;
		int valread;
		buffer = std::vector<char>(buffersize + 1, 0);
		
		if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 
			printf("\n Socket creation error \n"); 
		}
		
		memset(&serv_addr, '0', sizeof(serv_addr)); 
		serv_addr.sin_family = AF_INET; 
		serv_addr.sin_port = htons(PORT);
		
		if(inet_pton(AF_INET, addr.c_str(), &serv_addr.sin_addr)<=0){ 
			throw std::invalid_argument("Invalid address: " + addr);
		} 

		if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { 
			throw socket_exception("Could not reach server " + addr);  
		}
	}
	void write(const std::string& message){
		for(size_t i = 0;i < message.length();i += buffersize){
			char cs[buffersize + 1] = {0};
			std::memcpy(cs, message.c_str() + i,buffersize);
			if((i + buffersize) < message.length()){
				cs[buffersize] = 'c';
			}
			else{
				cs[buffersize] = (char)0;
			}
			send(sock, message.c_str(), message.size(), 0);
		}
	}
	
	std::vector<char> receive(){
		std::vector<char> stor;
		while(true){
			std::fill(buffer.begin(), buffer.end(), (char)0);
			size_t val = read(sock, buffer.data(), buffersize + 1);
			if(val == 0)throw socket_exception("Connection reset by peer");
			stor.insert(stor.end(),buffer.begin(),buffer.begin() + std::min(val, (size_t)buffersize));
			if(buffer.data()[buffersize] == (char)0)break;
		}
		
		return std::move(stor);
	}
};
class server_socket{
private:
	int port_;
	int server_fd;
	struct sockaddr_in address;
	socklen_t addrlen;
public:
	int port(){return port_;}
	server_socket(int _port) : port_(_port){ 
		int opt = 1; 
		addrlen = sizeof(address);
		if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { 
			throw socket_exception("server_socket creation failed"); 
		}
		if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) { 
			throw socket_exception("server_socket creation failed"); 
		} 
		address.sin_family = AF_INET; 
		address.sin_addr.s_addr = INADDR_ANY; 
		address.sin_port = htons(port());
		if(bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0){ 
			throw socket_exception("Couldn't bind to port " + std::to_string(port()) + ", is it already in use?"); 
		}
		if (listen(server_fd, 16) < 0){ 
			throw socket_exception("Error in listen() call, no clue why"); 
		}
	}
	cppsocket accept_connection(){
		int new_socket;
		sockaddr client_addr;
		if ((new_socket = accept(server_fd, (struct sockaddr *)&client_addr,(socklen_t*)&addrlen))<0){ 
			throw socket_exception("Socket accept failed"); 
		}
		return cppsocket(*((sockaddr_in*)&client_addr), new_socket);
	}
};