String Peer::getHostName() const
{
char name[256];
if(enet_address_get_host(&peer->address, name, ARRAY_SIZE(name)) < 0)
{
LogError("Could not get hostname of network peer");
return "";
}
return String(name);
}
int enet_lua_api enet_lua_address_get_host(lua_State* L) {
int err;
char namebuffer[256];
enet_lua_Address_t* udata = luaL_checkudata(L, 1, "_enet.address");
err = enet_address_get_host(&udata->address_, namebuffer, sizeof(namebuffer));
if (err < 0) {
luaL_error(L, "enet_address_get_host failed with error code %d", err);
}
lua_pushstring(L, namebuffer);
lua_pushinteger(L, udata->address_.host);
return 2;
}
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;
}
int main(int argc, char const *argv[])
{
if (enet_initialize () != 0)
{
return EXIT_FAILURE;
}
atexit(enet_deinitialize);
ENetAddress address;
ENetHost* client;
ENetPeer* peer;
std::string message;
ENetEvent event;
int eventStatus;
if (enet_initialize() != 0)
{
return EXIT_FAILURE;
}
atexit(enet_deinitialize);
client = enet_host_create(NULL, 1, 2, 57600 / 8, 14400 / 8);
enet_address_set_host(&address, "localhost");
char hej[10];
enet_address_get_host(&address, hej, 10);
std::cout << hej << std::endl;
address.port = 1234;
peer = enet_host_connect(client, &address, 2, 0);
while(true)
{
while (enet_host_service(client, &event, 1000) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
std::cout << "We got a new connection " << event.peer->address.host << std::endl;
break;
case ENET_EVENT_TYPE_RECEIVE:
std::cout << "Message from servv: " << event.packet->data << std::endl;
//enet_peer_disconnect(peer, 3);
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
std::cout << "Disconnected from serv: " << event.peer->data << std::endl;
event.peer->data = NULL;
break;
}
/*message = "HEJ SERVERHAH!";
ENetPacket* packet = enet_packet_create(message.c_str(), message.length() + 1, ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(peer, 0, packet);*/
}
}
std::cout << "5 sek har gått på client" << std::endl;
enet_host_destroy(client);
return 0;
}
void network()
{
ENetAddress address;
ENetHost* client;
ENetPeer* peer;
std::string message;
ENetEvent event;
int eventStatus;
if (enet_initialize () != 0)
{
std::cout << "Could not start ENet." << std::endl;
return;
}else
std::cout << "Started ENet." << std::endl;
atexit(enet_deinitialize);
client = enet_host_create(NULL, 1, 2, 57600 / 8, 14400 / 8);
enet_address_set_host(&address, "localhost");
char hej[10];
enet_address_get_host(&address, hej, 10);
std::cout << hej << std::endl;
address.port = 1234;
peer = enet_host_connect(client, &address, 2, 0);
while(true)
{
while (enet_host_service(client, &event, 1000) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
std::cout << "We got a new connection " << event.peer->address.host << std::endl;
break;
case ENET_EVENT_TYPE_RECEIVE:
{
std::cout << "Message from servv: ";
//enet_peer_disconnect(peer, 3);
char header[] = {((char*) event.packet->data)[0],
((char*) event.packet->data)[1],
((char*) event.packet->data)[2],
((char*) event.packet->data)[3]};
int* headerInt = (int*) header;
std::cout << *headerInt << std::endl;
if (*headerInt == PLAYER_POSITION)
{
Package<PLAYER_POSITION_TYPE>* message = (Package<PLAYER_POSITION_TYPE>*) event.packet->data;
std::cout << "player: " << message->_player << std::endl;
std::cout << "x: " << message->_data.x << std::endl;
std::cout << "y: " << message->_data.y << std::endl;
std::cout << "z: " << message->_data.z << std::endl;
}else if (*headerInt == ASSIGN_PLAYER_NUMBER)
{
Package<int>* message = (Package<int>*) event.packet->data;
std::cout << "Player number: " << message->_data << std::endl;
}
// int message = ((char*) event.packet->data)
enet_packet_destroy(event.packet);
break;
}
case ENET_EVENT_TYPE_DISCONNECT:
std::cout << "Disconnected from serv: " << event.peer->data << std::endl;
event.peer->data = NULL;
break;
}
}
posMutex.lock();
glm::vec3 hej = pos;
posMutex.unlock();
// std::cout << "Position sent: (" << hej.x << ", " << hej.y << ", " << hej.x << ")" << std::endl;
ENetPacket* packet = enet_packet_create(&hej, sizeof(glm::vec3), ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(peer, 0, packet);
std::cout << "ping: " << peer->roundTripTime << " ms" << std::endl;
offMutex.lock();
if (turnOfNetwork)
{
offMutex.unlock();
std::cout << "Network recived shoudown command." << std::endl;
break;
}else
offMutex.unlock();
}
std::cout << "Turning of network." << std::endl;
enet_host_destroy(client);
}
bool Host::update(Time timeout)
{
ENetEvent event;
bool status = true;
enet_uint32 ms = (enet_uint32) (timeout * 1000.0);
while (enet_host_service((ENetHost*) m_object, &event, ms) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
{
char name[2048];
enet_address_get_host(&(event.peer->address), name, sizeof(name) - 1);
name[sizeof(name) - 1] = '\0';
TargetID peerID;
if (isClient())
peerID = SERVER;
else
peerID = m_clientIDs.allocateID();
m_peers.push_back(Peer(event.peer, peerID, name));
event.peer->data = &(m_peers.back());
if (m_observer)
m_observer->onPeerConnected(m_peers.back());
break;
}
case ENET_EVENT_TYPE_DISCONNECT:
{
const Peer* peer = static_cast<Peer*>(event.peer->data);
for (auto p = m_peers.begin(); p != m_peers.end(); p++)
{
if (&(*p) == peer)
{
uint32 reason;
if (peer->m_disconnecting)
reason = peer->m_reason;
else
reason = event.data;
if (m_observer)
m_observer->onPeerDisconnected(*p, reason);
m_clientIDs.releaseID(p->targetID());
m_peers.erase(p);
break;
}
}
if (isClient())
status = false;
event.peer->data = nullptr;
break;
}
case ENET_EVENT_TYPE_RECEIVE:
{
if (m_observer)
{
if (Peer* peer = static_cast<Peer*>(event.peer->data))
{
PacketData data(event.packet->data,
event.packet->dataLength,
event.packet->dataLength);
m_observer->onPacketReceived(peer->targetID(), data);
}
}
enet_packet_destroy(event.packet);
break;
}
case ENET_EVENT_TYPE_NONE:
{
// This removes a useless warning by Clang
break;
}
}
}
enet_host_flush((ENetHost*) m_object);
m_allocated = 0;
return status;
}
