src/network/networkpacket.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "networkpacket.h"
  22 #include "debug.h"
  23 #include "util/serialize.h"
  24
  25 NetworkPacket::NetworkPacket(u8 *data, u32 datasize, u16 peer_id):
  26 m_peer_id(peer_id)
  27 {
  28         m_read_offset = 0;
  29         m_datasize = datasize - 2;
  30
  31         // Copy data packet to remove opcode
  32         m_data = new u8[m_datasize];
  33
  34         memcpy(m_data, &data[2], m_datasize);
  35 }
  36
  37 NetworkPacket::~NetworkPacket()
  38 {
  39         delete [] m_data;
  40 }
  41
  42 char* NetworkPacket::getString(u32 from_offset)
  43 {
  44         assert(from_offset < m_datasize);
  45
  46         return (char*)&m_data[from_offset];
  47 }
  48
  49 char NetworkPacket::getChar(u32 offset)
  50 {
  51         assert(offset < m_datasize);
  52
  53         return m_data[offset];
  54 }
  55
  56 NetworkPacket& NetworkPacket::operator>>(std::string& dst)
  57 {
  58         u16 strLen = readU16(&m_data[m_read_offset]);
  59         m_read_offset += sizeof(u16);
  60
  61         dst.clear();
  62
  63         if (strLen == 0) {
  64                 return *this;
  65         }
  66
  67
  68         dst.reserve(strLen);
  69         dst.append((char*)&m_data[m_read_offset], strLen);
  70
  71         m_read_offset += strLen*sizeof(char);
  72         return *this;
  73 }
  74
  75 NetworkPacket& NetworkPacket::operator>>(std::wstring& dst)
  76 {
  77         u16 strLen = readU16(&m_data[m_read_offset]);
  78         m_read_offset += sizeof(u16);
  79
  80         dst.clear();
  81
  82         if (strLen == 0) {
  83                 return *this;
  84         }
  85
  86         dst.reserve(strLen);
  87         for(u16 i=0; i<strLen; i++) {
  88                 wchar_t c16 = readU16(&m_data[m_read_offset]);
  89                 dst.append(&c16, 1);
  90                 m_read_offset += sizeof(u16);
  91         }
  92
  93         return *this;
  94 }
  95
  96 std::string NetworkPacket::readLongString()
  97 {
  98         u32 strLen = readU32(&m_data[m_read_offset]);
  99         m_read_offset += sizeof(u32);
 100
 101         if (strLen == 0) {
 102                 return "";
 103         }
 104
 105         std::string dst;
 106
 107         dst.reserve(strLen);
 108         dst.append((char*)&m_data[m_read_offset], strLen);
 109
 110         m_read_offset += strLen*sizeof(char);
 111
 112         return dst;
 113 }
 114
 115 NetworkPacket& NetworkPacket::operator>>(char& dst)
 116 {
 117         dst = getChar(m_read_offset);
 118
 119         m_read_offset += sizeof(char);
 120         return *this;
 121 }
 122
 123 u8* NetworkPacket::getU8Ptr(u32 from_offset)
 124 {
 125         assert(from_offset < m_datasize);
 126
 127         return (u8*)&m_data[from_offset];
 128 }
 129
 130 u8 NetworkPacket::getU8(u32 offset)
 131 {
 132         assert(offset < m_datasize);
 133
 134         return m_data[offset];
 135 }
 136
 137 NetworkPacket& NetworkPacket::operator>>(u8& dst)
 138 {
 139         assert(m_read_offset < m_datasize);
 140         dst = m_data[m_read_offset];
 141
 142         m_read_offset += sizeof(u8);
 143         return *this;
 144 }
 145
 146 NetworkPacket& NetworkPacket::operator>>(bool& dst)
 147 {
 148         assert(m_read_offset < m_datasize);
 149         dst = m_data[m_read_offset];
 150
 151         m_read_offset += sizeof(u8);
 152         return *this;
 153 }
 154
 155 u16 NetworkPacket::getU16(u32 from_offset)
 156 {
 157         assert(from_offset < m_datasize);
 158
 159         return readU16(&m_data[from_offset]);
 160 }
 161
 162 NetworkPacket& NetworkPacket::operator>>(u16& dst)
 163 {
 164         dst = getU16(m_read_offset);
 165
 166         m_read_offset += sizeof(u16);
 167         return *this;
 168 }
 169
 170 u32 NetworkPacket::getU32(u32 from_offset)
 171 {
 172         assert(from_offset < m_datasize);
 173
 174         return readU32(&m_data[from_offset]);
 175 }
 176
 177 NetworkPacket& NetworkPacket::operator>>(u32& dst)
 178 {
 179         dst = getU32(m_read_offset);
 180
 181         m_read_offset += sizeof(u32);
 182         return *this;
 183 }
 184
 185 u64 NetworkPacket::getU64(u32 from_offset)
 186 {
 187         assert(from_offset < m_datasize);
 188
 189         return readU64(&m_data[from_offset]);
 190 }
 191
 192 NetworkPacket& NetworkPacket::operator>>(u64& dst)
 193 {
 194         dst = getU64(m_read_offset);
 195
 196         m_read_offset += sizeof(u64);
 197         return *this;
 198 }
 199
 200 float NetworkPacket::getF1000(u32 from_offset)
 201 {
 202         assert(from_offset < m_datasize);
 203
 204         return readF1000(&m_data[from_offset]);
 205 }
 206
 207 NetworkPacket& NetworkPacket::operator>>(float& dst)
 208 {
 209         dst = getF1000(m_read_offset);
 210
 211         m_read_offset += sizeof(float);
 212         return *this;
 213 }
 214
 215 NetworkPacket& NetworkPacket::operator>>(v2f& dst)
 216 {
 217         assert(m_read_offset < m_datasize);
 218
 219         dst = readV2F1000(&m_data[m_read_offset]);
 220
 221         m_read_offset += sizeof(v2f);
 222         return *this;
 223 }
 224
 225 NetworkPacket& NetworkPacket::operator>>(v3f& dst)
 226 {
 227         assert(m_read_offset < m_datasize);
 228
 229         dst = readV3F1000(&m_data[m_read_offset]);
 230
 231         m_read_offset += sizeof(v3f);
 232         return *this;
 233 }
 234
 235 s16 NetworkPacket::getS16(u32 from_offset)
 236 {
 237         assert(from_offset < m_datasize);
 238
 239         return readS16(&m_data[from_offset]);
 240 }
 241
 242 NetworkPacket& NetworkPacket::operator>>(s16& dst)
 243 {
 244         dst = getS16(m_read_offset);
 245
 246         m_read_offset += sizeof(s16);
 247         return *this;
 248 }
 249
 250 s32 NetworkPacket::getS32(u32 from_offset)
 251 {
 252         assert(from_offset < m_datasize);
 253
 254         return readS32(&m_data[from_offset]);
 255 }
 256
 257 NetworkPacket& NetworkPacket::operator>>(s32& dst)
 258 {
 259         dst = getS32(m_read_offset);
 260
 261         m_read_offset += sizeof(s32);
 262         return *this;
 263 }
 264
 265 NetworkPacket& NetworkPacket::operator>>(v2s32& dst)
 266 {
 267         dst = readV2S32(&m_data[m_read_offset]);
 268
 269         m_read_offset += sizeof(v2s32);
 270         return *this;
 271 }
 272
 273 v3s16 NetworkPacket::getV3S16(u32 from_offset)
 274 {
 275         assert(from_offset < m_datasize);
 276
 277         return readV3S16(&m_data[from_offset]);
 278 }
 279
 280 NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
 281 {
 282         dst = getV3S16(m_read_offset);
 283
 284         m_read_offset += sizeof(v3s16);
 285         return *this;
 286 }
 287
 288 v3s32 NetworkPacket::getV3S32(u32 from_offset)
 289 {
 290         assert(from_offset < m_datasize);
 291
 292         return readV3S32(&m_data[from_offset]);
 293 }
 294
 295 NetworkPacket& NetworkPacket::operator>>(v3s32& dst)
 296 {
 297         dst = getV3S32(m_read_offset);
 298
 299         m_read_offset += sizeof(v3s32);
 300         return *this;
 301 }