virtualx-engine/modules/enet/networked_multiplayer_enet.cpp

#include "os/os.h"
#include "io/marshalls.h"
#include "networked_multiplayer_enet.h"

void NetworkedMultiplayerENet::set_transfer_mode(TransferMode p_mode) {

	transfer_mode=p_mode;
}

void NetworkedMultiplayerENet::set_target_peer(int p_peer){

	target_peer=p_peer;
}

int NetworkedMultiplayerENet::get_packet_peer() const{

	ERR_FAIL_COND_V(!active,1);
	ERR_FAIL_COND_V(incoming_packets.size()==0,1);

	return incoming_packets.front()->get().from;

}

Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth){

	ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE);

	ENetAddress address;
	address.host = ENET_HOST_ANY;

	address.port = p_port;

	host = enet_host_create (& address /* the address to bind the server host to */,
				     p_max_clients      /* allow up to 32 clients and/or outgoing connections */,
				     2      /* allow up to 2 channels to be used, 0 and 1 */,
				     p_in_bandwidth      /* assume any amount of incoming bandwidth */,
				     p_out_bandwidth      /* assume any amount of outgoing bandwidth */);

	ERR_FAIL_COND_V(!host,ERR_CANT_CREATE);

	_setup_compressor();
	active=true;
	server=true;
	refuse_connections=false;
	unique_id=1;
	connection_status=CONNECTION_CONNECTED;
	return OK;
}
Error NetworkedMultiplayerENet::create_client(const IP_Address& p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth){

	ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE);

	host = enet_host_create (NULL /* create a client host */,
		    1 /* only allow 1 outgoing connection */,
		    2 /* allow up 2 channels to be used, 0 and 1 */,
		    p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */,
		    p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */);

	ERR_FAIL_COND_V(!host,ERR_CANT_CREATE);


	_setup_compressor();

	ENetAddress address;
	address.host=p_ip.host;
	address.port=p_port;

	//enet_address_set_host (& address, "localhost");
	//address.port = p_port;

	unique_id=_gen_unique_id();

	/* Initiate the connection, allocating the two channels 0 and 1. */
	ENetPeer *peer = enet_host_connect (host, & address, 2, unique_id);

	if (peer == NULL) {
		enet_host_destroy(host);
		ERR_FAIL_COND_V(!peer,ERR_CANT_CREATE);
	}

	//technically safe to ignore the peer or anything else.

	connection_status=CONNECTION_CONNECTING;
	active=true;
	server=false;
	refuse_connections=false;

	return OK;
}

void NetworkedMultiplayerENet::poll(){

	ERR_FAIL_COND(!active);

	_pop_current_packet();

	ENetEvent event;
	/* Wait up to 1000 milliseconds for an event. */
	while (true) {

		if (!host || !active) //might have been disconnected while emitting a notification
			return;

		int ret = enet_host_service (host, & event, 1);

		if (ret<0) {
			//error, do something?
			break;
		} else if (ret==0) {
			break;
		}

		switch (event.type)
		{
			case ENET_EVENT_TYPE_CONNECT: {
				/* Store any relevant client information here. */

				if (server && refuse_connections) {
					enet_peer_reset(event.peer);
					break;
				}

				IP_Address ip;
				ip.host=event.peer -> address.host;

				int *new_id = memnew( int );
				*new_id = event.data;

				if (*new_id==0) { //data zero is sent by server (enet won't let you configure this). Server is always 1
					*new_id=1;
				}

				event.peer->data=new_id;

				peer_map[*new_id]=event.peer;

				connection_status=CONNECTION_CONNECTED; //if connecting, this means it connected t something!

				emit_signal("peer_connected",*new_id);

				if (server) {
					//someone connected, let it know of all the peers available
					for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {

						if (E->key()==*new_id)
							continue;
						//send existing peers to new peer
						ENetPacket * packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
						encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]);
						encode_uint32(E->key(),&packet->data[4]);
						enet_peer_send(event.peer,1,packet);
						//send the new peer to existing peers
						packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
						encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]);
						encode_uint32(*new_id,&packet->data[4]);
						enet_peer_send(E->get(),1,packet);
					}
				} else {

					emit_signal("connection_succeeded");
				}

			} break;
			case ENET_EVENT_TYPE_DISCONNECT: {

				/* Reset the peer's client information. */

				int *id = (int*)event.peer -> data;



				if (!id) {
					if (!server) {
						emit_signal("connection_failed");
					}
				} else {

					if (server) {
						//someone disconnected, let it know to everyone else
						for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {

							if (E->key()==*id)
								continue;
							//send the new peer to existing peers
							ENetPacket* packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
							encode_uint32(SYSMSG_REMOVE_PEER,&packet->data[0]);
							encode_uint32(*id,&packet->data[4]);
							enet_peer_send(E->get(),1,packet);
						}
					} else if (!server) {
						emit_signal("server_disconnected");
						close_connection();
						return;
					}

					emit_signal("peer_disconnected",*id);
					peer_map.erase(*id);
					memdelete( id );

				}


			} break;
			case ENET_EVENT_TYPE_RECEIVE: {


				if (event.channelID==1) {
					//some config message
					ERR_CONTINUE( event.packet->dataLength < 8);

					int msg = decode_uint32(&event.packet->data[0]);
					int id = decode_uint32(&event.packet->data[4]);

					switch(msg) {
						case SYSMSG_ADD_PEER: {

							peer_map[id]=NULL;
							emit_signal("peer_connected",id);

						} break;
						case SYSMSG_REMOVE_PEER: {

							peer_map.erase(id);
							emit_signal("peer_disconnected",id);
						} break;
					}

					enet_packet_destroy(event.packet);
				} else if (event.channelID==0){

					Packet packet;
					packet.packet = event.packet;

					int *id = (int*)event.peer -> data;

					ERR_CONTINUE(event.packet->dataLength<12)


					uint32_t source = decode_uint32(&event.packet->data[0]);
					int target = decode_uint32(&event.packet->data[4]);
					uint32_t flags = decode_uint32(&event.packet->data[8]);

					packet.from=source;

					if (server) {

						packet.from=*id;

						if (target==0) {
							//re-send the everyone but sender :|

							incoming_packets.push_back(packet);
							//and make copies for sending
							for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {

								if (uint32_t(E->key())==source) //do not resend to self
									continue;

								ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags);

								enet_peer_send(E->get(),0,packet2);
							}

						} else if (target<0) {
							//to all but one

							//and make copies for sending
							for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {

								if (uint32_t(E->key())==source || E->key()==-target) //do not resend to self, also do not send to excluded
									continue;

								ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags);

								enet_peer_send(E->get(),0,packet2);
							}

							if (-target != 1) {
								//server is not excluded
								incoming_packets.push_back(packet);
							} else {
								//server is excluded, erase packet
								enet_packet_destroy(packet.packet);
							}

						} else if (target==1) {
							//to myself and only myself
							incoming_packets.push_back(packet);
						} else {
							//to someone else, specifically
							ERR_CONTINUE(!peer_map.has(target));
							enet_peer_send(peer_map[target],0,packet.packet);
						}
					} else {

						incoming_packets.push_back(packet);
					}


					//destroy packet later..
				} else {
					ERR_CONTINUE(true);
				}


			}break;
			case ENET_EVENT_TYPE_NONE: {
				//do nothing
			} break;
		}
	}
}

bool NetworkedMultiplayerENet::is_server() const {
	ERR_FAIL_COND_V(!active,false);

	return server;
}

void NetworkedMultiplayerENet::close_connection() {

	if (!active)
		return;

	_pop_current_packet();

	bool peers_disconnected=false;
	for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
		if (E->get()) {
			enet_peer_disconnect_now(E->get(),unique_id);
			peers_disconnected=true;
		}
	}

	if (peers_disconnected) {
		enet_host_flush(host);
		OS::get_singleton()->delay_usec(100); //wait 100ms for disconnection packets to send

	}

	enet_host_destroy(host);
	active=false;
	incoming_packets.clear();
	unique_id=1; //server is 1
	connection_status=CONNECTION_DISCONNECTED;
}

int NetworkedMultiplayerENet::get_available_packet_count() const {

	return incoming_packets.size();
}
Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer,int &r_buffer_size) const{

	ERR_FAIL_COND_V(incoming_packets.size()==0,ERR_UNAVAILABLE);

	_pop_current_packet();

	current_packet = incoming_packets.front()->get();
	incoming_packets.pop_front();

	*r_buffer=(const uint8_t*)(&current_packet.packet->data[12]);
	r_buffer_size=current_packet.packet->dataLength;

	return OK;
}
Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_size){

	ERR_FAIL_COND_V(!active,ERR_UNCONFIGURED);
	ERR_FAIL_COND_V(connection_status!=CONNECTION_CONNECTED,ERR_UNCONFIGURED);

	int packet_flags=0;

	switch(transfer_mode) {
		case TRANSFER_MODE_UNRELIABLE: {
			packet_flags=ENET_PACKET_FLAG_UNSEQUENCED;
		} break;
		case TRANSFER_MODE_UNRELIABLE_ORDERED: {
			packet_flags=0;
		} break;
		case TRANSFER_MODE_RELIABLE: {
			packet_flags=ENET_PACKET_FLAG_RELIABLE;
		} break;
	}

	Map<int,ENetPeer*>::Element *E=NULL;

	if (target_peer!=0) {

		E = peer_map.find(ABS(target_peer));
		if (!E) {
			ERR_EXPLAIN("Invalid Target Peer: "+itos(target_peer));
			ERR_FAIL_V(ERR_INVALID_PARAMETER);
		}
	}

	ENetPacket * packet = enet_packet_create (NULL,p_buffer_size+12,packet_flags);
	encode_uint32(unique_id,&packet->data[0]); //source ID
	encode_uint32(target_peer,&packet->data[4]); //dest ID
	encode_uint32(packet_flags,&packet->data[8]); //dest ID
	copymem(&packet->data[12],p_buffer,p_buffer_size);

	if (server) {

		if (target_peer==0) {
			enet_host_broadcast(host,0,packet);
		} else if (target_peer<0) {
			//send to all but one
			//and make copies for sending

			int exclude=-target_peer;

			for (Map<int,ENetPeer*>::Element *F=peer_map.front();F;F=F->next()) {

				if (F->key()==exclude) // exclude packet
					continue;

				ENetPacket* packet2 = enet_packet_create (packet->data,packet->dataLength,packet_flags);

				enet_peer_send(F->get(),0,packet2);
			}

			enet_packet_destroy(packet); //original packet no longer needed
		} else {
			enet_peer_send (E->get(), 0, packet);

		}
	} else {

		ERR_FAIL_COND_V(!peer_map.has(1),ERR_BUG);
		enet_peer_send (peer_map[1], 0, packet); //send to server for broadcast..

	}

	enet_host_flush(host);

	return OK;
}

int NetworkedMultiplayerENet::get_max_packet_size() const {

	return 1<<24; //anything is good
}

void NetworkedMultiplayerENet::_pop_current_packet() const {

	if (current_packet.packet) {
		enet_packet_destroy(current_packet.packet);
		current_packet.packet=NULL;
		current_packet.from=0;
	}

}

NetworkedMultiplayerPeer::ConnectionStatus NetworkedMultiplayerENet::get_connection_status() const {

	return connection_status;
}

uint32_t NetworkedMultiplayerENet::_gen_unique_id() const {

	uint32_t hash = 0;

	while (hash==0 || hash==1) {

		hash = hash_djb2_one_32(
					(uint32_t)OS::get_singleton()->get_ticks_usec() );
		hash = hash_djb2_one_32(
					(uint32_t)OS::get_singleton()->get_unix_time(), hash );
		hash = hash_djb2_one_32(
					(uint32_t)OS::get_singleton()->get_data_dir().hash64(), hash );
		//hash = hash_djb2_one_32(
		//			(uint32_t)OS::get_singleton()->get_unique_ID().hash64(), hash );
		hash = hash_djb2_one_32(
					(uint32_t)((uint64_t)this), hash ); //rely on aslr heap
		hash = hash_djb2_one_32(
					(uint32_t)((uint64_t)&hash), hash ); //rely on aslr stack

		hash=hash&0x7FFFFFFF; // make it compatible with unsigned, since negatie id is used for exclusion
	}

	return hash;
}

int NetworkedMultiplayerENet::get_unique_id() const {

	ERR_FAIL_COND_V(!active,0);
	return unique_id;
}

void NetworkedMultiplayerENet::set_refuse_new_connections(bool p_enable) {

	refuse_connections=p_enable;
}

bool NetworkedMultiplayerENet::is_refusing_new_connections() const {

	return refuse_connections;
}

void NetworkedMultiplayerENet::set_compression_mode(CompressionMode p_mode) {

	compression_mode=p_mode;
}

NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const{

	return compression_mode;
}

size_t NetworkedMultiplayerENet::enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit) {

	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context);

	if (size_t(enet->src_compressor_mem.size())<inLimit) {
		enet->src_compressor_mem.resize( inLimit );
	}

	int total = inLimit;
	int ofs=0;
	while(total) {
		for(size_t i=0;i<inBufferCount;i++) {
			int to_copy = MIN(total,int(inBuffers[i].dataLength));
			copymem(&enet->src_compressor_mem[ofs],inBuffers[i].data,to_copy);
			ofs+=to_copy;
			total-=to_copy;
		}
	}

	Compression::Mode mode;

	switch(enet->compression_mode) {
		case COMPRESS_FASTLZ: {
			mode=Compression::MODE_FASTLZ;
		} break;
		case COMPRESS_ZLIB: {
			mode=Compression::MODE_DEFLATE;
		} break;
		default: { ERR_FAIL_V(0); }
	}

	int req_size = Compression::get_max_compressed_buffer_size(ofs,mode);
	if (enet->dst_compressor_mem.size()<req_size) {
		enet->dst_compressor_mem.resize(req_size);
	}
	int ret=Compression::compress(enet->dst_compressor_mem.ptr(),enet->src_compressor_mem.ptr(),ofs,mode);

	if (ret<0)
		return 0;


	if (ret>int(outLimit))
		return 0; //do not bother

	copymem(outData,enet->dst_compressor_mem.ptr(),ret);

	return ret;
}

size_t NetworkedMultiplayerENet::enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit){

	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context);
	int ret = -1;
	switch(enet->compression_mode) {
		case COMPRESS_FASTLZ: {

			ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_FASTLZ);
		} break;
		case COMPRESS_ZLIB: {

			ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_DEFLATE);
		} break;
		default: {}
	}
	if (ret<0) {
		return 0;
	} else {
		return ret;
	}
}

void NetworkedMultiplayerENet::_setup_compressor() {

	switch(compression_mode) {

		case COMPRESS_NONE: {

			enet_host_compress(host,NULL);
		} break;
		case COMPRESS_RANGE_CODER: {
			enet_host_compress_with_range_coder(host);
		} break;
		case COMPRESS_FASTLZ:
		case COMPRESS_ZLIB: {

			enet_host_compress(host,&enet_compressor);
		} break;
	}
}

void NetworkedMultiplayerENet::enet_compressor_destroy(void * context){

	//do none
}


void NetworkedMultiplayerENet::_bind_methods() {

	ObjectTypeDB::bind_method(_MD("create_server","port","max_clients","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_server,DEFVAL(32),DEFVAL(0),DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("create_client","ip","port","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_client,DEFVAL(0),DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("close_connection"),&NetworkedMultiplayerENet::close_connection);
	ObjectTypeDB::bind_method(_MD("set_compression_mode","mode"),&NetworkedMultiplayerENet::set_compression_mode);
	ObjectTypeDB::bind_method(_MD("get_compression_mode"),&NetworkedMultiplayerENet::get_compression_mode);

	BIND_CONSTANT( COMPRESS_NONE );
	BIND_CONSTANT( COMPRESS_RANGE_CODER );
	BIND_CONSTANT( COMPRESS_FASTLZ );
	BIND_CONSTANT( COMPRESS_ZLIB );

}


NetworkedMultiplayerENet::NetworkedMultiplayerENet(){

	active=false;
	server=false;
	refuse_connections=false;
	unique_id=0;
	target_peer=0;
	current_packet.packet=NULL;
	transfer_mode=TRANSFER_MODE_RELIABLE;
	connection_status=CONNECTION_DISCONNECTED;
	compression_mode=COMPRESS_NONE;
	enet_compressor.context=this;
	enet_compressor.compress=enet_compress;
	enet_compressor.decompress=enet_decompress;
	enet_compressor.destroy=enet_compressor_destroy;

}

NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){

	close_connection();
}