Peer* ClientHost::Connect( std::string server_ip, uint16_t port, size_t channel_count ) { CHECK(_state == STATE_INITIALIZED); ENetAddress address; if (enet_address_set_host(&address, server_ip.c_str()) != 0) { // THROW_ERROR("Unable to set enet host address!"); return NULL; } address.port = port; // XXX: type cast. ENetPeer* enet_peer = enet_host_connect(_host, &address, channel_count, 0); if (enet_peer == NULL) { // THROW_ERROR("Enet host is unable to connect!"); return NULL; } Peer* peer = Host::_GetPeer(enet_peer); CHECK(peer != NULL); return peer; }
static int initEnet(const char *host_ip, const int host_port, ServerData *data) { ENetAddress address; assert(data); if (enet_initialize() != 0) { fprintf (stderr, "An error occurred while initializing ENet.\n"); return RETURN_FAIL; } address.host = ENET_HOST_ANY; address.port = host_port; if (host_ip) enet_address_set_host(&address, host_ip); data->server = enet_host_create(&address, 32 /* max clients */, 2 /* max channels */, 0 /* download bandwidth */, 0 /* upload bandwidth */); if (!data->server) { fprintf (stderr, "An error occurred while trying to create an ENet server host.\n"); return RETURN_FAIL; } /* enable compression */ data->server->checksum = enet_crc32; enet_host_compress_with_range_coder(data->server); return RETURN_OK; }
void CC_Client::connect(const char *host=HOST, uint16_t port=PORT) { if (connected) { printf("Connected already.\n"); return; } enet_address_set_host(&address, host); address.port = port; peer = enet_host_connect(client, &address, 2, 0); if (peer == NULL) { fprintf(stderr, "No available peers to connect\n"); exit(EXIT_FAILURE); } if (enet_host_service(client, &evt, 5000) > 0 && evt.type == ENET_EVENT_TYPE_CONNECT) { printf("Connected to server %s:%u\n", HOST, PORT); connected = true; } else { enet_peer_reset(peer); printf("Connection failed to %s:%u\n", HOST, PORT); } //~ conn_t_ret = pthread_create(&conn_t, NULL, CC_Client::loop, (void*)this); }
bool CNetClientSession::Connect(u16 port, const CStr& server) { ENSURE(!m_Host); ENSURE(!m_Server); // Create ENet host ENetHost* host = enet_host_create(NULL, 1, CHANNEL_COUNT, 0, 0); if (!host) return false; // Bind to specified host ENetAddress addr; addr.port = port; if (enet_address_set_host(&addr, server.c_str()) < 0) return false; // Initiate connection to server ENetPeer* peer = enet_host_connect(host, &addr, CHANNEL_COUNT, 0); if (!peer) return false; m_Host = host; m_Server = peer; m_Stats = new CNetStatsTable(m_Server); if (CProfileViewer::IsInitialised()) g_ProfileViewer.AddRootTable(m_Stats); return true; }
VALUE renet_connection_initialize(VALUE self, VALUE host, VALUE port, VALUE channels, VALUE download, VALUE upload) { rb_funcall(mENet, rb_intern("initialize"), 0); Connection* connection; /* Now that we're releasing the GIL while waiting for enet_host_service we need a lock to prevent potential segfaults if another thread tries to do an operation on same connection */ VALUE lock = rb_mutex_new(); rb_iv_set(self, "@lock", lock); rb_mutex_lock(lock); Data_Get_Struct(self, Connection, connection); Check_Type(host, T_STRING); if (enet_address_set_host(connection->address, StringValuePtr(host)) != 0) { rb_raise(rb_eStandardError, "Cannot set address"); } connection->address->port = NUM2UINT(port); connection->channels = NUM2UINT(channels); connection->online = 0; connection->host = enet_host_create(NULL, 1, connection->channels, NUM2UINT(download), NUM2UINT(upload)); if (connection->host == NULL) { rb_raise(rb_eStandardError, "Cannot create host"); } rb_iv_set(self, "@total_sent_data", INT2FIX(0)); rb_iv_set(self, "@total_received_data", INT2FIX(0)); rb_iv_set(self, "@total_sent_packets", INT2FIX(0)); rb_iv_set(self, "@total_received_packets", INT2FIX(0)); rb_mutex_unlock(lock); return self; }
void NetworkController::initEnet() { if( enet_initialize() != 0){ root->fatalError("NetController", "Cannot initialise ENet"); }; root->sout << "Attempting to create host..." << endl; if( root->confMgr.varExists("host_address") ){ enet_address_set_host( &enetAddress, root->confMgr.getVarS("host_address").c_str() ); root->sout << "Binding to configured address " << root->confMgr.getVarS("host_address") <<endl; }else{ enetAddress.host = ENET_HOST_ANY; root->sout << "Binding to any available address" << endl; } if( root->confMgr.varExists("host_port") ){ enetAddress.port = root->confMgr.getVarI("host_port"); }else{ enetAddress.port = HOST_PORT_DEFAULT; } root->sout << "Binding to port " << enetAddress.port << endl; enetHost = enet_host_create(&enetAddress, (root->confMgr.varExists("max_clients")) ? (root->confMgr.getVarI("max_clients")) : MAX_CLIENTS_DEFAULT, 2, 0, 0); if(enetHost == NULL) { root->fatalError("NetController", "Cannot create ENet host"); } }
NetClient::NetClient(const std::string& ip) : me (0), server (0), exit (false), is_game (false), game_start (false), game_end (false), room_data_change (false), player_data_change(false), level_change (false), updates_change (0), ourself (players.begin()) // will crash if dereferenced if empty { // 0 = Client, 1 = one connection at most (to server), 0, 0 = unlim. bandw. // // ############################################################# // # NOTE: If you get a compiler error for the following line, # // # check your enet version. Lix assumes you have enet 1.3. # // ############################################################# me = enet_host_create(0, 1, LEMNET_CHANNEL_MAX, 0, 0); ENetAddress address; enet_address_set_host(&address, ip.c_str()); address.port = gloB->server_port; server = enet_host_connect(me, &address, LEMNET_CHANNEL_MAX, 0); }
bool NNetwork::Connect(std::string i_HostName, unsigned int Port) { if (Host) { Disconnect(); } HostName = i_HostName; Address.port = Port; enet_address_set_host(&Address, HostName.c_str()); Host = enet_host_connect(Client,&Address,2,0); if (!Host) { std::stringstream Message; Message << "Failed to connect to host " << HostName << " on port " << Port << "!"; GetGame()->GetLog()->Send("NETWORK",0,Message.str()); return 1; } ENetEvent Event; if (enet_host_service(Client, &Event, 2500) > 0 && Event.type == ENET_EVENT_TYPE_CONNECT) { std::stringstream Message; Message << "Successfully connected to " << HostName << " on port " << Port << "."; GetGame()->GetLog()->Send("NETWORK",2,Message.str()); return 0; } else { std::stringstream Message; Message << "Failed to connect to host " << HostName << " on port " << Port << "!"; GetGame()->GetLog()->Send("NETWORK",0,Message.str()); Host = NULL; return 1; } return 1; }
int NetworkManager::connexionToHost(std::string url,int port) { enet_address_set_host (& address,url.c_str()); address.port = port; peer = enet_host_connect (client, & address, 2, 0); if (peer == NULL) { return 1; } if (enet_host_service (client, &eventClient, 1000) > 0 && eventClient.type == ENET_EVENT_TYPE_CONNECT) { isConnectedflag = true; endThread = false; thread = boost::thread(&NetworkManager::threadConnexion, (void *) this); return 0; } 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); return 2 ; } }
int resolverloop(void * data) { resolverthread *rt = (resolverthread *)data; for(;;) { SDL_SemWait(resolversem); SDL_LockMutex(resolvermutex); if(resolverqueries.empty()) { SDL_UnlockMutex(resolvermutex); continue; } rt->query = resolverqueries.pop(); rt->starttime = lastmillis; SDL_UnlockMutex(resolvermutex); ENetAddress address = { ENET_HOST_ANY, CUBE_SERVINFO_PORT }; enet_address_set_host(&address, rt->query); SDL_LockMutex(resolvermutex); resolverresult &rr = resolverresults.add(); rr.query = rt->query; rr.address = address; rt->query = NULL; rt->starttime = 0; SDL_UnlockMutex(resolvermutex); }; return 0; };
void networkEngine::serverSetup() { //gameEngine *gameE = gameEngine::Instance(); boost::shared_ptr<gameEngine> gameE = gameEngine::Instance(); /* Bind the server to the default localhost. */ /* A specific host address can be specified by */ /* enet_address_set_host (& address, "x.x.x.x"); */ // Old Pre-GUI ip address input code // string ipAddress; // cout << "IP Address to bind to:" << endl; // cin >> ipAddress; listenAddress.host = enet_address_set_host (& listenAddress, ipAddress.c_str()); // listenAddress.host = enet_address_set_host (& listenAddress, ENET_HOST_ANY); /* Bind the server to port 1234. */ listenAddress.port = 1234; server = enet_host_create (& listenAddress /* the address to bind the server host to */, 32 /* allow up to 32 clients and/or outgoing connections */, 2 /* allows up to 2 channels, 0, 1*/, 0 /* assume any amount of incoming bandwidth */, 0 /* assume any amount of outgoing bandwidth */); if (server == NULL) { logMsg("An error occurred while trying to create an ENet server host."); exit (EXIT_FAILURE); } gameE->setServerRunning(true); }
void menu_connect_start(component *c, void *userdata) { scene *s = userdata; connect_menu_data *local = menu_get_userdata(c->parent); ENetAddress address; const char *addr = textinput_value(local->addr_input); s->gs->role = ROLE_CLIENT; // Free old saved address, and set new free(settings_get()->net.net_connect_ip); settings_get()->net.net_connect_ip = strdup(addr); // Set up enet host local->host = enet_host_create(NULL, 1, 2, 0, 0); if(local->host == NULL) { DEBUG("Failed to initialize ENet client"); return; } // Disable connect button and address input field component_disable(local->connect_button, 1); component_disable(local->addr_input, 1); menu_select(c->parent, local->cancel_button); // Set address enet_address_set_host(&address, addr); address.port = settings_get()->net.net_connect_port; ENetPeer *peer = enet_host_connect(local->host, &address, 2, 0); if(peer == NULL) { DEBUG("Unable to connect to %s", addr); enet_host_destroy(local->host); local->host = NULL; } time(&local->connect_start); }
NetManager::NetManager(bool isServer, const FAWorld::PlayerFactory& playerFactory) : mPlayerFactory(playerFactory) { assert(singletonInstance == NULL); singletonInstance = this; enet_initialize(); mAddress.port = 6666; mIsServer = isServer; if(isServer) { mAddress.host = ENET_HOST_ANY; mHost = enet_host_create(&mAddress, 32, 2, 0, 0); } else { enet_address_set_host(&mAddress, "127.0.0.1"); mHost = enet_host_create(NULL, 32, 2, 0, 0); mServerPeer = enet_host_connect(mHost, &mAddress, 2, 0); ENetEvent event; if(enet_host_service(mHost, &event, 5000)) { std::cout << "connected" << std::endl; } else { std::cout << "connection failed" << std::endl; } } }
void *Network::readThread(void *context) { struct thread_args *args = (struct thread_args *)context; char *ip = args->ip; Network *instance = args->instance; ENetEvent event; ENetAddress address; client = enet_host_create(NULL, 1, 1, 0, 0); if (client == NULL) return (void*)1; enet_address_set_host (&address, ip); address.port = 1400; server = enet_host_connect (client, &address, 1, 0); if (server == NULL) return (void*)2; if (!(enet_host_service (client, &event, 5000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT)) return (void*)3; emit instance->connected(); while(true) { pthread_mutex_lock(&net_mutex); enet_host_service (client, &event, 0); pthread_mutex_unlock(&net_mutex); switch (event.type) { case ENET_EVENT_TYPE_CONNECT: server = event.peer; emit instance->connected(); break; case ENET_EVENT_TYPE_RECEIVE: switch(event.packet->data[0]) { case SET_MEASURED_VALUES: float values[3]; memcpy(values, event.packet->data + 1, sizeof(float) * 3); emit instance->setMeasuredValues(values[0], values[1], values[2]); break; case SET_CPU_USAGE: emit instance->setCPUUsage(event.packet->data[1]); break; case SET_MEMORY_USAGE: emit instance->setMemoryUsage(event.packet->data[1]); break; } enet_packet_destroy(event.packet); break; case ENET_EVENT_TYPE_DISCONNECT: server = NULL; emit instance->disconnect(); break; default: break; } usleep(100); } return (void*)0; }
int main (int argc, char ** argv) { if (enet_initialize () != 0) { fprintf (stderr, "An error occurred while initializing ENet.\n"); return EXIT_FAILURE; } atexit (enet_deinitialize); printf("creating host\n"); host = 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 (host == NULL) { fprintf (stderr, "An error occurred while trying to create an ENet client host.\n"); exit (EXIT_FAILURE); } ENetAddress address; enet_address_set_host (& address, "localhost"); address.port = SOCKK; printf("connecting to server...\n"); ENetPeer *peer = enet_host_connect (host, & address, 2, 0); if (peer == NULL) { fprintf (stderr, "No available peers for initiating an ENet connection.\n"); exit (EXIT_FAILURE); } #ifdef __EMSCRIPTEN__ #if USE_IFRAME emscripten_run_script("console.log('adding iframe');" "var iframe = document.createElement('iframe');" "iframe.src = 'server.html';" "iframe.width = '100%';" "iframe.height = '33%';" "document.body.appendChild(iframe);" "console.log('added.');"); #endif #endif #ifdef __EMSCRIPTEN__ emscripten_set_main_loop(main_loop, 3, 1); #else while (1) main_loop(); #endif return 1; }
void networkEngine::clientConnect() { //gameEngine *gameE = gameEngine::Instance(); boost::shared_ptr<gameEngine> gameE = gameEngine::Instance(); if (!clientEstablishedConnection) { client = enet_host_create (NULL /* create a client host */, 4 /* only allow 1 outgoing connection */, 2 /* allow up to 2 channels to be used, 0 and 1*/, 0 /* 56K modem with 56 Kbps downstream bandwidth */, 0 /* 56K modem with 14 Kbps upstream bandwidth */); if (client == NULL) { logMsg("An error occurred while trying to create an ENet client host."); exit (EXIT_FAILURE); } // Old Pre-GUI ipAddress input code // string ipAddress; // cout << "IP Address: " << endl; // cin >> ipAddress; /* Connect to some.server.net:1234. */ enet_address_set_host (& serverAddress, ipAddress.c_str()); serverAddress.port = 1234; /* Initiate the connection, allocating the two channels 0 and 1. */ peer = enet_host_connect (client, & serverAddress, 2, 0); if (peer == NULL) { logMsg("No available peers for initiating an ENet connection."); 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) { logMsg("Connection to " +ipAddress +":1234 succeeded."); clientEstablishedConnection = true; // Tells other code that this instance is a network client } 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); logMsg("Connection to " +ipAddress +":1234 failed."); } gameE->setClientRunning(true); clientEstablishedConnection = true; } }
/** * COMMAND /connect host port * * Initiate connection to svceserver. */ static int cmd_connect(int argc, dstring** argv) { ENetAddress address; char buffer[100]; /* check if client is in correct state to connect */ if (client.state != SVCECLIENT_STATE_DISCONNECTED) { if (client.state == SVCECLIENT_STATE_CONNECTED) { fprintf(stderr, "Already connected.\n"); } else if (client.state == SVCECLIENT_STATE_CONNECTING) { fprintf(stderr, "Already trying to connect.\n"); } else { fprintf(stderr, "Unknown client state.\n"); } return 0; } if (argc != 3) { fprintf(stderr, "usage: /connect host port\n"); return 0; } /* resolve host */ address.port = atoi(argv[2]->data); if (enet_address_set_host(&address, argv[1]->data)) { fprintf(stderr, "Failed to resolve '%s'\n", argv[1]->data); return 0; } else { dcpy(client.server_host_name, argv[1]); buffer[0] = 0; enet_address_get_host_ip(&address, buffer, 100); dcpycs(client.server_host_addr, buffer); client.server_host_port = address.port; } mutex_lock(&client.network_lock); /* create host */ client.host = enet_host_create(NULL, 1, 2, 0, 0); if (client.host == NULL) { mutex_unlock(&client.network_lock); fprintf(stderr, "An error occurred while trying to create enet host.\n"); return 0; } /* initiate connection */ client.client = enet_host_connect(client.host, &address, 2, 0); if (client.client == NULL) { enet_host_destroy(client.host); mutex_unlock(&client.network_lock); fprintf(stderr, "No available peers to initiate a connection.\n"); return 0; } mutex_unlock(&client.network_lock); client.state = SVCECLIENT_STATE_CONNECTING; msg_state(); return 0; }
bool Client::set_ip(std::string new_ip) { if(!_V_is_running and !enet_address_set_host(&_V_address,new_ip.c_str())) { _V_ip=new_ip; return true; } return false; }
int module_start (Q5Module* self) { int i; uint32_t gameEngineSrvNo; ENetAddress address; if (enet_initialize () != 0) { eclogger_msg (LL_ERROR, properties.name, "server", "could not initialize enet"); return FALSE; } enet_address_set_host (&address, self->host); address.port = self->port; self->server = enet_host_create (&address, 32, 2, 0, 0); if (!self->server) { enet_deinitialize(); eclogger_msg (LL_ERROR, properties.name, "server", "can't start enet server"); return FALSE; } eclogger_fmt (LL_DEBUG, properties.name, "server", "listen '%s' on port '%u'", self->host, self->port); self->threads = eclist_new (); self->done = FALSE; for (i = 0; i < 1; i++) { EcThread thread = ecthread_new (); eclist_append(self->threads, thread); ecthread_start(thread, module_thread_run, self); } gameEngineSrvNo = q5core_getModuleId (self->core, "GAME_E"); if (gameEngineSrvNo == 0) { eclogger_fmt (LL_WARN, properties.name, "server", "no game engine available"); } self->entities = gse_create (self->server, gameEngineSrvNo, "Lobo's geiler server"); gse_addRealm (self->entities, "the shire"); ecmessages_add (self->instance->msgid, Q5_DATA_GET, module_callback_get, self); return TRUE; }
/* @brief Connect the client to a remote server. createClient() should be called first. @return True for success. */ bool clientConnect(const char* hostName) { if (client == nullptr) { return false; } if (strcmp(hostName, "localhost") == 0) { enet_address_set_host(&address, "127.0.0.1"); } else { enet_address_set_host(&address, hostName); } address.port = PORT; peer = enet_host_connect(client, &address, NUM_CHANNELS, CHANNEL_ID); return (peer != nullptr); }
void ClientTransmissionManager::Connect() { boost::mutex::scoped_lock lock(this->mHostMutex); std::stringstream s; this->mAddress.host = ENET_HOST_ANY; this->mAddress.port = this->mPort; if(enet_address_set_host(&this->mAddress, this->mHost.c_str())==0) { s << "Resolved hostname."; this->GetClientSessionManager().Log(s); if(this->mClient==NULL) { this->mClient = enet_host_create( NULL, this->mClientLimit, this->mDownstreamLimit, this->mUpstreamLimit); } if(this->mClient!=NULL) { s << "Connected to network."; this->GetClientSessionManager().Log(s); this->mPeer = enet_host_connect(this->mClient,&this->mAddress, 5); if (this->mPeer == NULL) { s << "Server not found."; this->GetClientSessionManager().Log(s); } else { this->mPeer->data=NULL; s << "Server found."; this->GetClientSessionManager().Log(s); } } else { s << "Unable to connect to network."; this->GetClientSessionManager().Log(s); } } else { s << "Couldn't resolve hostname."; this->GetClientSessionManager().Log(s); } }
void Host::connect(const std::string &hostname, unsigned int port) { // set the address of the server to connect to enet_address_set_host(&mAddress, hostname.c_str()); mAddress.port = port; // connect to the server #ifdef ENET_VERSION mServer = enet_host_connect(mClient, &mAddress, 0, 1); #else mServer = enet_host_connect (mClient, &mAddress, 1); #endif }
bool network_connect( ENetHost* socket, const char* server, int port, int timeout ) { ENetAddress address; ENetEvent ev; if( socket == 0 ) return false; enet_address_set_host( &address, server ); address.port = port; enet_host_connect( socket, &address, 1, 0 ); return (enet_host_service( socket, &ev, timeout) > 0 && ev.type == ENET_EVENT_TYPE_CONNECT); }
void NetClient::Connect(const char* connect) { m_enetclient = enet_host_create(NULL, 1, 1, 350000, 95000); // This is 3 megabit d/l, .75 megabit upload. Should be the lowest common denominator of internet connection today. ENetAddress address; enet_address_set_host(&address, connect); address.port = 51072; m_enetpeer = enet_host_connect(m_enetclient, &address, 1, 0); #ifdef _DEBUG enet_peer_timeout(m_enetpeer, UINT32_MAX, UINT32_MAX, UINT32_MAX); #endif }
bool Client::Connect(const std::string &ip) { ENetAddress address; ENetEvent event; enet_address_set_host(&address, ip.c_str()); address.port = _port; RN_ASSERT((_host = enet_host_create(NULL, 1, 2, 0, 0)), "Enet couldn't create client!"); RN_ASSERT((_peer = enet_host_connect(_host, &address, 2, 0)), "Enet couldn't create a peer!"); _connected = (enet_host_service(_host, &event, 5000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT); return _connected; }
/** Initialises the client. This function tries to connect to the server. */ bool NetworkManager::initClient(const char* hostName, int portHost) { m_host = enet_host_create (NULL /* create a client host */, 1 /* only allow 1 outgoing connection */, 0 /* channel limit */, 0 /* downstream bandwidth unlimited */, 0 /* upstream bandwidth unlimited */ ); if (m_host == NULL) { fprintf (stderr, "An error occurred while trying to create an ENet client host.\n"); return false; } ENetAddress address; ENetEvent event; ENetPeer *peer; enet_address_set_host (& address, hostName); address.port = portHost; /* Initiate the connection, allocating the two channels 0 and 1. */ peer = enet_host_connect (m_host, &address, 2, 0); if (peer == NULL) { fprintf(stderr, "No available peers for initiating an ENet connection.\n"); return false; } /* Wait up to 5 seconds for the connection attempt to succeed. */ if (enet_host_service (m_host, & event, 5000) <= 0 || event.type != ENET_EVENT_TYPE_CONNECT) { /* 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 '%s:%d' failed.\n", hostName, portHost); return false; } m_server = peer; return true; } // initClient
ServerBase::ServerBase(const std::string &listenAddress, const Kiaro::Common::U16 &listenPort, const Kiaro::Common::U32 &maximumClientCount) : mIsRunning(true), mInternalHost(NULL), mListenPort(listenPort), mListenAddress(listenAddress) { ENetAddress enetAddress; enetAddress.port = listenPort; enet_address_set_host(&enetAddress, listenAddress.c_str()); mInternalHost = enet_host_create(&enetAddress, maximumClientCount, 2, 0, 0); if (!mInternalHost) { mIsRunning = false; throw std::runtime_error("ServerBase: Failed to create ENet host!"); return; } }
CConexion* CClienteENet::connect(char* address, int port, int channels, unsigned int timeout) { if(estado = NO_INIT) return NULL; ENetAddress _address; ENetEvent event; CConexionENet* conexion = 0; /* Connect */ enet_address_set_host (& _address, address); _address.port = port; ENetPeer* peer = enet_host_connect (client, & _address, channels); if (peer == NULL) { printf ("No available peers for initiating an ENet connection.\n"); } else { /* Wait up to 5 seconds for the connection attempt to succeed.*/ if (enet_host_service (client, & event, timeout*1000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT) { if(DEBUG_CLIENT) fprintf(stdout, "Connection succeeded."); conexion = new CConexionENet(); conexion -> setENetPeer(peer); listaConexiones.push_back(conexion); } 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); printf ("Connection failed."); } } enet_host_flush (client); estado = INIT_AND_CONNECTED; return conexion; }
void Client::connect() { ENetAddress address; ENetEvent event; m_connected = true; enet_address_set_host(&address, m_serverAdress.c_str()); address.port = m_serverPort; LOG(INFO) << "Trying to connect to " << m_serverAdress << ":" << m_serverPort << "."; m_serverPeer = enet_host_connect(m_client, &address, 2, 0); if(m_serverPeer == nullptr) { LOG(FATAL) << "No available peers to initialize connection!"; m_connected = false; } }
bool connection_join(const char *hostname, uint16_t port) { destroy_host(); ENetAddress address; enet_address_set_host(&address, hostname); address.port = port; host = enet_host_create(NULL, 1, CHANNEL_COUNT, 0, 0); server = enet_host_connect(host, &address, CHANNEL_COUNT, 0); ENetEvent event; if (enet_host_service(host, &event, 1000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT) { entity_reset_all(); } return host != NULL; }