src/network/networkpacket.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2015 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "networkpacket.h"
  21 #include <sstream>
  22 #include "networkexceptions.h"
  23 #include "util/serialize.h"
  24 #include "networkprotocol.h"
  25
  26 NetworkPacket::NetworkPacket(u16 command, u32 datasize, session_t peer_id):
  27 m_datasize(datasize), m_command(command), m_peer_id(peer_id)
  28 {
  29         m_data.resize(m_datasize);
  30 }
  31
  32 NetworkPacket::NetworkPacket(u16 command, u32 datasize):
  33 m_datasize(datasize), m_command(command)
  34 {
  35         m_data.resize(m_datasize);
  36 }
  37
  38 NetworkPacket::~NetworkPacket()
  39 {
  40         m_data.clear();
  41 }
  42
  43 void NetworkPacket::checkReadOffset(u32 from_offset, u32 field_size)
  44 {
  45         if (from_offset + field_size > m_datasize) {
  46                 std::stringstream ss;
  47                 ss << "Reading outside packet (offset: " <<
  48                                 from_offset << ", packet size: " << getSize() << ")";
  49                 throw PacketError(ss.str());
  50         }
  51 }
  52
  53 void NetworkPacket::putRawPacket(u8 *data, u32 datasize, session_t peer_id)
  54 {
  55         // If a m_command is already set, we are rewriting on same packet
  56         // This is not permitted
  57         assert(m_command == 0);
  58
  59         m_datasize = datasize - 2;
  60         m_peer_id = peer_id;
  61
  62         m_data.resize(m_datasize);
  63
  64         // split command and datas
  65         m_command = readU16(&data[0]);
  66         memcpy(m_data.data(), &data[2], m_datasize);
  67 }
  68
  69 const char* NetworkPacket::getString(u32 from_offset)
  70 {
  71         checkReadOffset(from_offset, 0);
  72
  73         return (char*)&m_data[from_offset];
  74 }
  75
  76 void NetworkPacket::putRawString(const char* src, u32 len)
  77 {
  78         if (m_read_offset + len > m_datasize) {
  79                 m_datasize = m_read_offset + len;
  80                 m_data.resize(m_datasize);
  81         }
  82
  83         if (len == 0)
  84                 return;
  85
  86         memcpy(&m_data[m_read_offset], src, len);
  87         m_read_offset += len;
  88 }
  89
  90 NetworkPacket& NetworkPacket::operator>>(std::string& dst)
  91 {
  92         checkReadOffset(m_read_offset, 2);
  93         u16 strLen = readU16(&m_data[m_read_offset]);
  94         m_read_offset += 2;
  95
  96         dst.clear();
  97
  98         if (strLen == 0) {
  99                 return *this;
 100         }
 101
 102         checkReadOffset(m_read_offset, strLen);
 103
 104         dst.reserve(strLen);
 105         dst.append((char*)&m_data[m_read_offset], strLen);
 106
 107         m_read_offset += strLen;
 108         return *this;
 109 }
 110
 111 NetworkPacket& NetworkPacket::operator<<(const std::string &src)
 112 {
 113         if (src.size() > STRING_MAX_LEN) {
 114                 throw PacketError("String too long");
 115         }
 116
 117         u16 msgsize = src.size();
 118
 119         *this << msgsize;
 120
 121         putRawString(src.c_str(), (u32)msgsize);
 122
 123         return *this;
 124 }
 125
 126 void NetworkPacket::putLongString(const std::string &src)
 127 {
 128         if (src.size() > LONG_STRING_MAX_LEN) {
 129                 throw PacketError("String too long");
 130         }
 131
 132         u32 msgsize = src.size();
 133
 134         *this << msgsize;
 135
 136         putRawString(src.c_str(), msgsize);
 137 }
 138
 139 NetworkPacket& NetworkPacket::operator>>(std::wstring& dst)
 140 {
 141         checkReadOffset(m_read_offset, 2);
 142         u16 strLen = readU16(&m_data[m_read_offset]);
 143         m_read_offset += 2;
 144
 145         dst.clear();
 146
 147         if (strLen == 0) {
 148                 return *this;
 149         }
 150
 151         checkReadOffset(m_read_offset, strLen * 2);
 152
 153         dst.reserve(strLen);
 154         for(u16 i=0; i<strLen; i++) {
 155                 wchar_t c16 = readU16(&m_data[m_read_offset]);
 156                 dst.append(&c16, 1);
 157                 m_read_offset += sizeof(u16);
 158         }
 159
 160         return *this;
 161 }
 162
 163 NetworkPacket& NetworkPacket::operator<<(const std::wstring &src)
 164 {
 165         if (src.size() > WIDE_STRING_MAX_LEN) {
 166                 throw PacketError("String too long");
 167         }
 168
 169         u16 msgsize = src.size();
 170
 171         *this << msgsize;
 172
 173         // Write string
 174         for (u16 i=0; i<msgsize; i++) {
 175                 *this << (u16) src[i];
 176         }
 177
 178         return *this;
 179 }
 180
 181 std::string NetworkPacket::readLongString()
 182 {
 183         checkReadOffset(m_read_offset, 4);
 184         u32 strLen = readU32(&m_data[m_read_offset]);
 185         m_read_offset += 4;
 186
 187         if (strLen == 0) {
 188                 return "";
 189         }
 190
 191         if (strLen > LONG_STRING_MAX_LEN) {
 192                 throw PacketError("String too long");
 193         }
 194
 195         checkReadOffset(m_read_offset, strLen);
 196
 197         std::string dst;
 198
 199         dst.reserve(strLen);
 200         dst.append((char*)&m_data[m_read_offset], strLen);
 201
 202         m_read_offset += strLen;
 203
 204         return dst;
 205 }
 206
 207 NetworkPacket& NetworkPacket::operator>>(char& dst)
 208 {
 209         checkReadOffset(m_read_offset, 1);
 210
 211         dst = readU8(&m_data[m_read_offset]);
 212
 213         m_read_offset += 1;
 214         return *this;
 215 }
 216
 217 char NetworkPacket::getChar(u32 offset)
 218 {
 219         checkReadOffset(offset, 1);
 220
 221         return readU8(&m_data[offset]);
 222 }
 223
 224 NetworkPacket& NetworkPacket::operator<<(char src)
 225 {
 226         checkDataSize(1);
 227
 228         writeU8(&m_data[m_read_offset], src);
 229
 230         m_read_offset += 1;
 231         return *this;
 232 }
 233
 234 NetworkPacket& NetworkPacket::operator<<(u8 src)
 235 {
 236         checkDataSize(1);
 237
 238         writeU8(&m_data[m_read_offset], src);
 239
 240         m_read_offset += 1;
 241         return *this;
 242 }
 243
 244 NetworkPacket& NetworkPacket::operator<<(bool src)
 245 {
 246         checkDataSize(1);
 247
 248         writeU8(&m_data[m_read_offset], src);
 249
 250         m_read_offset += 1;
 251         return *this;
 252 }
 253
 254 NetworkPacket& NetworkPacket::operator<<(u16 src)
 255 {
 256         checkDataSize(2);
 257
 258         writeU16(&m_data[m_read_offset], src);
 259
 260         m_read_offset += 2;
 261         return *this;
 262 }
 263
 264 NetworkPacket& NetworkPacket::operator<<(u32 src)
 265 {
 266         checkDataSize(4);
 267
 268         writeU32(&m_data[m_read_offset], src);
 269
 270         m_read_offset += 4;
 271         return *this;
 272 }
 273
 274 NetworkPacket& NetworkPacket::operator<<(u64 src)
 275 {
 276         checkDataSize(8);
 277
 278         writeU64(&m_data[m_read_offset], src);
 279
 280         m_read_offset += 8;
 281         return *this;
 282 }
 283
 284 NetworkPacket& NetworkPacket::operator<<(float src)
 285 {
 286         checkDataSize(4);
 287
 288         writeF32(&m_data[m_read_offset], src);
 289
 290         m_read_offset += 4;
 291         return *this;
 292 }
 293
 294 NetworkPacket& NetworkPacket::operator>>(bool& dst)
 295 {
 296         checkReadOffset(m_read_offset, 1);
 297
 298         dst = readU8(&m_data[m_read_offset]);
 299
 300         m_read_offset += 1;
 301         return *this;
 302 }
 303
 304 NetworkPacket& NetworkPacket::operator>>(u8& dst)
 305 {
 306         checkReadOffset(m_read_offset, 1);
 307
 308         dst = readU8(&m_data[m_read_offset]);
 309
 310         m_read_offset += 1;
 311         return *this;
 312 }
 313
 314 u8 NetworkPacket::getU8(u32 offset)
 315 {
 316         checkReadOffset(offset, 1);
 317
 318         return readU8(&m_data[offset]);
 319 }
 320
 321 u8* NetworkPacket::getU8Ptr(u32 from_offset)
 322 {
 323         if (m_datasize == 0) {
 324                 return NULL;
 325         }
 326
 327         checkReadOffset(from_offset, 1);
 328
 329         return (u8*)&m_data[from_offset];
 330 }
 331
 332 NetworkPacket& NetworkPacket::operator>>(u16& dst)
 333 {
 334         checkReadOffset(m_read_offset, 2);
 335
 336         dst = readU16(&m_data[m_read_offset]);
 337
 338         m_read_offset += 2;
 339         return *this;
 340 }
 341
 342 u16 NetworkPacket::getU16(u32 from_offset)
 343 {
 344         checkReadOffset(from_offset, 2);
 345
 346         return readU16(&m_data[from_offset]);
 347 }
 348
 349 NetworkPacket& NetworkPacket::operator>>(u32& dst)
 350 {
 351         checkReadOffset(m_read_offset, 4);
 352
 353         dst = readU32(&m_data[m_read_offset]);
 354
 355         m_read_offset += 4;
 356         return *this;
 357 }
 358
 359 NetworkPacket& NetworkPacket::operator>>(u64& dst)
 360 {
 361         checkReadOffset(m_read_offset, 8);
 362
 363         dst = readU64(&m_data[m_read_offset]);
 364
 365         m_read_offset += 8;
 366         return *this;
 367 }
 368
 369 NetworkPacket& NetworkPacket::operator>>(float& dst)
 370 {
 371         checkReadOffset(m_read_offset, 4);
 372
 373         dst = readF32(&m_data[m_read_offset]);
 374
 375         m_read_offset += 4;
 376         return *this;
 377 }
 378
 379 NetworkPacket& NetworkPacket::operator>>(v2f& dst)
 380 {
 381         checkReadOffset(m_read_offset, 8);
 382
 383         dst = readV2F32(&m_data[m_read_offset]);
 384
 385         m_read_offset += 8;
 386         return *this;
 387 }
 388
 389 NetworkPacket& NetworkPacket::operator>>(v3f& dst)
 390 {
 391         checkReadOffset(m_read_offset, 12);
 392
 393         dst = readV3F32(&m_data[m_read_offset]);
 394
 395         m_read_offset += 12;
 396         return *this;
 397 }
 398
 399 NetworkPacket& NetworkPacket::operator>>(s16& dst)
 400 {
 401         checkReadOffset(m_read_offset, 2);
 402
 403         dst = readS16(&m_data[m_read_offset]);
 404
 405         m_read_offset += 2;
 406         return *this;
 407 }
 408
 409 NetworkPacket& NetworkPacket::operator<<(s16 src)
 410 {
 411         *this << (u16) src;
 412         return *this;
 413 }
 414
 415 NetworkPacket& NetworkPacket::operator>>(s32& dst)
 416 {
 417         checkReadOffset(m_read_offset, 4);
 418
 419         dst = readS32(&m_data[m_read_offset]);
 420
 421         m_read_offset += 4;
 422         return *this;
 423 }
 424
 425 NetworkPacket& NetworkPacket::operator<<(s32 src)
 426 {
 427         *this << (u32) src;
 428         return *this;
 429 }
 430
 431 NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
 432 {
 433         checkReadOffset(m_read_offset, 6);
 434
 435         dst = readV3S16(&m_data[m_read_offset]);
 436
 437         m_read_offset += 6;
 438         return *this;
 439 }
 440
 441 NetworkPacket& NetworkPacket::operator>>(v2s32& dst)
 442 {
 443         checkReadOffset(m_read_offset, 8);
 444
 445         dst = readV2S32(&m_data[m_read_offset]);
 446
 447         m_read_offset += 8;
 448         return *this;
 449 }
 450
 451 NetworkPacket& NetworkPacket::operator>>(v3s32& dst)
 452 {
 453         checkReadOffset(m_read_offset, 12);
 454
 455         dst = readV3S32(&m_data[m_read_offset]);
 456
 457         m_read_offset += 12;
 458         return *this;
 459 }
 460
 461 NetworkPacket& NetworkPacket::operator<<(v2f src)
 462 {
 463         *this << (float) src.X;
 464         *this << (float) src.Y;
 465         return *this;
 466 }
 467
 468 NetworkPacket& NetworkPacket::operator<<(v3f src)
 469 {
 470         *this << (float) src.X;
 471         *this << (float) src.Y;
 472         *this << (float) src.Z;
 473         return *this;
 474 }
 475
 476 NetworkPacket& NetworkPacket::operator<<(v3s16 src)
 477 {
 478         *this << (s16) src.X;
 479         *this << (s16) src.Y;
 480         *this << (s16) src.Z;
 481         return *this;
 482 }
 483
 484 NetworkPacket& NetworkPacket::operator<<(v2s32 src)
 485 {
 486         *this << (s32) src.X;
 487         *this << (s32) src.Y;
 488         return *this;
 489 }
 490
 491 NetworkPacket& NetworkPacket::operator<<(v3s32 src)
 492 {
 493         *this << (s32) src.X;
 494         *this << (s32) src.Y;
 495         *this << (s32) src.Z;
 496         return *this;
 497 }
 498
 499 NetworkPacket& NetworkPacket::operator>>(video::SColor& dst)
 500 {
 501         checkReadOffset(m_read_offset, 4);
 502
 503         dst = readARGB8(&m_data[m_read_offset]);
 504
 505         m_read_offset += 4;
 506         return *this;
 507 }
 508
 509 NetworkPacket& NetworkPacket::operator<<(video::SColor src)
 510 {
 511         checkDataSize(4);
 512
 513         writeU32(&m_data[m_read_offset], src.color);
 514
 515         m_read_offset += 4;
 516         return *this;
 517 }
 518
 519 SharedBuffer<u8> NetworkPacket::oldForgePacket()
 520 {
 521         SharedBuffer<u8> sb(m_datasize + 2);
 522         writeU16(&sb[0], m_command);
 523
 524         u8* datas = getU8Ptr(0);
 525
 526         if (datas != NULL)
 527                 memcpy(&sb[2], datas, m_datasize);
 528         return sb;
 529 }