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; }