socket/socketio_posix.cpp

#include "socketio.hpp"
#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);
	}
	socket_exception(const std::string& _msg){
		msg = _msg;
	}
	socket_exception(const char* _msg){
		msg = std::string(_msg);
	}
	const char* what() const throw (){
    	return msg.length() == 0 ? "Connection creation failure" : msg.c_str();
    }
};
cppsocket::cppsocket(sockaddr_in _serv_addr,int _sock) : sock(_sock), serv_addr(_serv_addr){
	buffer = std::vector<char>(buffersize + 1,0);
}
cppsocket::cppsocket(){};
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 cppsocket::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> cppsocket::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);
}
server_socket::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 server_socket::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);
}

int server_socket::port(){return port_;}