[1711] | 1 | /* |
---|
| 2 | * ORXONOX - the hottest 3D action shooter ever to exist |
---|
| 3 | * > www.orxonox.net < |
---|
| 4 | * |
---|
| 5 | * |
---|
| 6 | * License notice: |
---|
| 7 | * |
---|
| 8 | * This program is free software; you can redistribute it and/or |
---|
| 9 | * modify it under the terms of the GNU General Public License |
---|
| 10 | * as published by the Free Software Foundation; either version 2 |
---|
| 11 | * of the License, or (at your option) any later version. |
---|
| 12 | * |
---|
| 13 | * This program is distributed in the hope that it will be useful, |
---|
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
| 16 | * GNU General Public License for more details. |
---|
| 17 | * |
---|
| 18 | * You should have received a copy of the GNU General Public License |
---|
| 19 | * along with this program; if not, write to the Free Software |
---|
| 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
---|
| 21 | * |
---|
| 22 | * Author: |
---|
| 23 | * Oliver Scheuss, (C) 2008 |
---|
| 24 | * Co-authors: |
---|
| 25 | * ... |
---|
| 26 | * |
---|
| 27 | */ |
---|
[1701] | 28 | |
---|
[1711] | 29 | |
---|
[1760] | 30 | #include "Packet.h" |
---|
| 31 | |
---|
| 32 | #include <cassert> |
---|
[1701] | 33 | #include <enet/enet.h> |
---|
| 34 | |
---|
| 35 | #include "network/ClientInformation.h" |
---|
| 36 | |
---|
| 37 | #include "Acknowledgement.h" |
---|
[3084] | 38 | #include "DeleteObjects.h" |
---|
[1701] | 39 | #include "Chat.h" |
---|
| 40 | #include "ClassID.h" |
---|
[3084] | 41 | #include "FunctionCalls.h" |
---|
| 42 | #include "FunctionIDs.h" |
---|
[1709] | 43 | #include "Gamestate.h" |
---|
[1711] | 44 | #include "Welcome.h" |
---|
[1701] | 45 | #include "network/Host.h" |
---|
[1705] | 46 | #include "core/CoreIncludes.h" |
---|
[1701] | 47 | |
---|
[2171] | 48 | namespace orxonox{ |
---|
[1701] | 49 | |
---|
| 50 | namespace packet{ |
---|
[2087] | 51 | |
---|
[1711] | 52 | #define PACKET_FLAG_DEFAULT ENET_PACKET_FLAG_NO_ALLOCATE |
---|
[1701] | 53 | #define _PACKETID 0 |
---|
[2087] | 54 | |
---|
[2171] | 55 | std::map<size_t, Packet *> Packet::packetMap_; |
---|
[2087] | 56 | |
---|
[1701] | 57 | Packet::Packet(){ |
---|
[1711] | 58 | flags_ = PACKET_FLAG_DEFAULT; |
---|
[1701] | 59 | packetDirection_ = ENUM::Outgoing; |
---|
| 60 | clientID_=0; |
---|
[1711] | 61 | data_=0; |
---|
[1701] | 62 | enetPacket_=0; |
---|
[2087] | 63 | bDataENetAllocated_ = false; |
---|
[1701] | 64 | } |
---|
| 65 | |
---|
[1712] | 66 | void blub(ENetPacket *packet){ |
---|
[1713] | 67 | COUT(4) << "blubb" << std::endl; |
---|
[1712] | 68 | } |
---|
| 69 | |
---|
[1907] | 70 | Packet::Packet(uint8_t *data, unsigned int clientID){ |
---|
[1711] | 71 | flags_ = PACKET_FLAG_DEFAULT; |
---|
[1713] | 72 | packetDirection_ = ENUM::Incoming; |
---|
[1711] | 73 | clientID_=clientID; |
---|
| 74 | data_=data; |
---|
[1701] | 75 | enetPacket_=0; |
---|
[2087] | 76 | bDataENetAllocated_ = false; |
---|
[1701] | 77 | } |
---|
| 78 | |
---|
| 79 | |
---|
[1711] | 80 | Packet::Packet(const Packet &p){ |
---|
[1712] | 81 | enetPacket_=p.enetPacket_; |
---|
[1711] | 82 | flags_=p.flags_; |
---|
[1730] | 83 | packetDirection_ = p.packetDirection_; |
---|
| 84 | clientID_ = p.clientID_; |
---|
[1711] | 85 | if(p.data_){ |
---|
[1907] | 86 | data_ = new uint8_t[p.getSize()]; |
---|
[1711] | 87 | memcpy(data_, p.data_, p.getSize()); |
---|
| 88 | }else |
---|
| 89 | data_=0; |
---|
[2087] | 90 | bDataENetAllocated_ = p.bDataENetAllocated_; |
---|
[1701] | 91 | } |
---|
| 92 | |
---|
[2087] | 93 | /** |
---|
| 94 | @brief |
---|
| 95 | Destroys a packet completely. |
---|
| 96 | |
---|
| 97 | That also means destroying the ENetPacket if one exists. There |
---|
| 98 | */ |
---|
[1711] | 99 | Packet::~Packet(){ |
---|
[2087] | 100 | // Deallocate data_ memory if necessary. |
---|
| 101 | if (this->bDataENetAllocated_){ |
---|
| 102 | // In this case ENet allocated data_ and will destroy it. |
---|
| 103 | } |
---|
| 104 | else if (this->data_) { |
---|
| 105 | // This destructor was probably called as a consequence to ENet executing our callback. |
---|
| 106 | // It simply serves us to be able to deallocate the packet content (data_) ourselves since |
---|
| 107 | // we have created it in the first place. |
---|
| 108 | delete[] this->data_; |
---|
| 109 | } |
---|
| 110 | |
---|
| 111 | // Destroy the ENetPacket if necessary. |
---|
| 112 | // Note: For the case ENet used the callback to destroy the packet, we have already set |
---|
| 113 | // enetPacket_ to NULL to avoid destroying it again. |
---|
| 114 | if (this->enetPacket_){ |
---|
| 115 | // enetPacket_->data gets destroyed too by ENet if it was allocated by it. |
---|
[1705] | 116 | enet_packet_destroy(enetPacket_); |
---|
[1751] | 117 | } |
---|
[1705] | 118 | } |
---|
[1701] | 119 | |
---|
| 120 | bool Packet::send(){ |
---|
[1730] | 121 | if(packetDirection_ != ENUM::Outgoing && packetDirection_ != ENUM::Bidirectional ){ |
---|
[1712] | 122 | assert(0); |
---|
[1701] | 123 | return false; |
---|
[1730] | 124 | } |
---|
[1701] | 125 | if(!enetPacket_){ |
---|
[1712] | 126 | if(!data_){ |
---|
| 127 | assert(0); |
---|
[1701] | 128 | return false; |
---|
[1712] | 129 | } |
---|
[2087] | 130 | // We deliver ENet the data address so that it doesn't memcpy everything again. |
---|
| 131 | // --> We have to delete data_ ourselves! |
---|
[1711] | 132 | enetPacket_ = enet_packet_create(getData(), getSize(), getFlags()); |
---|
[1751] | 133 | enetPacket_->freeCallback = &Packet::deletePacket; |
---|
[2087] | 134 | // Add the packet to a global list so we can access it again once enet calls our |
---|
| 135 | // deletePacket method. We can of course only give a one argument function to the ENet C library. |
---|
[2662] | 136 | { |
---|
| 137 | // Assures we don't create a packet and destroy it right after in another thread |
---|
| 138 | // without having a reference in the packetMap_ |
---|
| 139 | packetMap_[(size_t)(void*)enetPacket_] = this; |
---|
| 140 | } |
---|
[1701] | 141 | } |
---|
[2087] | 142 | #ifndef NDEBUG |
---|
[1751] | 143 | switch( *(ENUM::Type *)(data_ + _PACKETID) ) |
---|
[1715] | 144 | { |
---|
| 145 | case ENUM::Acknowledgement: |
---|
| 146 | case ENUM::Chat: |
---|
| 147 | case ENUM::ClassID: |
---|
| 148 | case ENUM::Gamestate: |
---|
| 149 | case ENUM::Welcome: |
---|
[1907] | 150 | case ENUM::DeleteObjects: |
---|
[3084] | 151 | case ENUM::FunctionIDs: |
---|
| 152 | case ENUM::FunctionCalls: |
---|
[1751] | 153 | break; |
---|
[1715] | 154 | default: |
---|
[1751] | 155 | assert(0); //there was some error, if this is the case |
---|
[1715] | 156 | break; |
---|
[1751] | 157 | } |
---|
| 158 | #endif |
---|
[2087] | 159 | // ENetPacket *temp = enetPacket_; |
---|
| 160 | // enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet |
---|
[3097] | 161 | if(!Host::addPacket( enetPacket_, clientID_)) |
---|
| 162 | enet_packet_destroy(this->enetPacket_); // if we could not add the packet to the enet queue delete it manually |
---|
[1701] | 163 | return true; |
---|
| 164 | } |
---|
| 165 | |
---|
[1711] | 166 | Packet *Packet::createPacket(ENetPacket *packet, ENetPeer *peer){ |
---|
[1907] | 167 | uint8_t *data = packet->data; |
---|
[2087] | 168 | assert(ClientInformation::findClient(&peer->address)->getID() != (unsigned int)-2 || !Host::isServer()); |
---|
[1711] | 169 | unsigned int clientID = ClientInformation::findClient(&peer->address)->getID(); |
---|
[2710] | 170 | Packet *p = 0; |
---|
[3084] | 171 | COUT(6) << "packet type: " << *(ENUM::Type *)&data[_PACKETID] << std::endl; |
---|
[1715] | 172 | switch( *(ENUM::Type *)(data + _PACKETID) ) |
---|
[1701] | 173 | { |
---|
| 174 | case ENUM::Acknowledgement: |
---|
[3084] | 175 | COUT(5) << "ack" << std::endl; |
---|
[1711] | 176 | p = new Acknowledgement( data, clientID ); |
---|
[1701] | 177 | break; |
---|
| 178 | case ENUM::Chat: |
---|
[3084] | 179 | COUT(5) << "chat" << std::endl; |
---|
[1711] | 180 | p = new Chat( data, clientID ); |
---|
[1701] | 181 | break; |
---|
| 182 | case ENUM::ClassID: |
---|
[3084] | 183 | COUT(5) << "classid" << std::endl; |
---|
[1711] | 184 | p = new ClassID( data, clientID ); |
---|
[1701] | 185 | break; |
---|
| 186 | case ENUM::Gamestate: |
---|
[3084] | 187 | COUT(5) << "gamestate" << std::endl; |
---|
[1701] | 188 | // TODO: remove brackets |
---|
[1715] | 189 | p = new Gamestate( data, clientID ); |
---|
[1701] | 190 | break; |
---|
[1711] | 191 | case ENUM::Welcome: |
---|
[3084] | 192 | COUT(5) << "welcome" << std::endl; |
---|
[1711] | 193 | p = new Welcome( data, clientID ); |
---|
[1715] | 194 | break; |
---|
[1907] | 195 | case ENUM::DeleteObjects: |
---|
[3084] | 196 | COUT(5) << "deleteobjects" << std::endl; |
---|
[1907] | 197 | p = new DeleteObjects( data, clientID ); |
---|
| 198 | break; |
---|
[3084] | 199 | case ENUM::FunctionCalls: |
---|
| 200 | COUT(5) << "functionCalls" << std::endl; |
---|
| 201 | p = new FunctionCalls( data, clientID ); |
---|
| 202 | break; |
---|
| 203 | case ENUM::FunctionIDs: |
---|
| 204 | COUT(5) << "functionIDs" << std::endl; |
---|
| 205 | p = new FunctionIDs( data, clientID ); |
---|
| 206 | break; |
---|
[1701] | 207 | default: |
---|
[1710] | 208 | assert(0); //TODO: repair this |
---|
| 209 | break; |
---|
[1701] | 210 | } |
---|
[2087] | 211 | |
---|
| 212 | // Data was created by ENet |
---|
| 213 | p->bDataENetAllocated_ = true; |
---|
[3208] | 214 | p->enetPacket_ = packet; |
---|
[2087] | 215 | |
---|
[1711] | 216 | return p; |
---|
[1701] | 217 | } |
---|
| 218 | |
---|
[2087] | 219 | /** |
---|
| 220 | @brief |
---|
| 221 | ENet calls this method whenever it wants to destroy a packet that contains |
---|
| 222 | data we allocated ourselves. |
---|
| 223 | */ |
---|
| 224 | void Packet::deletePacket(ENetPacket *enetPacket){ |
---|
| 225 | // Get our Packet from a gloabal map with all Packets created in the send() method of Packet. |
---|
[2171] | 226 | std::map<size_t, Packet*>::iterator it = packetMap_.find((size_t)enetPacket); |
---|
[2087] | 227 | assert(it != packetMap_.end()); |
---|
| 228 | // Make sure we don't delete it again in the destructor |
---|
| 229 | it->second->enetPacket_ = 0; |
---|
| 230 | delete it->second; |
---|
[2171] | 231 | packetMap_.erase(it); |
---|
[3208] | 232 | COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl; |
---|
[1711] | 233 | } |
---|
| 234 | |
---|
[1701] | 235 | } // namespace packet |
---|
| 236 | |
---|
[2171] | 237 | } // namespace orxonox |
---|
[1701] | 238 | |
---|