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[0], &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         u16 msgsize = src.size();
 114         if (msgsize > STRING_MAX_LEN) {
 115                 throw PacketError("String too long");
 116         }
 117
 118         *this << msgsize;
 119
 120         putRawString(src.c_str(), (u32)msgsize);
 121
 122         return *this;
 123 }
 124
 125 void NetworkPacket::putLongString(const std::string &src)
 126 {
 127         u32 msgsize = src.size();
 128         if (msgsize > LONG_STRING_MAX_LEN) {
 129                 throw PacketError("String too long");
 130         }
 131
 132         *this << msgsize;
 133
 134         putRawString(src.c_str(), msgsize);
 135 }
 136
 137 NetworkPacket& NetworkPacket::operator>>(std::wstring& dst)
 138 {
 139         checkReadOffset(m_read_offset, 2);
 140         u16 strLen = readU16(&m_data[m_read_offset]);
 141         m_read_offset += 2;
 142
 143         dst.clear();
 144
 145         if (strLen == 0) {
 146                 return *this;
 147         }
 148
 149         checkReadOffset(m_read_offset, strLen * 2);
 150
 151         dst.reserve(strLen);
 152         for(u16 i=0; i<strLen; i++) {
 153                 wchar_t c16 = readU16(&m_data[m_read_offset]);
 154                 dst.append(&c16, 1);
 155                 m_read_offset += sizeof(u16);
 156         }
 157
 158         return *this;
 159 }
 160
 161 NetworkPacket& NetworkPacket::operator<<(const std::wstring &src)
 162 {
 163         u16 msgsize = src.size();
 164         if (msgsize > WIDE_STRING_MAX_LEN) {
 165                 throw PacketError("String too long");
 166         }
 167
 168         *this << msgsize;
 169
 170         // Write string
 171         for (u16 i=0; i<msgsize; i++) {
 172                 *this << (u16) src[i];
 173         }
 174
 175         return *this;
 176 }
 177
 178 std::string NetworkPacket::readLongString()
 179 {
 180         checkReadOffset(m_read_offset, 4);
 181         u32 strLen = readU32(&m_data[m_read_offset]);
 182         m_read_offset += 4;
 183
 184         if (strLen == 0) {
 185                 return "";
 186         }
 187
 188         if (strLen > LONG_STRING_MAX_LEN) {
 189                 throw PacketError("String too long");
 190         }
 191
 192         checkReadOffset(m_read_offset, strLen);
 193
 194         std::string dst;
 195
 196         dst.reserve(strLen);
 197         dst.append((char*)&m_data[m_read_offset], strLen);
 198
 199         m_read_offset += strLen;
 200
 201         return dst;
 202 }
 203
 204 NetworkPacket& NetworkPacket::operator>>(char& dst)
 205 {
 206         checkReadOffset(m_read_offset, 1);
 207
 208         dst = readU8(&m_data[m_read_offset]);
 209
 210         m_read_offset += 1;
 211         return *this;
 212 }
 213
 214 char NetworkPacket::getChar(u32 offset)
 215 {
 216         checkReadOffset(offset, 1);
 217
 218         return readU8(&m_data[offset]);
 219 }
 220
 221 NetworkPacket& NetworkPacket::operator<<(char src)
 222 {
 223         checkDataSize(1);
 224
 225         writeU8(&m_data[m_read_offset], src);
 226
 227         m_read_offset += 1;
 228         return *this;
 229 }
 230
 231 NetworkPacket& NetworkPacket::operator<<(u8 src)
 232 {
 233         checkDataSize(1);
 234
 235         writeU8(&m_data[m_read_offset], src);
 236
 237         m_read_offset += 1;
 238         return *this;
 239 }
 240
 241 NetworkPacket& NetworkPacket::operator<<(bool src)
 242 {
 243         checkDataSize(1);
 244
 245         writeU8(&m_data[m_read_offset], src);
 246
 247         m_read_offset += 1;
 248         return *this;
 249 }
 250
 251 NetworkPacket& NetworkPacket::operator<<(u16 src)
 252 {
 253         checkDataSize(2);
 254
 255         writeU16(&m_data[m_read_offset], src);
 256
 257         m_read_offset += 2;
 258         return *this;
 259 }
 260
 261 NetworkPacket& NetworkPacket::operator<<(u32 src)
 262 {
 263         checkDataSize(4);
 264
 265         writeU32(&m_data[m_read_offset], src);
 266
 267         m_read_offset += 4;
 268         return *this;
 269 }
 270
 271 NetworkPacket& NetworkPacket::operator<<(u64 src)
 272 {
 273         checkDataSize(8);
 274
 275         writeU64(&m_data[m_read_offset], src);
 276
 277         m_read_offset += 8;
 278         return *this;
 279 }
 280
 281 NetworkPacket& NetworkPacket::operator<<(std::time_t src)
 282 {
 283         *this << (u64) src;
 284         return *this;
 285 }
 286
 287 NetworkPacket& NetworkPacket::operator<<(float src)
 288 {
 289         checkDataSize(4);
 290
 291         writeF1000(&m_data[m_read_offset], src);
 292
 293         m_read_offset += 4;
 294         return *this;
 295 }
 296
 297 NetworkPacket& NetworkPacket::operator>>(bool& dst)
 298 {
 299         checkReadOffset(m_read_offset, 1);
 300
 301         dst = readU8(&m_data[m_read_offset]);
 302
 303         m_read_offset += 1;
 304         return *this;
 305 }
 306
 307 NetworkPacket& NetworkPacket::operator>>(u8& dst)
 308 {
 309         checkReadOffset(m_read_offset, 1);
 310
 311         dst = readU8(&m_data[m_read_offset]);
 312
 313         m_read_offset += 1;
 314         return *this;
 315 }
 316
 317 u8 NetworkPacket::getU8(u32 offset)
 318 {
 319         checkReadOffset(offset, 1);
 320
 321         return readU8(&m_data[offset]);
 322 }
 323
 324 u8* NetworkPacket::getU8Ptr(u32 from_offset)
 325 {
 326         if (m_datasize == 0) {
 327                 return NULL;
 328         }
 329
 330         checkReadOffset(from_offset, 1);
 331
 332         return (u8*)&m_data[from_offset];
 333 }
 334
 335 NetworkPacket& NetworkPacket::operator>>(u16& dst)
 336 {
 337         checkReadOffset(m_read_offset, 2);
 338
 339         dst = readU16(&m_data[m_read_offset]);
 340
 341         m_read_offset += 2;
 342         return *this;
 343 }
 344
 345 u16 NetworkPacket::getU16(u32 from_offset)
 346 {
 347         checkReadOffset(from_offset, 2);
 348
 349         return readU16(&m_data[from_offset]);
 350 }
 351
 352 NetworkPacket& NetworkPacket::operator>>(u32& dst)
 353 {
 354         checkReadOffset(m_read_offset, 4);
 355
 356         dst = readU32(&m_data[m_read_offset]);
 357
 358         m_read_offset += 4;
 359         return *this;
 360 }
 361
 362 NetworkPacket& NetworkPacket::operator>>(u64& dst)
 363 {
 364         checkReadOffset(m_read_offset, 8);
 365
 366         dst = readU64(&m_data[m_read_offset]);
 367
 368         m_read_offset += 8;
 369         return *this;
 370 }
 371
 372 NetworkPacket& NetworkPacket::operator>>(std::time_t& dst)
 373 {
 374         checkReadOffset(m_read_offset, 8);
 375
 376         dst = readU64(&m_data[m_read_offset]);
 377
 378         m_read_offset += 8;
 379         return *this;
 380 }
 381
 382 NetworkPacket& NetworkPacket::operator>>(float& dst)
 383 {
 384         checkReadOffset(m_read_offset, 4);
 385
 386         dst = readF1000(&m_data[m_read_offset]);
 387
 388         m_read_offset += 4;
 389         return *this;
 390 }
 391
 392 NetworkPacket& NetworkPacket::operator>>(v2f& dst)
 393 {
 394         checkReadOffset(m_read_offset, 8);
 395
 396         dst = readV2F1000(&m_data[m_read_offset]);
 397
 398         m_read_offset += 8;
 399         return *this;
 400 }
 401
 402 NetworkPacket& NetworkPacket::operator>>(v3f& dst)
 403 {
 404         checkReadOffset(m_read_offset, 12);
 405
 406         dst = readV3F1000(&m_data[m_read_offset]);
 407
 408         m_read_offset += 12;
 409         return *this;
 410 }
 411
 412 NetworkPacket& NetworkPacket::operator>>(s16& dst)
 413 {
 414         checkReadOffset(m_read_offset, 2);
 415
 416         dst = readS16(&m_data[m_read_offset]);
 417
 418         m_read_offset += 2;
 419         return *this;
 420 }
 421
 422 NetworkPacket& NetworkPacket::operator<<(s16 src)
 423 {
 424         *this << (u16) src;
 425         return *this;
 426 }
 427
 428 NetworkPacket& NetworkPacket::operator>>(s32& dst)
 429 {
 430         checkReadOffset(m_read_offset, 4);
 431
 432         dst = readS32(&m_data[m_read_offset]);
 433
 434         m_read_offset += 4;
 435         return *this;
 436 }
 437
 438 NetworkPacket& NetworkPacket::operator<<(s32 src)
 439 {
 440         *this << (u32) src;
 441         return *this;
 442 }
 443
 444 NetworkPacket& NetworkPacket::operator>>(v3s16& dst)
 445 {
 446         checkReadOffset(m_read_offset, 6);
 447
 448         dst = readV3S16(&m_data[m_read_offset]);
 449
 450         m_read_offset += 6;
 451         return *this;
 452 }
 453
 454 NetworkPacket& NetworkPacket::operator>>(v2s32& dst)
 455 {
 456         checkReadOffset(m_read_offset, 8);
 457
 458         dst = readV2S32(&m_data[m_read_offset]);
 459
 460         m_read_offset += 8;
 461         return *this;
 462 }
 463
 464 NetworkPacket& NetworkPacket::operator>>(v3s32& dst)
 465 {
 466         checkReadOffset(m_read_offset, 12);
 467
 468         dst = readV3S32(&m_data[m_read_offset]);
 469
 470         m_read_offset += 12;
 471         return *this;
 472 }
 473
 474 NetworkPacket& NetworkPacket::operator<<(v2f src)
 475 {
 476         *this << (float) src.X;
 477         *this << (float) src.Y;
 478         return *this;
 479 }
 480
 481 NetworkPacket& NetworkPacket::operator<<(v3f src)
 482 {
 483         *this << (float) src.X;
 484         *this << (float) src.Y;
 485         *this << (float) src.Z;
 486         return *this;
 487 }
 488
 489 NetworkPacket& NetworkPacket::operator<<(v3s16 src)
 490 {
 491         *this << (s16) src.X;
 492         *this << (s16) src.Y;
 493         *this << (s16) src.Z;
 494         return *this;
 495 }
 496
 497 NetworkPacket& NetworkPacket::operator<<(v2s32 src)
 498 {
 499         *this << (s32) src.X;
 500         *this << (s32) src.Y;
 501         return *this;
 502 }
 503
 504 NetworkPacket& NetworkPacket::operator<<(v3s32 src)
 505 {
 506         *this << (s32) src.X;
 507         *this << (s32) src.Y;
 508         *this << (s32) src.Z;
 509         return *this;
 510 }
 511
 512 NetworkPacket& NetworkPacket::operator>>(video::SColor& dst)
 513 {
 514         checkReadOffset(m_read_offset, 4);
 515
 516         dst = readARGB8(&m_data[m_read_offset]);
 517
 518         m_read_offset += 4;
 519         return *this;
 520 }
 521
 522 NetworkPacket& NetworkPacket::operator<<(video::SColor src)
 523 {
 524         checkDataSize(4);
 525
 526         writeU32(&m_data[m_read_offset], src.color);
 527
 528         m_read_offset += 4;
 529         return *this;
 530 }
 531
 532 SharedBuffer<u8> NetworkPacket::oldForgePacket()
 533 {
 534         SharedBuffer<u8> sb(m_datasize + 2);
 535         writeU16(&sb[0], m_command);
 536
 537         u8* datas = getU8Ptr(0);
 538
 539         if (datas != NULL)
 540                 memcpy(&sb[2], datas, m_datasize);
 541         return sb;
 542 }