#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 = bind_ip; 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::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::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::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::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::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*)(¤t_packet.packet->data[12]); r_buffer_size=current_packet.packet->dataLength-12; 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::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::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())src_compressor_mem.resize( inLimit ); } int total = inLimit; int ofs=0; while(total) { for(size_t i=0;isrc_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()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); ObjectTypeDB::bind_method(_MD("set_bind_ip", "ip"),&NetworkedMultiplayerENet::set_bind_ip); 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; bind_ip=ENET_HOST_ANY; } NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){ close_connection(); } // sets IP for ENet to bind when using create_server // if no IP is set, then ENet bind to ENET_HOST_ANY void NetworkedMultiplayerENet::set_bind_ip(const IP_Address& p_ip){ bind_ip=p_ip.host; }