예제 #1
0
파일: main.cpp 프로젝트: Nuos/crawler
int main(int argc, char* argv[])
{
	printf("starting client (and server)\n");

    if (enet_initialize () != 0)
    {
        fprintf (stderr, "An error occurred while initializing ENet.\n");
        return EXIT_FAILURE;
    }
    atexit (enet_deinitialize);

	ENetAddress selfaddress;
	selfaddress.host = ENET_HOST_ANY;
	/* Bind the server to port 1111. */
	selfaddress.port = 1111;

	ENetHost * client=0;
	while (!client)
	{
		client = enet_host_create (&selfaddress/* create a client host */,
					32 /* only 32 connections */,
					2 /* allow up 2 channels to be used, 0 and 1 */,
					0/*57600 / 8  56K modem with 56 Kbps downstream bandwidth */,
					0 /* 14400 / 8  56K modem with 14 Kbps upstream bandwidth */);
		if (client == NULL)
		{
			selfaddress.port++;
		}
	}
	if (client == NULL)
	{
		fprintf (stderr, 
				 "An error occurred while trying to create an ENet client host.\n");
		exit (EXIT_FAILURE);
	}



	ENetAddress dedicatedserveraddress;
	ENetEvent event;
	ENetPeer* dedicatedpeer=0;
	ENetPeer* natpeer=0;

	/* Connect to some.server.net:1234. */
	enet_address_set_host (& dedicatedserveraddress, "bulletphysics.org");
	dedicatedserveraddress.port = 1234;
	/* Initiate the connection, allocating the two channels 0 and 1. */
	dedicatedpeer = enet_host_connect (client, & dedicatedserveraddress, 2, 0);    
	if (dedicatedpeer == NULL)
	{
	   fprintf (stderr, "No available peers for initiating an ENet connection.\n");
	   exit (EXIT_FAILURE);
	}
	/* 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)
	{
		char servername[1024];
		enet_address_get_host(&dedicatedserveraddress,servername, 1024);
		char serverinfo[1024];

		sprintf(serverinfo,"Connection to %s:%d succeeded", servername,dedicatedserveraddress.port);
		puts (serverinfo);

		/////....

		/* Wait up to 1000 milliseconds for an event. */
		while (enet_host_service (client, & event, 1000000000) > 0)
		{
			static int count=10;
			count--;
			if (natpeer && count>0)
			{
					/* 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 (natpeer, 0, packet);
			}
			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);
				/* Store any relevant client information here. */
				event.peer -> data = (void*)"Client information";
				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. */

				if (event.packet->dataLength==sizeof(ENetAddress))
				{
					ENetAddress* address = (ENetAddress*)event.packet->data;
					printf("received other client's address from server, connecting...\n");
					natpeer = enet_host_connect (client, address, 2, 0);    
					if (natpeer== NULL)
					{
						fprintf (stderr, "No available peers for initiating an ENet connection.\n");
						exit (EXIT_FAILURE);
					}
					/* 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)
					{
						puts ("Connection to natpeer succeeded.");
					} else
					{
						enet_peer_reset (natpeer);
						puts ("Connection to natpeer failed.");
						natpeer=0;
						exit(0);
					}

				}

				enet_packet_destroy (event.packet);
				break;
       
			case ENET_EVENT_TYPE_DISCONNECT:
				printf ("%s disconected.\n", event.peer -> data);
				/* Reset the peer's client information. */
				event.peer -> data = NULL;
			}
		}
		/* One could just use enet_host_service() instead. */
		enet_host_flush (client);//host);
	}
	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 (dedicatedpeer);
		puts ("Connection to some.server.net:1234 failed.");
	}


	



	enet_host_destroy(client);
	
	return 0;
}
예제 #2
0
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;
}