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