src/network/clientpackethandler.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 "client.h"
  21
  22 #include "util/base64.h"
  23 #include "clientmedia.h"
  24 #include "log.h"
  25 #include "map.h"
  26 #include "mapsector.h"
  27 #include "minimap.h"
  28 #include "nodedef.h"
  29 #include "serialization.h"
  30 #include "server.h"
  31 #include "strfnd.h"
  32 #include "network/clientopcodes.h"
  33 #include "util/serialize.h"
  34 #include "util/srp.h"
  35
  36 void Client::handleCommand_Deprecated(NetworkPacket* pkt)
  37 {
  38         infostream << "Got deprecated command "
  39                         << toClientCommandTable[pkt->getCommand()].name << " from peer "
  40                         << pkt->getPeerId() << "!" << std::endl;
  41 }
  42
  43 void Client::handleCommand_Hello(NetworkPacket* pkt)
  44 {
  45         if (pkt->getSize() < 1)
  46                 return;
  47
  48         u8 serialization_ver;
  49         u16 proto_ver;
  50         u16 compression_mode;
  51         u32 auth_mechs;
  52         std::string username_legacy; // for case insensitivity
  53         *pkt >> serialization_ver >> compression_mode >> proto_ver
  54                 >> auth_mechs >> username_legacy;
  55
  56         // Chose an auth method we support
  57         AuthMechanism chosen_auth_mechanism = choseAuthMech(auth_mechs);
  58
  59         infostream << "Client: TOCLIENT_HELLO received with "
  60                         << "serialization_ver=" << (u32)serialization_ver
  61                         << ", auth_mechs=" << auth_mechs
  62                         << ", proto_ver=" << proto_ver
  63                         << ", compression_mode=" << compression_mode
  64                         << ". Doing auth with mech " << chosen_auth_mechanism << std::endl;
  65
  66         if (!ser_ver_supported(serialization_ver)) {
  67                 infostream << "Client: TOCLIENT_HELLO: Server sent "
  68                                 << "unsupported ser_fmt_ver"<< std::endl;
  69                 return;
  70         }
  71
  72         m_server_ser_ver = serialization_ver;
  73         m_proto_ver = proto_ver;
  74
  75         //TODO verify that username_legacy matches sent username, only
  76         // differs in casing (make both uppercase and compare)
  77         // This is only neccessary though when we actually want to add casing support
  78
  79         if (m_chosen_auth_mech != AUTH_MECHANISM_NONE) {
  80                 // we recieved a TOCLIENT_HELLO while auth was already going on
  81                 errorstream << "Client: TOCLIENT_HELLO while auth was already going on"
  82                         << "(chosen_mech=" << m_chosen_auth_mech << ")." << std::endl;
  83                 if ((m_chosen_auth_mech == AUTH_MECHANISM_SRP)
  84                                 || (m_chosen_auth_mech == AUTH_MECHANISM_LEGACY_PASSWORD)) {
  85                         srp_user_delete((SRPUser *) m_auth_data);
  86                         m_auth_data = 0;
  87                 }
  88         }
  89
  90         // Authenticate using that method, or abort if there wasn't any method found
  91         if (chosen_auth_mechanism != AUTH_MECHANISM_NONE) {
  92                 startAuth(chosen_auth_mechanism);
  93         } else {
  94                 m_chosen_auth_mech = AUTH_MECHANISM_NONE;
  95                 m_access_denied = true;
  96                 m_access_denied_reason = "Unknown";
  97                 m_con.Disconnect();
  98         }
  99
 100 }
 101
 102 void Client::handleCommand_AuthAccept(NetworkPacket* pkt)
 103 {
 104         deleteAuthData();
 105
 106         v3f playerpos;
 107         *pkt >> playerpos >> m_map_seed >> m_recommended_send_interval
 108                 >> m_sudo_auth_methods;
 109
 110         playerpos -= v3f(0, BS / 2, 0);
 111
 112         // Set player position
 113         Player *player = m_env.getLocalPlayer();
 114         assert(player != NULL);
 115         player->setPosition(playerpos);
 116
 117         infostream << "Client: received map seed: " << m_map_seed << std::endl;
 118         infostream << "Client: received recommended send interval "
 119                                         << m_recommended_send_interval<<std::endl;
 120
 121         // Reply to server
 122         NetworkPacket resp_pkt(TOSERVER_INIT2, 0);
 123         Send(&resp_pkt);
 124
 125         m_state = LC_Init;
 126 }
 127 void Client::handleCommand_AcceptSudoMode(NetworkPacket* pkt)
 128 {
 129         deleteAuthData();
 130
 131         m_password = m_new_password;
 132
 133         verbosestream << "Client: Recieved TOCLIENT_ACCEPT_SUDO_MODE." << std::endl;
 134
 135         // send packet to actually set the password
 136         startAuth(AUTH_MECHANISM_FIRST_SRP);
 137
 138         // reset again
 139         m_chosen_auth_mech = AUTH_MECHANISM_NONE;
 140 }
 141 void Client::handleCommand_DenySudoMode(NetworkPacket* pkt)
 142 {
 143         m_chat_queue.push(L"Password change denied. Password NOT changed.");
 144         // reset everything and be sad
 145         deleteAuthData();
 146 }
 147 void Client::handleCommand_InitLegacy(NetworkPacket* pkt)
 148 {
 149         if (pkt->getSize() < 1)
 150                 return;
 151
 152         u8 server_ser_ver;
 153         *pkt >> server_ser_ver;
 154
 155         infostream << "Client: TOCLIENT_INIT_LEGACY received with "
 156                 "server_ser_ver=" << ((int)server_ser_ver & 0xff) << std::endl;
 157
 158         if (!ser_ver_supported(server_ser_ver)) {
 159                 infostream << "Client: TOCLIENT_INIT_LEGACY: Server sent "
 160                                 << "unsupported ser_fmt_ver"<< std::endl;
 161                 return;
 162         }
 163
 164         m_server_ser_ver = server_ser_ver;
 165
 166         // We can be totally wrong with this guess
 167         // but we only need some value < 25.
 168         m_proto_ver = 24;
 169
 170         // Get player position
 171         v3s16 playerpos_s16(0, BS * 2 + BS * 20, 0);
 172         if (pkt->getSize() >= 1 + 6) {
 173                 *pkt >> playerpos_s16;
 174         }
 175         v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS / 2, 0);
 176
 177
 178         // Set player position
 179         Player *player = m_env.getLocalPlayer();
 180         assert(player != NULL);
 181         player->setPosition(playerpos_f);
 182
 183         if (pkt->getSize() >= 1 + 6 + 8) {
 184                 // Get map seed
 185                 *pkt >> m_map_seed;
 186                 infostream << "Client: received map seed: " << m_map_seed << std::endl;
 187         }
 188
 189         if (pkt->getSize() >= 1 + 6 + 8 + 4) {
 190                 *pkt >> m_recommended_send_interval;
 191                 infostream << "Client: received recommended send interval "
 192                                 << m_recommended_send_interval<<std::endl;
 193         }
 194
 195         // Reply to server
 196         NetworkPacket resp_pkt(TOSERVER_INIT2, 0);
 197         Send(&resp_pkt);
 198
 199         m_state = LC_Init;
 200 }
 201
 202 void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
 203 {
 204         // The server didn't like our password. Note, this needs
 205         // to be processed even if the serialisation format has
 206         // not been agreed yet, the same as TOCLIENT_INIT.
 207         m_access_denied = true;
 208         m_access_denied_reason = "Unknown";
 209
 210         if (pkt->getCommand() == TOCLIENT_ACCESS_DENIED) {
 211                 if (pkt->getSize() < 1)
 212                         return;
 213
 214                 u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA;
 215                 *pkt >> denyCode;
 216                 if (denyCode == SERVER_ACCESSDENIED_SHUTDOWN ||
 217                                 denyCode == SERVER_ACCESSDENIED_CRASH) {
 218                         *pkt >> m_access_denied_reason;
 219                         if (m_access_denied_reason == "") {
 220                                 m_access_denied_reason = accessDeniedStrings[denyCode];
 221                         }
 222                         u8 reconnect;
 223                         *pkt >> reconnect;
 224                         m_access_denied_reconnect = reconnect & 1;
 225                 } else if (denyCode == SERVER_ACCESSDENIED_CUSTOM_STRING) {
 226                         *pkt >> m_access_denied_reason;
 227                 } else if (denyCode < SERVER_ACCESSDENIED_MAX) {
 228                         m_access_denied_reason = accessDeniedStrings[denyCode];
 229                 } else {
 230                         // Allow us to add new error messages to the
 231                         // protocol without raising the protocol version, if we want to.
 232                         // Until then (which may be never), this is outside
 233                         // of the defined protocol.
 234                         *pkt >> m_access_denied_reason;
 235                         if (m_access_denied_reason == "") {
 236                                 m_access_denied_reason = "Unknown";
 237                         }
 238                 }
 239         }
 240         // 13/03/15 Legacy code from 0.4.12 and lesser. must stay 1 year
 241         // for compat with old clients
 242         else {
 243                 if (pkt->getSize() >= 2) {
 244                         std::wstring wide_reason;
 245                         *pkt >> wide_reason;
 246                         m_access_denied_reason = wide_to_utf8(wide_reason);
 247                 }
 248         }
 249 }
 250
 251 void Client::handleCommand_RemoveNode(NetworkPacket* pkt)
 252 {
 253         if (pkt->getSize() < 6)
 254                 return;
 255
 256         v3s16 p;
 257         *pkt >> p;
 258         removeNode(p);
 259 }
 260
 261 void Client::handleCommand_AddNode(NetworkPacket* pkt)
 262 {
 263         if (pkt->getSize() < 6 + MapNode::serializedLength(m_server_ser_ver))
 264                 return;
 265
 266         v3s16 p;
 267         *pkt >> p;
 268
 269         MapNode n;
 270         n.deSerialize(pkt->getU8Ptr(6), m_server_ser_ver);
 271
 272         bool remove_metadata = true;
 273         u32 index = 6 + MapNode::serializedLength(m_server_ser_ver);
 274         if ((pkt->getSize() >= index + 1) && pkt->getU8(index)) {
 275                 remove_metadata = false;
 276         }
 277
 278         addNode(p, n, remove_metadata);
 279 }
 280 void Client::handleCommand_BlockData(NetworkPacket* pkt)
 281 {
 282         // Ignore too small packet
 283         if (pkt->getSize() < 6)
 284                 return;
 285
 286         v3s16 p;
 287         *pkt >> p;
 288
 289         std::string datastring(pkt->getString(6), pkt->getSize() - 6);
 290         std::istringstream istr(datastring, std::ios_base::binary);
 291
 292         MapSector *sector;
 293         MapBlock *block;
 294
 295         v2s16 p2d(p.X, p.Z);
 296         sector = m_env.getMap().emergeSector(p2d);
 297
 298         assert(sector->getPos() == p2d);
 299
 300         block = sector->getBlockNoCreateNoEx(p.Y);
 301         if (block) {
 302                 /*
 303                         Update an existing block
 304                 */
 305                 block->deSerialize(istr, m_server_ser_ver, false);
 306                 block->deSerializeNetworkSpecific(istr);
 307         }
 308         else {
 309                 /*
 310                         Create a new block
 311                 */
 312                 block = new MapBlock(&m_env.getMap(), p, this);
 313                 block->deSerialize(istr, m_server_ser_ver, false);
 314                 block->deSerializeNetworkSpecific(istr);
 315                 sector->insertBlock(block);
 316         }
 317
 318         if (m_localdb) {
 319                 ServerMap::saveBlock(block, m_localdb);
 320         }
 321
 322         /*
 323                 Add it to mesh update queue and set it to be acknowledged after update.
 324         */
 325         addUpdateMeshTaskWithEdge(p, true);
 326 }
 327
 328 void Client::handleCommand_Inventory(NetworkPacket* pkt)
 329 {
 330         if (pkt->getSize() < 1)
 331                 return;
 332
 333         std::string datastring(pkt->getString(0), pkt->getSize());
 334         std::istringstream is(datastring, std::ios_base::binary);
 335
 336         Player *player = m_env.getLocalPlayer();
 337         assert(player != NULL);
 338
 339         player->inventory.deSerialize(is);
 340
 341         m_inventory_updated = true;
 342
 343         delete m_inventory_from_server;
 344         m_inventory_from_server = new Inventory(player->inventory);
 345         m_inventory_from_server_age = 0.0;
 346 }
 347
 348 void Client::handleCommand_TimeOfDay(NetworkPacket* pkt)
 349 {
 350         if (pkt->getSize() < 2)
 351                 return;
 352
 353         u16 time_of_day;
 354
 355         *pkt >> time_of_day;
 356
 357         time_of_day      = time_of_day % 24000;
 358         float time_speed = 0;
 359
 360         if (pkt->getSize() >= 2 + 4) {
 361                 *pkt >> time_speed;
 362         }
 363         else {
 364                 // Old message; try to approximate speed of time by ourselves
 365                 float time_of_day_f = (float)time_of_day / 24000.0;
 366                 float tod_diff_f = 0;
 367
 368                 if (time_of_day_f < 0.2 && m_last_time_of_day_f > 0.8)
 369                         tod_diff_f = time_of_day_f - m_last_time_of_day_f + 1.0;
 370                 else
 371                         tod_diff_f = time_of_day_f - m_last_time_of_day_f;
 372
 373                 m_last_time_of_day_f       = time_of_day_f;
 374                 float time_diff            = m_time_of_day_update_timer;
 375                 m_time_of_day_update_timer = 0;
 376
 377                 if (m_time_of_day_set) {
 378                         time_speed = (3600.0 * 24.0) * tod_diff_f / time_diff;
 379                         infostream << "Client: Measured time_of_day speed (old format): "
 380                                         << time_speed << " tod_diff_f=" << tod_diff_f
 381                                         << " time_diff=" << time_diff << std::endl;
 382                 }
 383         }
 384
 385         // Update environment
 386         m_env.setTimeOfDay(time_of_day);
 387         m_env.setTimeOfDaySpeed(time_speed);
 388         m_time_of_day_set = true;
 389
 390         u32 dr = m_env.getDayNightRatio();
 391         infostream << "Client: time_of_day=" << time_of_day
 392                         << " time_speed=" << time_speed
 393                         << " dr=" << dr << std::endl;
 394 }
 395
 396 void Client::handleCommand_ChatMessage(NetworkPacket* pkt)
 397 {
 398         /*
 399                 u16 command
 400                 u16 length
 401                 wstring message
 402         */
 403         u16 len, read_wchar;
 404
 405         *pkt >> len;
 406
 407         std::wstring message;
 408         for (u32 i = 0; i < len; i++) {
 409                 *pkt >> read_wchar;
 410                 message += (wchar_t)read_wchar;
 411         }
 412
 413         m_chat_queue.push(message);
 414 }
 415
 416 void Client::handleCommand_ActiveObjectRemoveAdd(NetworkPacket* pkt)
 417 {
 418         /*
 419                 u16 count of removed objects
 420                 for all removed objects {
 421                         u16 id
 422                 }
 423                 u16 count of added objects
 424                 for all added objects {
 425                         u16 id
 426                         u8 type
 427                         u32 initialization data length
 428                         string initialization data
 429                 }
 430         */
 431
 432         try {
 433                 u8 type;
 434                 u16 removed_count, added_count, id;
 435
 436                 // Read removed objects
 437                 *pkt >> removed_count;
 438
 439                 for (u16 i = 0; i < removed_count; i++) {
 440                         *pkt >> id;
 441                         m_env.removeActiveObject(id);
 442                 }
 443
 444                 // Read added objects
 445                 *pkt >> added_count;
 446
 447                 for (u16 i = 0; i < added_count; i++) {
 448                         *pkt >> id >> type;
 449                         m_env.addActiveObject(id, type, pkt->readLongString());
 450                 }
 451         } catch (PacketError &e) {
 452                 infostream << "handleCommand_ActiveObjectRemoveAdd: " << e.what()
 453                                 << ". The packet is unreliable, ignoring" << std::endl;
 454         }
 455 }
 456
 457 void Client::handleCommand_ActiveObjectMessages(NetworkPacket* pkt)
 458 {
 459         /*
 460                 for all objects
 461                 {
 462                         u16 id
 463                         u16 message length
 464                         string message
 465                 }
 466         */
 467         std::string datastring(pkt->getString(0), pkt->getSize());
 468         std::istringstream is(datastring, std::ios_base::binary);
 469
 470         try {
 471                 while (is.good()) {
 472                         u16 id = readU16(is);
 473                         if (!is.good())
 474                                 break;
 475
 476                         std::string message = deSerializeString(is);
 477
 478                         // Pass on to the environment
 479                         m_env.processActiveObjectMessage(id, message);
 480                 }
 481         } catch (SerializationError &e) {
 482                 errorstream << "Client::handleCommand_ActiveObjectMessages: "
 483                         << "caught SerializationError: " << e.what() << std::endl;
 484         }
 485 }
 486
 487 void Client::handleCommand_Movement(NetworkPacket* pkt)
 488 {
 489         Player *player = m_env.getLocalPlayer();
 490         assert(player != NULL);
 491
 492         float mad, maa, maf, msw, mscr, msf, mscl, msj, lf, lfs, ls, g;
 493
 494         *pkt >> mad >> maa >> maf >> msw >> mscr >> msf >> mscl >> msj
 495                 >> lf >> lfs >> ls >> g;
 496
 497         player->movement_acceleration_default   = mad * BS;
 498         player->movement_acceleration_air       = maa * BS;
 499         player->movement_acceleration_fast      = maf * BS;
 500         player->movement_speed_walk             = msw * BS;
 501         player->movement_speed_crouch           = mscr * BS;
 502         player->movement_speed_fast             = msf * BS;
 503         player->movement_speed_climb            = mscl * BS;
 504         player->movement_speed_jump             = msj * BS;
 505         player->movement_liquid_fluidity        = lf * BS;
 506         player->movement_liquid_fluidity_smooth = lfs * BS;
 507         player->movement_liquid_sink            = ls * BS;
 508         player->movement_gravity                = g * BS;
 509 }
 510
 511 void Client::handleCommand_HP(NetworkPacket* pkt)
 512 {
 513
 514         Player *player = m_env.getLocalPlayer();
 515         assert(player != NULL);
 516
 517         u8 oldhp   = player->hp;
 518
 519         u8 hp;
 520         *pkt >> hp;
 521
 522         player->hp = hp;
 523
 524         if (hp < oldhp) {
 525                 // Add to ClientEvent queue
 526                 ClientEvent event;
 527                 event.type = CE_PLAYER_DAMAGE;
 528                 event.player_damage.amount = oldhp - hp;
 529                 m_client_event_queue.push(event);
 530         }
 531 }
 532
 533 void Client::handleCommand_Breath(NetworkPacket* pkt)
 534 {
 535         Player *player = m_env.getLocalPlayer();
 536         assert(player != NULL);
 537
 538         u16 breath;
 539
 540         *pkt >> breath;
 541
 542         player->setBreath(breath);
 543 }
 544
 545 void Client::handleCommand_MovePlayer(NetworkPacket* pkt)
 546 {
 547         Player *player = m_env.getLocalPlayer();
 548         assert(player != NULL);
 549
 550         v3f pos;
 551         f32 pitch, yaw;
 552
 553         *pkt >> pos >> pitch >> yaw;
 554
 555         player->setPosition(pos);
 556
 557         infostream << "Client got TOCLIENT_MOVE_PLAYER"
 558                         << " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
 559                         << " pitch=" << pitch
 560                         << " yaw=" << yaw
 561                         << std::endl;
 562
 563         /*
 564                 Add to ClientEvent queue.
 565                 This has to be sent to the main program because otherwise
 566                 it would just force the pitch and yaw values to whatever
 567                 the camera points to.
 568         */
 569         ClientEvent event;
 570         event.type = CE_PLAYER_FORCE_MOVE;
 571         event.player_force_move.pitch = pitch;
 572         event.player_force_move.yaw = yaw;
 573         m_client_event_queue.push(event);
 574
 575         // Ignore damage for a few seconds, so that the player doesn't
 576         // get damage from falling on ground
 577         m_ignore_damage_timer = 3.0;
 578 }
 579
 580 void Client::handleCommand_PlayerItem(NetworkPacket* pkt)
 581 {
 582         infostream << "Client: WARNING: Ignoring TOCLIENT_PLAYERITEM" << std::endl;
 583 }
 584
 585 void Client::handleCommand_DeathScreen(NetworkPacket* pkt)
 586 {
 587         bool set_camera_point_target;
 588         v3f camera_point_target;
 589
 590         *pkt >> set_camera_point_target;
 591         *pkt >> camera_point_target;
 592
 593         ClientEvent event;
 594         event.type                                = CE_DEATHSCREEN;
 595         event.deathscreen.set_camera_point_target = set_camera_point_target;
 596         event.deathscreen.camera_point_target_x   = camera_point_target.X;
 597         event.deathscreen.camera_point_target_y   = camera_point_target.Y;
 598         event.deathscreen.camera_point_target_z   = camera_point_target.Z;
 599         m_client_event_queue.push(event);
 600 }
 601
 602 void Client::handleCommand_AnnounceMedia(NetworkPacket* pkt)
 603 {
 604         u16 num_files;
 605
 606         *pkt >> num_files;
 607
 608         infostream << "Client: Received media announcement: packet size: "
 609                         << pkt->getSize() << std::endl;
 610
 611         if (m_media_downloader == NULL ||
 612                         m_media_downloader->isStarted()) {
 613                 const char *problem = m_media_downloader ?
 614                         "we already saw another announcement" :
 615                         "all media has been received already";
 616                 errorstream << "Client: Received media announcement but "
 617                         << problem << "! "
 618                         << " files=" << num_files
 619                         << " size=" << pkt->getSize() << std::endl;
 620                 return;
 621         }
 622
 623         // Mesh update thread must be stopped while
 624         // updating content definitions
 625         sanity_check(!m_mesh_update_thread.isRunning());
 626
 627         for (u16 i = 0; i < num_files; i++) {
 628                 std::string name, sha1_base64;
 629
 630                 *pkt >> name >> sha1_base64;
 631
 632                 std::string sha1_raw = base64_decode(sha1_base64);
 633                 m_media_downloader->addFile(name, sha1_raw);
 634         }
 635
 636         std::vector<std::string> remote_media;
 637         try {
 638                 std::string str;
 639
 640                 *pkt >> str;
 641
 642                 Strfnd sf(str);
 643                 while(!sf.atend()) {
 644                         std::string baseurl = trim(sf.next(","));
 645                         if (baseurl != "")
 646                                 m_media_downloader->addRemoteServer(baseurl);
 647                 }
 648         }
 649         catch(SerializationError& e) {
 650                 // not supported by server or turned off
 651         }
 652
 653         m_media_downloader->step(this);
 654 }
 655
 656 void Client::handleCommand_Media(NetworkPacket* pkt)
 657 {
 658         /*
 659                 u16 command
 660                 u16 total number of file bunches
 661                 u16 index of this bunch
 662                 u32 number of files in this bunch
 663                 for each file {
 664                         u16 length of name
 665                         string name
 666                         u32 length of data
 667                         data
 668                 }
 669         */
 670         u16 num_bunches;
 671         u16 bunch_i;
 672         u32 num_files;
 673
 674         *pkt >> num_bunches >> bunch_i >> num_files;
 675
 676         infostream << "Client: Received files: bunch " << bunch_i << "/"
 677                         << num_bunches << " files=" << num_files
 678                         << " size=" << pkt->getSize() << std::endl;
 679
 680         if (num_files == 0)
 681                 return;
 682
 683         if (m_media_downloader == NULL ||
 684                         !m_media_downloader->isStarted()) {
 685                 const char *problem = m_media_downloader ?
 686                         "media has not been requested" :
 687                         "all media has been received already";
 688                 errorstream << "Client: Received media but "
 689                         << problem << "! "
 690                         << " bunch " << bunch_i << "/" << num_bunches
 691                         << " files=" << num_files
 692                         << " size=" << pkt->getSize() << std::endl;
 693                 return;
 694         }
 695
 696         // Mesh update thread must be stopped while
 697         // updating content definitions
 698         sanity_check(!m_mesh_update_thread.isRunning());
 699
 700         for (u32 i=0; i < num_files; i++) {
 701                 std::string name;
 702
 703                 *pkt >> name;
 704
 705                 std::string data = pkt->readLongString();
 706
 707                 m_media_downloader->conventionalTransferDone(
 708                                 name, data, this);
 709         }
 710 }
 711
 712 void Client::handleCommand_ToolDef(NetworkPacket* pkt)
 713 {
 714         infostream << "Client: WARNING: Ignoring TOCLIENT_TOOLDEF" << std::endl;
 715 }
 716
 717 void Client::handleCommand_NodeDef(NetworkPacket* pkt)
 718 {
 719         infostream << "Client: Received node definitions: packet size: "
 720                         << pkt->getSize() << std::endl;
 721
 722         // Mesh update thread must be stopped while
 723         // updating content definitions
 724         sanity_check(!m_mesh_update_thread.isRunning());
 725
 726         // Decompress node definitions
 727         std::string datastring(pkt->getString(0), pkt->getSize());
 728         std::istringstream is(datastring, std::ios_base::binary);
 729         std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
 730         std::ostringstream tmp_os;
 731         decompressZlib(tmp_is, tmp_os);
 732
 733         // Deserialize node definitions
 734         std::istringstream tmp_is2(tmp_os.str());
 735         m_nodedef->deSerialize(tmp_is2);
 736         m_nodedef_received = true;
 737 }
 738
 739 void Client::handleCommand_CraftItemDef(NetworkPacket* pkt)
 740 {
 741         infostream << "Client: WARNING: Ignoring TOCLIENT_CRAFTITEMDEF" << std::endl;
 742 }
 743
 744 void Client::handleCommand_ItemDef(NetworkPacket* pkt)
 745 {
 746         infostream << "Client: Received item definitions: packet size: "
 747                         << pkt->getSize() << std::endl;
 748
 749         // Mesh update thread must be stopped while
 750         // updating content definitions
 751         sanity_check(!m_mesh_update_thread.isRunning());
 752
 753         // Decompress item definitions
 754         std::string datastring(pkt->getString(0), pkt->getSize());
 755         std::istringstream is(datastring, std::ios_base::binary);
 756         std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
 757         std::ostringstream tmp_os;
 758         decompressZlib(tmp_is, tmp_os);
 759
 760         // Deserialize node definitions
 761         std::istringstream tmp_is2(tmp_os.str());
 762         m_itemdef->deSerialize(tmp_is2);
 763         m_itemdef_received = true;
 764 }
 765
 766 void Client::handleCommand_PlaySound(NetworkPacket* pkt)
 767 {
 768         s32 server_id;
 769         std::string name;
 770         float gain;
 771         u8 type; // 0=local, 1=positional, 2=object
 772         v3f pos;
 773         u16 object_id;
 774         bool loop;
 775
 776         *pkt >> server_id >> name >> gain >> type >> pos >> object_id >> loop;
 777
 778         // Start playing
 779         int client_id = -1;
 780         switch(type) {
 781                 case 0: // local
 782                         client_id = m_sound->playSound(name, loop, gain);
 783                         break;
 784                 case 1: // positional
 785                         client_id = m_sound->playSoundAt(name, loop, gain, pos);
 786                         break;
 787                 case 2:
 788                 { // object
 789                         ClientActiveObject *cao = m_env.getActiveObject(object_id);
 790                         if (cao)
 791                                 pos = cao->getPosition();
 792                         client_id = m_sound->playSoundAt(name, loop, gain, pos);
 793                         // TODO: Set up sound to move with object
 794                         break;
 795                 }
 796                 default:
 797                         break;
 798         }
 799
 800         if (client_id != -1) {
 801                 m_sounds_server_to_client[server_id] = client_id;
 802                 m_sounds_client_to_server[client_id] = server_id;
 803                 if (object_id != 0)
 804                         m_sounds_to_objects[client_id] = object_id;
 805         }
 806 }
 807
 808 void Client::handleCommand_StopSound(NetworkPacket* pkt)
 809 {
 810         s32 server_id;
 811
 812         *pkt >> server_id;
 813
 814         std::map<s32, int>::iterator i =
 815                 m_sounds_server_to_client.find(server_id);
 816
 817         if (i != m_sounds_server_to_client.end()) {
 818                 int client_id = i->second;
 819                 m_sound->stopSound(client_id);
 820         }
 821 }
 822
 823 void Client::handleCommand_Privileges(NetworkPacket* pkt)
 824 {
 825         m_privileges.clear();
 826         infostream << "Client: Privileges updated: ";
 827         u16 num_privileges;
 828
 829         *pkt >> num_privileges;
 830
 831         for (u16 i = 0; i < num_privileges; i++) {
 832                 std::string priv;
 833
 834                 *pkt >> priv;
 835
 836                 m_privileges.insert(priv);
 837                 infostream << priv << " ";
 838         }
 839         infostream << std::endl;
 840 }
 841
 842 void Client::handleCommand_InventoryFormSpec(NetworkPacket* pkt)
 843 {
 844         Player *player = m_env.getLocalPlayer();
 845         assert(player != NULL);
 846
 847         // Store formspec in LocalPlayer
 848         player->inventory_formspec = pkt->readLongString();
 849 }
 850
 851 void Client::handleCommand_DetachedInventory(NetworkPacket* pkt)
 852 {
 853         std::string datastring(pkt->getString(0), pkt->getSize());
 854         std::istringstream is(datastring, std::ios_base::binary);
 855
 856         std::string name = deSerializeString(is);
 857
 858         infostream << "Client: Detached inventory update: \"" << name
 859                         << "\"" << std::endl;
 860
 861         Inventory *inv = NULL;
 862         if (m_detached_inventories.count(name) > 0)
 863                 inv = m_detached_inventories[name];
 864         else {
 865                 inv = new Inventory(m_itemdef);
 866                 m_detached_inventories[name] = inv;
 867         }
 868         inv->deSerialize(is);
 869 }
 870
 871 void Client::handleCommand_ShowFormSpec(NetworkPacket* pkt)
 872 {
 873         std::string formspec = pkt->readLongString();
 874         std::string formname;
 875
 876         *pkt >> formname;
 877
 878         ClientEvent event;
 879         event.type = CE_SHOW_FORMSPEC;
 880         // pointer is required as event is a struct only!
 881         // adding a std:string to a struct isn't possible
 882         event.show_formspec.formspec = new std::string(formspec);
 883         event.show_formspec.formname = new std::string(formname);
 884         m_client_event_queue.push(event);
 885 }
 886
 887 void Client::handleCommand_SpawnParticle(NetworkPacket* pkt)
 888 {
 889         std::string datastring(pkt->getString(0), pkt->getSize());
 890         std::istringstream is(datastring, std::ios_base::binary);
 891
 892         v3f pos                 = readV3F1000(is);
 893         v3f vel                 = readV3F1000(is);
 894         v3f acc                 = readV3F1000(is);
 895         float expirationtime    = readF1000(is);
 896         float size              = readF1000(is);
 897         bool collisiondetection = readU8(is);
 898         std::string texture     = deSerializeLongString(is);
 899         bool vertical           = false;
 900         try {
 901                 vertical = readU8(is);
 902         } catch (...) {}
 903
 904         ClientEvent event;
 905         event.type                              = CE_SPAWN_PARTICLE;
 906         event.spawn_particle.pos                = new v3f (pos);
 907         event.spawn_particle.vel                = new v3f (vel);
 908         event.spawn_particle.acc                = new v3f (acc);
 909         event.spawn_particle.expirationtime     = expirationtime;
 910         event.spawn_particle.size               = size;
 911         event.spawn_particle.collisiondetection = collisiondetection;
 912         event.spawn_particle.vertical           = vertical;
 913         event.spawn_particle.texture            = new std::string(texture);
 914
 915         m_client_event_queue.push(event);
 916 }
 917
 918 void Client::handleCommand_AddParticleSpawner(NetworkPacket* pkt)
 919 {
 920         u16 amount;
 921         float spawntime;
 922         v3f minpos;
 923         v3f maxpos;
 924         v3f minvel;
 925         v3f maxvel;
 926         v3f minacc;
 927         v3f maxacc;
 928         float minexptime;
 929         float maxexptime;
 930         float minsize;
 931         float maxsize;
 932         bool collisiondetection;
 933         u32 id;
 934
 935         *pkt >> amount >> spawntime >> minpos >> maxpos >> minvel >> maxvel
 936                 >> minacc >> maxacc >> minexptime >> maxexptime >> minsize
 937                 >> maxsize >> collisiondetection;
 938
 939         std::string texture = pkt->readLongString();
 940
 941         *pkt >> id;
 942
 943         bool vertical = false;
 944         try {
 945                 *pkt >> vertical;
 946         } catch (...) {}
 947
 948         ClientEvent event;
 949         event.type                                   = CE_ADD_PARTICLESPAWNER;
 950         event.add_particlespawner.amount             = amount;
 951         event.add_particlespawner.spawntime          = spawntime;
 952         event.add_particlespawner.minpos             = new v3f (minpos);
 953         event.add_particlespawner.maxpos             = new v3f (maxpos);
 954         event.add_particlespawner.minvel             = new v3f (minvel);
 955         event.add_particlespawner.maxvel             = new v3f (maxvel);
 956         event.add_particlespawner.minacc             = new v3f (minacc);
 957         event.add_particlespawner.maxacc             = new v3f (maxacc);
 958         event.add_particlespawner.minexptime         = minexptime;
 959         event.add_particlespawner.maxexptime         = maxexptime;
 960         event.add_particlespawner.minsize            = minsize;
 961         event.add_particlespawner.maxsize            = maxsize;
 962         event.add_particlespawner.collisiondetection = collisiondetection;
 963         event.add_particlespawner.vertical           = vertical;
 964         event.add_particlespawner.texture            = new std::string(texture);
 965         event.add_particlespawner.id                 = id;
 966
 967         m_client_event_queue.push(event);
 968 }
 969
 970
 971 void Client::handleCommand_DeleteParticleSpawner(NetworkPacket* pkt)
 972 {
 973         u16 legacy_id;
 974         u32 id;
 975
 976         // Modification set 13/03/15, 1 year of compat for protocol v24
 977         if (pkt->getCommand() == TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY) {
 978                 *pkt >> legacy_id;
 979         }
 980         else {
 981                 *pkt >> id;
 982         }
 983
 984
 985         ClientEvent event;
 986         event.type                      = CE_DELETE_PARTICLESPAWNER;
 987         event.delete_particlespawner.id =
 988                         (pkt->getCommand() == TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY ? (u32) legacy_id : id);
 989
 990         m_client_event_queue.push(event);
 991 }
 992
 993 void Client::handleCommand_HudAdd(NetworkPacket* pkt)
 994 {
 995         std::string datastring(pkt->getString(0), pkt->getSize());
 996         std::istringstream is(datastring, std::ios_base::binary);
 997
 998         u32 id;
 999         u8 type;
1000         v2f pos;
1001         std::string name;
1002         v2f scale;
1003         std::string text;
1004         u32 number;
1005         u32 item;
1006         u32 dir;
1007         v2f align;
1008         v2f offset;
1009         v3f world_pos;
1010         v2s32 size;
1011
1012         *pkt >> id >> type >> pos >> name >> scale >> text >> number >> item
1013                 >> dir >> align >> offset;
1014         try {
1015                 *pkt >> world_pos;
1016         }
1017         catch(SerializationError &e) {};
1018
1019         try {
1020                 *pkt >> size;
1021         } catch(SerializationError &e) {};
1022
1023         ClientEvent event;
1024         event.type             = CE_HUDADD;
1025         event.hudadd.id        = id;
1026         event.hudadd.type      = type;
1027         event.hudadd.pos       = new v2f(pos);
1028         event.hudadd.name      = new std::string(name);
1029         event.hudadd.scale     = new v2f(scale);
1030         event.hudadd.text      = new std::string(text);
1031         event.hudadd.number    = number;
1032         event.hudadd.item      = item;
1033         event.hudadd.dir       = dir;
1034         event.hudadd.align     = new v2f(align);
1035         event.hudadd.offset    = new v2f(offset);
1036         event.hudadd.world_pos = new v3f(world_pos);
1037         event.hudadd.size      = new v2s32(size);
1038         m_client_event_queue.push(event);
1039 }
1040
1041 void Client::handleCommand_HudRemove(NetworkPacket* pkt)
1042 {
1043         u32 id;
1044
1045         *pkt >> id;
1046
1047         ClientEvent event;
1048         event.type     = CE_HUDRM;
1049         event.hudrm.id = id;
1050         m_client_event_queue.push(event);
1051 }
1052
1053 void Client::handleCommand_HudChange(NetworkPacket* pkt)
1054 {
1055         std::string sdata;
1056         v2f v2fdata;
1057         v3f v3fdata;
1058         u32 intdata = 0;
1059         v2s32 v2s32data;
1060         u32 id;
1061         u8 stat;
1062
1063         *pkt >> id >> stat;
1064
1065         if (stat == HUD_STAT_POS || stat == HUD_STAT_SCALE ||
1066                 stat == HUD_STAT_ALIGN || stat == HUD_STAT_OFFSET)
1067                 *pkt >> v2fdata;
1068         else if (stat == HUD_STAT_NAME || stat == HUD_STAT_TEXT)
1069                 *pkt >> sdata;
1070         else if (stat == HUD_STAT_WORLD_POS)
1071                 *pkt >> v3fdata;
1072         else if (stat == HUD_STAT_SIZE )
1073                 *pkt >> v2s32data;
1074         else
1075                 *pkt >> intdata;
1076
1077         ClientEvent event;
1078         event.type              = CE_HUDCHANGE;
1079         event.hudchange.id      = id;
1080         event.hudchange.stat    = (HudElementStat)stat;
1081         event.hudchange.v2fdata = new v2f(v2fdata);
1082         event.hudchange.v3fdata = new v3f(v3fdata);
1083         event.hudchange.sdata   = new std::string(sdata);
1084         event.hudchange.data    = intdata;
1085         event.hudchange.v2s32data = new v2s32(v2s32data);
1086         m_client_event_queue.push(event);
1087 }
1088
1089 void Client::handleCommand_HudSetFlags(NetworkPacket* pkt)
1090 {
1091         u32 flags, mask;
1092
1093         *pkt >> flags >> mask;
1094
1095         Player *player = m_env.getLocalPlayer();
1096         assert(player != NULL);
1097
1098         bool was_minimap_visible = player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE;
1099
1100         player->hud_flags &= ~mask;
1101         player->hud_flags |= flags;
1102
1103         m_minimap_disabled_by_server = !(player->hud_flags & HUD_FLAG_MINIMAP_VISIBLE);
1104
1105         // Hide minimap if it has been disabled by the server
1106         if (m_minimap_disabled_by_server && was_minimap_visible) {
1107                 // defers a minimap update, therefore only call it if really
1108                 // needed, by checking that minimap was visible before
1109                 m_mapper->setMinimapMode(MINIMAP_MODE_OFF);
1110         }
1111 }
1112
1113 void Client::handleCommand_HudSetParam(NetworkPacket* pkt)
1114 {
1115         u16 param; std::string value;
1116
1117         *pkt >> param >> value;
1118
1119         Player *player = m_env.getLocalPlayer();
1120         assert(player != NULL);
1121
1122         if (param == HUD_PARAM_HOTBAR_ITEMCOUNT && value.size() == 4) {
1123                 s32 hotbar_itemcount = readS32((u8*) value.c_str());
1124                 if (hotbar_itemcount > 0 && hotbar_itemcount <= HUD_HOTBAR_ITEMCOUNT_MAX)
1125                         player->hud_hotbar_itemcount = hotbar_itemcount;
1126         }
1127         else if (param == HUD_PARAM_HOTBAR_IMAGE) {
1128                 ((LocalPlayer *) player)->hotbar_image = value;
1129         }
1130         else if (param == HUD_PARAM_HOTBAR_SELECTED_IMAGE) {
1131                 ((LocalPlayer *) player)->hotbar_selected_image = value;
1132         }
1133 }
1134
1135 void Client::handleCommand_HudSetSky(NetworkPacket* pkt)
1136 {
1137         std::string datastring(pkt->getString(0), pkt->getSize());
1138         std::istringstream is(datastring, std::ios_base::binary);
1139
1140         video::SColor *bgcolor           = new video::SColor(readARGB8(is));
1141         std::string *type                = new std::string(deSerializeString(is));
1142         u16 count                        = readU16(is);
1143         std::vector<std::string> *params = new std::vector<std::string>;
1144
1145         for (size_t i = 0; i < count; i++)
1146                 params->push_back(deSerializeString(is));
1147
1148         ClientEvent event;
1149         event.type            = CE_SET_SKY;
1150         event.set_sky.bgcolor = bgcolor;
1151         event.set_sky.type    = type;
1152         event.set_sky.params  = params;
1153         m_client_event_queue.push(event);
1154 }
1155
1156 void Client::handleCommand_OverrideDayNightRatio(NetworkPacket* pkt)
1157 {
1158         bool do_override;
1159         u16 day_night_ratio_u;
1160
1161         *pkt >> do_override >> day_night_ratio_u;
1162
1163         float day_night_ratio_f = (float)day_night_ratio_u / 65536;
1164
1165         ClientEvent event;
1166         event.type                                 = CE_OVERRIDE_DAY_NIGHT_RATIO;
1167         event.override_day_night_ratio.do_override = do_override;
1168         event.override_day_night_ratio.ratio_f     = day_night_ratio_f;
1169         m_client_event_queue.push(event);
1170 }
1171
1172 void Client::handleCommand_LocalPlayerAnimations(NetworkPacket* pkt)
1173 {
1174         LocalPlayer *player = m_env.getLocalPlayer();
1175         assert(player != NULL);
1176
1177         *pkt >> player->local_animations[0];
1178         *pkt >> player->local_animations[1];
1179         *pkt >> player->local_animations[2];
1180         *pkt >> player->local_animations[3];
1181         *pkt >> player->local_animation_speed;
1182 }
1183
1184 void Client::handleCommand_EyeOffset(NetworkPacket* pkt)
1185 {
1186         LocalPlayer *player = m_env.getLocalPlayer();
1187         assert(player != NULL);
1188
1189         *pkt >> player->eye_offset_first >> player->eye_offset_third;
1190 }
1191
1192 void Client::handleCommand_SrpBytesSandB(NetworkPacket* pkt)
1193 {
1194         if ((m_chosen_auth_mech != AUTH_MECHANISM_LEGACY_PASSWORD)
1195                         && (m_chosen_auth_mech != AUTH_MECHANISM_SRP)) {
1196                 errorstream << "Client: Recieved SRP S_B login message,"
1197                         << " but wasn't supposed to (chosen_mech="
1198                         << m_chosen_auth_mech << ")." << std::endl;
1199                 return;
1200         }
1201
1202         char *bytes_M = 0;
1203         size_t len_M = 0;
1204         SRPUser *usr = (SRPUser *) m_auth_data;
1205         std::string s;
1206         std::string B;
1207         *pkt >> s >> B;
1208
1209         infostream << "Client: Recieved TOCLIENT_SRP_BYTES_S_B." << std::endl;
1210
1211         srp_user_process_challenge(usr, (const unsigned char *) s.c_str(), s.size(),
1212                 (const unsigned char *) B.c_str(), B.size(),
1213                 (unsigned char **) &bytes_M, &len_M);
1214
1215         if ( !bytes_M ) {
1216                 errorstream << "Client: SRP-6a S_B safety check violation!" << std::endl;
1217                 return;
1218         }
1219
1220         NetworkPacket resp_pkt(TOSERVER_SRP_BYTES_M, 0);
1221         resp_pkt << std::string(bytes_M, len_M);
1222         Send(&resp_pkt);
1223 }