path: root/src/core/netconnection.cc

/*
   net/netconnection.cc
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#include <sstream>

#include "sys/sys.h"
#include "core/application.h"
#include "core/gameconnection.h"
#include "core/netconnection.h"
#include "core/player.h"

namespace core 
{

NetConnection::NetConnection()
{
	connection_timeout = core::application()->time();
	connection_state = Connecting;
}

NetConnection::~NetConnection()
{
	disconnect();
}

void NetConnection::abort()
{
	connection_error= true;
}

void NetConnection::connect(std::string const &to_host, int to_port)
{
	connection_error = false;
	connection_fd = -1;
	connection_state = Connecting;

	if (valid())
		return;
		
	// resolve serverhostname
	struct hostent *serverhostent;
	serverhostent = gethostbyname(to_host.c_str());
	if (!serverhostent) {
		con_warn << "Could not resolve '" << to_host.c_str() << "'" << std::endl;
		abort();
		return;
	}
	
	// Get a socket file descriptor
	connection_fd = socket(PF_INET, SOCK_DGRAM, 0);
	if (connection_fd == -1) {
		//con_error << "Network socket() failed!" << std::endl;
		abort();
		return;
	}
	
	// make the connection
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(to_port);
	// FIXME inet_addr can still fail
	server_addr.sin_addr.s_addr = inet_addr(inet_ntoa(*((struct in_addr *)serverhostent->h_addr)));
	memset(server_addr.sin_zero, '\0', sizeof server_addr.sin_zero);
	if (server_addr.sin_addr.s_addr == INADDR_NONE) {
		con_error << "Network invalid address " << to_host << "!" << std::endl;
		abort();
		return;
	}
	
	connection_host = to_host;
	connection_port = to_port;
	connection_error = false;

	FD_ZERO(&clientset);
	FD_SET(fd(), &clientset);
	
	connection_timeout = application()->time();
	connection_keepalive = application()->time();

	game()->localplayer()->player_dirty = true;

	con_print << "Connecting to " << inet_ntoa(*((struct in_addr *)serverhostent->h_addr))  << ":" << to_port << "..." << std::endl;
}

void NetConnection::disconnect()
{
	if (connection_fd != -1) {
		sendq.clear();
		sendq.assign("disconnect\n");
		transmit();

		FD_ZERO(&clientset);
		close(connection_fd);
	}
	
	connection_fd = -1;
	connection_error = false;
	connection_host.clear();
	connection_port = 0;
	connection_state = Connecting;
}

bool NetConnection::has_messages() const
{
	return (recvq.size() > 0);
}

void NetConnection::retreive(std::string & message)
{
	if (recvq.size() > 0) {
		message.assign(recvq.front());
		recvq.pop_front();
	} else {
		message.clear();
	}
}

// receive data and decode it into lines
void NetConnection::receive()
{
	// TODO: binary mode data transfer
	if (error() || invalid())
		return;

	ssize_t		bytes_received;
	
	memset(recvbuf, '\0', BLOCKSIZE);
	bytes_received = ::recv(connection_fd, recvbuf, BLOCKSIZE-1, 0);
	connection_timeout = core::application()->time();

	if (bytes_received == 0) {
		con_print << "Disconnected.";
		abort();
		return;
	} else if (bytes_received < 0) {
		con_error << "Network receive() error!" << std::endl;
		//perror("recv");
		abort();
		return;
	}

	std::string datablock;
	datablock.assign(recvbuf);

	while (datablock.size()) {
		// scan the datablock for enters
		if (datablock[0] == '\n' || datablock[0] == '\r') {
			if (messageblock.size() >= FRAMESIZE) {
				con_warn << "Incoming message exceeds " << FRAMESIZE << " bytes!\n";
				messageblock.clear();
			} else if (messageblock.size()) {
				recvq.push_back(messageblock);
				//con_debug << "Incoming message '" << messageblock << "'" << std::endl;
				messageblock.clear();
			}
		} else {
			messageblock.append(datablock.substr(0,1));
		}
		datablock.erase(0,1);
	}
	datablock.clear();
}

void NetConnection::frame(float seconds)
{
	timeval timeout;
	timeout.tv_sec = 0;
	timeout.tv_usec = 0;
	fd_set readset = clientset;

	int nb = select(fd()+1, &readset, NULL, NULL, &timeout);
	if (nb == 0) {
		if (connection_timeout + NETTIMEOUT < core::application()->time()) {
			con_error << "Connection timeout!\n";
			abort();
		}
		return;
	}
	if (nb == -1) {
		con_error << "Network error on select()" << std::endl;
		//perror("select");
		abort();
	}

	while (FD_ISSET(this->fd(), &readset) && !error()) {
		receive();

		while (has_messages()) {
			std::string message;
			retreive(message);
			parse_incoming_message(message);
		}

		nb = select(fd()+1, &readset, NULL, NULL, &timeout);
		if (nb == 0) {
			return;
		}
		if (nb == -1) {
			con_error << "Network error on select()" << std::endl;
			//perror("select");
			abort();
		}
	}
}

void NetConnection::send(std::string const &msg)
{
	sendq.append(msg);
}

void NetConnection::transmit()
{

	if (error() || invalid())
		return;
	
	if (!sendq.size()) {
		if (connection_keepalive + NETTIMEOUT /2 < application()->time()) {
			sendq.assign("ping\n");
		} else {
			return;
		}
	} else if (sendq.size() > FRAMESIZE) {
		con_warn << "Outgoing message exceeds " << FRAMESIZE << " bytes!\n";
		//sendq.clear();
		//return;
	}
	
	ssize_t 	bytes_sent = 0;
	
	while (sendq.size()) {
		bytes_sent = ::sendto(connection_fd, sendq.c_str(), sendq.size(), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
		if (bytes_sent <= 0) {
			con_error << "Network send() error!" << std::endl;
			//perror("send");
			abort();
			return;
		}
		
		// assert (bytes_sent <= sendbuf.size());
		sendq.erase(0, bytes_sent);
	}

	connection_keepalive = application()->time();
}

// parse incoming client messages
/**
 * The following incoming messages are parsed;
 *
 * connect
 * disconnect
 * msg info <text>
 * msg public <name> <text>
 * die
 * ent
 * sup
 * pif
 */
void NetConnection::parse_incoming_message(const std::string & message)
{
	std::istringstream msgstream(message);
	
	std::string command;
	msgstream >> command;
	
	if (command == "msg") {
		std::string level;
		if (msgstream >> level) {
			if (level =="info") {
				if (message.size() > 9) {
					con_print << message.substr(9) << std::endl;
				}
			} else if (level == "public") {
				// FIXME - separate sender nickname
				if (message.size() > 11) {
					con_print << message.substr(11) << std::endl;
				}
				
			}
		}
	} else if (command == "connect") {

		connection_state = Connected;
		con_print << "Connected." << std::endl;
		return;

	} else if (command == "disconnect") {

		con_error << "Server disconnected!" << std::endl;
		abort();

	} else if (command == "ping") {

	} else if (command == "die") {
		unsigned int id;
		msgstream >> id;

		Entity *e = Entity::find(id);
		//con_debug << "Received die entity id " << id << "\n";
		
		if (localcontrol() == e) 
			localplayer()->player_control = 0;
		if (e)
			Entity::remove(id);

	} else if (command == "ent") {
		unsigned int type;
		msgstream >> type;

		//con_debug << "Received create entity type " << type << "\n";
		switch (type) 
		{
		case Entity::Default:
			new Entity(msgstream);
			break;
		case Entity::Dynamic:
			new EntityDynamic(msgstream);
			break;
		case Entity::Controlable:
			new EntityControlable(msgstream);
			break;
		default:
			break;
		}
		
	} else if (command == "sup") {
		unsigned int id;
		if (msgstream >> id) {
			Entity *entity = Entity::find(id);
			if (!entity) {
				con_warn << "Update for unknown entity " << id << "\n";
			} else 
				entity->recieve_server_update(msgstream);
		}

	} else if (command == "pif") {

		connection()->localplayer()->recieve_server_update(msgstream);
	}
	
}

}