src/server.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
   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 "server.h"
  21 #include <iostream>
  22 #include <queue>
  23 #include "clientserver.h"
  24 #include "map.h"
  25 #include "jmutexautolock.h"
  26 #include "main.h"
  27 #include "constants.h"
  28 #include "voxel.h"
  29 #include "config.h"
  30 #include "filesys.h"
  31 #include "mapblock.h"
  32 #include "serverobject.h"
  33 #include "settings.h"
  34 #include "profiler.h"
  35 #include "log.h"
  36 #include "script.h"
  37 #include "scriptapi.h"
  38 #include "nodedef.h"
  39 #include "itemdef.h"
  40 #include "craftdef.h"
  41 #include "mapgen.h"
  42 #include "content_mapnode.h"
  43 #include "content_nodemeta.h"
  44 #include "content_abm.h"
  45 #include "content_sao.h"
  46 #include "mods.h"
  47 #include "sha1.h"
  48 #include "base64.h"
  49 #include "tool.h"
  50 #include "sound.h" // dummySoundManager
  51 #include "event_manager.h"
  52 #include "hex.h"
  53 #include "util/string.h"
  54 #include "util/pointedthing.h"
  55 #include "util/mathconstants.h"
  56 #include "rollback.h"
  57 #include "util/serialize.h"
  58
  59 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
  60
  61 #define BLOCK_EMERGE_FLAG_FROMDISK (1<<0)
  62
  63 class MapEditEventIgnorer
  64 {
  65 public:
  66         MapEditEventIgnorer(bool *flag):
  67                 m_flag(flag)
  68         {
  69                 if(*m_flag == false)
  70                         *m_flag = true;
  71                 else
  72                         m_flag = NULL;
  73         }
  74
  75         ~MapEditEventIgnorer()
  76         {
  77                 if(m_flag)
  78                 {
  79                         assert(*m_flag);
  80                         *m_flag = false;
  81                 }
  82         }
  83
  84 private:
  85         bool *m_flag;
  86 };
  87
  88 class MapEditEventAreaIgnorer
  89 {
  90 public:
  91         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
  92                 m_ignorevariable(ignorevariable)
  93         {
  94                 if(m_ignorevariable->getVolume() == 0)
  95                         *m_ignorevariable = a;
  96                 else
  97                         m_ignorevariable = NULL;
  98         }
  99
 100         ~MapEditEventAreaIgnorer()
 101         {
 102                 if(m_ignorevariable)
 103                 {
 104                         assert(m_ignorevariable->getVolume() != 0);
 105                         *m_ignorevariable = VoxelArea();
 106                 }
 107         }
 108
 109 private:
 110         VoxelArea *m_ignorevariable;
 111 };
 112
 113 void * ServerThread::Thread()
 114 {
 115         ThreadStarted();
 116
 117         log_register_thread("ServerThread");
 118
 119         DSTACK(__FUNCTION_NAME);
 120
 121         BEGIN_DEBUG_EXCEPTION_HANDLER
 122
 123         while(getRun())
 124         {
 125                 try{
 126                         //TimeTaker timer("AsyncRunStep() + Receive()");
 127
 128                         {
 129                                 //TimeTaker timer("AsyncRunStep()");
 130                                 m_server->AsyncRunStep();
 131                         }
 132
 133                         //infostream<<"Running m_server->Receive()"<<std::endl;
 134                         m_server->Receive();
 135                 }
 136                 catch(con::NoIncomingDataException &e)
 137                 {
 138                 }
 139                 catch(con::PeerNotFoundException &e)
 140                 {
 141                         infostream<<"Server: PeerNotFoundException"<<std::endl;
 142                 }
 143                 catch(con::ConnectionBindFailed &e)
 144                 {
 145                         m_server->setAsyncFatalError(e.what());
 146                 }
 147                 catch(LuaError &e)
 148                 {
 149                         m_server->setAsyncFatalError(e.what());
 150                 }
 151         }
 152
 153         END_DEBUG_EXCEPTION_HANDLER(errorstream)
 154
 155         return NULL;
 156 }
 157
 158 void * EmergeThread::Thread()
 159 {
 160         ThreadStarted();
 161
 162         log_register_thread("EmergeThread");
 163
 164         DSTACK(__FUNCTION_NAME);
 165
 166         BEGIN_DEBUG_EXCEPTION_HANDLER
 167
 168         bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
 169
 170         v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
 171
 172         /*
 173                 Get block info from queue, emerge them and send them
 174                 to clients.
 175
 176                 After queue is empty, exit.
 177         */
 178         while(getRun())
 179         try{
 180                 QueuedBlockEmerge *qptr = m_server->m_emerge_queue.pop();
 181                 if(qptr == NULL)
 182                         break;
 183
 184                 SharedPtr<QueuedBlockEmerge> q(qptr);
 185
 186                 v3s16 &p = q->pos;
 187                 v2s16 p2d(p.X,p.Z);
 188
 189                 last_tried_pos = p;
 190
 191                 /*
 192                         Do not generate over-limit
 193                 */
 194                 if(blockpos_over_limit(p))
 195                         continue;
 196
 197                 //infostream<<"EmergeThread::Thread(): running"<<std::endl;
 198
 199                 //TimeTaker timer("block emerge");
 200
 201                 /*
 202                         Try to emerge it from somewhere.
 203
 204                         If it is only wanted as optional, only loading from disk
 205                         will be allowed.
 206                 */
 207
 208                 /*
 209                         Check if any peer wants it as non-optional. In that case it
 210                         will be generated.
 211
 212                         Also decrement the emerge queue count in clients.
 213                 */
 214
 215                 bool only_from_disk = true;
 216
 217                 {
 218                         core::map<u16, u8>::Iterator i;
 219                         for(i=q->peer_ids.getIterator(); i.atEnd()==false; i++)
 220                         {
 221                                 //u16 peer_id = i.getNode()->getKey();
 222
 223                                 // Check flags
 224                                 u8 flags = i.getNode()->getValue();
 225                                 if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false)
 226                                         only_from_disk = false;
 227
 228                         }
 229                 }
 230
 231                 if(enable_mapgen_debug_info)
 232                         infostream<<"EmergeThread: p="
 233                                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
 234                                         <<"only_from_disk="<<only_from_disk<<std::endl;
 235
 236                 ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
 237
 238                 MapBlock *block = NULL;
 239                 bool got_block = true;
 240                 core::map<v3s16, MapBlock*> modified_blocks;
 241
 242                 /*
 243                         Try to fetch block from memory or disk.
 244                         If not found and asked to generate, initialize generator.
 245                 */
 246
 247                 bool started_generate = false;
 248                 mapgen::BlockMakeData data;
 249
 250                 {
 251                         JMutexAutoLock envlock(m_server->m_env_mutex);
 252
 253                         // Load sector if it isn't loaded
 254                         if(map.getSectorNoGenerateNoEx(p2d) == NULL)
 255                                 map.loadSectorMeta(p2d);
 256
 257                         // Attempt to load block
 258                         block = map.getBlockNoCreateNoEx(p);
 259                         if(!block || block->isDummy() || !block->isGenerated())
 260                         {
 261                                 if(enable_mapgen_debug_info)
 262                                         infostream<<"EmergeThread: not in memory, "
 263                                                         <<"attempting to load from disk"<<std::endl;
 264
 265                                 block = map.loadBlock(p);
 266                         }
 267
 268                         // If could not load and allowed to generate, start generation
 269                         // inside this same envlock
 270                         if(only_from_disk == false &&
 271                                         (block == NULL || block->isGenerated() == false)){
 272                                 if(enable_mapgen_debug_info)
 273                                         infostream<<"EmergeThread: generating"<<std::endl;
 274                                 started_generate = true;
 275
 276                                 map.initBlockMake(&data, p);
 277                         }
 278                 }
 279
 280                 /*
 281                         If generator was initialized, generate now when envlock is free.
 282                 */
 283                 if(started_generate)
 284                 {
 285                         {
 286                                 ScopeProfiler sp(g_profiler, "EmergeThread: mapgen::make_block",
 287                                                 SPT_AVG);
 288                                 TimeTaker t("mapgen::make_block()");
 289
 290                                 mapgen::make_block(&data);
 291
 292                                 if(enable_mapgen_debug_info == false)
 293                                         t.stop(true); // Hide output
 294                         }
 295
 296                         do{ // enable break
 297                                 // Lock environment again to access the map
 298                                 JMutexAutoLock envlock(m_server->m_env_mutex);
 299
 300                                 ScopeProfiler sp(g_profiler, "EmergeThread: after "
 301                                                 "mapgen::make_block (envlock)", SPT_AVG);
 302
 303                                 // Blit data back on map, update lighting, add mobs and
 304                                 // whatever this does
 305                                 map.finishBlockMake(&data, modified_blocks);
 306
 307                                 // Get central block
 308                                 block = map.getBlockNoCreateNoEx(p);
 309
 310                                 // If block doesn't exist, don't try doing anything with it
 311                                 // This happens if the block is not in generation boundaries
 312                                 if(!block)
 313                                         break;
 314
 315                                 /*
 316                                         Do some post-generate stuff
 317                                 */
 318
 319                                 v3s16 minp = data.blockpos_min*MAP_BLOCKSIZE;
 320                                 v3s16 maxp = data.blockpos_max*MAP_BLOCKSIZE +
 321                                                 v3s16(1,1,1)*(MAP_BLOCKSIZE-1);
 322
 323                                 /*
 324                                         Ignore map edit events, they will not need to be
 325                                         sent to anybody because the block hasn't been sent
 326                                         to anybody
 327                                 */
 328                                 //MapEditEventIgnorer ign(&m_server->m_ignore_map_edit_events);
 329                                 MapEditEventAreaIgnorer ign(
 330                                                 &m_server->m_ignore_map_edit_events_area,
 331                                                 VoxelArea(minp, maxp));
 332                                 {
 333                                         TimeTaker timer("on_generated");
 334                                         scriptapi_environment_on_generated(m_server->m_lua,
 335                                                         minp, maxp, mapgen::get_blockseed(data.seed, minp));
 336                                         /*int t = timer.stop(true);
 337                                         dstream<<"on_generated took "<<t<<"ms"<<std::endl;*/
 338                                 }
 339
 340                                 if(enable_mapgen_debug_info)
 341                                         infostream<<"EmergeThread: ended up with: "
 342                                                         <<analyze_block(block)<<std::endl;
 343
 344                                 // Activate objects and stuff
 345                                 m_server->m_env->activateBlock(block, 0);
 346                         }while(false);
 347                 }
 348
 349                 if(block == NULL)
 350                         got_block = false;
 351
 352                 /*
 353                         Set sent status of modified blocks on clients
 354                 */
 355
 356                 // NOTE: Server's clients are also behind the connection mutex
 357                 JMutexAutoLock lock(m_server->m_con_mutex);
 358
 359                 /*
 360                         Add the originally fetched block to the modified list
 361                 */
 362                 if(got_block)
 363                 {
 364                         modified_blocks.insert(p, block);
 365                 }
 366
 367                 /*
 368                         Set the modified blocks unsent for all the clients
 369                 */
 370
 371                 for(core::map<u16, RemoteClient*>::Iterator
 372                                 i = m_server->m_clients.getIterator();
 373                                 i.atEnd() == false; i++)
 374                 {
 375                         RemoteClient *client = i.getNode()->getValue();
 376
 377                         if(modified_blocks.size() > 0)
 378                         {
 379                                 // Remove block from sent history
 380                                 client->SetBlocksNotSent(modified_blocks);
 381                         }
 382                 }
 383         }
 384         catch(VersionMismatchException &e)
 385         {
 386                 std::ostringstream err;
 387                 err<<"World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
 388                 err<<"----"<<std::endl;
 389                 err<<"\""<<e.what()<<"\""<<std::endl;
 390                 err<<"See debug.txt."<<std::endl;
 391                 err<<"World probably saved by a newer version of Minetest."<<std::endl;
 392                 m_server->setAsyncFatalError(err.str());
 393         }
 394         catch(SerializationError &e)
 395         {
 396                 std::ostringstream err;
 397                 err<<"Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
 398                 err<<"----"<<std::endl;
 399                 err<<"\""<<e.what()<<"\""<<std::endl;
 400                 err<<"See debug.txt."<<std::endl;
 401                 err<<"You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
 402                 m_server->setAsyncFatalError(err.str());
 403         }
 404
 405         END_DEBUG_EXCEPTION_HANDLER(errorstream)
 406
 407         log_deregister_thread();
 408
 409         return NULL;
 410 }
 411
 412 v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
 413 {
 414         if(pos_exists) *pos_exists = false;
 415         switch(type){
 416         case SSP_LOCAL:
 417                 return v3f(0,0,0);
 418         case SSP_POSITIONAL:
 419                 if(pos_exists) *pos_exists = true;
 420                 return pos;
 421         case SSP_OBJECT: {
 422                 if(object == 0)
 423                         return v3f(0,0,0);
 424                 ServerActiveObject *sao = env->getActiveObject(object);
 425                 if(!sao)
 426                         return v3f(0,0,0);
 427                 if(pos_exists) *pos_exists = true;
 428                 return sao->getBasePosition(); }
 429         }
 430         return v3f(0,0,0);
 431 }
 432
 433 void RemoteClient::GetNextBlocks(Server *server, float dtime,
 434                 core::array<PrioritySortedBlockTransfer> &dest)
 435 {
 436         DSTACK(__FUNCTION_NAME);
 437
 438         /*u32 timer_result;
 439         TimeTaker timer("RemoteClient::GetNextBlocks", &timer_result);*/
 440
 441         // Increment timers
 442         m_nothing_to_send_pause_timer -= dtime;
 443         m_nearest_unsent_reset_timer += dtime;
 444
 445         if(m_nothing_to_send_pause_timer >= 0)
 446                 return;
 447
 448         Player *player = server->m_env->getPlayer(peer_id);
 449         // This can happen sometimes; clients and players are not in perfect sync.
 450         if(player == NULL)
 451                 return;
 452
 453         // Won't send anything if already sending
 454         if(m_blocks_sending.size() >= g_settings->getU16
 455                         ("max_simultaneous_block_sends_per_client"))
 456         {
 457                 //infostream<<"Not sending any blocks, Queue full."<<std::endl;
 458                 return;
 459         }
 460
 461         //TimeTaker timer("RemoteClient::GetNextBlocks");
 462
 463         v3f playerpos = player->getPosition();
 464         v3f playerspeed = player->getSpeed();
 465         v3f playerspeeddir(0,0,0);
 466         if(playerspeed.getLength() > 1.0*BS)
 467                 playerspeeddir = playerspeed / playerspeed.getLength();
 468         // Predict to next block
 469         v3f playerpos_predicted = playerpos + playerspeeddir*MAP_BLOCKSIZE*BS;
 470
 471         v3s16 center_nodepos = floatToInt(playerpos_predicted, BS);
 472
 473         v3s16 center = getNodeBlockPos(center_nodepos);
 474
 475         // Camera position and direction
 476         v3f camera_pos = player->getEyePosition();
 477         v3f camera_dir = v3f(0,0,1);
 478         camera_dir.rotateYZBy(player->getPitch());
 479         camera_dir.rotateXZBy(player->getYaw());
 480
 481         /*infostream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<","
 482                         <<camera_dir.Z<<")"<<std::endl;*/
 483
 484         /*
 485                 Get the starting value of the block finder radius.
 486         */
 487
 488         if(m_last_center != center)
 489         {
 490                 m_nearest_unsent_d = 0;
 491                 m_last_center = center;
 492         }
 493
 494         /*infostream<<"m_nearest_unsent_reset_timer="
 495                         <<m_nearest_unsent_reset_timer<<std::endl;*/
 496
 497         // Reset periodically to workaround for some bugs or stuff
 498         if(m_nearest_unsent_reset_timer > 20.0)
 499         {
 500                 m_nearest_unsent_reset_timer = 0;
 501                 m_nearest_unsent_d = 0;
 502                 //infostream<<"Resetting m_nearest_unsent_d for "
 503                 //              <<server->getPlayerName(peer_id)<<std::endl;
 504         }
 505
 506         //s16 last_nearest_unsent_d = m_nearest_unsent_d;
 507         s16 d_start = m_nearest_unsent_d;
 508
 509         //infostream<<"d_start="<<d_start<<std::endl;
 510
 511         u16 max_simul_sends_setting = g_settings->getU16
 512                         ("max_simultaneous_block_sends_per_client");
 513         u16 max_simul_sends_usually = max_simul_sends_setting;
 514
 515         /*
 516                 Check the time from last addNode/removeNode.
 517
 518                 Decrease send rate if player is building stuff.
 519         */
 520         m_time_from_building += dtime;
 521         if(m_time_from_building < g_settings->getFloat(
 522                                 "full_block_send_enable_min_time_from_building"))
 523         {
 524                 max_simul_sends_usually
 525                         = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS;
 526         }
 527
 528         /*
 529                 Number of blocks sending + number of blocks selected for sending
 530         */
 531         u32 num_blocks_selected = m_blocks_sending.size();
 532
 533         /*
 534                 next time d will be continued from the d from which the nearest
 535                 unsent block was found this time.
 536
 537                 This is because not necessarily any of the blocks found this
 538                 time are actually sent.
 539         */
 540         s32 new_nearest_unsent_d = -1;
 541
 542         s16 d_max = g_settings->getS16("max_block_send_distance");
 543         s16 d_max_gen = g_settings->getS16("max_block_generate_distance");
 544
 545         // Don't loop very much at a time
 546         s16 max_d_increment_at_time = 2;
 547         if(d_max > d_start + max_d_increment_at_time)
 548                 d_max = d_start + max_d_increment_at_time;
 549         /*if(d_max_gen > d_start+2)
 550                 d_max_gen = d_start+2;*/
 551
 552         //infostream<<"Starting from "<<d_start<<std::endl;
 553
 554         s32 nearest_emerged_d = -1;
 555         s32 nearest_emergefull_d = -1;
 556         s32 nearest_sent_d = -1;
 557         bool queue_is_full = false;
 558
 559         s16 d;
 560         for(d = d_start; d <= d_max; d++)
 561         {
 562                 /*errorstream<<"checking d="<<d<<" for "
 563                                 <<server->getPlayerName(peer_id)<<std::endl;*/
 564                 //infostream<<"RemoteClient::SendBlocks(): d="<<d<<std::endl;
 565
 566                 /*
 567                         If m_nearest_unsent_d was changed by the EmergeThread
 568                         (it can change it to 0 through SetBlockNotSent),
 569                         update our d to it.
 570                         Else update m_nearest_unsent_d
 571                 */
 572                 /*if(m_nearest_unsent_d != last_nearest_unsent_d)
 573                 {
 574                         d = m_nearest_unsent_d;
 575                         last_nearest_unsent_d = m_nearest_unsent_d;
 576                 }*/
 577
 578                 /*
 579                         Get the border/face dot coordinates of a "d-radiused"
 580                         box
 581                 */
 582                 core::list<v3s16> list;
 583                 getFacePositions(list, d);
 584
 585                 core::list<v3s16>::Iterator li;
 586                 for(li=list.begin(); li!=list.end(); li++)
 587                 {
 588                         v3s16 p = *li + center;
 589
 590                         /*
 591                                 Send throttling
 592                                 - Don't allow too many simultaneous transfers
 593                                 - EXCEPT when the blocks are very close
 594
 595                                 Also, don't send blocks that are already flying.
 596                         */
 597
 598                         // Start with the usual maximum
 599                         u16 max_simul_dynamic = max_simul_sends_usually;
 600
 601                         // If block is very close, allow full maximum
 602                         if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D)
 603                                 max_simul_dynamic = max_simul_sends_setting;
 604
 605                         // Don't select too many blocks for sending
 606                         if(num_blocks_selected >= max_simul_dynamic)
 607                         {
 608                                 queue_is_full = true;
 609                                 goto queue_full_break;
 610                         }
 611
 612                         // Don't send blocks that are currently being transferred
 613                         if(m_blocks_sending.find(p) != NULL)
 614                                 continue;
 615
 616                         /*
 617                                 Do not go over-limit
 618                         */
 619                         if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 620                         || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 621                         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 622                         || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 623                         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
 624                         || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
 625                                 continue;
 626
 627                         // If this is true, inexistent block will be made from scratch
 628                         bool generate = d <= d_max_gen;
 629
 630                         {
 631                                 /*// Limit the generating area vertically to 2/3
 632                                 if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
 633                                         generate = false;*/
 634
 635                                 // Limit the send area vertically to 1/2
 636                                 if(abs(p.Y - center.Y) > d_max / 2)
 637                                         continue;
 638                         }
 639
 640 #if 0
 641                         /*
 642                                 If block is far away, don't generate it unless it is
 643                                 near ground level.
 644                         */
 645                         if(d >= 4)
 646                         {
 647         #if 1
 648                                 // Block center y in nodes
 649                                 f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2);
 650                                 // Don't generate if it's very high or very low
 651                                 if(y < -64 || y > 64)
 652                                         generate = false;
 653         #endif
 654         #if 0
 655                                 v2s16 p2d_nodes_center(
 656                                         MAP_BLOCKSIZE*p.X,
 657                                         MAP_BLOCKSIZE*p.Z);
 658
 659                                 // Get ground height in nodes
 660                                 s16 gh = server->m_env->getServerMap().findGroundLevel(
 661                                                 p2d_nodes_center);
 662
 663                                 // If differs a lot, don't generate
 664                                 if(fabs(gh - y) > MAP_BLOCKSIZE*2)
 665                                         generate = false;
 666                                         // Actually, don't even send it
 667                                         //continue;
 668         #endif
 669                         }
 670 #endif
 671
 672                         //infostream<<"d="<<d<<std::endl;
 673 #if 1
 674                         /*
 675                                 Don't generate or send if not in sight
 676                                 FIXME This only works if the client uses a small enough
 677                                 FOV setting. The default of 72 degrees is fine.
 678                         */
 679
 680                         float camera_fov = (72.0*M_PI/180) * 4./3.;
 681                         if(isBlockInSight(p, camera_pos, camera_dir, camera_fov, 10000*BS) == false)
 682                         {
 683                                 continue;
 684                         }
 685 #endif
 686                         /*
 687                                 Don't send already sent blocks
 688                         */
 689                         {
 690                                 if(m_blocks_sent.find(p) != NULL)
 691                                 {
 692                                         continue;
 693                                 }
 694                         }
 695
 696                         /*
 697                                 Check if map has this block
 698                         */
 699                         MapBlock *block = server->m_env->getMap().getBlockNoCreateNoEx(p);
 700
 701                         bool surely_not_found_on_disk = false;
 702                         bool block_is_invalid = false;
 703                         if(block != NULL)
 704                         {
 705                                 // Reset usage timer, this block will be of use in the future.
 706                                 block->resetUsageTimer();
 707
 708                                 // Block is dummy if data doesn't exist.
 709                                 // It means it has been not found from disk and not generated
 710                                 if(block->isDummy())
 711                                 {
 712                                         surely_not_found_on_disk = true;
 713                                 }
 714
 715                                 // Block is valid if lighting is up-to-date and data exists
 716                                 if(block->isValid() == false)
 717                                 {
 718                                         block_is_invalid = true;
 719                                 }
 720
 721                                 /*if(block->isFullyGenerated() == false)
 722                                 {
 723                                         block_is_invalid = true;
 724                                 }*/
 725
 726 #if 0
 727                                 v2s16 p2d(p.X, p.Z);
 728                                 ServerMap *map = (ServerMap*)(&server->m_env->getMap());
 729                                 v2s16 chunkpos = map->sector_to_chunk(p2d);
 730                                 if(map->chunkNonVolatile(chunkpos) == false)
 731                                         block_is_invalid = true;
 732 #endif
 733                                 if(block->isGenerated() == false)
 734                                         block_is_invalid = true;
 735 #if 1
 736                                 /*
 737                                         If block is not close, don't send it unless it is near
 738                                         ground level.
 739
 740                                         Block is near ground level if night-time mesh
 741                                         differs from day-time mesh.
 742                                 */
 743                                 if(d >= 4)
 744                                 {
 745                                         if(block->getDayNightDiff() == false)
 746                                                 continue;
 747                                 }
 748 #endif
 749                         }
 750
 751                         /*
 752                                 If block has been marked to not exist on disk (dummy)
 753                                 and generating new ones is not wanted, skip block.
 754                         */
 755                         if(generate == false && surely_not_found_on_disk == true)
 756                         {
 757                                 // get next one.
 758                                 continue;
 759                         }
 760
 761                         /*
 762                                 Add inexistent block to emerge queue.
 763                         */
 764                         if(block == NULL || surely_not_found_on_disk || block_is_invalid)
 765                         {
 766                                 //TODO: Get value from somewhere
 767                                 // Allow only one block in emerge queue
 768                                 //if(server->m_emerge_queue.peerItemCount(peer_id) < 1)
 769                                 // Allow two blocks in queue per client
 770                                 //if(server->m_emerge_queue.peerItemCount(peer_id) < 2)
 771                                 u32 max_emerge = 5;
 772                                 // Make it more responsive when needing to generate stuff
 773                                 if(surely_not_found_on_disk)
 774                                         max_emerge = 1;
 775                                 if(server->m_emerge_queue.peerItemCount(peer_id) < max_emerge)
 776                                 {
 777                                         //infostream<<"Adding block to emerge queue"<<std::endl;
 778
 779                                         // Add it to the emerge queue and trigger the thread
 780
 781                                         u8 flags = 0;
 782                                         if(generate == false)
 783                                                 flags |= BLOCK_EMERGE_FLAG_FROMDISK;
 784
 785                                         server->m_emerge_queue.addBlock(peer_id, p, flags);
 786                                         server->m_emergethread.trigger();
 787
 788                                         if(nearest_emerged_d == -1)
 789                                                 nearest_emerged_d = d;
 790                                 } else {
 791                                         if(nearest_emergefull_d == -1)
 792                                                 nearest_emergefull_d = d;
 793                                 }
 794
 795                                 // get next one.
 796                                 continue;
 797                         }
 798
 799                         if(nearest_sent_d == -1)
 800                                 nearest_sent_d = d;
 801
 802                         /*
 803                                 Add block to send queue
 804                         */
 805
 806                         /*errorstream<<"sending from d="<<d<<" to "
 807                                         <<server->getPlayerName(peer_id)<<std::endl;*/
 808
 809                         PrioritySortedBlockTransfer q((float)d, p, peer_id);
 810
 811                         dest.push_back(q);
 812
 813                         num_blocks_selected += 1;
 814                 }
 815         }
 816 queue_full_break:
 817
 818         //infostream<<"Stopped at "<<d<<std::endl;
 819
 820         // If nothing was found for sending and nothing was queued for
 821         // emerging, continue next time browsing from here
 822         if(nearest_emerged_d != -1){
 823                 new_nearest_unsent_d = nearest_emerged_d;
 824         } else if(nearest_emergefull_d != -1){
 825                 new_nearest_unsent_d = nearest_emergefull_d;
 826         } else {
 827                 if(d > g_settings->getS16("max_block_send_distance")){
 828                         new_nearest_unsent_d = 0;
 829                         m_nothing_to_send_pause_timer = 2.0;
 830                         /*infostream<<"GetNextBlocks(): d wrapped around for "
 831                                         <<server->getPlayerName(peer_id)
 832                                         <<"; setting to 0 and pausing"<<std::endl;*/
 833                 } else {
 834                         if(nearest_sent_d != -1)
 835                                 new_nearest_unsent_d = nearest_sent_d;
 836                         else
 837                                 new_nearest_unsent_d = d;
 838                 }
 839         }
 840
 841         if(new_nearest_unsent_d != -1)
 842                 m_nearest_unsent_d = new_nearest_unsent_d;
 843
 844         /*timer_result = timer.stop(true);
 845         if(timer_result != 0)
 846                 infostream<<"GetNextBlocks timeout: "<<timer_result<<" (!=0)"<<std::endl;*/
 847 }
 848
 849 void RemoteClient::GotBlock(v3s16 p)
 850 {
 851         if(m_blocks_sending.find(p) != NULL)
 852                 m_blocks_sending.remove(p);
 853         else
 854         {
 855                 /*infostream<<"RemoteClient::GotBlock(): Didn't find in"
 856                                 " m_blocks_sending"<<std::endl;*/
 857                 m_excess_gotblocks++;
 858         }
 859         m_blocks_sent.insert(p, true);
 860 }
 861
 862 void RemoteClient::SentBlock(v3s16 p)
 863 {
 864         if(m_blocks_sending.find(p) == NULL)
 865                 m_blocks_sending.insert(p, 0.0);
 866         else
 867                 infostream<<"RemoteClient::SentBlock(): Sent block"
 868                                 " already in m_blocks_sending"<<std::endl;
 869 }
 870
 871 void RemoteClient::SetBlockNotSent(v3s16 p)
 872 {
 873         m_nearest_unsent_d = 0;
 874
 875         if(m_blocks_sending.find(p) != NULL)
 876                 m_blocks_sending.remove(p);
 877         if(m_blocks_sent.find(p) != NULL)
 878                 m_blocks_sent.remove(p);
 879 }
 880
 881 void RemoteClient::SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks)
 882 {
 883         m_nearest_unsent_d = 0;
 884
 885         for(core::map<v3s16, MapBlock*>::Iterator
 886                         i = blocks.getIterator();
 887                         i.atEnd()==false; i++)
 888         {
 889                 v3s16 p = i.getNode()->getKey();
 890
 891                 if(m_blocks_sending.find(p) != NULL)
 892                         m_blocks_sending.remove(p);
 893                 if(m_blocks_sent.find(p) != NULL)
 894                         m_blocks_sent.remove(p);
 895         }
 896 }
 897
 898 /*
 899         PlayerInfo
 900 */
 901
 902 PlayerInfo::PlayerInfo()
 903 {
 904         name[0] = 0;
 905         avg_rtt = 0;
 906 }
 907
 908 void PlayerInfo::PrintLine(std::ostream *s)
 909 {
 910         (*s)<<id<<": ";
 911         (*s)<<"\""<<name<<"\" ("
 912                         <<(position.X/10)<<","<<(position.Y/10)
 913                         <<","<<(position.Z/10)<<") ";
 914         address.print(s);
 915         (*s)<<" avg_rtt="<<avg_rtt;
 916         (*s)<<std::endl;
 917 }
 918
 919 /*
 920         Server
 921 */
 922
 923 Server::Server(
 924                 const std::string &path_world,
 925                 const std::string &path_config,
 926                 const SubgameSpec &gamespec,
 927                 bool simple_singleplayer_mode
 928         ):
 929         m_path_world(path_world),
 930         m_path_config(path_config),
 931         m_gamespec(gamespec),
 932         m_simple_singleplayer_mode(simple_singleplayer_mode),
 933         m_async_fatal_error(""),
 934         m_env(NULL),
 935         m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
 936         m_banmanager(path_world+DIR_DELIM+"ipban.txt"),
 937         m_rollback(NULL),
 938         m_rollback_sink_enabled(true),
 939         m_enable_rollback_recording(false),
 940         m_lua(NULL),
 941         m_itemdef(createItemDefManager()),
 942         m_nodedef(createNodeDefManager()),
 943         m_craftdef(createCraftDefManager()),
 944         m_event(new EventManager()),
 945         m_thread(this),
 946         m_emergethread(this),
 947         m_time_of_day_send_timer(0),
 948         m_uptime(0),
 949         m_shutdown_requested(false),
 950         m_ignore_map_edit_events(false),
 951         m_ignore_map_edit_events_peer_id(0)
 952 {
 953         m_liquid_transform_timer = 0.0;
 954         m_print_info_timer = 0.0;
 955         m_objectdata_timer = 0.0;
 956         m_emergethread_trigger_timer = 0.0;
 957         m_savemap_timer = 0.0;
 958
 959         m_env_mutex.Init();
 960         m_con_mutex.Init();
 961         m_step_dtime_mutex.Init();
 962         m_step_dtime = 0.0;
 963
 964         if(path_world == "")
 965                 throw ServerError("Supplied empty world path");
 966
 967         if(!gamespec.isValid())
 968                 throw ServerError("Supplied invalid gamespec");
 969
 970         infostream<<"Server created for gameid \""<<m_gamespec.id<<"\"";
 971         if(m_simple_singleplayer_mode)
 972                 infostream<<" in simple singleplayer mode"<<std::endl;
 973         else
 974                 infostream<<std::endl;
 975         infostream<<"- world:  "<<m_path_world<<std::endl;
 976         infostream<<"- config: "<<m_path_config<<std::endl;
 977         infostream<<"- game:   "<<m_gamespec.path<<std::endl;
 978
 979         // Create rollback manager
 980         std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
 981         m_rollback = createRollbackManager(rollback_path, this);
 982
 983         // Add world mod search path
 984         m_modspaths.push_front(m_path_world + DIR_DELIM + "worldmods");
 985         // Add addon mod search path
 986         for(std::set<std::string>::const_iterator i = m_gamespec.mods_paths.begin();
 987                         i != m_gamespec.mods_paths.end(); i++)
 988                 m_modspaths.push_front((*i));
 989
 990         // Print out mod search paths
 991         for(core::list<std::string>::Iterator i = m_modspaths.begin();
 992                         i != m_modspaths.end(); i++){
 993                 std::string modspath = *i;
 994                 infostream<<"- mods:   "<<modspath<<std::endl;
 995         }
 996
 997         // Path to builtin.lua
 998         std::string builtinpath = getBuiltinLuaPath() + DIR_DELIM + "builtin.lua";
 999
1000         // Create world if it doesn't exist
1001         if(!initializeWorld(m_path_world, m_gamespec.id))
1002                 throw ServerError("Failed to initialize world");
1003
1004         // Lock environment
1005         JMutexAutoLock envlock(m_env_mutex);
1006         JMutexAutoLock conlock(m_con_mutex);
1007
1008         // Initialize scripting
1009
1010         infostream<<"Server: Initializing Lua"<<std::endl;
1011         m_lua = script_init();
1012         assert(m_lua);
1013         // Export API
1014         scriptapi_export(m_lua, this);
1015         // Load and run builtin.lua
1016         infostream<<"Server: Loading builtin.lua [\""
1017                         <<builtinpath<<"\"]"<<std::endl;
1018         bool success = scriptapi_loadmod(m_lua, builtinpath, "__builtin");
1019         if(!success){
1020                 errorstream<<"Server: Failed to load and run "
1021                                 <<builtinpath<<std::endl;
1022                 throw ModError("Failed to load and run "+builtinpath);
1023         }
1024         // Find mods in mod search paths
1025         m_mods = getMods(m_modspaths);
1026         // Print 'em
1027         infostream<<"Server: Loading mods: ";
1028         for(core::list<ModSpec>::Iterator i = m_mods.begin();
1029                         i != m_mods.end(); i++){
1030                 const ModSpec &mod = *i;
1031                 infostream<<mod.name<<" ";
1032         }
1033         infostream<<std::endl;
1034         // Load and run "mod" scripts
1035         for(core::list<ModSpec>::Iterator i = m_mods.begin();
1036                         i != m_mods.end(); i++){
1037                 const ModSpec &mod = *i;
1038                 std::string scriptpath = mod.path + DIR_DELIM + "init.lua";
1039                 infostream<<"  ["<<padStringRight(mod.name, 12)<<"] [\""
1040                                 <<scriptpath<<"\"]"<<std::endl;
1041                 bool success = scriptapi_loadmod(m_lua, scriptpath, mod.name);
1042                 if(!success){
1043                         errorstream<<"Server: Failed to load and run "
1044                                         <<scriptpath<<std::endl;
1045                         throw ModError("Failed to load and run "+scriptpath);
1046                 }
1047         }
1048
1049         // Read Textures and calculate sha1 sums
1050         fillMediaCache();
1051
1052         // Apply item aliases in the node definition manager
1053         m_nodedef->updateAliases(m_itemdef);
1054
1055         // Initialize Environment
1056
1057         m_env = new ServerEnvironment(new ServerMap(path_world, this), m_lua,
1058                         this, this);
1059
1060         // Give environment reference to scripting api
1061         scriptapi_add_environment(m_lua, m_env);
1062
1063         // Register us to receive map edit events
1064         m_env->getMap().addEventReceiver(this);
1065
1066         // If file exists, load environment metadata
1067         if(fs::PathExists(m_path_world+DIR_DELIM+"env_meta.txt"))
1068         {
1069                 infostream<<"Server: Loading environment metadata"<<std::endl;
1070                 m_env->loadMeta(m_path_world);
1071         }
1072
1073         // Load players
1074         infostream<<"Server: Loading players"<<std::endl;
1075         m_env->deSerializePlayers(m_path_world);
1076
1077         /*
1078                 Add some test ActiveBlockModifiers to environment
1079         */
1080         add_legacy_abms(m_env, m_nodedef);
1081 }
1082
1083 Server::~Server()
1084 {
1085         infostream<<"Server destructing"<<std::endl;
1086
1087         /*
1088                 Send shutdown message
1089         */
1090         {
1091                 JMutexAutoLock conlock(m_con_mutex);
1092
1093                 std::wstring line = L"*** Server shutting down";
1094
1095                 /*
1096                         Send the message to clients
1097                 */
1098                 for(core::map<u16, RemoteClient*>::Iterator
1099                         i = m_clients.getIterator();
1100                         i.atEnd() == false; i++)
1101                 {
1102                         // Get client and check that it is valid
1103                         RemoteClient *client = i.getNode()->getValue();
1104                         assert(client->peer_id == i.getNode()->getKey());
1105                         if(client->serialization_version == SER_FMT_VER_INVALID)
1106                                 continue;
1107
1108                         try{
1109                                 SendChatMessage(client->peer_id, line);
1110                         }
1111                         catch(con::PeerNotFoundException &e)
1112                         {}
1113                 }
1114         }
1115
1116         {
1117                 JMutexAutoLock envlock(m_env_mutex);
1118                 JMutexAutoLock conlock(m_con_mutex);
1119
1120                 /*
1121                         Execute script shutdown hooks
1122                 */
1123                 scriptapi_on_shutdown(m_lua);
1124         }
1125
1126         {
1127                 JMutexAutoLock envlock(m_env_mutex);
1128
1129                 /*
1130                         Save players
1131                 */
1132                 infostream<<"Server: Saving players"<<std::endl;
1133                 m_env->serializePlayers(m_path_world);
1134
1135                 /*
1136                         Save environment metadata
1137                 */
1138                 infostream<<"Server: Saving environment metadata"<<std::endl;
1139                 m_env->saveMeta(m_path_world);
1140         }
1141
1142         /*
1143                 Stop threads
1144         */
1145         stop();
1146
1147         /*
1148                 Delete clients
1149         */
1150         {
1151                 JMutexAutoLock clientslock(m_con_mutex);
1152
1153                 for(core::map<u16, RemoteClient*>::Iterator
1154                         i = m_clients.getIterator();
1155                         i.atEnd() == false; i++)
1156                 {
1157                         // Delete client
1158                         delete i.getNode()->getValue();
1159                 }
1160         }
1161
1162         // Delete things in the reverse order of creation
1163         delete m_env;
1164         delete m_rollback;
1165         delete m_event;
1166         delete m_itemdef;
1167         delete m_nodedef;
1168         delete m_craftdef;
1169
1170         // Deinitialize scripting
1171         infostream<<"Server: Deinitializing scripting"<<std::endl;
1172         script_deinit(m_lua);
1173
1174         // Delete detached inventories
1175         {
1176                 for(std::map<std::string, Inventory*>::iterator
1177                                 i = m_detached_inventories.begin();
1178                                 i != m_detached_inventories.end(); i++){
1179                         delete i->second;
1180                 }
1181         }
1182 }
1183
1184 void Server::start(unsigned short port)
1185 {
1186         DSTACK(__FUNCTION_NAME);
1187         infostream<<"Starting server on port "<<port<<"..."<<std::endl;
1188
1189         // Stop thread if already running
1190         m_thread.stop();
1191
1192         // Initialize connection
1193         m_con.SetTimeoutMs(30);
1194         m_con.Serve(port);
1195
1196         // Start thread
1197         m_thread.setRun(true);
1198         m_thread.Start();
1199
1200         // ASCII art for the win!
1201         actionstream
1202         <<"        .__               __                   __   "<<std::endl
1203         <<"  _____ |__| ____   _____/  |_  ____   _______/  |_ "<<std::endl
1204         <<" /     \\|  |/    \\_/ __ \\   __\\/ __ \\ /  ___/\\   __\\"<<std::endl
1205         <<"|  Y Y  \\  |   |  \\  ___/|  | \\  ___/ \\___ \\  |  |  "<<std::endl
1206         <<"|__|_|  /__|___|  /\\___  >__|  \\___  >____  > |__|  "<<std::endl
1207         <<"      \\/        \\/     \\/          \\/     \\/        "<<std::endl;
1208         actionstream<<"World at ["<<m_path_world<<"]"<<std::endl;
1209         actionstream<<"Server for gameid=\""<<m_gamespec.id
1210                         <<"\" listening on port "<<port<<"."<<std::endl;
1211 }
1212
1213 void Server::stop()
1214 {
1215         DSTACK(__FUNCTION_NAME);
1216
1217         infostream<<"Server: Stopping and waiting threads"<<std::endl;
1218
1219         // Stop threads (set run=false first so both start stopping)
1220         m_thread.setRun(false);
1221         m_emergethread.setRun(false);
1222         m_thread.stop();
1223         m_emergethread.stop();
1224
1225         infostream<<"Server: Threads stopped"<<std::endl;
1226 }
1227
1228 void Server::step(float dtime)
1229 {
1230         DSTACK(__FUNCTION_NAME);
1231         // Limit a bit
1232         if(dtime > 2.0)
1233                 dtime = 2.0;
1234         {
1235                 JMutexAutoLock lock(m_step_dtime_mutex);
1236                 m_step_dtime += dtime;
1237         }
1238         // Throw if fatal error occurred in thread
1239         std::string async_err = m_async_fatal_error.get();
1240         if(async_err != ""){
1241                 throw ServerError(async_err);
1242         }
1243 }
1244
1245 void Server::AsyncRunStep()
1246 {
1247         DSTACK(__FUNCTION_NAME);
1248
1249         g_profiler->add("Server::AsyncRunStep (num)", 1);
1250
1251         float dtime;
1252         {
1253                 JMutexAutoLock lock1(m_step_dtime_mutex);
1254                 dtime = m_step_dtime;
1255         }
1256
1257         {
1258                 // Send blocks to clients
1259                 SendBlocks(dtime);
1260         }
1261
1262         if(dtime < 0.001)
1263                 return;
1264
1265         g_profiler->add("Server::AsyncRunStep with dtime (num)", 1);
1266
1267         //infostream<<"Server steps "<<dtime<<std::endl;
1268         //infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
1269
1270         {
1271                 JMutexAutoLock lock1(m_step_dtime_mutex);
1272                 m_step_dtime -= dtime;
1273         }
1274
1275         /*
1276                 Update uptime
1277         */
1278         {
1279                 m_uptime.set(m_uptime.get() + dtime);
1280         }
1281
1282         {
1283                 // Process connection's timeouts
1284                 JMutexAutoLock lock2(m_con_mutex);
1285                 ScopeProfiler sp(g_profiler, "Server: connection timeout processing");
1286                 m_con.RunTimeouts(dtime);
1287         }
1288
1289         {
1290                 // This has to be called so that the client list gets synced
1291                 // with the peer list of the connection
1292                 handlePeerChanges();
1293         }
1294
1295         /*
1296                 Update time of day and overall game time
1297         */
1298         {
1299                 JMutexAutoLock envlock(m_env_mutex);
1300
1301                 m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
1302
1303                 /*
1304                         Send to clients at constant intervals
1305                 */
1306
1307                 m_time_of_day_send_timer -= dtime;
1308                 if(m_time_of_day_send_timer < 0.0)
1309                 {
1310                         m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
1311
1312                         //JMutexAutoLock envlock(m_env_mutex);
1313                         JMutexAutoLock conlock(m_con_mutex);
1314
1315                         for(core::map<u16, RemoteClient*>::Iterator
1316                                 i = m_clients.getIterator();
1317                                 i.atEnd() == false; i++)
1318                         {
1319                                 RemoteClient *client = i.getNode()->getValue();
1320                                 SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
1321                                                 m_env->getTimeOfDay(), g_settings->getFloat("time_speed"));
1322                                 // Send as reliable
1323                                 m_con.Send(client->peer_id, 0, data, true);
1324                         }
1325                 }
1326         }
1327
1328         {
1329                 JMutexAutoLock lock(m_env_mutex);
1330                 // Step environment
1331                 ScopeProfiler sp(g_profiler, "SEnv step");
1332                 ScopeProfiler sp2(g_profiler, "SEnv step avg", SPT_AVG);
1333                 m_env->step(dtime);
1334         }
1335
1336         const float map_timer_and_unload_dtime = 2.92;
1337         if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
1338         {
1339                 JMutexAutoLock lock(m_env_mutex);
1340                 // Run Map's timers and unload unused data
1341                 ScopeProfiler sp(g_profiler, "Server: map timer and unload");
1342                 m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
1343                                 g_settings->getFloat("server_unload_unused_data_timeout"));
1344         }
1345
1346         /*
1347                 Do background stuff
1348         */
1349
1350         /*
1351                 Handle players
1352         */
1353         {
1354                 JMutexAutoLock lock(m_env_mutex);
1355                 JMutexAutoLock lock2(m_con_mutex);
1356
1357                 ScopeProfiler sp(g_profiler, "Server: handle players");
1358
1359                 for(core::map<u16, RemoteClient*>::Iterator
1360                         i = m_clients.getIterator();
1361                         i.atEnd() == false; i++)
1362                 {
1363                         RemoteClient *client = i.getNode()->getValue();
1364                         PlayerSAO *playersao = getPlayerSAO(client->peer_id);
1365                         if(playersao == NULL)
1366                                 continue;
1367
1368                         /*
1369                                 Handle player HPs (die if hp=0)
1370                         */
1371                         if(playersao->m_hp_not_sent && g_settings->getBool("enable_damage"))
1372                         {
1373                                 if(playersao->getHP() == 0)
1374                                         DiePlayer(client->peer_id);
1375                                 else
1376                                         SendPlayerHP(client->peer_id);
1377                         }
1378
1379                         /*
1380                                 Send player inventories if necessary
1381                         */
1382                         if(playersao->m_moved){
1383                                 SendMovePlayer(client->peer_id);
1384                                 playersao->m_moved = false;
1385                         }
1386                         if(playersao->m_inventory_not_sent){
1387                                 UpdateCrafting(client->peer_id);
1388                                 SendInventory(client->peer_id);
1389                         }
1390                 }
1391         }
1392
1393         /* Transform liquids */
1394         m_liquid_transform_timer += dtime;
1395         if(m_liquid_transform_timer >= 1.00)
1396         {
1397                 m_liquid_transform_timer -= 1.00;
1398
1399                 JMutexAutoLock lock(m_env_mutex);
1400
1401                 ScopeProfiler sp(g_profiler, "Server: liquid transform");
1402
1403                 core::map<v3s16, MapBlock*> modified_blocks;
1404                 m_env->getMap().transformLiquids(modified_blocks);
1405 #if 0
1406                 /*
1407                         Update lighting
1408                 */
1409                 core::map<v3s16, MapBlock*> lighting_modified_blocks;
1410                 ServerMap &map = ((ServerMap&)m_env->getMap());
1411                 map.updateLighting(modified_blocks, lighting_modified_blocks);
1412
1413                 // Add blocks modified by lighting to modified_blocks
1414                 for(core::map<v3s16, MapBlock*>::Iterator
1415                                 i = lighting_modified_blocks.getIterator();
1416                                 i.atEnd() == false; i++)
1417                 {
1418                         MapBlock *block = i.getNode()->getValue();
1419                         modified_blocks.insert(block->getPos(), block);
1420                 }
1421 #endif
1422                 /*
1423                         Set the modified blocks unsent for all the clients
1424                 */
1425
1426                 JMutexAutoLock lock2(m_con_mutex);
1427
1428                 for(core::map<u16, RemoteClient*>::Iterator
1429                                 i = m_clients.getIterator();
1430                                 i.atEnd() == false; i++)
1431                 {
1432                         RemoteClient *client = i.getNode()->getValue();
1433
1434                         if(modified_blocks.size() > 0)
1435                         {
1436                                 // Remove block from sent history
1437                                 client->SetBlocksNotSent(modified_blocks);
1438                         }
1439                 }
1440         }
1441
1442         // Periodically print some info
1443         {
1444                 float &counter = m_print_info_timer;
1445                 counter += dtime;
1446                 if(counter >= 30.0)
1447                 {
1448                         counter = 0.0;
1449
1450                         JMutexAutoLock lock2(m_con_mutex);
1451
1452                         if(m_clients.size() != 0)
1453                                 infostream<<"Players:"<<std::endl;
1454                         for(core::map<u16, RemoteClient*>::Iterator
1455                                 i = m_clients.getIterator();
1456                                 i.atEnd() == false; i++)
1457                         {
1458                                 //u16 peer_id = i.getNode()->getKey();
1459                                 RemoteClient *client = i.getNode()->getValue();
1460                                 Player *player = m_env->getPlayer(client->peer_id);
1461                                 if(player==NULL)
1462                                         continue;
1463                                 infostream<<"* "<<player->getName()<<"\t";
1464                                 client->PrintInfo(infostream);
1465                         }
1466                 }
1467         }
1468
1469         //if(g_settings->getBool("enable_experimental"))
1470         {
1471
1472         /*
1473                 Check added and deleted active objects
1474         */
1475         {
1476                 //infostream<<"Server: Checking added and deleted active objects"<<std::endl;
1477                 JMutexAutoLock envlock(m_env_mutex);
1478                 JMutexAutoLock conlock(m_con_mutex);
1479
1480                 ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
1481
1482                 // Radius inside which objects are active
1483                 s16 radius = g_settings->getS16("active_object_send_range_blocks");
1484                 radius *= MAP_BLOCKSIZE;
1485
1486                 for(core::map<u16, RemoteClient*>::Iterator
1487                         i = m_clients.getIterator();
1488                         i.atEnd() == false; i++)
1489                 {
1490                         RemoteClient *client = i.getNode()->getValue();
1491
1492                         // If definitions and textures have not been sent, don't
1493                         // send objects either
1494                         if(!client->definitions_sent)
1495                                 continue;
1496
1497                         Player *player = m_env->getPlayer(client->peer_id);
1498                         if(player==NULL)
1499                         {
1500                                 // This can happen if the client timeouts somehow
1501                                 /*infostream<<"WARNING: "<<__FUNCTION_NAME<<": Client "
1502                                                 <<client->peer_id
1503                                                 <<" has no associated player"<<std::endl;*/
1504                                 continue;
1505                         }
1506                         v3s16 pos = floatToInt(player->getPosition(), BS);
1507
1508                         core::map<u16, bool> removed_objects;
1509                         core::map<u16, bool> added_objects;
1510                         m_env->getRemovedActiveObjects(pos, radius,
1511                                         client->m_known_objects, removed_objects);
1512                         m_env->getAddedActiveObjects(pos, radius,
1513                                         client->m_known_objects, added_objects);
1514
1515                         // Ignore if nothing happened
1516                         if(removed_objects.size() == 0 && added_objects.size() == 0)
1517                         {
1518                                 //infostream<<"active objects: none changed"<<std::endl;
1519                                 continue;
1520                         }
1521
1522                         std::string data_buffer;
1523
1524                         char buf[4];
1525
1526                         // Handle removed objects
1527                         writeU16((u8*)buf, removed_objects.size());
1528                         data_buffer.append(buf, 2);
1529                         for(core::map<u16, bool>::Iterator
1530                                         i = removed_objects.getIterator();
1531                                         i.atEnd()==false; i++)
1532                         {
1533                                 // Get object
1534                                 u16 id = i.getNode()->getKey();
1535                                 ServerActiveObject* obj = m_env->getActiveObject(id);
1536
1537                                 // Add to data buffer for sending
1538                                 writeU16((u8*)buf, i.getNode()->getKey());
1539                                 data_buffer.append(buf, 2);
1540
1541                                 // Remove from known objects
1542                                 client->m_known_objects.remove(i.getNode()->getKey());
1543
1544                                 if(obj && obj->m_known_by_count > 0)
1545                                         obj->m_known_by_count--;
1546                         }
1547
1548                         // Handle added objects
1549                         writeU16((u8*)buf, added_objects.size());
1550                         data_buffer.append(buf, 2);
1551                         for(core::map<u16, bool>::Iterator
1552                                         i = added_objects.getIterator();
1553                                         i.atEnd()==false; i++)
1554                         {
1555                                 // Get object
1556                                 u16 id = i.getNode()->getKey();
1557                                 ServerActiveObject* obj = m_env->getActiveObject(id);
1558
1559                                 // Get object type
1560                                 u8 type = ACTIVEOBJECT_TYPE_INVALID;
1561                                 if(obj == NULL)
1562                                         infostream<<"WARNING: "<<__FUNCTION_NAME
1563                                                         <<": NULL object"<<std::endl;
1564                                 else
1565                                         type = obj->getSendType();
1566
1567                                 // Add to data buffer for sending
1568                                 writeU16((u8*)buf, id);
1569                                 data_buffer.append(buf, 2);
1570                                 writeU8((u8*)buf, type);
1571                                 data_buffer.append(buf, 1);
1572
1573                                 if(obj)
1574                                         data_buffer.append(serializeLongString(
1575                                                         obj->getClientInitializationData(client->net_proto_version)));
1576                                 else
1577                                         data_buffer.append(serializeLongString(""));
1578
1579                                 // Add to known objects
1580                                 client->m_known_objects.insert(i.getNode()->getKey(), false);
1581
1582                                 if(obj)
1583                                         obj->m_known_by_count++;
1584                         }
1585
1586                         // Send packet
1587                         SharedBuffer<u8> reply(2 + data_buffer.size());
1588                         writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD);
1589                         memcpy((char*)&reply[2], data_buffer.c_str(),
1590                                         data_buffer.size());
1591                         // Send as reliable
1592                         m_con.Send(client->peer_id, 0, reply, true);
1593
1594                         verbosestream<<"Server: Sent object remove/add: "
1595                                         <<removed_objects.size()<<" removed, "
1596                                         <<added_objects.size()<<" added, "
1597                                         <<"packet size is "<<reply.getSize()<<std::endl;
1598                 }
1599
1600 #if 0
1601                 /*
1602                         Collect a list of all the objects known by the clients
1603                         and report it back to the environment.
1604                 */
1605
1606                 core::map<u16, bool> all_known_objects;
1607
1608                 for(core::map<u16, RemoteClient*>::Iterator
1609                         i = m_clients.getIterator();
1610                         i.atEnd() == false; i++)
1611                 {
1612                         RemoteClient *client = i.getNode()->getValue();
1613                         // Go through all known objects of client
1614                         for(core::map<u16, bool>::Iterator
1615                                         i = client->m_known_objects.getIterator();
1616                                         i.atEnd()==false; i++)
1617                         {
1618                                 u16 id = i.getNode()->getKey();
1619                                 all_known_objects[id] = true;
1620                         }
1621                 }
1622
1623                 m_env->setKnownActiveObjects(whatever);
1624 #endif
1625
1626         }
1627
1628         /*
1629                 Send object messages
1630         */
1631         {
1632                 JMutexAutoLock envlock(m_env_mutex);
1633                 JMutexAutoLock conlock(m_con_mutex);
1634
1635                 ScopeProfiler sp(g_profiler, "Server: sending object messages");
1636
1637                 // Key = object id
1638                 // Value = data sent by object
1639                 core::map<u16, core::list<ActiveObjectMessage>* > buffered_messages;
1640
1641                 // Get active object messages from environment
1642                 for(;;)
1643                 {
1644                         ActiveObjectMessage aom = m_env->getActiveObjectMessage();
1645                         if(aom.id == 0)
1646                                 break;
1647
1648                         core::list<ActiveObjectMessage>* message_list = NULL;
1649                         core::map<u16, core::list<ActiveObjectMessage>* >::Node *n;
1650                         n = buffered_messages.find(aom.id);
1651                         if(n == NULL)
1652                         {
1653                                 message_list = new core::list<ActiveObjectMessage>;
1654                                 buffered_messages.insert(aom.id, message_list);
1655                         }
1656                         else
1657                         {
1658                                 message_list = n->getValue();
1659                         }
1660                         message_list->push_back(aom);
1661                 }
1662
1663                 // Route data to every client
1664                 for(core::map<u16, RemoteClient*>::Iterator
1665                         i = m_clients.getIterator();
1666                         i.atEnd()==false; i++)
1667                 {
1668                         RemoteClient *client = i.getNode()->getValue();
1669                         std::string reliable_data;
1670                         std::string unreliable_data;
1671                         // Go through all objects in message buffer
1672                         for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
1673                                         j = buffered_messages.getIterator();
1674                                         j.atEnd()==false; j++)
1675                         {
1676                                 // If object is not known by client, skip it
1677                                 u16 id = j.getNode()->getKey();
1678                                 if(client->m_known_objects.find(id) == NULL)
1679                                         continue;
1680                                 // Get message list of object
1681                                 core::list<ActiveObjectMessage>* list = j.getNode()->getValue();
1682                                 // Go through every message
1683                                 for(core::list<ActiveObjectMessage>::Iterator
1684                                                 k = list->begin(); k != list->end(); k++)
1685                                 {
1686                                         // Compose the full new data with header
1687                                         ActiveObjectMessage aom = *k;
1688                                         std::string new_data;
1689                                         // Add object id
1690                                         char buf[2];
1691                                         writeU16((u8*)&buf[0], aom.id);
1692                                         new_data.append(buf, 2);
1693                                         // Add data
1694                                         new_data += serializeString(aom.datastring);
1695                                         // Add data to buffer
1696                                         if(aom.reliable)
1697                                                 reliable_data += new_data;
1698                                         else
1699                                                 unreliable_data += new_data;
1700                                 }
1701                         }
1702                         /*
1703                                 reliable_data and unreliable_data are now ready.
1704                                 Send them.
1705                         */
1706                         if(reliable_data.size() > 0)
1707                         {
1708                                 SharedBuffer<u8> reply(2 + reliable_data.size());
1709                                 writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
1710                                 memcpy((char*)&reply[2], reliable_data.c_str(),
1711                                                 reliable_data.size());
1712                                 // Send as reliable
1713                                 m_con.Send(client->peer_id, 0, reply, true);
1714                         }
1715                         if(unreliable_data.size() > 0)
1716                         {
1717                                 SharedBuffer<u8> reply(2 + unreliable_data.size());
1718                                 writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
1719                                 memcpy((char*)&reply[2], unreliable_data.c_str(),
1720                                                 unreliable_data.size());
1721                                 // Send as unreliable
1722                                 m_con.Send(client->peer_id, 0, reply, false);
1723                         }
1724
1725                         /*if(reliable_data.size() > 0 || unreliable_data.size() > 0)
1726                         {
1727                                 infostream<<"Server: Size of object message data: "
1728                                                 <<"reliable: "<<reliable_data.size()
1729                                                 <<", unreliable: "<<unreliable_data.size()
1730                                                 <<std::endl;
1731                         }*/
1732                 }
1733
1734                 // Clear buffered_messages
1735                 for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
1736                                 i = buffered_messages.getIterator();
1737                                 i.atEnd()==false; i++)
1738                 {
1739                         delete i.getNode()->getValue();
1740                 }
1741         }
1742
1743         } // enable_experimental
1744
1745         /*
1746                 Send queued-for-sending map edit events.
1747         */
1748         {
1749                 // We will be accessing the environment and the connection
1750                 JMutexAutoLock lock(m_env_mutex);
1751                 JMutexAutoLock conlock(m_con_mutex);
1752
1753                 // Don't send too many at a time
1754                 //u32 count = 0;
1755
1756                 // Single change sending is disabled if queue size is not small
1757                 bool disable_single_change_sending = false;
1758                 if(m_unsent_map_edit_queue.size() >= 4)
1759                         disable_single_change_sending = true;
1760
1761                 int event_count = m_unsent_map_edit_queue.size();
1762
1763                 // We'll log the amount of each
1764                 Profiler prof;
1765
1766                 while(m_unsent_map_edit_queue.size() != 0)
1767                 {
1768                         MapEditEvent* event = m_unsent_map_edit_queue.pop_front();
1769
1770                         // Players far away from the change are stored here.
1771                         // Instead of sending the changes, MapBlocks are set not sent
1772                         // for them.
1773                         core::list<u16> far_players;
1774
1775                         if(event->type == MEET_ADDNODE)
1776                         {
1777                                 //infostream<<"Server: MEET_ADDNODE"<<std::endl;
1778                                 prof.add("MEET_ADDNODE", 1);
1779                                 if(disable_single_change_sending)
1780                                         sendAddNode(event->p, event->n, event->already_known_by_peer,
1781                                                         &far_players, 5);
1782                                 else
1783                                         sendAddNode(event->p, event->n, event->already_known_by_peer,
1784                                                         &far_players, 30);
1785                         }
1786                         else if(event->type == MEET_REMOVENODE)
1787                         {
1788                                 //infostream<<"Server: MEET_REMOVENODE"<<std::endl;
1789                                 prof.add("MEET_REMOVENODE", 1);
1790                                 if(disable_single_change_sending)
1791                                         sendRemoveNode(event->p, event->already_known_by_peer,
1792                                                         &far_players, 5);
1793                                 else
1794                                         sendRemoveNode(event->p, event->already_known_by_peer,
1795                                                         &far_players, 30);
1796                         }
1797                         else if(event->type == MEET_BLOCK_NODE_METADATA_CHANGED)
1798                         {
1799                                 infostream<<"Server: MEET_BLOCK_NODE_METADATA_CHANGED"<<std::endl;
1800                                 prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
1801                                 setBlockNotSent(event->p);
1802                         }
1803                         else if(event->type == MEET_OTHER)
1804                         {
1805                                 infostream<<"Server: MEET_OTHER"<<std::endl;
1806                                 prof.add("MEET_OTHER", 1);
1807                                 for(core::map<v3s16, bool>::Iterator
1808                                                 i = event->modified_blocks.getIterator();
1809                                                 i.atEnd()==false; i++)
1810                                 {
1811                                         v3s16 p = i.getNode()->getKey();
1812                                         setBlockNotSent(p);
1813                                 }
1814                         }
1815                         else
1816                         {
1817                                 prof.add("unknown", 1);
1818                                 infostream<<"WARNING: Server: Unknown MapEditEvent "
1819                                                 <<((u32)event->type)<<std::endl;
1820                         }
1821
1822                         /*
1823                                 Set blocks not sent to far players
1824                         */
1825                         if(far_players.size() > 0)
1826                         {
1827                                 // Convert list format to that wanted by SetBlocksNotSent
1828                                 core::map<v3s16, MapBlock*> modified_blocks2;
1829                                 for(core::map<v3s16, bool>::Iterator
1830                                                 i = event->modified_blocks.getIterator();
1831                                                 i.atEnd()==false; i++)
1832                                 {
1833                                         v3s16 p = i.getNode()->getKey();
1834                                         modified_blocks2.insert(p,
1835                                                         m_env->getMap().getBlockNoCreateNoEx(p));
1836                                 }
1837                                 // Set blocks not sent
1838                                 for(core::list<u16>::Iterator
1839                                                 i = far_players.begin();
1840                                                 i != far_players.end(); i++)
1841                                 {
1842                                         u16 peer_id = *i;
1843                                         RemoteClient *client = getClient(peer_id);
1844                                         if(client==NULL)
1845                                                 continue;
1846                                         client->SetBlocksNotSent(modified_blocks2);
1847                                 }
1848                         }
1849
1850                         delete event;
1851
1852                         /*// Don't send too many at a time
1853                         count++;
1854                         if(count >= 1 && m_unsent_map_edit_queue.size() < 100)
1855                                 break;*/
1856                 }
1857
1858                 if(event_count >= 5){
1859                         infostream<<"Server: MapEditEvents:"<<std::endl;
1860                         prof.print(infostream);
1861                 } else if(event_count != 0){
1862                         verbosestream<<"Server: MapEditEvents:"<<std::endl;
1863                         prof.print(verbosestream);
1864                 }
1865
1866         }
1867
1868         /*
1869                 Trigger emergethread (it somehow gets to a non-triggered but
1870                 bysy state sometimes)
1871         */
1872         {
1873                 float &counter = m_emergethread_trigger_timer;
1874                 counter += dtime;
1875                 if(counter >= 2.0)
1876                 {
1877                         counter = 0.0;
1878
1879                         m_emergethread.trigger();
1880
1881                         // Update m_enable_rollback_recording here too
1882                         m_enable_rollback_recording =
1883                                         g_settings->getBool("enable_rollback_recording");
1884                 }
1885         }
1886
1887         // Save map, players and auth stuff
1888         {
1889                 float &counter = m_savemap_timer;
1890                 counter += dtime;
1891                 if(counter >= g_settings->getFloat("server_map_save_interval"))
1892                 {
1893                         counter = 0.0;
1894                         JMutexAutoLock lock(m_env_mutex);
1895
1896                         ScopeProfiler sp(g_profiler, "Server: saving stuff");
1897
1898                         //Ban stuff
1899                         if(m_banmanager.isModified())
1900                                 m_banmanager.save();
1901
1902                         // Save changed parts of map
1903                         m_env->getMap().save(MOD_STATE_WRITE_NEEDED);
1904
1905                         // Save players
1906                         m_env->serializePlayers(m_path_world);
1907
1908                         // Save environment metadata
1909                         m_env->saveMeta(m_path_world);
1910                 }
1911         }
1912 }
1913
1914 void Server::Receive()
1915 {
1916         DSTACK(__FUNCTION_NAME);
1917         SharedBuffer<u8> data;
1918         u16 peer_id;
1919         u32 datasize;
1920         try{
1921                 {
1922                         JMutexAutoLock conlock(m_con_mutex);
1923                         datasize = m_con.Receive(peer_id, data);
1924                 }
1925
1926                 // This has to be called so that the client list gets synced
1927                 // with the peer list of the connection
1928                 handlePeerChanges();
1929
1930                 ProcessData(*data, datasize, peer_id);
1931         }
1932         catch(con::InvalidIncomingDataException &e)
1933         {
1934                 infostream<<"Server::Receive(): "
1935                                 "InvalidIncomingDataException: what()="
1936                                 <<e.what()<<std::endl;
1937         }
1938         catch(con::PeerNotFoundException &e)
1939         {
1940                 //NOTE: This is not needed anymore
1941
1942                 // The peer has been disconnected.
1943                 // Find the associated player and remove it.
1944
1945                 /*JMutexAutoLock envlock(m_env_mutex);
1946
1947                 infostream<<"ServerThread: peer_id="<<peer_id
1948                                 <<" has apparently closed connection. "
1949                                 <<"Removing player."<<std::endl;
1950
1951                 m_env->removePlayer(peer_id);*/
1952         }
1953 }
1954
1955 void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
1956 {
1957         DSTACK(__FUNCTION_NAME);
1958         // Environment is locked first.
1959         JMutexAutoLock envlock(m_env_mutex);
1960         JMutexAutoLock conlock(m_con_mutex);
1961
1962         ScopeProfiler sp(g_profiler, "Server::ProcessData");
1963
1964         try{
1965                 Address address = m_con.GetPeerAddress(peer_id);
1966                 std::string addr_s = address.serializeString();
1967
1968                 // drop player if is ip is banned
1969                 if(m_banmanager.isIpBanned(addr_s)){
1970                         infostream<<"Server: A banned client tried to connect from "
1971                                         <<addr_s<<"; banned name was "
1972                                         <<m_banmanager.getBanName(addr_s)<<std::endl;
1973                         // This actually doesn't seem to transfer to the client
1974                         SendAccessDenied(m_con, peer_id,
1975                                         L"Your ip is banned. Banned name was "
1976                                         +narrow_to_wide(m_banmanager.getBanName(addr_s)));
1977                         m_con.DeletePeer(peer_id);
1978                         return;
1979                 }
1980         }
1981         catch(con::PeerNotFoundException &e)
1982         {
1983                 infostream<<"Server::ProcessData(): Cancelling: peer "
1984                                 <<peer_id<<" not found"<<std::endl;
1985                 return;
1986         }
1987
1988         std::string addr_s = m_con.GetPeerAddress(peer_id).serializeString();
1989
1990         u8 peer_ser_ver = getClient(peer_id)->serialization_version;
1991
1992         try
1993         {
1994
1995         if(datasize < 2)
1996                 return;
1997
1998         ToServerCommand command = (ToServerCommand)readU16(&data[0]);
1999
2000         if(command == TOSERVER_INIT)
2001         {
2002                 // [0] u16 TOSERVER_INIT
2003                 // [2] u8 SER_FMT_VER_HIGHEST
2004                 // [3] u8[20] player_name
2005                 // [23] u8[28] password <--- can be sent without this, from old versions
2006
2007                 if(datasize < 2+1+PLAYERNAME_SIZE)
2008                         return;
2009
2010                 verbosestream<<"Server: Got TOSERVER_INIT from "
2011                                 <<peer_id<<std::endl;
2012
2013                 // First byte after command is maximum supported
2014                 // serialization version
2015                 u8 client_max = data[2];
2016                 u8 our_max = SER_FMT_VER_HIGHEST;
2017                 // Use the highest version supported by both
2018                 u8 deployed = core::min_(client_max, our_max);
2019                 // If it's lower than the lowest supported, give up.
2020                 if(deployed < SER_FMT_VER_LOWEST)
2021                         deployed = SER_FMT_VER_INVALID;
2022
2023                 //peer->serialization_version = deployed;
2024                 getClient(peer_id)->pending_serialization_version = deployed;
2025
2026                 if(deployed == SER_FMT_VER_INVALID)
2027                 {
2028                         actionstream<<"Server: A mismatched client tried to connect from "
2029                                         <<addr_s<<std::endl;
2030                         infostream<<"Server: Cannot negotiate "
2031                                         "serialization version with peer "
2032                                         <<peer_id<<std::endl;
2033                         SendAccessDenied(m_con, peer_id, std::wstring(
2034                                         L"Your client's version is not supported.\n"
2035                                         L"Server version is ")
2036                                         + narrow_to_wide(VERSION_STRING) + L"."
2037                         );
2038                         return;
2039                 }
2040
2041                 /*
2042                         Read and check network protocol version
2043                 */
2044
2045                 u16 min_net_proto_version = 0;
2046                 if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2)
2047                         min_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE]);
2048
2049                 // Use same version as minimum and maximum if maximum version field
2050                 // doesn't exist (backwards compatibility)
2051                 u16 max_net_proto_version = min_net_proto_version;
2052                 if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2)
2053                         max_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2]);
2054
2055                 // Start with client's maximum version
2056                 u16 net_proto_version = max_net_proto_version;
2057
2058                 // Figure out a working version if it is possible at all
2059                 if(max_net_proto_version >= SERVER_PROTOCOL_VERSION_MIN ||
2060                                 min_net_proto_version <= SERVER_PROTOCOL_VERSION_MAX)
2061                 {
2062                         // If maximum is larger than our maximum, go with our maximum
2063                         if(max_net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
2064                                 net_proto_version = SERVER_PROTOCOL_VERSION_MAX;
2065                         // Else go with client's maximum
2066                         else
2067                                 net_proto_version = max_net_proto_version;
2068                 }
2069
2070                 verbosestream<<"Server: "<<peer_id<<" Protocol version: min: "
2071                                 <<min_net_proto_version<<", max: "<<max_net_proto_version
2072                                 <<", chosen: "<<net_proto_version<<std::endl;
2073
2074                 getClient(peer_id)->net_proto_version = net_proto_version;
2075
2076                 if(net_proto_version < SERVER_PROTOCOL_VERSION_MIN ||
2077                                 net_proto_version > SERVER_PROTOCOL_VERSION_MAX)
2078                 {
2079                         actionstream<<"Server: A mismatched client tried to connect from "<<addr_s
2080                                         <<std::endl;
2081                         SendAccessDenied(m_con, peer_id, std::wstring(
2082                                         L"Your client's version is not supported.\n"
2083                                         L"Server version is ")
2084                                         + narrow_to_wide(VERSION_STRING) + L",\n"
2085                                         + L"server's PROTOCOL_VERSION is "
2086                                         + narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MIN))
2087                                         + L"..."
2088                                         + narrow_to_wide(itos(SERVER_PROTOCOL_VERSION_MAX))
2089                                         + L", client's PROTOCOL_VERSION is "
2090                                         + narrow_to_wide(itos(min_net_proto_version))
2091                                         + L"..."
2092                                         + narrow_to_wide(itos(max_net_proto_version))
2093                         );
2094                         return;
2095                 }
2096
2097                 if(g_settings->getBool("strict_protocol_version_checking"))
2098                 {
2099                         if(net_proto_version != LATEST_PROTOCOL_VERSION)
2100                         {
2101                                 actionstream<<"Server: A mismatched (strict) client tried to "
2102                                                 <<"connect from "<<addr_s<<std::endl;
2103                                 SendAccessDenied(m_con, peer_id, std::wstring(
2104                                                 L"Your client's version is not supported.\n"
2105                                                 L"Server version is ")
2106                                                 + narrow_to_wide(VERSION_STRING) + L",\n"
2107                                                 + L"server's PROTOCOL_VERSION (strict) is "
2108                                                 + narrow_to_wide(itos(LATEST_PROTOCOL_VERSION))
2109                                                 + L", client's PROTOCOL_VERSION is "
2110                                                 + narrow_to_wide(itos(min_net_proto_version))
2111                                                 + L"..."
2112                                                 + narrow_to_wide(itos(max_net_proto_version))
2113                                 );
2114                                 return;
2115                         }
2116                 }
2117
2118                 /*
2119                         Set up player
2120                 */
2121
2122                 // Get player name
2123                 char playername[PLAYERNAME_SIZE];
2124                 for(u32 i=0; i<PLAYERNAME_SIZE-1; i++)
2125                 {
2126                         playername[i] = data[3+i];
2127                 }
2128                 playername[PLAYERNAME_SIZE-1] = 0;
2129
2130                 if(playername[0]=='\0')
2131                 {
2132                         actionstream<<"Server: Player with an empty name "
2133                                         <<"tried to connect from "<<addr_s<<std::endl;
2134                         SendAccessDenied(m_con, peer_id,
2135                                         L"Empty name");
2136                         return;
2137                 }
2138
2139                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
2140                 {
2141                         actionstream<<"Server: Player with an invalid name "
2142                                         <<"tried to connect from "<<addr_s<<std::endl;
2143                         SendAccessDenied(m_con, peer_id,
2144                                         L"Name contains unallowed characters");
2145                         return;
2146                 }
2147
2148                 infostream<<"Server: New connection: \""<<playername<<"\" from "
2149                                 <<m_con.GetPeerAddress(peer_id).serializeString()<<std::endl;
2150
2151                 // Get password
2152                 char given_password[PASSWORD_SIZE];
2153                 if(datasize < 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE)
2154                 {
2155                         // old version - assume blank password
2156                         given_password[0] = 0;
2157                 }
2158                 else
2159                 {
2160                         for(u32 i=0; i<PASSWORD_SIZE-1; i++)
2161                         {
2162                                 given_password[i] = data[23+i];
2163                         }
2164                         given_password[PASSWORD_SIZE-1] = 0;
2165                 }
2166
2167                 if(!base64_is_valid(given_password)){
2168                         infostream<<"Server: "<<playername
2169                                         <<" supplied invalid password hash"<<std::endl;
2170                         SendAccessDenied(m_con, peer_id, L"Invalid password hash");
2171                         return;
2172                 }
2173
2174                 std::string checkpwd; // Password hash to check against
2175                 bool has_auth = scriptapi_get_auth(m_lua, playername, &checkpwd, NULL);
2176
2177                 // If no authentication info exists for user, create it
2178                 if(!has_auth){
2179                         if(!isSingleplayer() &&
2180                                         g_settings->getBool("disallow_empty_password") &&
2181                                         std::string(given_password) == ""){
2182                                 SendAccessDenied(m_con, peer_id, L"Empty passwords are "
2183                                                 L"disallowed. Set a password and try again.");
2184                                 return;
2185                         }
2186                         std::wstring raw_default_password =
2187                                 narrow_to_wide(g_settings->get("default_password"));
2188                         std::string initial_password =
2189                                 translatePassword(playername, raw_default_password);
2190
2191                         // If default_password is empty, allow any initial password
2192                         if (raw_default_password.length() == 0)
2193                                 initial_password = given_password;
2194
2195                         scriptapi_create_auth(m_lua, playername, initial_password);
2196                 }
2197
2198                 has_auth = scriptapi_get_auth(m_lua, playername, &checkpwd, NULL);
2199
2200                 if(!has_auth){
2201                         SendAccessDenied(m_con, peer_id, L"Not allowed to login");
2202                         return;
2203                 }
2204
2205                 if(given_password != checkpwd){
2206                         infostream<<"Server: peer_id="<<peer_id
2207                                         <<": supplied invalid password for "
2208                                         <<playername<<std::endl;
2209                         SendAccessDenied(m_con, peer_id, L"Invalid password");
2210                         return;
2211                 }
2212
2213                 // Do not allow multiple players in simple singleplayer mode.
2214                 // This isn't a perfect way to do it, but will suffice for now.
2215                 if(m_simple_singleplayer_mode && m_clients.size() > 1){
2216                         infostream<<"Server: Not allowing another client to connect in"
2217                                         <<" simple singleplayer mode"<<std::endl;
2218                         SendAccessDenied(m_con, peer_id,
2219                                         L"Running in simple singleplayer mode.");
2220                         return;
2221                 }
2222
2223                 // Enforce user limit.
2224                 // Don't enforce for users that have some admin right
2225                 if(m_clients.size() >= g_settings->getU16("max_users") &&
2226                                 !checkPriv(playername, "server") &&
2227                                 !checkPriv(playername, "ban") &&
2228                                 !checkPriv(playername, "privs") &&
2229                                 !checkPriv(playername, "password") &&
2230                                 playername != g_settings->get("name"))
2231                 {
2232                         actionstream<<"Server: "<<playername<<" tried to join, but there"
2233                                         <<" are already max_users="
2234                                         <<g_settings->getU16("max_users")<<" players."<<std::endl;
2235                         SendAccessDenied(m_con, peer_id, L"Too many users.");
2236                         return;
2237                 }
2238
2239                 // Get player
2240                 PlayerSAO *playersao = emergePlayer(playername, peer_id);
2241
2242                 // If failed, cancel
2243                 if(playersao == NULL)
2244                 {
2245                         errorstream<<"Server: peer_id="<<peer_id
2246                                         <<": failed to emerge player"<<std::endl;
2247                         return;
2248                 }
2249
2250                 /*
2251                         Answer with a TOCLIENT_INIT
2252                 */
2253                 {
2254                         SharedBuffer<u8> reply(2+1+6+8+4);
2255                         writeU16(&reply[0], TOCLIENT_INIT);
2256                         writeU8(&reply[2], deployed);
2257                         writeV3S16(&reply[2+1], floatToInt(playersao->getPlayer()->getPosition()+v3f(0,BS/2,0), BS));
2258                         writeU64(&reply[2+1+6], m_env->getServerMap().getSeed());
2259                         writeF1000(&reply[2+1+6+8], g_settings->getFloat("dedicated_server_step"));
2260
2261                         // Send as reliable
2262                         m_con.Send(peer_id, 0, reply, true);
2263                 }
2264
2265                 /*
2266                         Send complete position information
2267                 */
2268                 SendMovePlayer(peer_id);
2269
2270                 return;
2271         }
2272
2273         if(command == TOSERVER_INIT2)
2274         {
2275                 verbosestream<<"Server: Got TOSERVER_INIT2 from "
2276                                 <<peer_id<<std::endl;
2277
2278                 Player *player = m_env->getPlayer(peer_id);
2279                 if(!player){
2280                         verbosestream<<"Server: TOSERVER_INIT2: "
2281                                         <<"Player not found; ignoring."<<std::endl;
2282                         return;
2283                 }
2284
2285                 RemoteClient *client = getClient(peer_id);
2286                 client->serialization_version =
2287                                 getClient(peer_id)->pending_serialization_version;
2288
2289                 /*
2290                         Send some initialization data
2291                 */
2292
2293                 infostream<<"Server: Sending content to "
2294                                 <<getPlayerName(peer_id)<<std::endl;
2295
2296                 // Send item definitions
2297                 SendItemDef(m_con, peer_id, m_itemdef);
2298
2299                 // Send node definitions
2300                 SendNodeDef(m_con, peer_id, m_nodedef, client->net_proto_version);
2301
2302                 // Send media announcement
2303                 sendMediaAnnouncement(peer_id);
2304
2305                 // Send privileges
2306                 SendPlayerPrivileges(peer_id);
2307
2308                 // Send inventory formspec
2309                 SendPlayerInventoryFormspec(peer_id);
2310
2311                 // Send inventory
2312                 UpdateCrafting(peer_id);
2313                 SendInventory(peer_id);
2314
2315                 // Send HP
2316                 if(g_settings->getBool("enable_damage"))
2317                         SendPlayerHP(peer_id);
2318
2319                 // Send detached inventories
2320                 sendDetachedInventories(peer_id);
2321
2322                 // Show death screen if necessary
2323                 if(player->hp == 0)
2324                         SendDeathscreen(m_con, peer_id, false, v3f(0,0,0));
2325
2326                 // Send time of day
2327                 {
2328                         SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
2329                                         m_env->getTimeOfDay(), g_settings->getFloat("time_speed"));
2330                         m_con.Send(peer_id, 0, data, true);
2331                 }
2332
2333                 // Note things in chat if not in simple singleplayer mode
2334                 if(!m_simple_singleplayer_mode)
2335                 {
2336                         // Send information about server to player in chat
2337                         SendChatMessage(peer_id, getStatusString());
2338
2339                         // Send information about joining in chat
2340                         {
2341                                 std::wstring name = L"unknown";
2342                                 Player *player = m_env->getPlayer(peer_id);
2343                                 if(player != NULL)
2344                                         name = narrow_to_wide(player->getName());
2345
2346                                 std::wstring message;
2347                                 message += L"*** ";
2348                                 message += name;
2349                                 message += L" joined the game.";
2350                                 BroadcastChatMessage(message);
2351                         }
2352                 }
2353
2354                 // Warnings about protocol version can be issued here
2355                 if(getClient(peer_id)->net_proto_version < LATEST_PROTOCOL_VERSION)
2356                 {
2357                         SendChatMessage(peer_id, L"# Server: WARNING: YOUR CLIENT'S "
2358                                         L"VERSION MAY NOT BE FULLY COMPATIBLE WITH THIS SERVER!");
2359                 }
2360
2361                 /*
2362                         Print out action
2363                 */
2364                 {
2365                         std::ostringstream os(std::ios_base::binary);
2366                         for(core::map<u16, RemoteClient*>::Iterator
2367                                 i = m_clients.getIterator();
2368                                 i.atEnd() == false; i++)
2369                         {
2370                                 RemoteClient *client = i.getNode()->getValue();
2371                                 assert(client->peer_id == i.getNode()->getKey());
2372                                 if(client->serialization_version == SER_FMT_VER_INVALID)
2373                                         continue;
2374                                 // Get player
2375                                 Player *player = m_env->getPlayer(client->peer_id);
2376                                 if(!player)
2377                                         continue;
2378                                 // Get name of player
2379                                 os<<player->getName()<<" ";
2380                         }
2381
2382                         actionstream<<player->getName()<<" joins game. List of players: "
2383                                         <<os.str()<<std::endl;
2384                 }
2385
2386                 return;
2387         }
2388
2389         if(peer_ser_ver == SER_FMT_VER_INVALID)
2390         {
2391                 infostream<<"Server::ProcessData(): Cancelling: Peer"
2392                                 " serialization format invalid or not initialized."
2393                                 " Skipping incoming command="<<command<<std::endl;
2394                 return;
2395         }
2396
2397         Player *player = m_env->getPlayer(peer_id);
2398         if(player == NULL){
2399                 infostream<<"Server::ProcessData(): Cancelling: "
2400                                 "No player for peer_id="<<peer_id
2401                                 <<std::endl;
2402                 return;
2403         }
2404
2405         PlayerSAO *playersao = player->getPlayerSAO();
2406         if(playersao == NULL){
2407                 infostream<<"Server::ProcessData(): Cancelling: "
2408                                 "No player object for peer_id="<<peer_id
2409                                 <<std::endl;
2410                 return;
2411         }
2412
2413         if(command == TOSERVER_PLAYERPOS)
2414         {
2415                 if(datasize < 2+12+12+4+4)
2416                         return;
2417
2418                 u32 start = 0;
2419                 v3s32 ps = readV3S32(&data[start+2]);
2420                 v3s32 ss = readV3S32(&data[start+2+12]);
2421                 f32 pitch = (f32)readS32(&data[2+12+12]) / 100.0;
2422                 f32 yaw = (f32)readS32(&data[2+12+12+4]) / 100.0;
2423                 u32 keyPressed = 0;
2424                 if(datasize >= 2+12+12+4+4+4)
2425                         keyPressed = (u32)readU32(&data[2+12+12+4+4]);
2426                 v3f position((f32)ps.X/100., (f32)ps.Y/100., (f32)ps.Z/100.);
2427                 v3f speed((f32)ss.X/100., (f32)ss.Y/100., (f32)ss.Z/100.);
2428                 pitch = wrapDegrees(pitch);
2429                 yaw = wrapDegrees(yaw);
2430
2431                 player->setPosition(position);
2432                 player->setSpeed(speed);
2433                 player->setPitch(pitch);
2434                 player->setYaw(yaw);
2435                 player->keyPressed=keyPressed;
2436                 player->control.up = (bool)(keyPressed&1);
2437                 player->control.down = (bool)(keyPressed&2);
2438                 player->control.left = (bool)(keyPressed&4);
2439                 player->control.right = (bool)(keyPressed&8);
2440                 player->control.jump = (bool)(keyPressed&16);
2441                 player->control.aux1 = (bool)(keyPressed&32);
2442                 player->control.sneak = (bool)(keyPressed&64);
2443                 player->control.LMB = (bool)(keyPressed&128);
2444                 player->control.RMB = (bool)(keyPressed&256);
2445
2446                 /*infostream<<"Server::ProcessData(): Moved player "<<peer_id<<" to "
2447                                 <<"("<<position.X<<","<<position.Y<<","<<position.Z<<")"
2448                                 <<" pitch="<<pitch<<" yaw="<<yaw<<std::endl;*/
2449         }
2450         else if(command == TOSERVER_GOTBLOCKS)
2451         {
2452                 if(datasize < 2+1)
2453                         return;
2454
2455                 /*
2456                         [0] u16 command
2457                         [2] u8 count
2458                         [3] v3s16 pos_0
2459                         [3+6] v3s16 pos_1
2460                         ...
2461                 */
2462
2463                 u16 count = data[2];
2464                 for(u16 i=0; i<count; i++)
2465                 {
2466                         if((s16)datasize < 2+1+(i+1)*6)
2467                                 throw con::InvalidIncomingDataException
2468                                         ("GOTBLOCKS length is too short");
2469                         v3s16 p = readV3S16(&data[2+1+i*6]);
2470                         /*infostream<<"Server: GOTBLOCKS ("
2471                                         <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
2472                         RemoteClient *client = getClient(peer_id);
2473                         client->GotBlock(p);
2474                 }
2475         }
2476         else if(command == TOSERVER_DELETEDBLOCKS)
2477         {
2478                 if(datasize < 2+1)
2479                         return;
2480
2481                 /*
2482                         [0] u16 command
2483                         [2] u8 count
2484                         [3] v3s16 pos_0
2485                         [3+6] v3s16 pos_1
2486                         ...
2487                 */
2488
2489                 u16 count = data[2];
2490                 for(u16 i=0; i<count; i++)
2491                 {
2492                         if((s16)datasize < 2+1+(i+1)*6)
2493                                 throw con::InvalidIncomingDataException
2494                                         ("DELETEDBLOCKS length is too short");
2495                         v3s16 p = readV3S16(&data[2+1+i*6]);
2496                         /*infostream<<"Server: DELETEDBLOCKS ("
2497                                         <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
2498                         RemoteClient *client = getClient(peer_id);
2499                         client->SetBlockNotSent(p);
2500                 }
2501         }
2502         else if(command == TOSERVER_CLICK_OBJECT)
2503         {
2504                 infostream<<"Server: CLICK_OBJECT not supported anymore"<<std::endl;
2505                 return;
2506         }
2507         else if(command == TOSERVER_CLICK_ACTIVEOBJECT)
2508         {
2509                 infostream<<"Server: CLICK_ACTIVEOBJECT not supported anymore"<<std::endl;
2510                 return;
2511         }
2512         else if(command == TOSERVER_GROUND_ACTION)
2513         {
2514                 infostream<<"Server: GROUND_ACTION not supported anymore"<<std::endl;
2515                 return;
2516
2517         }
2518         else if(command == TOSERVER_RELEASE)
2519         {
2520                 infostream<<"Server: RELEASE not supported anymore"<<std::endl;
2521                 return;
2522         }
2523         else if(command == TOSERVER_SIGNTEXT)
2524         {
2525                 infostream<<"Server: SIGNTEXT not supported anymore"
2526                                 <<std::endl;
2527                 return;
2528         }
2529         else if(command == TOSERVER_SIGNNODETEXT)
2530         {
2531                 infostream<<"Server: SIGNNODETEXT not supported anymore"
2532                                 <<std::endl;
2533                 return;
2534         }
2535         else if(command == TOSERVER_INVENTORY_ACTION)
2536         {
2537                 // Strip command and create a stream
2538                 std::string datastring((char*)&data[2], datasize-2);
2539                 verbosestream<<"TOSERVER_INVENTORY_ACTION: data="<<datastring<<std::endl;
2540                 std::istringstream is(datastring, std::ios_base::binary);
2541                 // Create an action
2542                 InventoryAction *a = InventoryAction::deSerialize(is);
2543                 if(a == NULL)
2544                 {
2545                         infostream<<"TOSERVER_INVENTORY_ACTION: "
2546                                         <<"InventoryAction::deSerialize() returned NULL"
2547                                         <<std::endl;
2548                         return;
2549                 }
2550
2551                 // If something goes wrong, this player is to blame
2552                 RollbackScopeActor rollback_scope(m_rollback,
2553                                 std::string("player:")+player->getName());
2554
2555                 /*
2556                         Note: Always set inventory not sent, to repair cases
2557                         where the client made a bad prediction.
2558                 */
2559
2560                 /*
2561                         Handle restrictions and special cases of the move action
2562                 */
2563                 if(a->getType() == IACTION_MOVE)
2564                 {
2565                         IMoveAction *ma = (IMoveAction*)a;
2566
2567                         ma->from_inv.applyCurrentPlayer(player->getName());
2568                         ma->to_inv.applyCurrentPlayer(player->getName());
2569
2570                         setInventoryModified(ma->from_inv);
2571                         setInventoryModified(ma->to_inv);
2572
2573                         bool from_inv_is_current_player =
2574                                 (ma->from_inv.type == InventoryLocation::PLAYER) &&
2575                                 (ma->from_inv.name == player->getName());
2576
2577                         bool to_inv_is_current_player =
2578                                 (ma->to_inv.type == InventoryLocation::PLAYER) &&
2579                                 (ma->to_inv.name == player->getName());
2580
2581                         /*
2582                                 Disable moving items out of craftpreview
2583                         */
2584                         if(ma->from_list == "craftpreview")
2585                         {
2586                                 infostream<<"Ignoring IMoveAction from "
2587                                                 <<(ma->from_inv.dump())<<":"<<ma->from_list
2588                                                 <<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
2589                                                 <<" because src is "<<ma->from_list<<std::endl;
2590                                 delete a;
2591                                 return;
2592                         }
2593
2594                         /*
2595                                 Disable moving items into craftresult and craftpreview
2596                         */
2597                         if(ma->to_list == "craftpreview" || ma->to_list == "craftresult")
2598                         {
2599                                 infostream<<"Ignoring IMoveAction from "
2600                                                 <<(ma->from_inv.dump())<<":"<<ma->from_list
2601                                                 <<" to "<<(ma->to_inv.dump())<<":"<<ma->to_list
2602                                                 <<" because dst is "<<ma->to_list<<std::endl;
2603                                 delete a;
2604                                 return;
2605                         }
2606
2607                         // Disallow moving items in elsewhere than player's inventory
2608                         // if not allowed to interact
2609                         if(!checkPriv(player->getName(), "interact") &&
2610                                         (!from_inv_is_current_player ||
2611                                         !to_inv_is_current_player))
2612                         {
2613                                 infostream<<"Cannot move outside of player's inventory: "
2614                                                 <<"No interact privilege"<<std::endl;
2615                                 delete a;
2616                                 return;
2617                         }
2618                 }
2619                 /*
2620                         Handle restrictions and special cases of the drop action
2621                 */
2622                 else if(a->getType() == IACTION_DROP)
2623                 {
2624                         IDropAction *da = (IDropAction*)a;
2625
2626                         da->from_inv.applyCurrentPlayer(player->getName());
2627
2628                         setInventoryModified(da->from_inv);
2629
2630                         // Disallow dropping items if not allowed to interact
2631                         if(!checkPriv(player->getName(), "interact"))
2632                         {
2633                                 delete a;
2634                                 return;
2635                         }
2636                 }
2637                 /*
2638                         Handle restrictions and special cases of the craft action
2639                 */
2640                 else if(a->getType() == IACTION_CRAFT)
2641                 {
2642                         ICraftAction *ca = (ICraftAction*)a;
2643
2644                         ca->craft_inv.applyCurrentPlayer(player->getName());
2645
2646                         setInventoryModified(ca->craft_inv);
2647
2648                         //bool craft_inv_is_current_player =
2649                         //      (ca->craft_inv.type == InventoryLocation::PLAYER) &&
2650                         //      (ca->craft_inv.name == player->getName());
2651
2652                         // Disallow crafting if not allowed to interact
2653                         if(!checkPriv(player->getName(), "interact"))
2654                         {
2655                                 infostream<<"Cannot craft: "
2656                                                 <<"No interact privilege"<<std::endl;
2657                                 delete a;
2658                                 return;
2659                         }
2660                 }
2661
2662                 // Do the action
2663                 a->apply(this, playersao, this);
2664                 // Eat the action
2665                 delete a;
2666         }
2667         else if(command == TOSERVER_CHAT_MESSAGE)
2668         {
2669                 /*
2670                         u16 command
2671                         u16 length
2672                         wstring message
2673                 */
2674                 u8 buf[6];
2675                 std::string datastring((char*)&data[2], datasize-2);
2676                 std::istringstream is(datastring, std::ios_base::binary);
2677
2678                 // Read stuff
2679                 is.read((char*)buf, 2);
2680                 u16 len = readU16(buf);
2681
2682                 std::wstring message;
2683                 for(u16 i=0; i<len; i++)
2684                 {
2685                         is.read((char*)buf, 2);
2686                         message += (wchar_t)readU16(buf);
2687                 }
2688
2689                 // If something goes wrong, this player is to blame
2690                 RollbackScopeActor rollback_scope(m_rollback,
2691                                 std::string("player:")+player->getName());
2692
2693                 // Get player name of this client
2694                 std::wstring name = narrow_to_wide(player->getName());
2695
2696                 // Run script hook
2697                 bool ate = scriptapi_on_chat_message(m_lua, player->getName(),
2698                                 wide_to_narrow(message));
2699                 // If script ate the message, don't proceed
2700                 if(ate)
2701                         return;
2702
2703                 // Line to send to players
2704                 std::wstring line;
2705                 // Whether to send to the player that sent the line
2706                 bool send_to_sender = false;
2707                 // Whether to send to other players
2708                 bool send_to_others = false;
2709
2710                 // Commands are implemented in Lua, so only catch invalid
2711                 // commands that were not "eaten" and send an error back
2712                 if(message[0] == L'/')
2713                 {
2714                         message = message.substr(1);
2715                         send_to_sender = true;
2716                         if(message.length() == 0)
2717                                 line += L"-!- Empty command";
2718                         else
2719                                 line += L"-!- Invalid command: " + str_split(message, L' ')[0];
2720                 }
2721                 else
2722                 {
2723                         if(checkPriv(player->getName(), "shout")){
2724                                 line += L"<";
2725                                 line += name;
2726                                 line += L"> ";
2727                                 line += message;
2728                                 send_to_others = true;
2729                         } else {
2730                                 line += L"-!- You don't have permission to shout.";
2731                                 send_to_sender = true;
2732                         }
2733                 }
2734
2735                 if(line != L"")
2736                 {
2737                         if(send_to_others)
2738                                 actionstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl;
2739
2740                         /*
2741                                 Send the message to clients
2742                         */
2743                         for(core::map<u16, RemoteClient*>::Iterator
2744                                 i = m_clients.getIterator();
2745                                 i.atEnd() == false; i++)
2746                         {
2747                                 // Get client and check that it is valid
2748                                 RemoteClient *client = i.getNode()->getValue();
2749                                 assert(client->peer_id == i.getNode()->getKey());
2750                                 if(client->serialization_version == SER_FMT_VER_INVALID)
2751                                         continue;
2752
2753                                 // Filter recipient
2754                                 bool sender_selected = (peer_id == client->peer_id);
2755                                 if(sender_selected == true && send_to_sender == false)
2756                                         continue;
2757                                 if(sender_selected == false && send_to_others == false)
2758                                         continue;
2759
2760                                 SendChatMessage(client->peer_id, line);
2761                         }
2762                 }
2763         }
2764         else if(command == TOSERVER_DAMAGE)
2765         {
2766                 std::string datastring((char*)&data[2], datasize-2);
2767                 std::istringstream is(datastring, std::ios_base::binary);
2768                 u8 damage = readU8(is);
2769
2770                 if(g_settings->getBool("enable_damage"))
2771                 {
2772                         actionstream<<player->getName()<<" damaged by "
2773                                         <<(int)damage<<" hp at "<<PP(player->getPosition()/BS)
2774                                         <<std::endl;
2775
2776                         playersao->setHP(playersao->getHP() - damage);
2777
2778                         if(playersao->getHP() == 0 && playersao->m_hp_not_sent)
2779                                 DiePlayer(peer_id);
2780
2781                         if(playersao->m_hp_not_sent)
2782                                 SendPlayerHP(peer_id);
2783                 }
2784         }
2785         else if(command == TOSERVER_PASSWORD)
2786         {
2787                 /*
2788                         [0] u16 TOSERVER_PASSWORD
2789                         [2] u8[28] old password
2790                         [30] u8[28] new password
2791                 */
2792
2793                 if(datasize != 2+PASSWORD_SIZE*2)
2794                         return;
2795                 /*char password[PASSWORD_SIZE];
2796                 for(u32 i=0; i<PASSWORD_SIZE-1; i++)
2797                         password[i] = data[2+i];
2798                 password[PASSWORD_SIZE-1] = 0;*/
2799                 std::string oldpwd;
2800                 for(u32 i=0; i<PASSWORD_SIZE-1; i++)
2801                 {
2802                         char c = data[2+i];
2803                         if(c == 0)
2804                                 break;
2805                         oldpwd += c;
2806                 }
2807                 std::string newpwd;
2808                 for(u32 i=0; i<PASSWORD_SIZE-1; i++)
2809                 {
2810                         char c = data[2+PASSWORD_SIZE+i];
2811                         if(c == 0)
2812                                 break;
2813                         newpwd += c;
2814                 }
2815
2816                 if(!base64_is_valid(newpwd)){
2817                         infostream<<"Server: "<<player->getName()<<" supplied invalid password hash"<<std::endl;
2818                         // Wrong old password supplied!!
2819                         SendChatMessage(peer_id, L"Invalid new password hash supplied. Password NOT changed.");
2820                         return;
2821                 }
2822
2823                 infostream<<"Server: Client requests a password change from "
2824                                 <<"'"<<oldpwd<<"' to '"<<newpwd<<"'"<<std::endl;
2825
2826                 std::string playername = player->getName();
2827
2828                 std::string checkpwd;
2829                 scriptapi_get_auth(m_lua, playername, &checkpwd, NULL);
2830
2831                 if(oldpwd != checkpwd)
2832                 {
2833                         infostream<<"Server: invalid old password"<<std::endl;
2834                         // Wrong old password supplied!!
2835                         SendChatMessage(peer_id, L"Invalid old password supplied. Password NOT changed.");
2836                         return;
2837                 }
2838
2839                 bool success = scriptapi_set_password(m_lua, playername, newpwd);
2840                 if(success){
2841                         actionstream<<player->getName()<<" changes password"<<std::endl;
2842                         SendChatMessage(peer_id, L"Password change successful.");
2843                 } else {
2844                         actionstream<<player->getName()<<" tries to change password but "
2845                                         <<"it fails"<<std::endl;
2846                         SendChatMessage(peer_id, L"Password change failed or inavailable.");
2847                 }
2848         }
2849         else if(command == TOSERVER_PLAYERITEM)
2850         {
2851                 if (datasize < 2+2)
2852                         return;
2853
2854                 u16 item = readU16(&data[2]);
2855                 playersao->setWieldIndex(item);
2856         }
2857         else if(command == TOSERVER_RESPAWN)
2858         {
2859                 if(player->hp != 0 || !g_settings->getBool("enable_damage"))
2860                         return;
2861
2862                 RespawnPlayer(peer_id);
2863
2864                 actionstream<<player->getName()<<" respawns at "
2865                                 <<PP(player->getPosition()/BS)<<std::endl;
2866
2867                 // ActiveObject is added to environment in AsyncRunStep after
2868                 // the previous addition has been succesfully removed
2869         }
2870         else if(command == TOSERVER_REQUEST_MEDIA) {
2871                 std::string datastring((char*)&data[2], datasize-2);
2872                 std::istringstream is(datastring, std::ios_base::binary);
2873
2874                 core::list<MediaRequest> tosend;
2875                 u16 numfiles = readU16(is);
2876
2877                 infostream<<"Sending "<<numfiles<<" files to "
2878                                 <<getPlayerName(peer_id)<<std::endl;
2879                 verbosestream<<"TOSERVER_REQUEST_MEDIA: "<<std::endl;
2880
2881                 for(int i = 0; i < numfiles; i++) {
2882                         std::string name = deSerializeString(is);
2883                         tosend.push_back(MediaRequest(name));
2884                         verbosestream<<"TOSERVER_REQUEST_MEDIA: requested file "
2885                                         <<name<<std::endl;
2886                 }
2887
2888                 sendRequestedMedia(peer_id, tosend);
2889
2890                 // Now the client should know about everything
2891                 // (definitions and files)
2892                 getClient(peer_id)->definitions_sent = true;
2893         }
2894         else if(command == TOSERVER_RECEIVED_MEDIA) {
2895                 getClient(peer_id)->definitions_sent = true;
2896         }
2897         else if(command == TOSERVER_INTERACT)
2898         {
2899                 std::string datastring((char*)&data[2], datasize-2);
2900                 std::istringstream is(datastring, std::ios_base::binary);
2901
2902                 /*
2903                         [0] u16 command
2904                         [2] u8 action
2905                         [3] u16 item
2906                         [5] u32 length of the next item
2907                         [9] serialized PointedThing
2908                         actions:
2909                         0: start digging (from undersurface) or use
2910                         1: stop digging (all parameters ignored)
2911                         2: digging completed
2912                         3: place block or item (to abovesurface)
2913                         4: use item
2914                 */
2915                 u8 action = readU8(is);
2916                 u16 item_i = readU16(is);
2917                 std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
2918                 PointedThing pointed;
2919                 pointed.deSerialize(tmp_is);
2920
2921                 verbosestream<<"TOSERVER_INTERACT: action="<<(int)action<<", item="
2922                                 <<item_i<<", pointed="<<pointed.dump()<<std::endl;
2923
2924                 if(player->hp == 0)
2925                 {
2926                         verbosestream<<"TOSERVER_INTERACT: "<<player->getName()
2927                                 <<" tried to interact, but is dead!"<<std::endl;
2928                         return;
2929                 }
2930
2931                 v3f player_pos = playersao->getLastGoodPosition();
2932
2933                 // Update wielded item
2934                 playersao->setWieldIndex(item_i);
2935
2936                 // Get pointed to node (undefined if not POINTEDTYPE_NODE)
2937                 v3s16 p_under = pointed.node_undersurface;
2938                 v3s16 p_above = pointed.node_abovesurface;
2939
2940                 // Get pointed to object (NULL if not POINTEDTYPE_OBJECT)
2941                 ServerActiveObject *pointed_object = NULL;
2942                 if(pointed.type == POINTEDTHING_OBJECT)
2943                 {
2944                         pointed_object = m_env->getActiveObject(pointed.object_id);
2945                         if(pointed_object == NULL)
2946                         {
2947                                 verbosestream<<"TOSERVER_INTERACT: "
2948                                         "pointed object is NULL"<<std::endl;
2949                                 return;
2950                         }
2951
2952                 }
2953
2954                 v3f pointed_pos_under = player_pos;
2955                 v3f pointed_pos_above = player_pos;
2956                 if(pointed.type == POINTEDTHING_NODE)
2957                 {
2958                         pointed_pos_under = intToFloat(p_under, BS);
2959                         pointed_pos_above = intToFloat(p_above, BS);
2960                 }
2961                 else if(pointed.type == POINTEDTHING_OBJECT)
2962                 {
2963                         pointed_pos_under = pointed_object->getBasePosition();
2964                         pointed_pos_above = pointed_pos_under;
2965                 }
2966
2967                 /*
2968                         Check that target is reasonably close
2969                         (only when digging or placing things)
2970                 */
2971                 if(action == 0 || action == 2 || action == 3)
2972                 {
2973                         float d = player_pos.getDistanceFrom(pointed_pos_under);
2974                         float max_d = BS * 14; // Just some large enough value
2975                         if(d > max_d){
2976                                 actionstream<<"Player "<<player->getName()
2977                                                 <<" tried to access "<<pointed.dump()
2978                                                 <<" from too far: "
2979                                                 <<"d="<<d<<", max_d="<<max_d
2980                                                 <<". ignoring."<<std::endl;
2981                                 // Re-send block to revert change on client-side
2982                                 RemoteClient *client = getClient(peer_id);
2983                                 v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
2984                                 client->SetBlockNotSent(blockpos);
2985                                 // Do nothing else
2986                                 return;
2987                         }
2988                 }
2989
2990                 /*
2991                         Make sure the player is allowed to do it
2992                 */
2993                 if(!checkPriv(player->getName(), "interact"))
2994                 {
2995                         actionstream<<player->getName()<<" attempted to interact with "
2996                                         <<pointed.dump()<<" without 'interact' privilege"
2997                                         <<std::endl;
2998                         // Re-send block to revert change on client-side
2999                         RemoteClient *client = getClient(peer_id);
3000                         // Digging completed -> under
3001                         if(action == 2){
3002                                 v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
3003                                 client->SetBlockNotSent(blockpos);
3004                         }
3005                         // Placement -> above
3006                         if(action == 3){
3007                                 v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
3008                                 client->SetBlockNotSent(blockpos);
3009                         }
3010                         return;
3011                 }
3012
3013                 /*
3014                         If something goes wrong, this player is to blame
3015                 */
3016                 RollbackScopeActor rollback_scope(m_rollback,
3017                                 std::string("player:")+player->getName());
3018
3019                 /*
3020                         0: start digging or punch object
3021                 */
3022                 if(action == 0)
3023                 {
3024                         if(pointed.type == POINTEDTHING_NODE)
3025                         {
3026                                 /*
3027                                         NOTE: This can be used in the future to check if
3028                                         somebody is cheating, by checking the timing.
3029                                 */
3030                                 MapNode n(CONTENT_IGNORE);
3031                                 try
3032                                 {
3033                                         n = m_env->getMap().getNode(p_under);
3034                                 }
3035                                 catch(InvalidPositionException &e)
3036                                 {
3037                                         infostream<<"Server: Not punching: Node not found."
3038                                                         <<" Adding block to emerge queue."
3039                                                         <<std::endl;
3040                                         m_emerge_queue.addBlock(peer_id,
3041                                                         getNodeBlockPos(p_above), BLOCK_EMERGE_FLAG_FROMDISK);
3042                                 }
3043                                 if(n.getContent() != CONTENT_IGNORE)
3044                                         scriptapi_node_on_punch(m_lua, p_under, n, playersao);
3045                                 // Cheat prevention
3046                                 playersao->noCheatDigStart(p_under);
3047                         }
3048                         else if(pointed.type == POINTEDTHING_OBJECT)
3049                         {
3050                                 // Skip if object has been removed
3051                                 if(pointed_object->m_removed)
3052                                         return;
3053
3054                                 actionstream<<player->getName()<<" punches object "
3055                                                 <<pointed.object_id<<": "
3056                                                 <<pointed_object->getDescription()<<std::endl;
3057
3058                                 ItemStack punchitem = playersao->getWieldedItem();
3059                                 ToolCapabilities toolcap =
3060                                                 punchitem.getToolCapabilities(m_itemdef);
3061                                 v3f dir = (pointed_object->getBasePosition() -
3062                                                 (player->getPosition() + player->getEyeOffset())
3063                                                         ).normalize();
3064                                 float time_from_last_punch =
3065                                         playersao->resetTimeFromLastPunch();
3066                                 pointed_object->punch(dir, &toolcap, playersao,
3067                                                 time_from_last_punch);
3068                         }
3069
3070                 } // action == 0
3071
3072                 /*
3073                         1: stop digging
3074                 */
3075                 else if(action == 1)
3076                 {
3077                 } // action == 1
3078
3079                 /*
3080                         2: Digging completed
3081                 */
3082                 else if(action == 2)
3083                 {
3084                         // Only digging of nodes
3085                         if(pointed.type == POINTEDTHING_NODE)
3086                         {
3087                                 MapNode n(CONTENT_IGNORE);
3088                                 try
3089                                 {
3090                                         n = m_env->getMap().getNode(p_under);
3091                                 }
3092                                 catch(InvalidPositionException &e)
3093                                 {
3094                                         infostream<<"Server: Not finishing digging: Node not found."
3095                                                         <<" Adding block to emerge queue."
3096                                                         <<std::endl;
3097                                         m_emerge_queue.addBlock(peer_id,
3098                                                         getNodeBlockPos(p_above), BLOCK_EMERGE_FLAG_FROMDISK);
3099                                 }
3100
3101                                 /* Cheat prevention */
3102                                 bool is_valid_dig = true;
3103                                 if(!isSingleplayer() && !g_settings->getBool("disable_anticheat"))
3104                                 {
3105                                         v3s16 nocheat_p = playersao->getNoCheatDigPos();
3106                                         float nocheat_t = playersao->getNoCheatDigTime();
3107                                         playersao->noCheatDigEnd();
3108                                         // If player didn't start digging this, ignore dig
3109                                         if(nocheat_p != p_under){
3110                                                 infostream<<"Server: NoCheat: "<<player->getName()
3111                                                                 <<" started digging "
3112                                                                 <<PP(nocheat_p)<<" and completed digging "
3113                                                                 <<PP(p_under)<<"; not digging."<<std::endl;
3114                                                 is_valid_dig = false;
3115                                         }
3116                                         // Get player's wielded item
3117                                         ItemStack playeritem;
3118                                         InventoryList *mlist = playersao->getInventory()->getList("main");
3119                                         if(mlist != NULL)
3120                                                 playeritem = mlist->getItem(playersao->getWieldIndex());
3121                                         ToolCapabilities playeritem_toolcap =
3122                                                         playeritem.getToolCapabilities(m_itemdef);
3123                                         // Get diggability and expected digging time
3124                                         DigParams params = getDigParams(m_nodedef->get(n).groups,
3125                                                         &playeritem_toolcap);
3126                                         // If can't dig, try hand
3127                                         if(!params.diggable){
3128                                                 const ItemDefinition &hand = m_itemdef->get("");
3129                                                 const ToolCapabilities *tp = hand.tool_capabilities;
3130                                                 if(tp)
3131                                                         params = getDigParams(m_nodedef->get(n).groups, tp);
3132                                         }
3133                                         // If can't dig, ignore dig
3134                                         if(!params.diggable){
3135                                                 infostream<<"Server: NoCheat: "<<player->getName()
3136                                                                 <<" completed digging "<<PP(p_under)
3137                                                                 <<", which is not diggable with tool. not digging."
3138                                                                 <<std::endl;
3139                                                 is_valid_dig = false;
3140                                         }
3141                                         // If time is considerably too short, ignore dig
3142                                         // Check time only for medium and slow timed digs
3143                                         if(params.diggable && params.time > 0.3 && nocheat_t < 0.5 * params.time){
3144                                                 infostream<<"Server: NoCheat: "<<player->getName()
3145                                                                 <<" completed digging "
3146                                                                 <<PP(p_under)<<" in "<<nocheat_t<<"s; expected "
3147                                                                 <<params.time<<"s; not digging."<<std::endl;
3148                                                 is_valid_dig = false;
3149                                         }
3150                                 }
3151
3152                                 /* Actually dig node */
3153
3154                                 if(is_valid_dig && n.getContent() != CONTENT_IGNORE)
3155                                         scriptapi_node_on_dig(m_lua, p_under, n, playersao);
3156
3157                                 // Send unusual result (that is, node not being removed)
3158                                 if(m_env->getMap().getNodeNoEx(p_under).getContent() != CONTENT_AIR)
3159                                 {
3160                                         // Re-send block to revert change on client-side
3161                                         RemoteClient *client = getClient(peer_id);
3162                                         v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_under, BS));
3163                                         client->SetBlockNotSent(blockpos);
3164                                 }
3165                         }
3166                 } // action == 2
3167
3168                 /*
3169                         3: place block or right-click object
3170                 */
3171                 else if(action == 3)
3172                 {
3173                         ItemStack item = playersao->getWieldedItem();
3174
3175                         // Reset build time counter
3176                         if(pointed.type == POINTEDTHING_NODE &&
3177                                         item.getDefinition(m_itemdef).type == ITEM_NODE)
3178                                 getClient(peer_id)->m_time_from_building = 0.0;
3179
3180                         if(pointed.type == POINTEDTHING_OBJECT)
3181                         {
3182                                 // Right click object
3183
3184                                 // Skip if object has been removed
3185                                 if(pointed_object->m_removed)
3186                                         return;
3187
3188                                 actionstream<<player->getName()<<" right-clicks object "
3189                                                 <<pointed.object_id<<": "
3190                                                 <<pointed_object->getDescription()<<std::endl;
3191
3192                                 // Do stuff
3193                                 pointed_object->rightClick(playersao);
3194                         }
3195                         else if(scriptapi_item_on_place(m_lua,
3196                                         item, playersao, pointed))
3197                         {
3198                                 // Placement was handled in lua
3199
3200                                 // Apply returned ItemStack
3201                                 playersao->setWieldedItem(item);
3202                         }
3203
3204                         // If item has node placement prediction, always send the above
3205                         // node to make sure the client knows what exactly happened
3206                         if(item.getDefinition(m_itemdef).node_placement_prediction != ""){
3207                                 RemoteClient *client = getClient(peer_id);
3208                                 v3s16 blockpos = getNodeBlockPos(floatToInt(pointed_pos_above, BS));
3209                                 client->SetBlockNotSent(blockpos);
3210                         }
3211                 } // action == 3
3212
3213                 /*
3214                         4: use
3215                 */
3216                 else if(action == 4)
3217                 {
3218                         ItemStack item = playersao->getWieldedItem();
3219
3220                         actionstream<<player->getName()<<" uses "<<item.name
3221                                         <<", pointing at "<<pointed.dump()<<std::endl;
3222
3223                         if(scriptapi_item_on_use(m_lua,
3224                                         item, playersao, pointed))
3225                         {
3226                                 // Apply returned ItemStack
3227                                 playersao->setWieldedItem(item);
3228                         }
3229
3230                 } // action == 4
3231
3232
3233                 /*
3234                         Catch invalid actions
3235                 */
3236                 else
3237                 {
3238                         infostream<<"WARNING: Server: Invalid action "
3239                                         <<action<<std::endl;
3240                 }
3241         }
3242         else if(command == TOSERVER_REMOVED_SOUNDS)
3243         {
3244                 std::string datastring((char*)&data[2], datasize-2);
3245                 std::istringstream is(datastring, std::ios_base::binary);
3246
3247                 int num = readU16(is);
3248                 for(int k=0; k<num; k++){
3249                         s32 id = readS32(is);
3250                         std::map<s32, ServerPlayingSound>::iterator i =
3251                                         m_playing_sounds.find(id);
3252                         if(i == m_playing_sounds.end())
3253                                 continue;
3254                         ServerPlayingSound &psound = i->second;
3255                         psound.clients.erase(peer_id);
3256                         if(psound.clients.size() == 0)
3257                                 m_playing_sounds.erase(i++);
3258                 }
3259         }
3260         else if(command == TOSERVER_NODEMETA_FIELDS)
3261         {
3262                 std::string datastring((char*)&data[2], datasize-2);
3263                 std::istringstream is(datastring, std::ios_base::binary);
3264
3265                 v3s16 p = readV3S16(is);
3266                 std::string formname = deSerializeString(is);
3267                 int num = readU16(is);
3268                 std::map<std::string, std::string> fields;
3269                 for(int k=0; k<num; k++){
3270                         std::string fieldname = deSerializeString(is);
3271                         std::string fieldvalue = deSerializeLongString(is);
3272                         fields[fieldname] = fieldvalue;
3273                 }
3274
3275                 // If something goes wrong, this player is to blame
3276                 RollbackScopeActor rollback_scope(m_rollback,
3277                                 std::string("player:")+player->getName());
3278
3279                 // Check the target node for rollback data; leave others unnoticed
3280                 RollbackNode rn_old(&m_env->getMap(), p, this);
3281
3282                 scriptapi_node_on_receive_fields(m_lua, p, formname, fields,
3283                                 playersao);
3284
3285                 // Report rollback data
3286                 RollbackNode rn_new(&m_env->getMap(), p, this);
3287                 if(rollback() && rn_new != rn_old){
3288                         RollbackAction action;
3289                         action.setSetNode(p, rn_old, rn_new);
3290                         rollback()->reportAction(action);
3291                 }
3292         }
3293         else if(command == TOSERVER_INVENTORY_FIELDS)
3294         {
3295                 std::string datastring((char*)&data[2], datasize-2);
3296                 std::istringstream is(datastring, std::ios_base::binary);
3297
3298                 std::string formname = deSerializeString(is);
3299                 int num = readU16(is);
3300                 std::map<std::string, std::string> fields;
3301                 for(int k=0; k<num; k++){
3302                         std::string fieldname = deSerializeString(is);
3303                         std::string fieldvalue = deSerializeLongString(is);
3304                         fields[fieldname] = fieldvalue;
3305                 }
3306
3307                 scriptapi_on_player_receive_fields(m_lua, playersao, formname, fields);
3308         }
3309         else
3310         {
3311                 infostream<<"Server::ProcessData(): Ignoring "
3312                                 "unknown command "<<command<<std::endl;
3313         }
3314
3315         } //try
3316         catch(SendFailedException &e)
3317         {
3318                 errorstream<<"Server::ProcessData(): SendFailedException: "
3319                                 <<"what="<<e.what()
3320                                 <<std::endl;
3321         }
3322 }
3323
3324 void Server::onMapEditEvent(MapEditEvent *event)
3325 {
3326         //infostream<<"Server::onMapEditEvent()"<<std::endl;
3327         if(m_ignore_map_edit_events)
3328                 return;
3329         if(m_ignore_map_edit_events_area.contains(event->getArea()))
3330                 return;
3331         MapEditEvent *e = event->clone();
3332         m_unsent_map_edit_queue.push_back(e);
3333 }
3334
3335 Inventory* Server::getInventory(const InventoryLocation &loc)
3336 {
3337         switch(loc.type){
3338         case InventoryLocation::UNDEFINED:
3339         {}
3340         break;
3341         case InventoryLocation::CURRENT_PLAYER:
3342         {}
3343         break;
3344         case InventoryLocation::PLAYER:
3345         {
3346                 Player *player = m_env->getPlayer(loc.name.c_str());
3347                 if(!player)
3348                         return NULL;
3349                 PlayerSAO *playersao = player->getPlayerSAO();
3350                 if(!playersao)
3351                         return NULL;
3352                 return playersao->getInventory();
3353         }
3354         break;
3355         case InventoryLocation::NODEMETA:
3356         {
3357                 NodeMetadata *meta = m_env->getMap().getNodeMetadata(loc.p);
3358                 if(!meta)
3359                         return NULL;
3360                 return meta->getInventory();
3361         }
3362         break;
3363         case InventoryLocation::DETACHED:
3364         {
3365                 if(m_detached_inventories.count(loc.name) == 0)
3366                         return NULL;
3367                 return m_detached_inventories[loc.name];
3368         }
3369         break;
3370         default:
3371                 assert(0);
3372         }
3373         return NULL;
3374 }
3375 void Server::setInventoryModified(const InventoryLocation &loc)
3376 {
3377         switch(loc.type){
3378         case InventoryLocation::UNDEFINED:
3379         {}
3380         break;
3381         case InventoryLocation::PLAYER:
3382         {
3383                 Player *player = m_env->getPlayer(loc.name.c_str());
3384                 if(!player)
3385                         return;
3386                 PlayerSAO *playersao = player->getPlayerSAO();
3387                 if(!playersao)
3388                         return;
3389                 playersao->m_inventory_not_sent = true;
3390                 playersao->m_wielded_item_not_sent = true;
3391         }
3392         break;
3393         case InventoryLocation::NODEMETA:
3394         {
3395                 v3s16 blockpos = getNodeBlockPos(loc.p);
3396
3397                 MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos);
3398                 if(block)
3399                         block->raiseModified(MOD_STATE_WRITE_NEEDED);
3400
3401                 setBlockNotSent(blockpos);
3402         }
3403         break;
3404         case InventoryLocation::DETACHED:
3405         {
3406                 sendDetachedInventoryToAll(loc.name);
3407         }
3408         break;
3409         default:
3410                 assert(0);
3411         }
3412 }
3413
3414 core::list<PlayerInfo> Server::getPlayerInfo()
3415 {
3416         DSTACK(__FUNCTION_NAME);
3417         JMutexAutoLock envlock(m_env_mutex);
3418         JMutexAutoLock conlock(m_con_mutex);
3419
3420         core::list<PlayerInfo> list;
3421
3422         core::list<Player*> players = m_env->getPlayers();
3423
3424         core::list<Player*>::Iterator i;
3425         for(i = players.begin();
3426                         i != players.end(); i++)
3427         {
3428                 PlayerInfo info;
3429
3430                 Player *player = *i;
3431
3432                 try{
3433                         // Copy info from connection to info struct
3434                         info.id = player->peer_id;
3435                         info.address = m_con.GetPeerAddress(player->peer_id);
3436                         info.avg_rtt = m_con.GetPeerAvgRTT(player->peer_id);
3437                 }
3438                 catch(con::PeerNotFoundException &e)
3439                 {
3440                         // Set dummy peer info
3441                         info.id = 0;
3442                         info.address = Address(0,0,0,0,0);
3443                         info.avg_rtt = 0.0;
3444                 }
3445
3446                 snprintf(info.name, PLAYERNAME_SIZE, "%s", player->getName());
3447                 info.position = player->getPosition();
3448
3449                 list.push_back(info);
3450         }
3451
3452         return list;
3453 }
3454
3455
3456 void Server::peerAdded(con::Peer *peer)
3457 {
3458         DSTACK(__FUNCTION_NAME);
3459         verbosestream<<"Server::peerAdded(): peer->id="
3460                         <<peer->id<<std::endl;
3461
3462         PeerChange c;
3463         c.type = PEER_ADDED;
3464         c.peer_id = peer->id;
3465         c.timeout = false;
3466         m_peer_change_queue.push_back(c);
3467 }
3468
3469 void Server::deletingPeer(con::Peer *peer, bool timeout)
3470 {
3471         DSTACK(__FUNCTION_NAME);
3472         verbosestream<<"Server::deletingPeer(): peer->id="
3473                         <<peer->id<<", timeout="<<timeout<<std::endl;
3474
3475         PeerChange c;
3476         c.type = PEER_REMOVED;
3477         c.peer_id = peer->id;
3478         c.timeout = timeout;
3479         m_peer_change_queue.push_back(c);
3480 }
3481
3482 /*
3483         Static send methods
3484 */
3485
3486 void Server::SendHP(con::Connection &con, u16 peer_id, u8 hp)
3487 {
3488         DSTACK(__FUNCTION_NAME);
3489         std::ostringstream os(std::ios_base::binary);
3490
3491         writeU16(os, TOCLIENT_HP);
3492         writeU8(os, hp);
3493
3494         // Make data buffer
3495         std::string s = os.str();
3496         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3497         // Send as reliable
3498         con.Send(peer_id, 0, data, true);
3499 }
3500
3501 void Server::SendAccessDenied(con::Connection &con, u16 peer_id,
3502                 const std::wstring &reason)
3503 {
3504         DSTACK(__FUNCTION_NAME);
3505         std::ostringstream os(std::ios_base::binary);
3506
3507         writeU16(os, TOCLIENT_ACCESS_DENIED);
3508         os<<serializeWideString(reason);
3509
3510         // Make data buffer
3511         std::string s = os.str();
3512         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3513         // Send as reliable
3514         con.Send(peer_id, 0, data, true);
3515 }
3516
3517 void Server::SendDeathscreen(con::Connection &con, u16 peer_id,
3518                 bool set_camera_point_target, v3f camera_point_target)
3519 {
3520         DSTACK(__FUNCTION_NAME);
3521         std::ostringstream os(std::ios_base::binary);
3522
3523         writeU16(os, TOCLIENT_DEATHSCREEN);
3524         writeU8(os, set_camera_point_target);
3525         writeV3F1000(os, camera_point_target);
3526
3527         // Make data buffer
3528         std::string s = os.str();
3529         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3530         // Send as reliable
3531         con.Send(peer_id, 0, data, true);
3532 }
3533
3534 void Server::SendItemDef(con::Connection &con, u16 peer_id,
3535                 IItemDefManager *itemdef)
3536 {
3537         DSTACK(__FUNCTION_NAME);
3538         std::ostringstream os(std::ios_base::binary);
3539
3540         /*
3541                 u16 command
3542                 u32 length of the next item
3543                 zlib-compressed serialized ItemDefManager
3544         */
3545         writeU16(os, TOCLIENT_ITEMDEF);
3546         std::ostringstream tmp_os(std::ios::binary);
3547         itemdef->serialize(tmp_os);
3548         std::ostringstream tmp_os2(std::ios::binary);
3549         compressZlib(tmp_os.str(), tmp_os2);
3550         os<<serializeLongString(tmp_os2.str());
3551
3552         // Make data buffer
3553         std::string s = os.str();
3554         verbosestream<<"Server: Sending item definitions to id("<<peer_id
3555                         <<"): size="<<s.size()<<std::endl;
3556         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3557         // Send as reliable
3558         con.Send(peer_id, 0, data, true);
3559 }
3560
3561 void Server::SendNodeDef(con::Connection &con, u16 peer_id,
3562                 INodeDefManager *nodedef, u16 protocol_version)
3563 {
3564         DSTACK(__FUNCTION_NAME);
3565         std::ostringstream os(std::ios_base::binary);
3566
3567         /*
3568                 u16 command
3569                 u32 length of the next item
3570                 zlib-compressed serialized NodeDefManager
3571         */
3572         writeU16(os, TOCLIENT_NODEDEF);
3573         std::ostringstream tmp_os(std::ios::binary);
3574         nodedef->serialize(tmp_os, protocol_version);
3575         std::ostringstream tmp_os2(std::ios::binary);
3576         compressZlib(tmp_os.str(), tmp_os2);
3577         os<<serializeLongString(tmp_os2.str());
3578
3579         // Make data buffer
3580         std::string s = os.str();
3581         verbosestream<<"Server: Sending node definitions to id("<<peer_id
3582                         <<"): size="<<s.size()<<std::endl;
3583         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3584         // Send as reliable
3585         con.Send(peer_id, 0, data, true);
3586 }
3587
3588 /*
3589         Non-static send methods
3590 */
3591
3592 void Server::SendInventory(u16 peer_id)
3593 {
3594         DSTACK(__FUNCTION_NAME);
3595
3596         PlayerSAO *playersao = getPlayerSAO(peer_id);
3597         assert(playersao);
3598
3599         playersao->m_inventory_not_sent = false;
3600
3601         /*
3602                 Serialize it
3603         */
3604
3605         std::ostringstream os;
3606         playersao->getInventory()->serialize(os);
3607
3608         std::string s = os.str();
3609
3610         SharedBuffer<u8> data(s.size()+2);
3611         writeU16(&data[0], TOCLIENT_INVENTORY);
3612         memcpy(&data[2], s.c_str(), s.size());
3613
3614         // Send as reliable
3615         m_con.Send(peer_id, 0, data, true);
3616 }
3617
3618 void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
3619 {
3620         DSTACK(__FUNCTION_NAME);
3621
3622         std::ostringstream os(std::ios_base::binary);
3623         u8 buf[12];
3624
3625         // Write command
3626         writeU16(buf, TOCLIENT_CHAT_MESSAGE);
3627         os.write((char*)buf, 2);
3628
3629         // Write length
3630         writeU16(buf, message.size());
3631         os.write((char*)buf, 2);
3632
3633         // Write string
3634         for(u32 i=0; i<message.size(); i++)
3635         {
3636                 u16 w = message[i];
3637                 writeU16(buf, w);
3638                 os.write((char*)buf, 2);
3639         }
3640
3641         // Make data buffer
3642         std::string s = os.str();
3643         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3644         // Send as reliable
3645         m_con.Send(peer_id, 0, data, true);
3646 }
3647 void Server::SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname)
3648 {
3649         DSTACK(__FUNCTION_NAME);
3650
3651         std::ostringstream os(std::ios_base::binary);
3652         u8 buf[12];
3653
3654         // Write command
3655         writeU16(buf, TOCLIENT_SHOW_FORMSPEC);
3656         os.write((char*)buf, 2);
3657         os<<serializeLongString(formspec);
3658         os<<serializeString(formname);
3659
3660         // Make data buffer
3661         std::string s = os.str();
3662         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3663         // Send as reliable
3664         m_con.Send(peer_id, 0, data, true);
3665 }
3666
3667 void Server::BroadcastChatMessage(const std::wstring &message)
3668 {
3669         for(core::map<u16, RemoteClient*>::Iterator
3670                 i = m_clients.getIterator();
3671                 i.atEnd() == false; i++)
3672         {
3673                 // Get client and check that it is valid
3674                 RemoteClient *client = i.getNode()->getValue();
3675                 assert(client->peer_id == i.getNode()->getKey());
3676                 if(client->serialization_version == SER_FMT_VER_INVALID)
3677                         continue;
3678
3679                 SendChatMessage(client->peer_id, message);
3680         }
3681 }
3682
3683 void Server::SendPlayerHP(u16 peer_id)
3684 {
3685         DSTACK(__FUNCTION_NAME);
3686         PlayerSAO *playersao = getPlayerSAO(peer_id);
3687         assert(playersao);
3688         playersao->m_hp_not_sent = false;
3689         SendHP(m_con, peer_id, playersao->getHP());
3690 }
3691
3692 void Server::SendMovePlayer(u16 peer_id)
3693 {
3694         DSTACK(__FUNCTION_NAME);
3695         Player *player = m_env->getPlayer(peer_id);
3696         assert(player);
3697
3698         std::ostringstream os(std::ios_base::binary);
3699         writeU16(os, TOCLIENT_MOVE_PLAYER);
3700         writeV3F1000(os, player->getPosition());
3701         writeF1000(os, player->getPitch());
3702         writeF1000(os, player->getYaw());
3703
3704         {
3705                 v3f pos = player->getPosition();
3706                 f32 pitch = player->getPitch();
3707                 f32 yaw = player->getYaw();
3708                 verbosestream<<"Server: Sending TOCLIENT_MOVE_PLAYER"
3709                                 <<" pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
3710                                 <<" pitch="<<pitch
3711                                 <<" yaw="<<yaw
3712                                 <<std::endl;
3713         }
3714
3715         // Make data buffer
3716         std::string s = os.str();
3717         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3718         // Send as reliable
3719         m_con.Send(peer_id, 0, data, true);
3720 }
3721
3722 void Server::SendPlayerPrivileges(u16 peer_id)
3723 {
3724         Player *player = m_env->getPlayer(peer_id);
3725         assert(player);
3726         if(player->peer_id == PEER_ID_INEXISTENT)
3727                 return;
3728
3729         std::set<std::string> privs;
3730         scriptapi_get_auth(m_lua, player->getName(), NULL, &privs);
3731
3732         std::ostringstream os(std::ios_base::binary);
3733         writeU16(os, TOCLIENT_PRIVILEGES);
3734         writeU16(os, privs.size());
3735         for(std::set<std::string>::const_iterator i = privs.begin();
3736                         i != privs.end(); i++){
3737                 os<<serializeString(*i);
3738         }
3739
3740         // Make data buffer
3741         std::string s = os.str();
3742         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3743         // Send as reliable
3744         m_con.Send(peer_id, 0, data, true);
3745 }
3746
3747 void Server::SendPlayerInventoryFormspec(u16 peer_id)
3748 {
3749         Player *player = m_env->getPlayer(peer_id);
3750         assert(player);
3751         if(player->peer_id == PEER_ID_INEXISTENT)
3752                 return;
3753
3754         std::ostringstream os(std::ios_base::binary);
3755         writeU16(os, TOCLIENT_INVENTORY_FORMSPEC);
3756         os<<serializeLongString(player->inventory_formspec);
3757
3758         // Make data buffer
3759         std::string s = os.str();
3760         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3761         // Send as reliable
3762         m_con.Send(peer_id, 0, data, true);
3763 }
3764
3765 s32 Server::playSound(const SimpleSoundSpec &spec,
3766                 const ServerSoundParams &params)
3767 {
3768         // Find out initial position of sound
3769         bool pos_exists = false;
3770         v3f pos = params.getPos(m_env, &pos_exists);
3771         // If position is not found while it should be, cancel sound
3772         if(pos_exists != (params.type != ServerSoundParams::SSP_LOCAL))
3773                 return -1;
3774         // Filter destination clients
3775         std::set<RemoteClient*> dst_clients;
3776         if(params.to_player != "")
3777         {
3778                 Player *player = m_env->getPlayer(params.to_player.c_str());
3779                 if(!player){
3780                         infostream<<"Server::playSound: Player \""<<params.to_player
3781                                         <<"\" not found"<<std::endl;
3782                         return -1;
3783                 }
3784                 if(player->peer_id == PEER_ID_INEXISTENT){
3785                         infostream<<"Server::playSound: Player \""<<params.to_player
3786                                         <<"\" not connected"<<std::endl;
3787                         return -1;
3788                 }
3789                 RemoteClient *client = getClient(player->peer_id);
3790                 dst_clients.insert(client);
3791         }
3792         else
3793         {
3794                 for(core::map<u16, RemoteClient*>::Iterator
3795                                 i = m_clients.getIterator(); i.atEnd() == false; i++)
3796                 {
3797                         RemoteClient *client = i.getNode()->getValue();
3798                         Player *player = m_env->getPlayer(client->peer_id);
3799                         if(!player)
3800                                 continue;
3801                         if(pos_exists){
3802                                 if(player->getPosition().getDistanceFrom(pos) >
3803                                                 params.max_hear_distance)
3804                                         continue;
3805                         }
3806                         dst_clients.insert(client);
3807                 }
3808         }
3809         if(dst_clients.size() == 0)
3810                 return -1;
3811         // Create the sound
3812         s32 id = m_next_sound_id++;
3813         // The sound will exist as a reference in m_playing_sounds
3814         m_playing_sounds[id] = ServerPlayingSound();
3815         ServerPlayingSound &psound = m_playing_sounds[id];
3816         psound.params = params;
3817         for(std::set<RemoteClient*>::iterator i = dst_clients.begin();
3818                         i != dst_clients.end(); i++)
3819                 psound.clients.insert((*i)->peer_id);
3820         // Create packet
3821         std::ostringstream os(std::ios_base::binary);
3822         writeU16(os, TOCLIENT_PLAY_SOUND);
3823         writeS32(os, id);
3824         os<<serializeString(spec.name);
3825         writeF1000(os, spec.gain * params.gain);
3826         writeU8(os, params.type);
3827         writeV3F1000(os, pos);
3828         writeU16(os, params.object);
3829         writeU8(os, params.loop);
3830         // Make data buffer
3831         std::string s = os.str();
3832         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3833         // Send
3834         for(std::set<RemoteClient*>::iterator i = dst_clients.begin();
3835                         i != dst_clients.end(); i++){
3836                 // Send as reliable
3837                 m_con.Send((*i)->peer_id, 0, data, true);
3838         }
3839         return id;
3840 }
3841 void Server::stopSound(s32 handle)
3842 {
3843         // Get sound reference
3844         std::map<s32, ServerPlayingSound>::iterator i =
3845                         m_playing_sounds.find(handle);
3846         if(i == m_playing_sounds.end())
3847                 return;
3848         ServerPlayingSound &psound = i->second;
3849         // Create packet
3850         std::ostringstream os(std::ios_base::binary);
3851         writeU16(os, TOCLIENT_STOP_SOUND);
3852         writeS32(os, handle);
3853         // Make data buffer
3854         std::string s = os.str();
3855         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
3856         // Send
3857         for(std::set<u16>::iterator i = psound.clients.begin();
3858                         i != psound.clients.end(); i++){
3859                 // Send as reliable
3860                 m_con.Send(*i, 0, data, true);
3861         }
3862         // Remove sound reference
3863         m_playing_sounds.erase(i);
3864 }
3865
3866 void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
3867         core::list<u16> *far_players, float far_d_nodes)
3868 {
3869         float maxd = far_d_nodes*BS;
3870         v3f p_f = intToFloat(p, BS);
3871
3872         // Create packet
3873         u32 replysize = 8;
3874         SharedBuffer<u8> reply(replysize);
3875         writeU16(&reply[0], TOCLIENT_REMOVENODE);
3876         writeS16(&reply[2], p.X);
3877         writeS16(&reply[4], p.Y);
3878         writeS16(&reply[6], p.Z);
3879
3880         for(core::map<u16, RemoteClient*>::Iterator
3881                 i = m_clients.getIterator();
3882                 i.atEnd() == false; i++)
3883         {
3884                 // Get client and check that it is valid
3885                 RemoteClient *client = i.getNode()->getValue();
3886                 assert(client->peer_id == i.getNode()->getKey());
3887                 if(client->serialization_version == SER_FMT_VER_INVALID)
3888                         continue;
3889
3890                 // Don't send if it's the same one
3891                 if(client->peer_id == ignore_id)
3892                         continue;
3893
3894                 if(far_players)
3895                 {
3896                         // Get player
3897                         Player *player = m_env->getPlayer(client->peer_id);
3898                         if(player)
3899                         {
3900                                 // If player is far away, only set modified blocks not sent
3901                                 v3f player_pos = player->getPosition();
3902                                 if(player_pos.getDistanceFrom(p_f) > maxd)
3903                                 {
3904                                         far_players->push_back(client->peer_id);
3905                                         continue;
3906                                 }
3907                         }
3908                 }
3909
3910                 // Send as reliable
3911                 m_con.Send(client->peer_id, 0, reply, true);
3912         }
3913 }
3914
3915 void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
3916                 core::list<u16> *far_players, float far_d_nodes)
3917 {
3918         float maxd = far_d_nodes*BS;
3919         v3f p_f = intToFloat(p, BS);
3920
3921         for(core::map<u16, RemoteClient*>::Iterator
3922                 i = m_clients.getIterator();
3923                 i.atEnd() == false; i++)
3924         {
3925                 // Get client and check that it is valid
3926                 RemoteClient *client = i.getNode()->getValue();
3927                 assert(client->peer_id == i.getNode()->getKey());
3928                 if(client->serialization_version == SER_FMT_VER_INVALID)
3929                         continue;
3930
3931                 // Don't send if it's the same one
3932                 if(client->peer_id == ignore_id)
3933                         continue;
3934
3935                 if(far_players)
3936                 {
3937                         // Get player
3938                         Player *player = m_env->getPlayer(client->peer_id);
3939                         if(player)
3940                         {
3941                                 // If player is far away, only set modified blocks not sent
3942                                 v3f player_pos = player->getPosition();
3943                                 if(player_pos.getDistanceFrom(p_f) > maxd)
3944                                 {
3945                                         far_players->push_back(client->peer_id);
3946                                         continue;
3947                                 }
3948                         }
3949                 }
3950
3951                 // Create packet
3952                 u32 replysize = 8 + MapNode::serializedLength(client->serialization_version);
3953                 SharedBuffer<u8> reply(replysize);
3954                 writeU16(&reply[0], TOCLIENT_ADDNODE);
3955                 writeS16(&reply[2], p.X);
3956                 writeS16(&reply[4], p.Y);
3957                 writeS16(&reply[6], p.Z);
3958                 n.serialize(&reply[8], client->serialization_version);
3959
3960                 // Send as reliable
3961                 m_con.Send(client->peer_id, 0, reply, true);
3962         }
3963 }
3964
3965 void Server::setBlockNotSent(v3s16 p)
3966 {
3967         for(core::map<u16, RemoteClient*>::Iterator
3968                 i = m_clients.getIterator();
3969                 i.atEnd()==false; i++)
3970         {
3971                 RemoteClient *client = i.getNode()->getValue();
3972                 client->SetBlockNotSent(p);
3973         }
3974 }
3975
3976 void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver)
3977 {
3978         DSTACK(__FUNCTION_NAME);
3979
3980         v3s16 p = block->getPos();
3981
3982 #if 0
3983         // Analyze it a bit
3984         bool completely_air = true;
3985         for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
3986         for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
3987         for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
3988         {
3989                 if(block->getNodeNoEx(v3s16(x0,y0,z0)).d != CONTENT_AIR)
3990                 {
3991                         completely_air = false;
3992                         x0 = y0 = z0 = MAP_BLOCKSIZE; // Break out
3993                 }
3994         }
3995
3996         // Print result
3997         infostream<<"Server: Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<"): ";
3998         if(completely_air)
3999                 infostream<<"[completely air] ";
4000         infostream<<std::endl;
4001 #endif
4002
4003         /*
4004                 Create a packet with the block in the right format
4005         */
4006
4007         std::ostringstream os(std::ios_base::binary);
4008         block->serialize(os, ver, false);
4009         std::string s = os.str();
4010         SharedBuffer<u8> blockdata((u8*)s.c_str(), s.size());
4011
4012         u32 replysize = 8 + blockdata.getSize();
4013         SharedBuffer<u8> reply(replysize);
4014         writeU16(&reply[0], TOCLIENT_BLOCKDATA);
4015         writeS16(&reply[2], p.X);
4016         writeS16(&reply[4], p.Y);
4017         writeS16(&reply[6], p.Z);
4018         memcpy(&reply[8], *blockdata, blockdata.getSize());
4019
4020         /*infostream<<"Server: Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
4021                         <<":  \tpacket size: "<<replysize<<std::endl;*/
4022
4023         /*
4024                 Send packet
4025         */
4026         m_con.Send(peer_id, 1, reply, true);
4027 }
4028
4029 void Server::SendBlocks(float dtime)
4030 {
4031         DSTACK(__FUNCTION_NAME);
4032
4033         JMutexAutoLock envlock(m_env_mutex);
4034         JMutexAutoLock conlock(m_con_mutex);
4035
4036         ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients");
4037
4038         core::array<PrioritySortedBlockTransfer> queue;
4039
4040         s32 total_sending = 0;
4041
4042         {
4043                 ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending");
4044
4045                 for(core::map<u16, RemoteClient*>::Iterator
4046                         i = m_clients.getIterator();
4047                         i.atEnd() == false; i++)
4048                 {
4049                         RemoteClient *client = i.getNode()->getValue();
4050                         assert(client->peer_id == i.getNode()->getKey());
4051
4052                         // If definitions and textures have not been sent, don't
4053                         // send MapBlocks either
4054                         if(!client->definitions_sent)
4055                                 continue;
4056
4057                         total_sending += client->SendingCount();
4058
4059                         if(client->serialization_version == SER_FMT_VER_INVALID)
4060                                 continue;
4061
4062                         client->GetNextBlocks(this, dtime, queue);
4063                 }
4064         }
4065
4066         // Sort.
4067         // Lowest priority number comes first.
4068         // Lowest is most important.
4069         queue.sort();
4070
4071         for(u32 i=0; i<queue.size(); i++)
4072         {
4073                 //TODO: Calculate limit dynamically
4074                 if(total_sending >= g_settings->getS32
4075                                 ("max_simultaneous_block_sends_server_total"))
4076                         break;
4077
4078                 PrioritySortedBlockTransfer q = queue[i];
4079
4080                 MapBlock *block = NULL;
4081                 try
4082                 {
4083                         block = m_env->getMap().getBlockNoCreate(q.pos);
4084                 }
4085                 catch(InvalidPositionException &e)
4086                 {
4087                         continue;
4088                 }
4089
4090                 RemoteClient *client = getClient(q.peer_id);
4091
4092                 SendBlockNoLock(q.peer_id, block, client->serialization_version);
4093
4094                 client->SentBlock(q.pos);
4095
4096                 total_sending++;
4097         }
4098 }
4099
4100 void Server::fillMediaCache()
4101 {
4102         DSTACK(__FUNCTION_NAME);
4103
4104         infostream<<"Server: Calculating media file checksums"<<std::endl;
4105
4106         // Collect all media file paths
4107         std::list<std::string> paths;
4108         for(core::list<ModSpec>::Iterator i = m_mods.begin();
4109                         i != m_mods.end(); i++){
4110                 const ModSpec &mod = *i;
4111                 paths.push_back(mod.path + DIR_DELIM + "textures");
4112                 paths.push_back(mod.path + DIR_DELIM + "sounds");
4113                 paths.push_back(mod.path + DIR_DELIM + "media");
4114                 paths.push_back(mod.path + DIR_DELIM + "models");
4115         }
4116         std::string path_all = "textures";
4117         paths.push_back(path_all + DIR_DELIM + "all");
4118
4119         // Collect media file information from paths into cache
4120         for(std::list<std::string>::iterator i = paths.begin();
4121                         i != paths.end(); i++)
4122         {
4123                 std::string mediapath = *i;
4124                 std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
4125                 for(u32 j=0; j<dirlist.size(); j++){
4126                         if(dirlist[j].dir) // Ignode dirs
4127                                 continue;
4128                         std::string filename = dirlist[j].name;
4129                         // If name contains illegal characters, ignore the file
4130                         if(!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)){
4131                                 infostream<<"Server: ignoring illegal file name: \""
4132                                                 <<filename<<"\""<<std::endl;
4133                                 continue;
4134                         }
4135                         // If name is not in a supported format, ignore it
4136                         const char *supported_ext[] = {
4137                                 ".png", ".jpg", ".bmp", ".tga",
4138                                 ".pcx", ".ppm", ".psd", ".wal", ".rgb",
4139                                 ".ogg",
4140                                 ".x", ".b3d", ".md2", ".obj",
4141                                 NULL
4142                         };
4143                         if(removeStringEnd(filename, supported_ext) == ""){
4144                                 infostream<<"Server: ignoring unsupported file extension: \""
4145                                                 <<filename<<"\""<<std::endl;
4146                                 continue;
4147                         }
4148                         // Ok, attempt to load the file and add to cache
4149                         std::string filepath = mediapath + DIR_DELIM + filename;
4150                         // Read data
4151                         std::ifstream fis(filepath.c_str(), std::ios_base::binary);
4152                         if(fis.good() == false){
4153                                 errorstream<<"Server::fillMediaCache(): Could not open \""
4154                                                 <<filename<<"\" for reading"<<std::endl;
4155                                 continue;
4156                         }
4157                         std::ostringstream tmp_os(std::ios_base::binary);
4158                         bool bad = false;
4159                         for(;;){
4160                                 char buf[1024];
4161                                 fis.read(buf, 1024);
4162                                 std::streamsize len = fis.gcount();
4163                                 tmp_os.write(buf, len);
4164                                 if(fis.eof())
4165                                         break;
4166                                 if(!fis.good()){
4167                                         bad = true;
4168                                         break;
4169                                 }
4170                         }
4171                         if(bad){
4172                                 errorstream<<"Server::fillMediaCache(): Failed to read \""
4173                                                 <<filename<<"\""<<std::endl;
4174                                 continue;
4175                         }
4176                         if(tmp_os.str().length() == 0){
4177                                 errorstream<<"Server::fillMediaCache(): Empty file \""
4178                                                 <<filepath<<"\""<<std::endl;
4179                                 continue;
4180                         }
4181
4182                         SHA1 sha1;
4183                         sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
4184
4185                         unsigned char *digest = sha1.getDigest();
4186                         std::string sha1_base64 = base64_encode(digest, 20);
4187                         std::string sha1_hex = hex_encode((char*)digest, 20);
4188                         free(digest);
4189
4190                         // Put in list
4191                         this->m_media[filename] = MediaInfo(filepath, sha1_base64);
4192                         verbosestream<<"Server: "<<sha1_hex<<" is "<<filename<<std::endl;
4193                 }
4194         }
4195 }
4196
4197 struct SendableMediaAnnouncement
4198 {
4199         std::string name;
4200         std::string sha1_digest;
4201
4202         SendableMediaAnnouncement(const std::string name_="",
4203                         const std::string sha1_digest_=""):
4204                 name(name_),
4205                 sha1_digest(sha1_digest_)
4206         {}
4207 };
4208
4209 void Server::sendMediaAnnouncement(u16 peer_id)
4210 {
4211         DSTACK(__FUNCTION_NAME);
4212
4213         verbosestream<<"Server: Announcing files to id("<<peer_id<<")"
4214                         <<std::endl;
4215
4216         core::list<SendableMediaAnnouncement> file_announcements;
4217
4218         for(std::map<std::string, MediaInfo>::iterator i = m_media.begin();
4219                         i != m_media.end(); i++){
4220                 // Put in list
4221                 file_announcements.push_back(
4222                                 SendableMediaAnnouncement(i->first, i->second.sha1_digest));
4223         }
4224
4225         // Make packet
4226         std::ostringstream os(std::ios_base::binary);
4227
4228         /*
4229                 u16 command
4230                 u32 number of files
4231                 for each texture {
4232                         u16 length of name
4233                         string name
4234                         u16 length of sha1_digest
4235                         string sha1_digest
4236                 }
4237         */
4238
4239         writeU16(os, TOCLIENT_ANNOUNCE_MEDIA);
4240         writeU16(os, file_announcements.size());
4241
4242         for(core::list<SendableMediaAnnouncement>::Iterator
4243                         j = file_announcements.begin();
4244                         j != file_announcements.end(); j++){
4245                 os<<serializeString(j->name);
4246                 os<<serializeString(j->sha1_digest);
4247         }
4248         os<<serializeString(g_settings->get("remote_media"));
4249
4250         // Make data buffer
4251         std::string s = os.str();
4252         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
4253
4254         // Send as reliable
4255         m_con.Send(peer_id, 0, data, true);
4256 }
4257
4258 struct SendableMedia
4259 {
4260         std::string name;
4261         std::string path;
4262         std::string data;
4263
4264         SendableMedia(const std::string &name_="", const std::string path_="",
4265                         const std::string &data_=""):
4266                 name(name_),
4267                 path(path_),
4268                 data(data_)
4269         {}
4270 };
4271
4272 void Server::sendRequestedMedia(u16 peer_id,
4273                 const core::list<MediaRequest> &tosend)
4274 {
4275         DSTACK(__FUNCTION_NAME);
4276
4277         verbosestream<<"Server::sendRequestedMedia(): "
4278                         <<"Sending files to client"<<std::endl;
4279
4280         /* Read files */
4281
4282         // Put 5kB in one bunch (this is not accurate)
4283         u32 bytes_per_bunch = 5000;
4284
4285         core::array< core::list<SendableMedia> > file_bunches;
4286         file_bunches.push_back(core::list<SendableMedia>());
4287
4288         u32 file_size_bunch_total = 0;
4289
4290         for(core::list<MediaRequest>::ConstIterator i = tosend.begin();
4291                         i != tosend.end(); i++)
4292         {
4293                 if(m_media.find(i->name) == m_media.end()){
4294                         errorstream<<"Server::sendRequestedMedia(): Client asked for "
4295                                         <<"unknown file \""<<(i->name)<<"\""<<std::endl;
4296                         continue;
4297                 }
4298
4299                 //TODO get path + name
4300                 std::string tpath = m_media[(*i).name].path;
4301
4302                 // Read data
4303                 std::ifstream fis(tpath.c_str(), std::ios_base::binary);
4304                 if(fis.good() == false){
4305                         errorstream<<"Server::sendRequestedMedia(): Could not open \""
4306                                         <<tpath<<"\" for reading"<<std::endl;
4307                         continue;
4308                 }
4309                 std::ostringstream tmp_os(std::ios_base::binary);
4310                 bool bad = false;
4311                 for(;;){
4312                         char buf[1024];
4313                         fis.read(buf, 1024);
4314                         std::streamsize len = fis.gcount();
4315                         tmp_os.write(buf, len);
4316                         file_size_bunch_total += len;
4317                         if(fis.eof())
4318                                 break;
4319                         if(!fis.good()){
4320                                 bad = true;
4321                                 break;
4322                         }
4323                 }
4324                 if(bad){
4325                         errorstream<<"Server::sendRequestedMedia(): Failed to read \""
4326                                         <<(*i).name<<"\""<<std::endl;
4327                         continue;
4328                 }
4329                 /*infostream<<"Server::sendRequestedMedia(): Loaded \""
4330                                 <<tname<<"\""<<std::endl;*/
4331                 // Put in list
4332                 file_bunches[file_bunches.size()-1].push_back(
4333                                 SendableMedia((*i).name, tpath, tmp_os.str()));
4334
4335                 // Start next bunch if got enough data
4336                 if(file_size_bunch_total >= bytes_per_bunch){
4337                         file_bunches.push_back(core::list<SendableMedia>());
4338                         file_size_bunch_total = 0;
4339                 }
4340
4341         }
4342
4343         /* Create and send packets */
4344
4345         u32 num_bunches = file_bunches.size();
4346         for(u32 i=0; i<num_bunches; i++)
4347         {
4348                 std::ostringstream os(std::ios_base::binary);
4349
4350                 /*
4351                         u16 command
4352                         u16 total number of texture bunches
4353                         u16 index of this bunch
4354                         u32 number of files in this bunch
4355                         for each file {
4356                                 u16 length of name
4357                                 string name
4358                                 u32 length of data
4359                                 data
4360                         }
4361                 */
4362
4363                 writeU16(os, TOCLIENT_MEDIA);
4364                 writeU16(os, num_bunches);
4365                 writeU16(os, i);
4366                 writeU32(os, file_bunches[i].size());
4367
4368                 for(core::list<SendableMedia>::Iterator
4369                                 j = file_bunches[i].begin();
4370                                 j != file_bunches[i].end(); j++){
4371                         os<<serializeString(j->name);
4372                         os<<serializeLongString(j->data);
4373                 }
4374
4375                 // Make data buffer
4376                 std::string s = os.str();
4377                 verbosestream<<"Server::sendRequestedMedia(): bunch "
4378                                 <<i<<"/"<<num_bunches
4379                                 <<" files="<<file_bunches[i].size()
4380                                 <<" size=" <<s.size()<<std::endl;
4381                 SharedBuffer<u8> data((u8*)s.c_str(), s.size());
4382                 // Send as reliable
4383                 m_con.Send(peer_id, 0, data, true);
4384         }
4385 }
4386
4387 void Server::sendDetachedInventory(const std::string &name, u16 peer_id)
4388 {
4389         if(m_detached_inventories.count(name) == 0){
4390                 errorstream<<__FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
4391                 return;
4392         }
4393         Inventory *inv = m_detached_inventories[name];
4394
4395         std::ostringstream os(std::ios_base::binary);
4396         writeU16(os, TOCLIENT_DETACHED_INVENTORY);
4397         os<<serializeString(name);
4398         inv->serialize(os);
4399
4400         // Make data buffer
4401         std::string s = os.str();
4402         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
4403         // Send as reliable
4404         m_con.Send(peer_id, 0, data, true);
4405 }
4406
4407 void Server::sendDetachedInventoryToAll(const std::string &name)
4408 {
4409         DSTACK(__FUNCTION_NAME);
4410
4411         for(core::map<u16, RemoteClient*>::Iterator
4412                         i = m_clients.getIterator();
4413                         i.atEnd() == false; i++){
4414                 RemoteClient *client = i.getNode()->getValue();
4415                 sendDetachedInventory(name, client->peer_id);
4416         }
4417 }
4418
4419 void Server::sendDetachedInventories(u16 peer_id)
4420 {
4421         DSTACK(__FUNCTION_NAME);
4422
4423         for(std::map<std::string, Inventory*>::iterator
4424                         i = m_detached_inventories.begin();
4425                         i != m_detached_inventories.end(); i++){
4426                 const std::string &name = i->first;
4427                 //Inventory *inv = i->second;
4428                 sendDetachedInventory(name, peer_id);
4429         }
4430 }
4431
4432 /*
4433         Something random
4434 */
4435
4436 void Server::DiePlayer(u16 peer_id)
4437 {
4438         DSTACK(__FUNCTION_NAME);
4439
4440         PlayerSAO *playersao = getPlayerSAO(peer_id);
4441         assert(playersao);
4442
4443         infostream<<"Server::DiePlayer(): Player "
4444                         <<playersao->getPlayer()->getName()
4445                         <<" dies"<<std::endl;
4446
4447         playersao->setHP(0);
4448
4449         // Trigger scripted stuff
4450         scriptapi_on_dieplayer(m_lua, playersao);
4451
4452         SendPlayerHP(peer_id);
4453         SendDeathscreen(m_con, peer_id, false, v3f(0,0,0));
4454 }
4455
4456 void Server::RespawnPlayer(u16 peer_id)
4457 {
4458         DSTACK(__FUNCTION_NAME);
4459
4460         PlayerSAO *playersao = getPlayerSAO(peer_id);
4461         assert(playersao);
4462
4463         infostream<<"Server::RespawnPlayer(): Player "
4464                         <<playersao->getPlayer()->getName()
4465                         <<" respawns"<<std::endl;
4466
4467         playersao->setHP(PLAYER_MAX_HP);
4468
4469         bool repositioned = scriptapi_on_respawnplayer(m_lua, playersao);
4470         if(!repositioned){
4471                 v3f pos = findSpawnPos(m_env->getServerMap());
4472                 playersao->setPos(pos);
4473         }
4474 }
4475
4476 void Server::UpdateCrafting(u16 peer_id)
4477 {
4478         DSTACK(__FUNCTION_NAME);
4479
4480         Player* player = m_env->getPlayer(peer_id);
4481         assert(player);
4482
4483         // Get a preview for crafting
4484         ItemStack preview;
4485         getCraftingResult(&player->inventory, preview, false, this);
4486
4487         // Put the new preview in
4488         InventoryList *plist = player->inventory.getList("craftpreview");
4489         assert(plist);
4490         assert(plist->getSize() >= 1);
4491         plist->changeItem(0, preview);
4492 }
4493
4494 RemoteClient* Server::getClient(u16 peer_id)
4495 {
4496         DSTACK(__FUNCTION_NAME);
4497         //JMutexAutoLock lock(m_con_mutex);
4498         core::map<u16, RemoteClient*>::Node *n;
4499         n = m_clients.find(peer_id);
4500         // A client should exist for all peers
4501         assert(n != NULL);
4502         return n->getValue();
4503 }
4504
4505 std::wstring Server::getStatusString()
4506 {
4507         std::wostringstream os(std::ios_base::binary);
4508         os<<L"# Server: ";
4509         // Version
4510         os<<L"version="<<narrow_to_wide(VERSION_STRING);
4511         // Uptime
4512         os<<L", uptime="<<m_uptime.get();
4513         // Information about clients
4514         core::map<u16, RemoteClient*>::Iterator i;
4515         bool first;
4516         os<<L", clients={";
4517         for(i = m_clients.getIterator(), first = true;
4518                 i.atEnd() == false; i++)
4519         {
4520                 // Get client and check that it is valid
4521                 RemoteClient *client = i.getNode()->getValue();
4522                 assert(client->peer_id == i.getNode()->getKey());
4523                 if(client->serialization_version == SER_FMT_VER_INVALID)
4524                         continue;
4525                 // Get player
4526                 Player *player = m_env->getPlayer(client->peer_id);
4527                 // Get name of player
4528                 std::wstring name = L"unknown";
4529                 if(player != NULL)
4530                         name = narrow_to_wide(player->getName());
4531                 // Add name to information string
4532                 if(!first)
4533                         os<<L",";
4534                 else
4535                         first = false;
4536                 os<<name;
4537         }
4538         os<<L"}";
4539         if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false)
4540                 os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
4541         if(g_settings->get("motd") != "")
4542                 os<<std::endl<<L"# Server: "<<narrow_to_wide(g_settings->get("motd"));
4543         return os.str();
4544 }
4545
4546 std::set<std::string> Server::getPlayerEffectivePrivs(const std::string &name)
4547 {
4548         std::set<std::string> privs;
4549         scriptapi_get_auth(m_lua, name, NULL, &privs);
4550         return privs;
4551 }
4552
4553 bool Server::checkPriv(const std::string &name, const std::string &priv)
4554 {
4555         std::set<std::string> privs = getPlayerEffectivePrivs(name);
4556         return (privs.count(priv) != 0);
4557 }
4558
4559 void Server::reportPrivsModified(const std::string &name)
4560 {
4561         if(name == ""){
4562                 for(core::map<u16, RemoteClient*>::Iterator
4563                                 i = m_clients.getIterator();
4564                                 i.atEnd() == false; i++){
4565                         RemoteClient *client = i.getNode()->getValue();
4566                         Player *player = m_env->getPlayer(client->peer_id);
4567                         reportPrivsModified(player->getName());
4568                 }
4569         } else {
4570                 Player *player = m_env->getPlayer(name.c_str());
4571                 if(!player)
4572                         return;
4573                 SendPlayerPrivileges(player->peer_id);
4574                 PlayerSAO *sao = player->getPlayerSAO();
4575                 if(!sao)
4576                         return;
4577                 sao->updatePrivileges(
4578                                 getPlayerEffectivePrivs(name),
4579                                 isSingleplayer());
4580         }
4581 }
4582
4583 void Server::reportInventoryFormspecModified(const std::string &name)
4584 {
4585         Player *player = m_env->getPlayer(name.c_str());
4586         if(!player)
4587                 return;
4588         SendPlayerInventoryFormspec(player->peer_id);
4589 }
4590
4591 // Saves g_settings to configpath given at initialization
4592 void Server::saveConfig()
4593 {
4594         if(m_path_config != "")
4595                 g_settings->updateConfigFile(m_path_config.c_str());
4596 }
4597
4598 void Server::notifyPlayer(const char *name, const std::wstring msg)
4599 {
4600         Player *player = m_env->getPlayer(name);
4601         if(!player)
4602                 return;
4603         SendChatMessage(player->peer_id, std::wstring(L"Server: -!- ")+msg);
4604 }
4605
4606 bool Server::showFormspec(const char *playername, const std::string &formspec, const std::string &formname)
4607 {
4608         Player *player = m_env->getPlayer(playername);
4609
4610         if(!player)
4611         {
4612                 infostream<<"showFormspec: couldn't find player:"<<playername<<std::endl;
4613                 return false;
4614         }
4615
4616         SendShowFormspecMessage(player->peer_id, formspec, formname);
4617         return true;
4618 }
4619
4620 void Server::notifyPlayers(const std::wstring msg)
4621 {
4622         BroadcastChatMessage(msg);
4623 }
4624
4625 void Server::queueBlockEmerge(v3s16 blockpos, bool allow_generate)
4626 {
4627         u8 flags = 0;
4628         if(!allow_generate)
4629                 flags |= BLOCK_EMERGE_FLAG_FROMDISK;
4630         m_emerge_queue.addBlock(PEER_ID_INEXISTENT, blockpos, flags);
4631 }
4632
4633 Inventory* Server::createDetachedInventory(const std::string &name)
4634 {
4635         if(m_detached_inventories.count(name) > 0){
4636                 infostream<<"Server clearing detached inventory \""<<name<<"\""<<std::endl;
4637                 delete m_detached_inventories[name];
4638         } else {
4639                 infostream<<"Server creating detached inventory \""<<name<<"\""<<std::endl;
4640         }
4641         Inventory *inv = new Inventory(m_itemdef);
4642         assert(inv);
4643         m_detached_inventories[name] = inv;
4644         sendDetachedInventoryToAll(name);
4645         return inv;
4646 }
4647
4648 class BoolScopeSet
4649 {
4650 public:
4651         BoolScopeSet(bool *dst, bool val):
4652                 m_dst(dst)
4653         {
4654                 m_orig_state = *m_dst;
4655                 *m_dst = val;
4656         }
4657         ~BoolScopeSet()
4658         {
4659                 *m_dst = m_orig_state;
4660         }
4661 private:
4662         bool *m_dst;
4663         bool m_orig_state;
4664 };
4665
4666 // actions: time-reversed list
4667 // Return value: success/failure
4668 bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
4669                 std::list<std::string> *log)
4670 {
4671         infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
4672         ServerMap *map = (ServerMap*)(&m_env->getMap());
4673         // Disable rollback report sink while reverting
4674         BoolScopeSet rollback_scope_disable(&m_rollback_sink_enabled, false);
4675
4676         // Fail if no actions to handle
4677         if(actions.empty()){
4678                 log->push_back("Nothing to do.");
4679                 return false;
4680         }
4681
4682         int num_tried = 0;
4683         int num_failed = 0;
4684
4685         for(std::list<RollbackAction>::const_iterator
4686                         i = actions.begin();
4687                         i != actions.end(); i++)
4688         {
4689                 const RollbackAction &action = *i;
4690                 num_tried++;
4691                 bool success = action.applyRevert(map, this, this);
4692                 if(!success){
4693                         num_failed++;
4694                         std::ostringstream os;
4695                         os<<"Revert of step ("<<num_tried<<") "<<action.toString()<<" failed";
4696                         infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
4697                         if(log)
4698                                 log->push_back(os.str());
4699                 }else{
4700                         std::ostringstream os;
4701                         os<<"Successfully reverted step ("<<num_tried<<") "<<action.toString();
4702                         infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
4703                         if(log)
4704                                 log->push_back(os.str());
4705                 }
4706         }
4707
4708         infostream<<"Map::rollbackRevertActions(): "<<num_failed<<"/"<<num_tried
4709                         <<" failed"<<std::endl;
4710
4711         // Call it done if less than half failed
4712         return num_failed <= num_tried/2;
4713 }
4714
4715 // IGameDef interface
4716 // Under envlock
4717 IItemDefManager* Server::getItemDefManager()
4718 {
4719         return m_itemdef;
4720 }
4721 INodeDefManager* Server::getNodeDefManager()
4722 {
4723         return m_nodedef;
4724 }
4725 ICraftDefManager* Server::getCraftDefManager()
4726 {
4727         return m_craftdef;
4728 }
4729 ITextureSource* Server::getTextureSource()
4730 {
4731         return NULL;
4732 }
4733 IShaderSource* Server::getShaderSource()
4734 {
4735         return NULL;
4736 }
4737 u16 Server::allocateUnknownNodeId(const std::string &name)
4738 {
4739         return m_nodedef->allocateDummy(name);
4740 }
4741 ISoundManager* Server::getSoundManager()
4742 {
4743         return &dummySoundManager;
4744 }
4745 MtEventManager* Server::getEventManager()
4746 {
4747         return m_event;
4748 }
4749 IRollbackReportSink* Server::getRollbackReportSink()
4750 {
4751         if(!m_enable_rollback_recording)
4752                 return NULL;
4753         if(!m_rollback_sink_enabled)
4754                 return NULL;
4755         return m_rollback;
4756 }
4757
4758 IWritableItemDefManager* Server::getWritableItemDefManager()
4759 {
4760         return m_itemdef;
4761 }
4762 IWritableNodeDefManager* Server::getWritableNodeDefManager()
4763 {
4764         return m_nodedef;
4765 }
4766 IWritableCraftDefManager* Server::getWritableCraftDefManager()
4767 {
4768         return m_craftdef;
4769 }
4770
4771 const ModSpec* Server::getModSpec(const std::string &modname)
4772 {
4773         for(core::list<ModSpec>::Iterator i = m_mods.begin();
4774                         i != m_mods.end(); i++){
4775                 const ModSpec &mod = *i;
4776                 if(mod.name == modname)
4777                         return &mod;
4778         }
4779         return NULL;
4780 }
4781 void Server::getModNames(core::list<std::string> &modlist)
4782 {
4783         for(core::list<ModSpec>::Iterator i = m_mods.begin(); i != m_mods.end(); i++)
4784         {
4785                 modlist.push_back((*i).name);
4786         }
4787 }
4788 std::string Server::getBuiltinLuaPath()
4789 {
4790         return porting::path_share + DIR_DELIM + "builtin";
4791 }
4792
4793 v3f findSpawnPos(ServerMap &map)
4794 {
4795         //return v3f(50,50,50)*BS;
4796
4797         v3s16 nodepos;
4798
4799 #if 0
4800         nodepos = v2s16(0,0);
4801         groundheight = 20;
4802 #endif
4803
4804 #if 1
4805         // Try to find a good place a few times
4806         for(s32 i=0; i<1000; i++)
4807         {
4808                 s32 range = 1 + i;
4809                 // We're going to try to throw the player to this position
4810                 v2s16 nodepos2d = v2s16(-range + (myrand()%(range*2)),
4811                                 -range + (myrand()%(range*2)));
4812                 //v2s16 sectorpos = getNodeSectorPos(nodepos2d);
4813                 // Get ground height at point (fallbacks to heightmap function)
4814                 s16 groundheight = map.findGroundLevel(nodepos2d);
4815                 // Don't go underwater
4816                 if(groundheight < WATER_LEVEL)
4817                 {
4818                         //infostream<<"-> Underwater"<<std::endl;
4819                         continue;
4820                 }
4821                 // Don't go to high places
4822                 if(groundheight > WATER_LEVEL + 4)
4823                 {
4824                         //infostream<<"-> Underwater"<<std::endl;
4825                         continue;
4826                 }
4827
4828                 nodepos = v3s16(nodepos2d.X, groundheight-2, nodepos2d.Y);
4829                 bool is_good = false;
4830                 s32 air_count = 0;
4831                 for(s32 i=0; i<10; i++){
4832                         v3s16 blockpos = getNodeBlockPos(nodepos);
4833                         map.emergeBlock(blockpos, true);
4834                         MapNode n = map.getNodeNoEx(nodepos);
4835                         if(n.getContent() == CONTENT_AIR){
4836                                 air_count++;
4837                                 if(air_count >= 2){
4838                                         is_good = true;
4839                                         nodepos.Y -= 1;
4840                                         break;
4841                                 }
4842                         }
4843                         nodepos.Y++;
4844                 }
4845                 if(is_good){
4846                         // Found a good place
4847                         //infostream<<"Searched through "<<i<<" places."<<std::endl;
4848                         break;
4849                 }
4850         }
4851 #endif
4852
4853         return intToFloat(nodepos, BS);
4854 }
4855
4856 PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id)
4857 {
4858         RemotePlayer *player = NULL;
4859         bool newplayer = false;
4860
4861         /*
4862                 Try to get an existing player
4863         */
4864         player = static_cast<RemotePlayer*>(m_env->getPlayer(name));
4865
4866         // If player is already connected, cancel
4867         if(player != NULL && player->peer_id != 0)
4868         {
4869                 infostream<<"emergePlayer(): Player already connected"<<std::endl;
4870                 return NULL;
4871         }
4872
4873         /*
4874                 If player with the wanted peer_id already exists, cancel.
4875         */
4876         if(m_env->getPlayer(peer_id) != NULL)
4877         {
4878                 infostream<<"emergePlayer(): Player with wrong name but same"
4879                                 " peer_id already exists"<<std::endl;
4880                 return NULL;
4881         }
4882
4883         /*
4884                 Create a new player if it doesn't exist yet
4885         */
4886         if(player == NULL)
4887         {
4888                 newplayer = true;
4889                 player = new RemotePlayer(this);
4890                 player->updateName(name);
4891
4892                 /* Set player position */
4893                 infostream<<"Server: Finding spawn place for player \""
4894                                 <<name<<"\""<<std::endl;
4895                 v3f pos = findSpawnPos(m_env->getServerMap());
4896                 player->setPosition(pos);
4897
4898                 /* Add player to environment */
4899                 m_env->addPlayer(player);
4900         }
4901
4902         /*
4903                 Create a new player active object
4904         */
4905         PlayerSAO *playersao = new PlayerSAO(m_env, player, peer_id,
4906                         getPlayerEffectivePrivs(player->getName()),
4907                         isSingleplayer());
4908
4909         /* Add object to environment */
4910         m_env->addActiveObject(playersao);
4911
4912         /* Run scripts */
4913         if(newplayer)
4914                 scriptapi_on_newplayer(m_lua, playersao);
4915
4916         scriptapi_on_joinplayer(m_lua, playersao);
4917
4918         return playersao;
4919 }
4920
4921 void Server::handlePeerChange(PeerChange &c)
4922 {
4923         JMutexAutoLock envlock(m_env_mutex);
4924         JMutexAutoLock conlock(m_con_mutex);
4925
4926         if(c.type == PEER_ADDED)
4927         {
4928                 /*
4929                         Add
4930                 */
4931
4932                 // Error check
4933                 core::map<u16, RemoteClient*>::Node *n;
4934                 n = m_clients.find(c.peer_id);
4935                 // The client shouldn't already exist
4936                 assert(n == NULL);
4937
4938                 // Create client
4939                 RemoteClient *client = new RemoteClient();
4940                 client->peer_id = c.peer_id;
4941                 m_clients.insert(client->peer_id, client);
4942
4943         } // PEER_ADDED
4944         else if(c.type == PEER_REMOVED)
4945         {
4946                 /*
4947                         Delete
4948                 */
4949
4950                 // Error check
4951                 core::map<u16, RemoteClient*>::Node *n;
4952                 n = m_clients.find(c.peer_id);
4953                 // The client should exist
4954                 assert(n != NULL);
4955
4956                 /*
4957                         Mark objects to be not known by the client
4958                 */
4959                 RemoteClient *client = n->getValue();
4960                 // Handle objects
4961                 for(core::map<u16, bool>::Iterator
4962                                 i = client->m_known_objects.getIterator();
4963                                 i.atEnd()==false; i++)
4964                 {
4965                         // Get object
4966                         u16 id = i.getNode()->getKey();
4967                         ServerActiveObject* obj = m_env->getActiveObject(id);
4968
4969                         if(obj && obj->m_known_by_count > 0)
4970                                 obj->m_known_by_count--;
4971                 }
4972
4973                 /*
4974                         Clear references to playing sounds
4975                 */
4976                 for(std::map<s32, ServerPlayingSound>::iterator
4977                                 i = m_playing_sounds.begin();
4978                                 i != m_playing_sounds.end();)
4979                 {
4980                         ServerPlayingSound &psound = i->second;
4981                         psound.clients.erase(c.peer_id);
4982                         if(psound.clients.size() == 0)
4983                                 m_playing_sounds.erase(i++);
4984                         else
4985                                 i++;
4986                 }
4987
4988                 Player *player = m_env->getPlayer(c.peer_id);
4989
4990                 // Collect information about leaving in chat
4991                 std::wstring message;
4992                 {
4993                         if(player != NULL)
4994                         {
4995                                 std::wstring name = narrow_to_wide(player->getName());
4996                                 message += L"*** ";
4997                                 message += name;
4998                                 message += L" left the game.";
4999                                 if(c.timeout)
5000                                         message += L" (timed out)";
5001                         }
5002                 }
5003
5004                 /* Run scripts and remove from environment */
5005                 {
5006                         if(player != NULL)
5007                         {
5008                                 PlayerSAO *playersao = player->getPlayerSAO();
5009                                 assert(playersao);
5010
5011                                 scriptapi_on_leaveplayer(m_lua, playersao);
5012
5013                                 playersao->disconnected();
5014                         }
5015                 }
5016
5017                 /*
5018                         Print out action
5019                 */
5020                 {
5021                         if(player != NULL)
5022                         {
5023                                 std::ostringstream os(std::ios_base::binary);
5024                                 for(core::map<u16, RemoteClient*>::Iterator
5025                                         i = m_clients.getIterator();
5026                                         i.atEnd() == false; i++)
5027                                 {
5028                                         RemoteClient *client = i.getNode()->getValue();
5029                                         assert(client->peer_id == i.getNode()->getKey());
5030                                         if(client->serialization_version == SER_FMT_VER_INVALID)
5031                                                 continue;
5032                                         // Get player
5033                                         Player *player = m_env->getPlayer(client->peer_id);
5034                                         if(!player)
5035                                                 continue;
5036                                         // Get name of player
5037                                         os<<player->getName()<<" ";
5038                                 }
5039
5040                                 actionstream<<player->getName()<<" "
5041                                                 <<(c.timeout?"times out.":"leaves game.")
5042                                                 <<" List of players: "
5043                                                 <<os.str()<<std::endl;
5044                         }
5045                 }
5046
5047                 // Delete client
5048                 delete m_clients[c.peer_id];
5049                 m_clients.remove(c.peer_id);
5050
5051                 // Send player info to all remaining clients
5052                 //SendPlayerInfos();
5053
5054                 // Send leave chat message to all remaining clients
5055                 if(message.length() != 0)
5056                         BroadcastChatMessage(message);
5057
5058         } // PEER_REMOVED
5059         else
5060         {
5061                 assert(0);
5062         }
5063 }
5064
5065 void Server::handlePeerChanges()
5066 {
5067         while(m_peer_change_queue.size() > 0)
5068         {
5069                 PeerChange c = m_peer_change_queue.pop_front();
5070
5071                 verbosestream<<"Server: Handling peer change: "
5072                                 <<"id="<<c.peer_id<<", timeout="<<c.timeout
5073                                 <<std::endl;
5074
5075                 handlePeerChange(c);
5076         }
5077 }
5078
5079 void dedicated_server_loop(Server &server, bool &kill)
5080 {
5081         DSTACK(__FUNCTION_NAME);
5082
5083         verbosestream<<"dedicated_server_loop()"<<std::endl;
5084
5085         IntervalLimiter m_profiler_interval;
5086
5087         for(;;)
5088         {
5089                 float steplen = g_settings->getFloat("dedicated_server_step");
5090                 // This is kind of a hack but can be done like this
5091                 // because server.step() is very light
5092                 {
5093                         ScopeProfiler sp(g_profiler, "dedicated server sleep");
5094                         sleep_ms((int)(steplen*1000.0));
5095                 }
5096                 server.step(steplen);
5097
5098                 if(server.getShutdownRequested() || kill)
5099                 {
5100                         infostream<<"Dedicated server quitting"<<std::endl;
5101                         break;
5102                 }
5103
5104                 /*
5105                         Profiler
5106                 */
5107                 float profiler_print_interval =
5108                                 g_settings->getFloat("profiler_print_interval");
5109                 if(profiler_print_interval != 0)
5110                 {
5111                         if(m_profiler_interval.step(steplen, profiler_print_interval))
5112                         {
5113                                 infostream<<"Profiler:"<<std::endl;
5114                                 g_profiler->print(infostream);
5115                                 g_profiler->clear();
5116                         }
5117                 }
5118         }
5119 }
5120
5121