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