VALUE renet_connection_send_packet(VALUE self, VALUE data, VALUE flag, VALUE channel) { Connection* connection; Data_Get_Struct(self, Connection, connection); VALUE lock = rb_iv_get(self, "@lock"); rb_mutex_lock(lock); Check_Type(data, T_STRING); char* cdata = StringValuePtr(data); ENetPacket* packet; if (connection->online != 0) { if (flag == Qtrue) { packet = enet_packet_create(cdata, RSTRING_LEN(data) + 1, ENET_PACKET_FLAG_RELIABLE); } else { packet = enet_packet_create(cdata, RSTRING_LEN(data) + 1, 0); } enet_peer_send(connection->peer, NUM2UINT(channel), packet); } rb_mutex_unlock(lock); return Qnil; }
void sendmap(char *mapname) { if(*mapname) save_world(mapname); changemap(mapname); mapname = getclientmap(); int mapsize; uchar *mapdata = readmap(mapname, &mapsize); if(!mapdata) return; ENetPacket *packet = enet_packet_create(NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE); uchar *start = packet->data; uchar *p = start+2; putint(p, SV_SENDMAP); sendstring(mapname, p); putint(p, mapsize); if(65535 - (p - start) < mapsize) { conoutf("map %s is too large to send", mapname); free(mapdata); enet_packet_destroy(packet); return; }; memcpy(p, mapdata, mapsize); p += mapsize; free(mapdata); *(ushort *)start = ENET_HOST_TO_NET_16(p-start); enet_packet_resize(packet, p-start); sendpackettoserv(packet); conoutf("sending map %s to server...", mapname); sprintf_sd(msg)("[map %s uploaded to server, \"getmap\" to receive it]", mapname); toserver(msg); }
void NetClient::SendReadyToStartPacket() { std::string strDName = GetDriverName(); GfLogTrace("Sending ready to start packet\n"); PackedBuffer msg; try { msg.pack_ubyte(CLIENTREADYTOSTART_PACKET); msg.pack_stdstring(strDName); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SendReadyToStartPacket: packed buffer error\n"); } GfLogTrace("SendReadyToStartPacket: packed data length=%d\n", msg.length()); ENetPacket *pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)) GfLogError("SendReadyToStartPacket : enet_peer_send failed\n"); }
/** * Handle input command. * * This function should return 0, even if the command failed. * Return of != 0 means the event loop will quit. */ static int handle_input_command(const dstring* string) { dstrlist* list; dstring** argv; unsigned int argc; int error; ENetPacket* packet; if (string->len == 0) { /* empty command */ return 0; } else if (string->data[0] == '/') { /* local command */ /* parse the command */ list = dstrlex_parse(string, &error); if (list == NULL) { fprintf(stderr, "Failed to parse command string '%s': %s\n", string->data, dstrlex_errstr(error)); return 0; } /* convert list to vector */ argc = list->size; argv = dlist_tovector(list); dlist_free(list); /* select command to execute */ if (dcmpcs(argv[0], "/connect") == 0) { error = cmd_connect(argc, argv); } else if (dcmpcs(argv[0], "/disconnect") == 0) { error = cmd_disconnect(argc, argv); } else if (dcmpcs(argv[0], "/quit") == 0) { error = cmd_quit(argc, argv); } else if (dcmpcs(argv[0], "/mute") == 0) { error = cmd_mute(argc, argv); } else if (dcmpcs(argv[0], "/deafen") == 0) { error = cmd_deafen(argc, argv); } else { fprintf(stderr, "Unknown command '%s'\n", argv[0]->data); error = 0; } dvec_free(argv); return error; } else if (client.state == SVCECLIENT_STATE_CONNECTED) { /* send to server if connected */ mutex_lock(&client.network_lock); packet = enet_packet_create(string->data, string->len, ENET_PACKET_FLAG_RELIABLE); enet_peer_send(client.client, 0, packet); mutex_unlock(&client.network_lock); } else if (client.state == SVCECLIENT_STATE_CONNECTING) { /* server command but still connecting */ fprintf(stderr, "Can't send command to server, still connecting.\n"); } else { /* server command but not connected */ fprintf(stderr, "Can't send command to server, not connected.\n"); } return 0; }
void Connection::send_packet_unreliable(void *data,int ID){ ENetPacket *packet = enet_packet_create (data, sizeof(data), ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT); if(!client) enet_peer_send (&connS->peers[ID], 0, packet); else enet_peer_send(peer,0,packet); }
void GDNetHost::send_messages() { while (!_message_queue.is_empty()) { GDNetMessage* message = _message_queue.pop(); int flags = 0; switch (message->get_type()) { case GDNetMessage::UNSEQUENCED: flags |= ENET_PACKET_FLAG_UNSEQUENCED; break; case GDNetMessage::RELIABLE: flags |= ENET_PACKET_FLAG_RELIABLE; break; default: break; } ByteArray::Read r = message->get_packet().read(); ENetPacket * enet_packet = enet_packet_create(r.ptr(), message->get_packet().size(), flags); if (enet_packet != NULL) { if (message->is_broadcast()) { enet_host_broadcast(_host, message->get_channel_id(), enet_packet); } else { enet_peer_send(&_host->peers[message->get_peer_id()], message->get_channel_id(), enet_packet); } } memdelete(message); } }
void ENetServer::broadcastMessage(DeliveryType type, Message::Shared msg) const { if (numClients() == 0) { // no clients to broadcast to return; } uint32_t channel = 0; uint32_t flags = 0; if (type == DeliveryType::RELIABLE) { channel = RELIABLE_CHANNEL; flags = ENET_PACKET_FLAG_RELIABLE; } else { channel = UNRELIABLE_CHANNEL; flags = ENET_PACKET_FLAG_UNSEQUENCED; } // get bytes auto data = msg->serialize(); // create the packet ENetPacket* p = enet_packet_create( &data[0], data.size(), flags); // send the packet to the peer enet_host_broadcast(host_, channel, p); // flush / send the packet queue enet_host_flush(host_); }
void Tunnelc::onENetPeerConnected(ENetHost *enhost, ENetPeer *enpeer, quint32 data) { qDebug()<<enhost<<enpeer<<data; // ToxTunChannel *chan = this->m_enpeer_chans[enpeer]; // ToxTunChannel *chan = (ToxTunChannel*)enpeer->toxchan; ToxTunChannel *chan = peerLastChan(enpeer); // enet_peer_ping_interval() // enet_peer_ping( enet_peer_timeout(enpeer, UINT32_MAX/*ENET_PEER_TIMEOUT_LIMIT * 0xfffff*/, UINT32_MAX/*ENET_PEER_TIMEOUT_MINIMUM * 0xffff*/, UINT32_MAX/*ENET_PEER_TIMEOUT_MAXIMUM * 0xffff*/); enet_peer_ping_interval(enpeer, UINT32_MAX/*ENET_PEER_PING_INTERVAL * 0xfffff*/); emit chan->m_sock->readyRead(); if (false) { ENetPacket *packet = enet_packet_create("hehehe123", 10, ENET_PACKET_FLAG_RELIABLE); enet_packet_resize(packet, 13); strcpy((char*)&packet->data[9], "foo"); uint8_t chanid = 0; // enet_peer_send(enpeer, chanid, packet); m_enpoll->sendPacket(enpeer, chanid, packet); } }
int main (int argc, char * const argv[]) { if(enet_initialize() != 0) { printf("An error occurred while initializing ENet.\n"); } ENetAddress address; ENetHost* server; address.host = ENET_HOST_ANY; address.port = 9050; // up to 32 clients with unlimited bandwidth server = enet_host_create(&address, 32, 0, 0); if(server == NULL) { printf("An error occurred while trying to create an ENet server host.\n"); } int clients = 0; // server main loop while(true) { ENetEvent event; while(enet_host_service(server, &event, 1000) > 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); clients++; break; case ENET_EVENT_TYPE_RECEIVE: printf ("A packet of length %u containing %s was received.\n", event.packet->dataLength, event.packet->data); ENetPacket* packet = enet_packet_create(event.packet->data, event.packet->dataLength, ENET_PACKET_FLAG_RELIABLE); enet_host_broadcast(server, 0, packet); enet_host_flush(server); enet_packet_destroy(event.packet); break; case ENET_EVENT_TYPE_DISCONNECT: printf("Client disconnected.\n"); event.peer->data = NULL; } } } return 0; }
void NetManager::sendServerPacket() { FAWorld::World& world = *FAWorld::World::get(); size_t bytesPerClient = world.getCurrentPlayer()->getSize() + sizeof(uint32_t); // the uint is for player id size_t packetSize = sizeof(ServerPacketHeader) + bytesPerClient*(mClients.size() +1); // +1 for the local player ENetPacket* packet = enet_packet_create(NULL, packetSize, 0); size_t position = 0; // write header ServerPacketHeader header; header.numPlayers = mClients.size() + 1; header.tick = mTick; writeToPacket(packet, position, header); // write server player writeToPacket<uint32_t>(packet, position, SERVER_PLAYER_ID); position = world.getCurrentPlayer()->writeTo(packet, position); // write all clients for(size_t i = 0; i < mClients.size(); i++) { writeToPacket<uint32_t>(packet, position, mClients[i]->connectID); position = world.getPlayer(mClients[i]->connectID)->writeTo(packet, position); } enet_host_broadcast(mHost, 0, packet); }
void CNetManager::sendOutPacket(SOutPacket& outpacket) { ENetPacket* packet = enet_packet_create((char*)outpacket.getData(), outpacket.getSize(), ENET_PACKET_FLAG_RELIABLE); enet_host_broadcast(host, 0, packet); }
void send_welcome(int n) { ENetPacket * packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE); uchar *start = packet->data; uchar *p = start + 2; putint(p, SV_INITS2C); putint(p, n); putint(p, PROTOCOL_VERSION); putint(p, smapname[0]); sendIString(serverpassword, p); putint(p, clients.size() > maxclients); if (smapname[0]) { putint(p, SV_MAPCHANGE); sendIString(smapname, p); putint(p, mode); putint(p, SV_ITEMLIST); for (int i = 0; i < sents.size(); i++) { if (sents[i].spawned) putint(p, i); } putint(p, -1); }; *(ushort *) start = ENET_HOST_TO_NET_16(p - start); enet_packet_resize(packet, p - start); send(n, packet); }
bool Game::send(const Packet & packet, ENetPeer * peer) { ENetPacket * enetPacket = enet_packet_create(packet.getData(), packet.getDataSize(), ENET_PACKET_FLAG_RELIABLE); if (!enetPacket) return false; return enet_peer_send(peer, 0, enetPacket) == 0; }
void* ThreadSend() { while(1) { CCLOG("wait mutex to send"); mutexMapPlay.lock(); // pthread_mutex_lock(&mutexMapPlay); mapLayerToString(playLayer, packetBuffer); // strcpy(packetBuffer, "0000000030000003000000000000000000000010000000000\1"); ENetPacket * packet = enet_packet_create (packetBuffer, 150, ENET_PACKET_FLAG_RELIABLE); CCLOG(packet->data); /* 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. */ enet_host_flush (server); CCLOG("finish send packet"); } enet_peer_disconnect (peer, 0); enet_peer_reset (peer); CCLOG("exit thread send"); return NULL; }
void Tunneld::onTcpDisconnected() { qDebug()<<""<<enet_host_used_peer_size(m_ensrv)<<m_sock_chans.count()<<m_conid_chans.count(); QTcpSocket *sock = (QTcpSocket*)(sender()); ToxTunChannel *chan = this->m_sock_chans[sock]; // qDebug()<<chan<<chan->m_enpeer->state; chan->sock_closed = true; chan->sock_close_time = QDateTime::currentDateTime(); // 防止对方没有收完,暂时还不能关闭连接。 // enet_peer_disconnect_later(chan->m_enpeer, qrand()); if (true) { QByteArray ba = "SRVFIN"; ENetPacket *packet = enet_packet_create(ba.data(), ba.length(), ENET_PACKET_FLAG_RELIABLE); // enet_packet_resize(packet, 13); // strcpy((char*)&packet->data[9], "foo"); uint8_t chanid = 1; ENetPeer *enpeer = chan->m_enpeer; // enet_peer_send(enpeer, chanid, packet); m_enpoll->sendPacket(enpeer, chanid, packet); } this->promiseChannelCleanup(chan); }
ENetPacket* ListenServerNetMode::createSpawnPacket(Object* object) { rAssert(object); std::string prototype; if(object->getPrototype()) { prototype = object->getPrototype()->getFilePath(); } else { prototype.append("."); prototype.append(object->getObjectClassName()); } SNetSpawnObject data; data.type = NET_PT_SPAWN_OBJECT; data.objectNetId = object->xiGetNetId(); data.pathSize = prototype.length(); memcpy(m_riBuffer, &data, sizeof(SNetSpawnObject)); memcpy((m_riBuffer + sizeof(SNetSpawnObject)), prototype.data(), prototype.length()); ENetPacket* packet = enet_packet_create(m_riBuffer, sizeof(SNetSpawnObject) + prototype.length(), ENET_PACKET_FLAG_RELIABLE); return packet; }
void Tunneld::onTcpReadyRead() { QTcpSocket *sock = (QTcpSocket*)sender(); ToxTunChannel *chan = this->m_sock_chans[sock]; if (chan->m_enpeer->state == ENET_PEER_STATE_CONNECTED) { while (sock->bytesAvailable() > 0) { // QByteArray ba = sock->readAll(); QByteArray ba = sock->read(567); if (ba.length() >= 1371) { qDebug()<<"too long data packet."; } ENetPacket *packet = enet_packet_create(ba.data(), ba.length(), ENET_PACKET_FLAG_RELIABLE); // enet_packet_resize(packet, 13); // strcpy((char*)&packet->data[9], "foo"); uint8_t chanid = 0; ENetPeer *enpeer = chan->m_enpeer; // enet_peer_send(enpeer, chanid, packet); m_enpoll->sendPacket(enpeer, chanid, packet); } } }
ENetPacket* ListenServerNetMode::createDataPacket(Object* object, bool initial) { rAssert(object); SReplicationBuffer rb; rb.cbi = sizeof(SNetObjectData); rb.size = NETWORK_BUFFER_SIZE; rb.buffer = m_riBuffer; uint32 oldCbi = rb.cbi; getData(&rb, object->riGetRepLayout(), initial); // Check if anything was written if(rb.cbi > oldCbi) { SNetObjectData data; data.type = NET_PT_OBJECT_DATA; data.objectNetId = object->xiGetNetId(); data.size = rb.cbi; memcpy(m_riBuffer, &data, sizeof(SNetObjectData)); ENetPacket* packet = enet_packet_create(rb.buffer, rb.cbi, ENET_PACKET_FLAG_RELIABLE); return packet; } return nullptr; }
void ENetServer::sendMessage(uint32_t id, DeliveryType type, Message::Shared msg) const { auto client = getClient(id); if (!client) { // no client to send to LOG_WARN("No connected client with id: " << id); return; } uint32_t channel = 0; uint32_t flags = 0; if (type == DeliveryType::RELIABLE) { channel = RELIABLE_CHANNEL; flags = ENET_PACKET_FLAG_RELIABLE; } else { channel = UNRELIABLE_CHANNEL; flags = ENET_PACKET_FLAG_UNSEQUENCED; } // get bytes auto data = msg->serialize(); // create the packet ENetPacket* p = enet_packet_create( &data[0], data.size(), flags); // send the packet to the peer enet_peer_send(client, channel, p); // flush / send the packet queue enet_host_flush(host_); }
/** udpr_write : ENetPeer-> data:string -> Channel->Reliable:Bool->void Send a full string [data] **/ static value udpr_write(value p, value data, value chan, value reliable) { ENetPeer *peer; ENetPacket *packet; int c; val_check_kind(p,k_udprpeer); val_check(data,string); val_check(chan,int); val_check(reliable,bool); c = val_int(chan); peer = (ENetPeer *)val_data(p); #ifdef ENET_DEBUG_FULL fprintf(stderr, "udpr_write: Writing packet '%s' to peer %x on channel %d\n", val_string(data), peer, c); fprintf(stderr, "peer state: %d peer channels: %d\n", peer -> state, peer->channelCount); #endif if(peer == NULL || c < 0 || c > 255) neko_error(); packet = enet_packet_create( val_string(data), val_strlen(data), val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0); if(enet_peer_send(peer, c, packet)) { #ifdef ENET_DEBUG fprintf(stderr, "ERROR: udpr_write: enet_peer_send error\n"); fprintf(stderr, "peer state: %d peer channels: %d\n", peer -> state, peer->channelCount); #endif neko_error(); } return val_true; }
/** * audio callback. */ void send_callback(svc_network_packet_t* packet){ enet_uint32 src; ENetPacket* epacket; unsigned char* data; /* get ID */ mutex_lock(&client.network_lock); src = client.my_id; /* this client didn't get it's ID yet (this also handles connection state as my_id==-1 if not connected) * or is muted. */ if (src == -1 || client.muted) { mutex_unlock(&client.network_lock); return; } /* allocate data */ data = (unsigned char*)malloc(packet->data_len+10); *(enet_uint32*)data = ENET_HOST_TO_NET_32(src); *(enet_uint32*)(data + 4) = ENET_HOST_TO_NET_32(packet->data_len+2); *(enet_uint16*)(data + 8) = ENET_HOST_TO_NET_16(packet->time); /* copy audio data */ memcpy(data + 10, packet->data, packet->data_len); epacket = enet_packet_create(data, packet->data_len + 10, ENET_PACKET_FLAG_UNSEQUENCED); enet_peer_send(client.client, 1, epacket); enet_host_flush(client.host); mutex_unlock(&client.network_lock); free(data); }
/** udpr_send : peer -> data:string -> pos:int -> len:int -> chan:int -> reliable:bool -> int Send up to [len] bytes from [buf] starting at [pos] over a connected socket on channel [chan] using reliable setting [reliable] Return the number of bytes sent. **/ static value udpr_send( value p, value data, value pos, value len, value chan, value reliable ) { ENetPeer *peer; ENetPacket *packet; int pp,l,sLen,c; val_check_kind(p,k_udprpeer); val_check(data,string); val_check(pos,int); val_check(len,int); val_check(chan,int); val_check(reliable,bool); peer = (ENetPeer *)val_data(p); pp = val_int(pos); l = val_int(len); sLen = val_strlen(data); c = val_int(chan); if( peer == NULL || c < 0 || c > 255 || pp < 0 || l < 0 || pp > sLen || pp + l > sLen ) neko_error(); packet = enet_packet_create( val_string(data) + pp, l, val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0); if(enet_peer_send(peer, c, packet)) neko_error(); return alloc_int(l); }
/** \brief Broadcasts a packet to all peers. * \param data : Data to send. */ void Network::broadcastPacket(const NetworkString& data, bool reliable) { ENetPacket* packet = enet_packet_create(data.getBytes(), data.size() + 1, reliable ? ENET_PACKET_FLAG_RELIABLE : ENET_PACKET_FLAG_UNSEQUENCED); enet_host_broadcast(m_host, 0, packet); } // broadcastPacket
/** udpr_send_char : peer -> data:int -> chan:int -> reliable:bool -> void Send a character [ over a connected socket. Must be in the range 0..255</doc> **/ static value udpr_send_char( value p, value data, value chan, value reliable ) { ENetPeer *peer; ENetPacket *packet; int c,d; char buf[2]; val_check_kind(p,k_udprpeer); val_check(data,int); val_check(chan,int); val_check(reliable,bool); peer = (ENetPeer *)val_data(p); c = val_int(chan); d = val_int(data); if( peer == NULL || c < 0 || c > 255 || d < 0 || d > 255 ) neko_error(); buf[0] = (unsigned char)d; buf[1] = '\0'; packet = enet_packet_create( buf, 1, val_bool(reliable) ? ENET_PACKET_FLAG_RELIABLE : 0); if(enet_peer_send(peer, c, packet)) neko_error(); return val_true; }
void Connection::broadcast_packet(void *data){ if(!client){ ENetPacket *packet = enet_packet_create (data, sizeof(data), ENET_PACKET_FLAG_RELIABLE); enet_host_broadcast (connS, 0, packet); } else std::cout << "Warn! Client can't broadcast!\n"; }
void Connection::send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable) { { //MutexAutoLock peerlock(m_peers_mutex); if (m_peers.find(peer_id) == m_peers.end()) return; } //dout_con<<getDesc()<<" sending to peer_id="<<peer_id<<std::endl; assert(channelnum < CHANNEL_COUNT); ENetPacket *packet = enet_packet_create(*data, data.getSize(), reliable ? ENET_PACKET_FLAG_RELIABLE : 0); ENetPeer *peer = getPeer(peer_id); if(!peer) { deletePeer(peer_id, false); return; } if (enet_peer_send(peer, channelnum, packet) < 0) { infostream<<"enet_peer_send failed peer="<<peer_id<<" reliable="<<reliable<< " size="<<data.getSize()<<std::endl; if (reliable) deletePeer(peer_id, false); return; } }
void NetClient::SetDriverReady(bool bReady) { // Get local driver index in the race driver list int idx = GetDriverIdx(); NetMutexData *pNData = LockNetworkData(); pNData->m_vecReadyStatus[idx-1] = bReady; UnlockNetworkData(); PackedBuffer msg; try { msg.pack_ubyte(DRIVERREADY_PACKET); msg.pack_int(idx); msg.pack_int(bReady); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SetDriverReady: packed buffer error\n"); } GfLogTrace("SetDriverReady: packed data length=%d\n", msg.length()); ENetPacket *pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) return; }
void Room::RoomImpl::BroadcastRoomInformation() { Packet packet; packet << static_cast<u8>(IdRoomInformation); packet << room_information.name; packet << room_information.member_slots; packet << room_information.uid; packet << room_information.port; packet << room_information.preferred_game; packet << static_cast<u32>(members.size()); { std::lock_guard<std::mutex> lock(member_mutex); for (const auto& member : members) { packet << member.nickname; packet << member.mac_address; packet << member.game_info.name; packet << member.game_info.id; } } ENetPacket* enet_packet = enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); enet_host_broadcast(server, 0, enet_packet); enet_host_flush(server); }
void NetClient::SendServerTimeRequest() { m_packetsendtime = GfTimeClock(); PackedBuffer msg; try { msg.pack_ubyte(SERVER_TIME_REQUEST_PACKET); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SendServerTimeRequest: packed buffer error\n"); } GfLogTrace("SendServerTimeRequest: packed data length=%d\n", msg.length()); ENetPacket *pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_UNSEQUENCED); if (enet_peer_send (m_pServer, UNRELIABLECHANNEL, pPacket)) GfLogError("SendServerTimeRequest : enet_peer_send failed\n"); }
void net_controller_har_hook(int action, void *cb_data) { controller *ctrl = cb_data; wtf *data = ctrl->data; serial ser; ENetPeer *peer = data->peer; ENetHost *host = data->host; ENetPacket *packet; if (action == ACT_STOP && data->last_action == ACT_STOP) { data->last_action = -1; return; } if (action == ACT_FLUSH) { enet_host_flush(host); return; } data->last_action = action; serial_create(&ser); serial_write_int8(&ser, EVENT_TYPE_ACTION); serial_write_int16(&ser, action); /*DEBUG("controller hook fired with %d", action);*/ /*sprintf(buf, "k%d", action);*/ packet = enet_packet_create(ser.data, ser.len, ENET_PACKET_FLAG_RELIABLE); if (peer) { enet_peer_send(peer, 1, packet); /*enet_host_flush (host);*/ } else { DEBUG("peer is null~"); } }