/**
Destroy an ENetPeer structure.
**/
static void destroy_enetpeer( value p ) {
#ifdef ENET_DEBUG
fprintf(stderr, "*** destroy_enetpeer\n");
exit(0);
#endif
return;
ENetPeer *peer;
if(!val_is_abstract(p) || !val_is_kind(p, k_udprpeer))
return;
peer = (ENetPeer *)val_data(p);
if(peer == NULL)
return;
// force immediate disconnect, if still connected.
enet_peer_disconnect_now(peer, 0);
// if the peer has an event still, destroy it
//free_peer_event(peer);
// clear the peer structure
enet_peer_reset(peer);
// peers never need be deallocated, they are part of an ENetHost
#ifdef ENET_DEBUG
fprintf(stderr, "*** destroy_enetpeer done.\n");
#endif
return;
}
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;
}
/**
Destroy an allocated ENetHost pointer. Must be used with val_gc() for every ENetHost created.
*/
static void destroy_enethost( value h ) {
#ifdef ENET_DEBUG
fprintf(stderr, "*** destroy_enethost\n");
//exit(0);
#endif
//return;
if(!val_is_kind(h, k_udprhost))
return;
ENetHost *host = (ENetHost *)val_data(h);
ENetPeer *peer;
//int x, count;
if(host == NULL)
return;
enet_host_flush( host );
for (peer = host->peers;
peer < &host->peers[host->peerCount];
++peer)
{
if (peer->state == ENET_PEER_STATE_CONNECTED) {
enet_peer_disconnect_now(peer, 0);
}
}
#ifdef ENET_DEBUG
fprintf(stderr, "*** destroy_enethost\n");
#endif
enet_host_destroy( host );
//val_kind(v) = NULL;
#ifdef ENET_DEBUG
fprintf(stderr, "*** destroy_enethost done.\n");
#endif
return;
}
static value udpr_close_now(value p)
{
// in order to avoid this, the library would have to queue events
// and handle them in select() and add to them in udpr_close()
val_check_kind(p,k_udprpeer);
enet_peer_disconnect_now((ENetPeer *)val_data(p), 0);
return val_true;
}
void CNetManager::kickClient(const u16 playerId, bool hardKick = false)
{
ENetPeer* currentPeer = getPlayerById(playerId);
if(currentPeer)
hardKick ? enet_peer_disconnect_now(currentPeer,0) :
enet_peer_disconnect(currentPeer,0);
}
void Network::finalize(Client & client)
{
if(m_server)
enet_peer_disconnect_now(m_server, 0);
if(m_client)
enet_host_destroy(m_client);
enet_socket_destroy(m_socket);
enet_deinitialize();
}
void GameLabyrinth::Client::disconenct()
{
if (peer != NULL)
{
log_msg("net", "Disconnecting client " + getNetworkName());
enet_peer_disconnect_now(peer, 0);
state = DISCONNECTED;
peer->data = NULL;
peer = NULL;
}
}
VALUE renet_server_disconnect_client(VALUE self, VALUE peer_id)
{
Server* server;
Data_Get_Struct(self, Server, server);
VALUE lock = rb_iv_get(self, "@lock");
rb_mutex_lock(lock);
enet_peer_disconnect_now(&(server->host->peers[NUM2UINT(peer_id)]), 0);
renet_server_execute_on_disconnection(self, peer_id);
rb_mutex_unlock(lock);
return Qtrue;
}
void CNetClientSession::Disconnect(u32 reason)
{
ENSURE(m_Host && m_Server);
// TODO: ought to do reliable async disconnects, probably
enet_peer_disconnect_now(m_Server, reason);
enet_host_destroy(m_Host);
m_Host = NULL;
m_Server = NULL;
SAFE_DELETE(m_Stats);
}
CNetClientSession::~CNetClientSession()
{
delete m_Stats;
if (m_Host && m_Server)
{
// Disconnect immediately (we can't wait for acks)
enet_peer_disconnect_now(m_Server, NDR_SERVER_SHUTDOWN);
enet_host_destroy(m_Host);
m_Host = NULL;
m_Server = NULL;
}
}
Host::~Host()
{
for (auto& p : m_peers)
enet_peer_disconnect_now((ENetPeer*) p.m_peer, 0);
m_peers.clear();
if (m_object)
{
enet_host_flush((ENetHost*) m_object);
enet_host_destroy((ENetHost*) m_object);
m_object = nullptr;
}
}
/**
* Destroy the host and all connected peers.
*/
void host_destroy (void)
{
int i = 0;
/* deallocate all peers */
for (i = 0; i < host->peerCount; i++) {
if (host->peers[i].state == ENET_PEER_STATE_CONNECTED) {
if (host->peerCount > 1)
free(host->peers[i].data);
enet_peer_disconnect_now(&host->peers[i], 0);
}
}
/* deallocate the host */
enet_host_destroy(host);
}
void PNetworkServer::shutdown()
{
if (m_state == NETWORK_CONNECTED ||
m_state == NETWORK_ERROR)
{
PMap<puint32, PNetworkPeer*>::iterator it = m_peers.begin();
PMap<puint32, PNetworkPeer*>::iterator ie = m_peers.end();
while (it != ie)
{
enet_peer_disconnect_now(it.value()->data()->peer, it.key());
PDELETE(it.value());
++it;
}
enet_host_destroy(m_data->server);
m_state = NETWORK_DISCONNECTED;
}
}
VALUE renet_connection_disconnect(VALUE self, VALUE timeout)
{
Connection* connection;
Data_Get_Struct(self, Connection, connection);
VALUE lock = rb_iv_get(self, "@lock");
rb_mutex_lock(lock);
VALUE rv = Qfalse;
if (connection->online == 0)
{
rv = Qtrue;
}
else
{
connection->online = 0;
enet_peer_disconnect(connection->peer, 0);
while (service(self, connection, NUM2UINT(timeout)) > 0)
{
switch (connection->event->type)
{
case ENET_EVENT_TYPE_NONE:
break;
case ENET_EVENT_TYPE_CONNECT:
break;
case ENET_EVENT_TYPE_RECEIVE:
enet_packet_destroy (connection->event->packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
rv = Qtrue;
break;
}
if (rv == Qtrue)
{
break;
}
}
if (rv != Qtrue) { enet_peer_disconnect_now(connection->peer, 0); }
}
rb_mutex_unlock(lock);
return rv;
}
int enet_lua_api enet_lua_peer_disconnect_now(lua_State* L) {
ENetPeer** udata = luaL_checkudata(L, 1, "_enet.peer");
enet_peer_disconnect_now(*udata, 0);
return 0;
}
void IncomingClientBase::disconnect(void)
{
enet_peer_disconnect_now(mInternalClient, 0);
}
void ServerClient::disconnect()
{
enet_peer_disconnect_now (m_peer, 0);
}
void CNetServerSession::DisconnectNow(u32 reason)
{
enet_peer_disconnect_now(m_Peer, reason);
}
