コード例 #1
0
ファイル: enetTest.c プロジェクト: osblinnikov/cnets
int main (int argc, char ** argv){
  printf("-- enetTests started --\n");
  if (enet_initialize () != 0){
    fprintf (stderr, "An error occurred while initializing ENet.\n");
    return EXIT_FAILURE;
  }
  ENetAddress address;
  ENetHost * server;
  /* Bind the server to the default localhost.     */
  /* A specific host address can be specified by   */
  /* enet_address_set_host (& address, "x.x.x.x"); */
  address.host = ENET_HOST_ANY;
  /* Bind the server to port 1234. */
  address.port = 1234;

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

  if (server == NULL){
      fprintf (stderr, "An error occurred while trying to create an ENet server host.\n");
      exit (EXIT_FAILURE);
  }

  ENetHost * client;
  client = 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 */,
              57600 / 8 /* 56K modem with 56 Kbps downstream bandwidth */,
              14400 / 8 /* 56K modem with 14 Kbps upstream bandwidth */);
  if (client == NULL)
  {
      fprintf (stderr, "An error occurred while trying to create an ENet client host.\n");
      exit (EXIT_FAILURE);
  }


  ENetAddress dstaddress;
  ENetEvent event;
  ENetPeer *peer;

  /* Connect to some.server.net:1234. */
  enet_address_set_host (& dstaddress, "localhost");
  dstaddress.port = 1234;
  /* Initiate the connection, allocating the two channels 0 and 1. */
  peer = enet_host_connect (client, & dstaddress, 2, 0);
  if (peer == NULL){
     fprintf (stderr,  "No available peers for initiating an ENet connection.\n");
     exit (EXIT_FAILURE);
  }

  waitEvents(client, 100, "client send connect");

  waitEvents(server, 100, "server wait connect");

  /* Wait up to 5 seconds for the connection attempt to succeed. */
  if (enet_host_service (client, & event, 5000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT){
      printf("Connection to localhost:1234 succeeded\n");
  }else{
      /* Either the 5 seconds are up or a disconnect event was */
      /* received. Reset the peer in the event the 5 seconds   */
      /* had run out without any significant event.            */
      enet_peer_reset (peer);
      fprintf (stderr, "Connection to localhost:1234 failed\n");
      exit(EXIT_FAILURE);
  }

  /* Create a reliable packet of size 7 containing "packet\0" */
  ENetPacket * packet = enet_packet_create ("packet",
                                            strlen ("packet") + 1,
                                            ENET_PACKET_FLAG_RELIABLE);
  /* Extend the packet so and append the string "foo", so it now */
  /* contains "packetfoo\0"                                      */
  enet_packet_resize (packet, strlen ("packetfoo") + 1);
  strcpy ((char*)& packet -> data [strlen ("packet")], "foo");
  /* Send the packet to the peer over channel id 0. */
  /* One could also broadcast the packet by         */
  /* enet_host_broadcast (host, 0, packet);         */
  enet_peer_send (peer, 0, packet);
  /* One could just use enet_host_service() instead. */

  waitEvents(client, 100, "client send msg");

  waitEvents(server, 100, "server wait connect");
  waitEvents(server, 100, "server wait msg");


  enet_peer_disconnect (peer, 0);

  waitEvents(client, 100, "client send disconnect");
  waitEvents(server, 100, "server wait disconnect");

  if(waitEvents(client, 100, "client wait disconnect")!=ENET_EVENT_TYPE_DISCONNECT){
    /* We've arrived here, so the disconnect attempt didn't */
    /* succeed yet.  Force the connection down.             */
    enet_peer_reset (peer);
    fprintf(stderr, "received event is not disconnect, will reset the peer\n");
    exit(EXIT_FAILURE);
  }

  enet_host_destroy(client);
  enet_host_destroy(server);
  enet_deinitialize();
  printf("-- enetTests Finished --\n");
  return EXIT_SUCCESS;
}
コード例 #2
0
ファイル: UdpSocket.cpp プロジェクト: riseven/ri7engine
void UdpSocket::Disconnect(ENetPeer *peer)
{
    // Disconnect socket
    enet_peer_disconnect( peer, 0 );
}
コード例 #3
0
ファイル: stk_peer.cpp プロジェクト: jubalh/stk-code
void STKPeer::disconnect()
{
    enet_peer_disconnect(m_peer, 0);
}
コード例 #4
0
ファイル: main.cpp プロジェクト: Ochakko/MameBake3D
int main(int argc, char* argv[]) {
	ENetHost *client;
	ENetAddress address;
	ENetPeer *peer;
	ENetEvent event;
	char message[1024];
	int serviceResult;

	puts("Starting client");

	if (enet_initialize() != 0) {
		fprintf(stderr, "Error initialising enet");
		exit(EXIT_FAILURE);

	}

	client = enet_host_create(NULL, /* create a client host */
		1,    /* number of clients */
		2,    /* number of channels */
		57600 / 8,    /* incoming bandwith */
		14400 / 8);   /* outgoing bandwith */

	if (client == NULL) {
		fprintf(stderr, "Could not create client host");
		exit(EXIT_FAILURE);

	}


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

	peer = enet_host_connect(client,
		&address,    /* address to connect to */
		2,           /* number of channels */
		0);          /* user data supplied to
						  the receiving host */

	if (peer == NULL) {
		fprintf(stderr, "No available peers for initiating an ENet "
			"connection.\n");
		exit(EXIT_FAILURE);

	}


	/* Try to connect to server within 5 seconds */
	if (enet_host_service(client, &event, 5000) > 0 &&
		event.type == ENET_EVENT_TYPE_CONNECT)
	{
		puts("Connection to server succeeded.");
	}
	else
	{
		/* Either the 5 seconds are up or a disconnect event was */
		/* received. Reset the peer in the event the 5 seconds   */
		/* had run out without any significant event.            */
		enet_peer_reset(peer);

		fprintf(stderr, "Connection to server failed.");
		exit(EXIT_FAILURE);
	}

	while (true)
	{
		serviceResult = 1;

		/* Keep doing host_service until no events are left */
		while (serviceResult > 0)
		{
			serviceResult = enet_host_service(client, &event, 0);

			if (serviceResult > 0)
			{
				switch (event.type)
				{
				case ENET_EVENT_TYPE_CONNECT:
					printf("A new client connected from %x:%u.\n",
						event.peer->address.host,
						event.peer->address.port);

					event.peer->data = (void*)"New User";
					break;

				case ENET_EVENT_TYPE_RECEIVE:
					printf("A packet of length %u containing '%s' was "
						"received from %s on channel %u.\n",
						event.packet->dataLength,
						event.packet->data,
						event.peer->data,
						event.channelID);

					/* Clean up the packet now that we're done using it.
						> */
					enet_packet_destroy(event.packet);

					break;

				case ENET_EVENT_TYPE_DISCONNECT:
					printf("%s disconnected.\n", event.peer->data);

					break;
				}
			}
			else if (serviceResult > 0)
			{
				puts("Error with servicing the client");
				exit(EXIT_FAILURE);
			}

		}


		printf("Say> ");
#ifdef _WIN32
		gets_s(message, 1024);
#else
		gets(message);
#endif
		if (strcmp(message, "exit") == 0 ||
			strcmp(message, "quit") == 0) {
			break;

		}

		if (strlen(message) > 0) {
			ENetPacket *packet = enet_packet_create(message, strlen
			(message) + 1, ENET_PACKET_FLAG_RELIABLE);
			enet_peer_send(peer, 0, packet);

		}

	}

	enet_peer_disconnect(peer, 0);

	/* Allow up to 3 seconds for the disconnect to succeed */
	/* and drop any packets received packets */
	while (enet_host_service(client, &event, 3000) > 0)
	{

		switch (event.type)
		{
		case ENET_EVENT_TYPE_RECEIVE:
			enet_packet_destroy(event.packet);
			break;

		case ENET_EVENT_TYPE_DISCONNECT:
			puts("Disconnection succeeded.");
			break;
		}
	}


	enet_host_destroy(client);
	enet_deinitialize();

	return 0;


}
コード例 #5
0
void NetServer::ResetNetwork()
{
	if (m_pServer)
	{
	    ENetPeer * pCurrentPeer;

		for (pCurrentPeer = m_pServer-> peers;
			 pCurrentPeer < & m_pServer->peers [m_pServer->peerCount];
			 ++ pCurrentPeer)
		{
		   if (pCurrentPeer->state != ENET_PEER_STATE_CONNECTED)
			 continue;

		   enet_peer_disconnect (pCurrentPeer, 0);
		}

		ENetEvent event;
		bool bDisconnect = false;
		
	    /* Allow up to 3 seconds for the disconnect to succeed
		and drop any received packets.
		*/
		while (enet_host_service (m_pServer, & event, 3000) > 0)
		{
			switch (event.type)
			{
			case ENET_EVENT_TYPE_RECEIVE:
				enet_packet_destroy (event.packet);
				break;

			case ENET_EVENT_TYPE_DISCONNECT:
				GfLogTrace ("Disconnection succeeded.");
				bDisconnect=true;
				break;
				
			case ENET_EVENT_TYPE_NONE:
			case ENET_EVENT_TYPE_CONNECT:
				// Do nothing.
				break;
			}
		}

	    /* We've arrived here, so the disconnect attempt didn't */
		/* succeed yet.  Force the connection down.             */
		if (!bDisconnect)
		{
		    ENetPeer * pCurrentPeer1;

			for (pCurrentPeer1 = m_pServer-> peers;
				 pCurrentPeer1 < & m_pServer->peers [m_pServer->peerCount];
				 ++ pCurrentPeer1)
			{
			   if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED)
				 continue;

			   enet_peer_reset (pCurrentPeer1);
			}
		}

		enet_host_destroy(m_pServer);
		m_pServer = NULL;
	}
}
コード例 #6
0
bool NetServer::ServerStep()
{
	// use lastTic to keep track of how many tics per second we have; control "tics per second"
	// perform any periodic, timed events here

	ENetEvent event;
	int status = enet_host_service(server, &event, HOST_TIMEOUT);

	if (status < 0) return false; // ERROR happened! Server shut down!	

	TimedEvent();

	if (status == 0) return true; // nothing to do, try again later

	switch(event.type)
	{
	case ENET_EVENT_TYPE_CONNECT:
		{
			printf ("A new client (%d) connected from %x:%u.\n", 
				event.peer,
				event.peer -> address.host,
				event.peer -> address.port);

			client *c = new client;
			char hostname[256] = "error";
			enet_address_get_host_ip(&event.peer->address, hostname, 256);
			printf("%s connected\n", hostname);

			if (event.peer != master)
			{
				c->hostname = string(hostname);
				c->peer = event.peer;
				c->state = ST_AUTH;

				// associate peer with the client object for them
				event.peer->data = c;

				// Call HandleConnect method of the game logic
				// if it returns false, then that means connection denied, otherwise specifies state client is in
				// also add to list of clients
				if (HandleConnect(event.peer)) {
					bool client_added = false;
					for (size_t i = 0; i < clients.size(); i++) {
						if (clients.at(i)->state == ST_EMPTY) {
							clients.at(i) = c;
							client_added = true;
							break;
						}
					}
					if (!client_added)
						clients.push_back(c);
				} else {
					enet_peer_disconnect(event.peer, 121);
				}
			} else {
				MasterCheckin();
			}
			break;
		}

	case ENET_EVENT_TYPE_DISCONNECT:
		{
			if (event.peer != master) {
				printf ("%d disconnected.\n", event.peer);

				// Call HandleDisconnect method some form of id for the connection
				HandleDisconnect(323, event.peer);

				// free up this client slot for reuse
				((client*) event.peer->data)->state = ST_EMPTY;
			} else {
				printf ("Master timed out.\n");
				master = 0;
			}
			break;
		}
	case ENET_EVENT_TYPE_RECEIVE:
		{
			char hostname[256] = "error";
			enet_address_get_host_ip(&event.peer->address, hostname, 256);
			printf("receiving packet.\n");
			printf ("A packet of length %u ",
				event.packet -> dataLength);
			printf("containing %s ",
				event.packet -> data);
			printf("was received from %s ",
				hostname);
			printf("on channel %u.\n",
				event.channelID);
			/*printf ("A packet of length %u containing %s was received from %s on channel %u.\n",
			event.packet -> dataLength,
			event.packet -> data,
			((client*)event.peer -> data)->hostname.c_str(),
			event.channelID);*/

			client *c = (client*) event.peer->data;

			// Call Packet Handler to deal with packets, and send a response
			HandlePacket(event.packet->data, event.packet->dataLength, event.peer);

			if (event.packet->referenceCount == 0) enet_packet_destroy(event.packet);
			break;
		}
	default:
		break;
	}
	enet_host_flush(server);
	return true;
}
コード例 #7
0
extern "C" int main(int argc, char **argv)
{
#if _WIN32
	// hack to redirect output to text files
	freopen("stdout.txt", "w", stdout);
	freopen("stderr.txt", "w", stderr);
#endif

	clientConsole = new narf::ClientConsole();
	narf::console = clientConsole;

	narf::console->println("Version: " + std::to_string(VERSION_MAJOR) + "." + std::to_string(VERSION_MINOR) + std::string(VERSION_RELEASE) + "+" VERSION_REV);

	if (enet_initialize() != 0) {
		narf::console->println("Error initializing ENet");
		return 1;
	}

	narf::cmd::cmds["set"] = cmdSet;
	narf::cmd::cmds["quit"] = cmdQuit;
	narf::cmd::cmds["connect"] = cmdConnect;
	narf::cmd::cmds["disconnect"] = cmdDisconnect;
	narf::cmd::cmds["save"] = cmdSave;
	narf::cmd::cmds["saveconfig"] = cmdSaveConfig;
	narf::cmd::cmds["load"] = cmdLoad;
	narf::cmd::cmds["stats"] = cmdStats;
	narf::cmd::cmds["about"] = cmdAbout;
	narf::cmd::cmds["music"] = cmdMusic;

	narf::MemoryFile iniMem;
	auto configFile = narf::util::appendPath(narf::util::userConfigDir("narfblock"), "client.ini");
	narf::console->println("Attempting to open user config file: " + configFile);
	if (!iniMem.read(configFile)) {
		configFile = narf::util::appendPath(narf::util::dataDir(), "client.ini");
		narf::console->println("Could not load user config file; falling back to local config file: " + configFile);
		if (!iniMem.read(configFile)) {
			narf::console->println("Could not load local config file; falling back to compile-time defaults");
		}
	}

	if (iniMem.size) {
		config.load(iniMem.data, iniMem.size);
	}

	config.updateSignal += configEvent;

	client = enet_host_create(nullptr, 1, narf::net::MAX_CHANNELS, 0, 0);
	if (!client) {
		fatalError("Could not create ENet client");
		return 1;
	}

	if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
		fatalError("SDL_Init() failed: " + std::string(SDL_GetError()));
		SDL_Quit();
		return 1;
	}

	musicMutex = SDL_CreateMutex();
	config.initBool("audio.enabled", true);

	SDL_DisplayMode mode;
	// TODO: iterate over monitors?
	if (SDL_GetDesktopDisplayMode(0, &mode)) {
		fatalError("SDL_GetDesktopDisplayMode failed: " + std::string(SDL_GetError()));
		SDL_Quit();
		return 1;
	}

	auto w = mode.w;
	auto h = mode.h;

	narf::console->println("Current video mode is " + std::to_string(w) + "x" + std::to_string(h));

	// TODO: convert these to be modifiable at runtime and use config.init*
	bool fullscreen = config.getBool("video.fullscreen", true);
	float width_cfg = config.getFloat("video.width", 0.6f);
	float height_cfg = config.getFloat("video.height", 0.6f);
	if (!fullscreen) {
		if (width_cfg > 1) {
			w = (int32_t)width_cfg;
		} else {
			w = (int32_t)((float)w * width_cfg);
		}
		if (height_cfg > 1) {
			h = (int32_t)height_cfg;
		} else {
			h = (int32_t)((float)h * height_cfg);
		}
		narf::console->println("Setting video to windowed " + std::to_string(w) + "x" + std::to_string(h));
	} else {
		narf::console->println("Setting video to fullscreen");
	}

	if (!initVideo(w, h, fullscreen)) {
		fatalError("Error: could not set OpenGL video mode " + std::to_string(w) + "x" + std::to_string(h));
		SDL_Quit();
		return 1;
	}

	clientConsole->setGLContext(display);

	config.initBool("video.vsync", false);

	newWorld();

	playerEID = world->entityManager.newEntity();
	{
		narf::EntityRef player(world->entityManager, playerEID);

		// initial player position
		player->position = narf::Vector3f(15.0f, 10.0f, 3.0f * 16.0f);
		player->prevPosition = player->position;
	}

	// initialize camera to look at origin
	cam.orientation.yaw = atan2f(cam.position.y, cam.position.x);
	cam.orientation.pitch = 0.0f;

	bouncyBlockEID = world->entityManager.newEntity();
	{
		narf::EntityRef bouncyBlock(world->entityManager, bouncyBlockEID);
		bouncyBlock->position = narf::Vector3f(10.0f, 10.0f, 21.0f);
		bouncyBlock->prevPosition = bouncyBlock->position;
		bouncyBlock->bouncy = true;
		bouncyBlock->model = true;
	}

	if (!init_textures()) {
		fatalError("init_textures() failed");
		return 1;
	}

	renderer = new narf::Renderer(world, *display, tilesTex);

	config.initInt32("video.renderDistance", 5);

	fpsTextBuffer = new narf::font::TextBuffer(*display, nullptr);
	blockInfoBuffer = new narf::font::TextBuffer(*display, nullptr);
	entityInfoBuffer = new narf::font::TextBuffer(*display, nullptr);
	locationBuffer = new narf::font::TextBuffer(*display, nullptr);

	config.initString("video.hudFont", "DroidSansMono");
	config.initInt32("video.hudFontSize", 30);
	if (!fpsTextBuffer->getFont()) {
		fatalError("Error: could not load HUD font");
		return 1;
	}

	config.initString("video.consoleFont", "DroidSansMono");
	config.initInt32("video.consoleFontSize", 18);
	if (!clientConsole->getFont()) {
		fatalError("Error: could not load Console font");
		return 1;
	}

	config.initString("video.consoleCursorShape", "default");

	config.initBool("video.stereo.enabled", false);
	config.initBool("video.stereo.cross", true);
	config.initFloat("video.stereo.separation", 0.1f);

	SDL_SetRelativeMouseMode(SDL_TRUE);

	config.initDouble("misc.tickRate", 60);
	config.initDouble("misc.maxFrameTime", 0.25);

	narf::console->println("Unicode test\xE2\x80\xBC pi: \xCF\x80 (2-byte sequence), square root: \xE2\x88\x9A (3-byte sequence), U+2070E: \xF0\xA0\x9C\x8E (4-byte sequence)");

	gameLoop = new ClientGameLoop(config.getDouble("misc.maxFrameTime"), config.getDouble("misc.tickRate"));
	gameLoop->run();

	if (connectState == ConnectState::Connected) {
		enet_peer_disconnect(server, (uint32_t)narf::net::DisconnectType::UserQuit);
	} else if (connectState == ConnectState::Connecting) {
		enet_peer_reset(server);
	}

	enet_host_flush(client);
	enet_host_destroy(client);
	enet_deinitialize();
	SDL_Quit();
	return 0;
}
コード例 #8
0
/**
 * Disconnects the client from the server, deinitializes ENet and releases the engine core.
 * Allow up to 3 seconds for the disconnect to succeed and drop any packets received packets.
 */
void Client::disconnect()
{
	if(!m_pClientHost)
	{
		return;
	}

	// Send disconnecting request
	m_disconnectingEvent.connectionID = m_pPeer->connectID;
	network::send(m_disconnectingEvent, m_pPeer);

	enet_host_flush(m_pClientHost);


	//// Waiting for ACK
	//bool acked = false;
	//int startTime = glutGet(GLUT_ELAPSED_TIME);
	//
	//while (glutGet(GLUT_ELAPSED_TIME) - startTime < 3000 && enet_host_service(m_clientHost, &m_event, 3000) > 0) {
	//	switch (m_event.type) {
	//		case ENET_EVENT_TYPE_RECEIVE:
	//
	//			if (unmarshal(m_netObject, std::string((char*) m_event.packet->data, m_event.packet->dataLength))) {
	//				if (m_netObject.type == events::PlayerDisconnectingEvent::NETOBJ_PLAYER_DC) {
	//					if (unmarshal(m_disconnectingEvent, std::string((char*) m_event.packet->data, m_event.packet->dataLength))) {
	//						if (m_disconnectingEvent.connectionID == m_peer->connectID) {
	//							TRACE_NETWORK("Disconnection ACK-ed.", 0);
	//							acked = true;
	//						}
	//					}
	//				}
	//			}
	//
	//			enet_packet_destroy(m_event.packet);
	//
	//			break;
	//	}
	//}

	enet_peer_disconnect(m_pPeer, 0);

	// Allow up to 3 seconds for the disconnect to succeed and drop any packets received packets
	while (enet_host_service(m_pClientHost, &m_event, 3000) > 0)
	{
		switch (m_event.type)
		{
			case ENET_EVENT_TYPE_RECEIVE:
				if (unmarshal(m_disconnectingEvent, std::string((char*) m_event.packet->data, m_event.packet->dataLength)))
					if (m_disconnectingEvent.connectionID == m_pPeer->connectID)
					{
						TRACE_NETWORK("Disconnection ACK-ed.", 0);
					}

				enet_packet_destroy(m_event.packet);
				break;

			case ENET_EVENT_TYPE_DISCONNECT:
				TRACE_NETWORK("Disconnection succeeded.", 0);
				break;
		}
	}


	enet_host_destroy(m_pClientHost);
	enet_deinitialize();
}
コード例 #9
0
void CNetServerSession::Disconnect(u32 reason)
{
	Update((uint)NMT_CONNECTION_LOST, NULL);

	enet_peer_disconnect(m_Peer, reason);
}
コード例 #10
0
ファイル: server.cpp プロジェクト: r-lyeh-forks/mini.q
void disconnect_client(int n, const char *reason) {
  printf("client::disconnecting client (%s) [%s]\n", clients[n].hostname, reason);
  enet_peer_disconnect(clients[n].peer);
  clients[n].type = ST_EMPTY;
  send2(true, -1, SV_CDIS, n);
}
コード例 #11
0
ファイル: NetPlayServer.cpp プロジェクト: MerryMage/dolphin
// called from ---NETPLAY--- thread
void NetPlayServer::ThreadFunc()
{
  while (m_do_loop)
  {
    // update pings every so many seconds
    if ((m_ping_timer.GetTimeElapsed() > 1000) || m_update_pings)
    {
      m_ping_key = Common::Timer::GetTimeMs();

      sf::Packet spac;
      spac << (MessageId)NP_MSG_PING;
      spac << m_ping_key;

      m_ping_timer.Start();
      SendToClients(spac);
      m_update_pings = false;
    }

    ENetEvent netEvent;
    int net;
    if (m_traversal_client)
      m_traversal_client->HandleResends();
    net = enet_host_service(m_server, &netEvent, 1000);
    while (!m_async_queue.Empty())
    {
      {
        std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
        SendToClients(m_async_queue.Front());
      }
      m_async_queue.Pop();
    }
    if (net > 0)
    {
      switch (netEvent.type)
      {
      case ENET_EVENT_TYPE_CONNECT:
      {
        ENetPeer* accept_peer = netEvent.peer;
        unsigned int error;
        {
          std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
          error = OnConnect(accept_peer);
        }

        if (error)
        {
          sf::Packet spac;
          spac << (MessageId)error;
          // don't need to lock, this client isn't in the client map
          Send(accept_peer, spac);
          if (netEvent.peer->data)
          {
            delete (PlayerId*)netEvent.peer->data;
            netEvent.peer->data = nullptr;
          }
          enet_peer_disconnect_later(accept_peer, 0);
        }
      }
      break;
      case ENET_EVENT_TYPE_RECEIVE:
      {
        sf::Packet rpac;
        rpac.append(netEvent.packet->data, netEvent.packet->dataLength);

        auto it = m_players.find(*(PlayerId*)netEvent.peer->data);
        Client& client = it->second;
        if (OnData(rpac, client) != 0)
        {
          // if a bad packet is received, disconnect the client
          std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
          OnDisconnect(client);

          if (netEvent.peer->data)
          {
            delete (PlayerId*)netEvent.peer->data;
            netEvent.peer->data = nullptr;
          }
        }
        enet_packet_destroy(netEvent.packet);
      }
      break;
      case ENET_EVENT_TYPE_DISCONNECT:
      {
        std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
        if (!netEvent.peer->data)
          break;
        auto it = m_players.find(*(PlayerId*)netEvent.peer->data);
        if (it != m_players.end())
        {
          Client& client = it->second;
          OnDisconnect(client);

          if (netEvent.peer->data)
          {
            delete (PlayerId*)netEvent.peer->data;
            netEvent.peer->data = nullptr;
          }
        }
      }
      break;
      default:
        break;
      }
    }
  }

  // close listening socket and client sockets
  for (auto& player_entry : m_players)
  {
    delete (PlayerId*)player_entry.second.socket->data;
    player_entry.second.socket->data = nullptr;
    enet_peer_disconnect(player_entry.second.socket, 0);
  }
}
コード例 #12
0
ファイル: client.cpp プロジェクト: EmmetCooper/ore-infinium
void Client::disconnect()
{
    Debug::log(Debug::Area::NetworkClientInitialArea) << "attempting disconnect from server";
    enet_peer_disconnect(m_peer, 0);
}
コード例 #13
0
ファイル: room.cpp プロジェクト: citra-emu/citra
void Room::RoomImpl::HandleModBanPacket(const ENetEvent* event) {
    if (!HasModPermission(event->peer)) {
        SendModPermissionDenied(event->peer);
        return;
    }

    Packet packet;
    packet.Append(event->packet->data, event->packet->dataLength);
    packet.IgnoreBytes(sizeof(u8)); // Ignore the message type

    std::string nickname;
    packet >> nickname;

    std::string username;
    std::string ip;

    {
        std::lock_guard lock(member_mutex);
        const auto target_member =
            std::find_if(members.begin(), members.end(),
                         [&nickname](const auto& member) { return member.nickname == nickname; });
        if (target_member == members.end()) {
            SendModNoSuchUser(event->peer);
            return;
        }

        // Notify the banned member
        SendUserBanned(target_member->peer);

        nickname = target_member->nickname;
        username = target_member->user_data.username;

        char ip_raw[256];
        enet_address_get_host_ip(&target_member->peer->address, ip_raw, sizeof(ip_raw) - 1);
        ip = ip_raw;

        enet_peer_disconnect(target_member->peer, 0);
        members.erase(target_member);
    }

    {
        std::lock_guard lock(ban_list_mutex);

        if (!username.empty()) {
            // Ban the forum username
            if (std::find(username_ban_list.begin(), username_ban_list.end(), username) ==
                username_ban_list.end()) {

                username_ban_list.emplace_back(username);
            }
        }

        // Ban the member's IP as well
        if (std::find(ip_ban_list.begin(), ip_ban_list.end(), ip) == ip_ban_list.end()) {
            ip_ban_list.emplace_back(ip);
        }
    }

    // Announce the change to all clients.
    SendStatusMessage(IdMemberBanned, nickname, username);
    BroadcastRoomInformation();
}
コード例 #14
0
ファイル: enet_lua.c プロジェクト: JoJo2nd/Heart
int enet_lua_api enet_lua_peer_disconnect(lua_State* L) {
    ENetPeer** udata = luaL_checkudata(L, 1, "_enet.peer");
    enet_peer_disconnect(*udata, 0);
    return 0;
}
コード例 #15
0
ファイル: host.cpp プロジェクト: suprafun/smalltowns
 void Host::disconnect()
 {
     if (mServer)
         enet_peer_disconnect(mServer, 0);
 }
コード例 #16
0
ファイル: ENetServer.cpp プロジェクト: kbirk/enet-example
bool ENetServer::stop()
{
    if (!isRunning()) {
        // no clients to disconnect from
        return 0;
    }
    // attempt to gracefully disconnect all clients
    LOG_DEBUG("Disconnecting " << numClients() << " clients...");
    for (auto iter : clients_) {
        auto client = iter.second;
        LOG_DEBUG("Disconnecting from client_" << client->incomingPeerID);
        enet_peer_disconnect(client, 0);
    }
    // wait for the disconnections to be acknowledged
    auto timestamp = Time::timestamp();
    bool success = false;
    ENetEvent event;
    while (true) {
        int32_t res = enet_host_service(host_, &event, 0);
        if (res > 0) {
            // event occured
            if (event.type == ENET_EVENT_TYPE_RECEIVE) {
                // throw away any received packets during disconnect
                LOG_DEBUG("Discarding received packet");
                enet_packet_destroy(event.packet);
            } else if (event.type == ENET_EVENT_TYPE_DISCONNECT) {
                // disconnect successful
                LOG_DEBUG("Disconnection of client_"
                    << event.peer->incomingPeerID
                    << " succeeded, "
                    << (clients_.size() - 1)
                    << " remaining");
                // remove from remaining
                clients_.erase(event.peer->incomingPeerID);
            } else if (event.type == ENET_EVENT_TYPE_CONNECT) {
                // client connected
                LOG_DEBUG("Connection accepted from client_"
                    << event.peer->incomingPeerID
                    << " during server shutdown, disconnect");
                // add and remove client
                enet_peer_disconnect(event.peer, 0);
                // add to remaining
                clients_[event.peer->incomingPeerID] = event.peer;
            }
        } else if (res < 0) {
            // error occured
            LOG_ERROR("Encountered error while polling");
            break;
        } else {
            // no event, check if finished
            if (clients_.empty()) {
                // all clients successfully disconnected
                LOG_DEBUG("Disconnection from all clients successful");
                success = true;
                break;
            }
        }
        // check timeout
        if (Time::timestamp() - timestamp > Time::fromMilliseconds(TIMEOUT_MS)) {
            LOG_ERROR("Disconnection was not acknowledged by server, shutdown forced");
            break;
        }
    }
    // force disconnect the remaining clients
    for (auto iter : clients_) {
        auto id = iter.first;
        auto client = iter.second;
        LOG_DEBUG("Forcibly disconnecting client_" << id);
        enet_peer_reset(client);
    }
    // clear clients
    clients_ = std::map<uint32_t, ENetPeer*>();
    // destroy the host
    enet_host_destroy(host_);
    host_ = nullptr;
    return !success;
}
コード例 #17
0
// Disconnect all peers
void _ServerNetwork::DisconnectAll() {

	// Disconnect all connected peers
	for(auto &Peer : Peers)
		enet_peer_disconnect(Peer->ENetPeer, 0);
}
コード例 #18
0
ファイル: host.c プロジェクト: turnage/Charl
/**
 *  Destroy any connections to peers and reset the peer metadata.
 */
void host_disconnect (void)
{
        enet_peer_disconnect(peer, 0);
        host_listen(0);
        connected = 0;
}
コード例 #19
0
ファイル: Network.cpp プロジェクト: tapio/Wendy
void Peer::disconnect(uint32 reason)
{
  m_disconnecting = true;
  m_reason = reason;
  enet_peer_disconnect((ENetPeer*) m_peer, reason);
}