Default server step to 0.1s and sync object/player update intervals to it
[marktraceur-minetest:marktraceur-minetest.git] / src / server.cpp
1 /*
2 Minetest-c55
3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "server.h"
21 #include <iostream>
22 #include <queue>
23 #include "clientserver.h"
24 #include "map.h"
25 #include "jmutexautolock.h"
26 #include "main.h"
27 #include "constants.h"
28 #include "voxel.h"
29 #include "config.h"
30 #include "filesys.h"
31 #include "mapblock.h"
32 #include "serverobject.h"
33 #include "settings.h"
34 #include "profiler.h"
35 #include "log.h"
36 #include "script.h"
37 #include "scriptapi.h"
38 #include "nodedef.h"
39 #include "itemdef.h"
40 #include "craftdef.h"
41 #include "mapgen.h"
42 #include "content_mapnode.h"
43 #include "content_nodemeta.h"
44 #include "content_abm.h"
45 #include "content_sao.h"
46 #include "mods.h"
47 #include "sha1.h"
48 #include "base64.h"
49 #include "tool.h"
50 #include "sound.h" // dummySoundManager
51 #include "event_manager.h"
52 #include "hex.h"
53 #include "util/string.h"
54 #include "util/pointedthing.h"
55 #include "util/mathconstants.h"
56 #include "rollback.h"
57 #include "util/serialize.h"
58
59 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
60
61 #define BLOCK_EMERGE_FLAG_FROMDISK (1<<0)
62
63 class MapEditEventIgnorer
64 {
65 public:
66         MapEditEventIgnorer(bool *flag):
67                 m_flag(flag)
68         {
69                 if(*m_flag == false)
70                         *m_flag = true;
71                 else
72                         m_flag = NULL;
73         }
74
75         ~MapEditEventIgnorer()
76         {
77                 if(m_flag)
78                 {
79                         assert(*m_flag);
80                         *m_flag = false;
81                 }
82         }
83         
84 private:
85         bool *m_flag;
86 };
87
88 class MapEditEventAreaIgnorer
89 {
90 public:
91         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
92                 m_ignorevariable(ignorevariable)
93         {
94                 if(m_ignorevariable->getVolume() == 0)
95                         *m_ignorevariable = a;
96                 else
97                         m_ignorevariable = NULL;
98         }
99
100         ~MapEditEventAreaIgnorer()
101         {
102                 if(m_ignorevariable)
103                 {
104                         assert(m_ignorevariable->getVolume() != 0);
105                         *m_ignorevariable = VoxelArea();
106                 }
107         }
108         
109 private:
110         VoxelArea *m_ignorevariable;
111 };
112
113 void * ServerThread::Thread()
114 {
115         ThreadStarted();
116
117         log_register_thread("ServerThread");
118
119         DSTACK(__FUNCTION_NAME);
120
121         BEGIN_DEBUG_EXCEPTION_HANDLER
122
123         while(getRun())
124         {
125                 try{
126                         //TimeTaker timer("AsyncRunStep() + Receive()");
127
128                         {
129                                 //TimeTaker timer("AsyncRunStep()");
130                                 m_server->AsyncRunStep();
131                         }
132                 
133                         //infostream<<"Running m_server->Receive()"<<std::endl;
134                         m_server->Receive();
135                 }
136                 catch(con::NoIncomingDataException &e)
137                 {
138                 }
139                 catch(con::PeerNotFoundException &e)
140                 {
141                         infostream<<"Server: PeerNotFoundException"<<std::endl;
142                 }
143                 catch(con::ConnectionBindFailed &e)
144                 {
145                         m_server->setAsyncFatalError(e.what());
146                 }
147                 catch(LuaError &e)
148                 {
149                         m_server->setAsyncFatalError(e.what());
150                 }
151         }
152         
153         END_DEBUG_EXCEPTION_HANDLER(errorstream)
154
155         return NULL;
156 }
157
158 void * EmergeThread::Thread()
159 {
160         ThreadStarted();
161
162         log_register_thread("EmergeThread");
163
164         DSTACK(__FUNCTION_NAME);
165
166         BEGIN_DEBUG_EXCEPTION_HANDLER
167
168         bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
169
170         v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
171         
172         /*
173                 Get block info from queue, emerge them and send them
174                 to clients.
175
176                 After queue is empty, exit.
177         */
178         while(getRun())
179         try{
180                 QueuedBlockEmerge *qptr = m_server->m_emerge_queue.pop();
181                 if(qptr == NULL)
182                         break;
183                 
184                 SharedPtr<QueuedBlockEmerge> q(qptr);
185
186                 v3s16 &p = q->pos;
187                 v2s16 p2d(p.X,p.Z);
188                 
189                 last_tried_pos = p;
190
191                 /*
192                         Do not generate over-limit
193                 */
194                 if(blockpos_over_limit(p))
195                         continue;
196                         
197                 //infostream<<"EmergeThread::Thread(): running"<<std::endl;
198
199                 //TimeTaker timer("block emerge");
200                 
201                 /*
202                         Try to emerge it from somewhere.
203
204                         If it is only wanted as optional, only loading from disk
205                         will be allowed.
206                 */
207                 
208                 /*
209                         Check if any peer wants it as non-optional. In that case it
210                         will be generated.
211
212                         Also decrement the emerge queue count in clients.
213                 */
214
215                 bool only_from_disk = true;
216
217                 {
218                         core::map<u16, u8>::Iterator i;
219                         for(i=q->peer_ids.getIterator(); i.atEnd()==false; i++)
220                         {
221                                 //u16 peer_id = i.getNode()->getKey();
222
223                                 // Check flags
224                                 u8 flags = i.getNode()->getValue();
225                                 if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false)
226                                         only_from_disk = false;
227                                 
228                         }
229                 }
230                 
231                 if(enable_mapgen_debug_info)
232                         infostream<<"EmergeThread: p="
233                                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
234                                         <<"only_from_disk="<<only_from_disk<<std::endl;
235                 
236                 ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
237                         
238                 MapBlock *block = NULL;
239                 bool got_block = true;
240                 core::map<v3s16, MapBlock*> modified_blocks;
241
242                 /*
243                         Try to fetch block from memory or disk.
244                         If not found and asked to generate, initialize generator.
245                 */
246                 
247                 bool started_generate = false;
248                 mapgen::BlockMakeData data;
249
250                 {
251                         JMutexAutoLock envlock(m_server->m_env_mutex);
252                         
253                         // Load sector if it isn't loaded
254                         if(map.getSectorNoGenerateNoEx(p2d) == NULL)
255                                 map.loadSectorMeta(p2d);
256                         
257                         // Attempt to load block
258                         block = map.getBlockNoCreateNoEx(p);
259                         if(!block || block->isDummy() || !block->isGenerated())
260                         {
261                                 if(enable_mapgen_debug_info)
262                                         infostream<<"EmergeThread: not in memory, "
263                                                         <<"attempting to load from disk"<<std::endl;
264
265                                 block = map.loadBlock(p);
266                         }
267                         
268                         // If could not load and allowed to generate, start generation
269                         // inside this same envlock
270                         if(only_from_disk == false &&
271                                         (block == NULL || block->isGenerated() == false)){
272                                 if(enable_mapgen_debug_info)
273                                         infostream<<"EmergeThread: generating"<<std::endl;
274                                 started_generate = true;
275
276                                 map.initBlockMake(&data, p);
277                         }
278                 }
279
280                 /*
281                         If generator was initialized, generate now when envlock is free.
282                 */
283                 if(started_generate)
284                 {
285                         {
286                                 ScopeProfiler sp(g_profiler, "EmergeThread: mapgen::make_block",
287                                                 SPT_AVG);
288                                 TimeTaker t("mapgen::make_block()");
289
290                                 mapgen::make_block(&data);
291
292                                 if(enable_mapgen_debug_info == false)
293                                         t.stop(true); // Hide output
294                         }
295                         
296                         do{ // enable break
297                                 // Lock environment again to access the map
298                                 JMutexAutoLock envlock(m_server->m_env_mutex);
299                                 
300                                 ScopeProfiler sp(g_profiler, "EmergeThread: after "
301                                                 "mapgen::make_block (envlock)", SPT_AVG);
302
303                                 // Blit data back on map, update lighting, add mobs and
304                                 // whatever this does
305                                 map.finishBlockMake(&data, modified_blocks);
306
307                                 // Get central block
308                                 block = map.getBlockNoCreateNoEx(p);
309                                 
310                                 // If block doesn't exist, don't try doing anything with it
311                                 // This happens if the block is not in generation boundaries
312                                 if(!block)
313                                         break;
314
315                                 /*
316                                         Do some post-generate stuff
317                                 */
318
319                                 v3s16 minp = data.blockpos_min*MAP_BLOCKSIZE;
320                                 v3s16 maxp = data.blockpos_max*MAP_BLOCKSIZE +
321                                                 v3s16(1,1,1)*(MAP_BLOCKSIZE-1);
322                                 
323                                 /*
324                                         Ignore map edit events, they will not need to be
325                                         sent to anybody because the block hasn't been sent
326                                         to anybody
327                                 */
328                                 //MapEditEventIgnorer ign(&m_server->m_ignore_map_edit_events);
329                                 MapEditEventAreaIgnorer ign(
330                                                 &m_server->m_ignore_map_edit_events_area,
331                                                 VoxelArea(minp, maxp));
332                                 {
333                                         TimeTaker timer("on_generated");
334                                         scriptapi_environment_on_generated(m_server->m_lua,
335                                                         minp, maxp, mapgen::get_blockseed(data.seed, minp));
336                                         /*int t = timer.stop(true);
337                                         dstream<<"on_generated took "<<t<<"ms"<<std::endl;*/
338                                 }
339                                 
340                                 if(enable_mapgen_debug_info)
341                                         infostream<<"EmergeThread: ended up with: "
342                                                         <<analyze_block(block)<<std::endl;
343
344                                 // Activate objects and stuff
345                                 m_server->m_env->activateBlock(block, 0);
346                         }while(false);
347                 }
348
349                 if(block == NULL)
350                         got_block = false;
351                         
352                 /*
353                         Set sent status of modified blocks on clients
354                 */
355         
356                 // NOTE: Server's clients are also behind the connection mutex
357                 JMutexAutoLock lock(m_server->m_con_mutex);
358
359                 /*
360                         Add the originally fetched block to the modified list
361                 */
362                 if(got_block)
363                 {
364                         modified_blocks.insert(p, block);
365                 }
366                 
367                 /*
368                         Set the modified blocks unsent for all the clients
369                 */
370                 
371                 for(core::map<u16, RemoteClient*>::Iterator
372                                 i = m_server->m_clients.getIterator();
373                                 i.atEnd() == false; i++)
374                 {
375                         RemoteClient *client = i.getNode()->getValue();
376                         
377                         if(modified_blocks.size() > 0)
378                         {
379                                 // Remove block from sent history
380                                 client->SetBlocksNotSent(modified_blocks);
381                         }
382                 }
383         }
384         catch(VersionMismatchException &e)
385         {
386                 std::ostringstream err;
387                 err<<"World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
388                 err<<"----"<<std::endl;
389                 err<<"\""<<e.what()<<"\""<<std::endl;
390                 err<<"See debug.txt."<<std::endl;
391                 err<<"World probably saved by a newer version of Minetest."<<std::endl;
392                 m_server->setAsyncFatalError(err.str());
393         }
394         catch(SerializationError &e)
395         {
396                 std::ostringstream err;
397                 err<<"Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
398                 err<<"----"<<std::endl;
399                 err<<"\""<<e.what()<<"\""<<std::endl;
400                 err<<"See debug.txt."<<std::endl;
401                 err<<"You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
402                 m_server->setAsyncFatalError(err.str());
403         }
404
405         END_DEBUG_EXCEPTION_HANDLER(errorstream)
406
407         log_deregister_thread();
408
409         return NULL;
410 }
411
412 v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
413 {
414         if(pos_exists) *pos_exists = false;
415         switch(type){
416         case SSP_LOCAL:
417                 return v3f(0,0,0);
418         case SSP_POSITIONAL:
419                 if(pos_exists) *pos_exists = true;
420                 return pos;
421         case SSP_OBJECT: {
422                 if(object == 0)
423                         return v3f(0,0,0);
424                 ServerActiveObject *sao = env->getActiveObject(object);
425                 if(!sao)
426                         return v3f(0,0,0);
427                 if(pos_exists) *pos_exists = true;
428                 return sao->getBasePosition(); }
429         }
430         return v3f(0,0,0);
431 }
432
433 void RemoteClient::GetNextBlocks(Server *server, float dtime,
434                 core::array<PrioritySortedBlockTransfer> &dest)
435 {
436         DSTACK(__FUNCTION_NAME);
437         
438         /*u32 timer_result;
439         TimeTaker timer("RemoteClient::GetNextBlocks", &timer_result);*/
440         
441         // Increment timers
442         m_nothing_to_send_pause_timer -= dtime;
443         m_nearest_unsent_reset_timer += dtime;
444         
445         if(m_nothing_to_send_pause_timer >= 0)
446                 return;
447
448         Player *player = server->m_env->getPlayer(peer_id);
449         // This can happen sometimes; clients and players are not in perfect sync.
450         if(player == NULL)
451                 return;
452
453         // Won't send anything if already sending
454         if(m_blocks_sending.size() >= g_settings->getU16
455                         ("max_simultaneous_block_sends_per_client"))
456         {
457                 //infostream<<"Not sending any blocks, Queue full."<<std::endl;
458                 return;
459         }
460
461         //TimeTaker timer("RemoteClient::GetNextBlocks");
462         
463         v3f playerpos = player->getPosition();
464         v3f playerspeed = player->getSpeed();
465         v3f playerspeeddir(0,0,0);
466         if(playerspeed.getLength() > 1.0*BS)
467                 playerspeeddir = playerspeed / playerspeed.getLength();
468         // Predict to next block
469         v3f playerpos_predicted = playerpos + playerspeeddir*MAP_BLOCKSIZE*BS;
470
471         v3s16 center_nodepos = floatToInt(playerpos_predicted, BS);
472
473         v3s16 center = getNodeBlockPos(center_nodepos);
474         
475         // Camera position and direction
476         v3f camera_pos = player->getEyePosition();
477         v3f camera_dir = v3f(0,0,1);
478         camera_dir.rotateYZBy(player->getPitch());
479         camera_dir.rotateXZBy(player->getYaw());
480
481         /*infostream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<","
482                         <<camera_dir.Z<<")"<<std::endl;*/
483
484         /*
485                 Get the starting value of the block finder radius.
486         */
487                 
488         if(m_last_center != center)
489         {
490                 m_nearest_unsent_d = 0;
491                 m_last_center = center;
492         }
493
494         /*infostream<<"m_nearest_unsent_reset_timer="
495                         <<m_nearest_unsent_reset_timer<<std::endl;*/
496                         
497         // Reset periodically to workaround for some bugs or stuff
498         if(m_nearest_unsent_reset_timer > 20.0)
499         {
500                 m_nearest_unsent_reset_timer = 0;
501                 m_nearest_unsent_d = 0;
502                 //infostream<<"Resetting m_nearest_unsent_d for "
503                 //              <<server->getPlayerName(peer_id)<<std::endl;
504         }
505
506         //s16 last_nearest_unsent_d = m_nearest_unsent_d;
507         s16 d_start = m_nearest_unsent_d;
508
509         //infostream<<"d_start="<<d_start<<std::endl;
510
511         u16 max_simul_sends_setting = g_settings->getU16
512                         ("max_simultaneous_block_sends_per_client");
513         u16 max_simul_sends_usually = max_simul_sends_setting;
514
515         /*
516                 Check the time from last addNode/removeNode.
517                 
518                 Decrease send rate if player is building stuff.
519         */
520         m_time_from_building += dtime;
521         if(m_time_from_building < g_settings->getFloat(
522                                 "full_block_send_enable_min_time_from_building"))
523         {
524                 max_simul_sends_usually
525                         = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS;
526         }
527         
528         /*
529                 Number of blocks sending + number of blocks selected for sending
530         */
531         u32 num_blocks_selected = m_blocks_sending.size();
532         
533         /*
534                 next time d will be continued from the d from which the nearest
535                 unsent block was found this time.
536
537                 This is because not necessarily any of the blocks found this
538                 time are actually sent.
539         */
540         s32 new_nearest_unsent_d = -1;
541
542         s16 d_max = g_settings->getS16("max_block_send_distance");
543         s16 d_max_gen = g_settings->getS16("max_block_generate_distance");
544         
545         // Don't loop very much at a time
546         s16 max_d_increment_at_time = 2;
547         if(d_max > d_start + max_d_increment_at_time)
548                 d_max = d_start + max_d_increment_at_time;
549         /*if(d_max_gen > d_start+2)
550                 d_max_gen = d_start+2;*/
551         
552         //infostream<<"Starting from "<<d_start<<std::endl;
553
554         s32 nearest_emerged_d = -1;
555         s32 nearest_emergefull_d = -1;
556         s32 nearest_sent_d = -1;
557         bool queue_is_full = false;
558         
559         s16 d;
560         for(d = d_start; d <= d_max; d++)
561         {
562                 /*errorstream<<"checking d="<<d<<" for "
563                                 <<server->getPlayerName(peer_id)<<std::endl;*/
564                 //infostream<<"RemoteClient::SendBlocks(): d="<<d<<std::endl;
565                 
566                 /*
567                         If m_nearest_unsent_d was changed by the EmergeThread
568                         (it can change it to 0 through SetBlockNotSent),
569                         update our d to it.
570                         Else update m_nearest_unsent_d
571                 */
572                 /*if(m_nearest_unsent_d != last_nearest_unsent_d)
573                 {
574                         d = m_nearest_unsent_d;
575                         last_nearest_unsent_d = m_nearest_unsent_d;
576                 }*/
577
578                 /*
579                         Get the border/face dot coordinates of a "d-radiused"
580                         box
581                 */
582                 core::list<v3s16> list;
583                 getFacePositions(list, d);
584                 
585                 core::list<v3s16>::Iterator li;
586                 for(li=list.begin(); li!=list.end(); li++)
587                 {
588                         v3s16 p = *li + center;
589                         
590                         /*
591                                 Send throttling
592                                 - Don't allow too many simultaneous transfers
593                                 - EXCEPT when the blocks are very close
594
595                                 Also, don't send blocks that are already flying.
596                         */
597                         
598                         // Start with the usual maximum
599                         u16 max_simul_dynamic = max_simul_sends_usually;
600                         
601                         // If block is very close, allow full maximum
602                         if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D)
603                                 max_simul_dynamic = max_simul_sends_setting;
604
605                         // Don't select too many blocks for sending
606                         if(num_blocks_selected >= max_simul_dynamic)
607                         {
608                                 queue_is_full = true;
609                                 goto queue_full_break;
610                         }
611                         
612                         // Don't send blocks that are currently being transferred
613                         if(m_blocks_sending.find(p) != NULL)
614                                 continue;
615                 
616                         /*
617                                 Do not go over-limit
618                         */
619                         if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
620                         || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
621                         || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
622                         || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
623                         || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
624                         || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
625                                 continue;
626                 
627                         // If this is true, inexistent block will be made from scratch
628                         bool generate = d <= d_max_gen;
629                         
630                         {
631                                 /*// Limit the generating area vertically to 2/3
632                                 if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3)
633                                         generate = false;*/
634
635                                 // Limit the send area vertically to 1/2
636                                 if(abs(p.Y - center.Y) > d_max / 2)
637                                         continue;
638                         }
639
640 #if 0
641                         /*
642                                 If block is far away, don't generate it unless it is
643                                 near ground level.
644                         */
645                         if(d >= 4)
646                         {
647         #if 1
648                                 // Block center y in nodes
649                                 f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2);
650                                 // Don't generate if it's very high or very low
651                                 if(y < -64 || y > 64)
652                                         generate = false;
653         #endif
654         #if 0
655                                 v2s16 p2d_nodes_center(
656                                         MAP_BLOCKSIZE*p.X,
657                                         MAP_BLOCKSIZE*p.Z);
658                                 
659                                 // Get ground height in nodes
660                                 s16 gh = server->m_env->getServerMap().findGroundLevel(
661                                                 p2d_nodes_center);
662
663                                 // If differs a lot, don't generate
664                                 if(fabs(gh - y) > MAP_BLOCKSIZE*2)
665                                         generate = false;
666                                         // Actually, don't even send it
667                                         //continue;
668         #endif
669                         }
670 #endif
671
672                         //infostream<<"d="<<d<<std::endl;
673 #if 1
674                         /*
675                                 Don't generate or send if not in sight
676                                 FIXME This only works if the client uses a small enough
677                                 FOV setting. The default of 72 degrees is fine.
678                         */
679
680                         float camera_fov = (72.0*M_PI/180) * 4./3.;
681                         if(isBlockInSight(p, camera_pos, camera_dir, camera_fov, 10000*BS) == false)
682                         {
683                                 continue;
684                         }
685 #endif
686                         /*
687                                 Don't send already sent blocks
688                         */
689                         {
690                                 if(m_blocks_sent.find(p) != NULL)
691                                 {
692                                         continue;
693                                 }
694                         }
695
696                         /*
697                                 Check if map has this block
698                         */
699                         MapBlock *block = server->m_env->getMap().getBlockNoCreateNoEx(p);
700                         
701                         bool surely_not_found_on_disk = false;
702                         bool block_is_invalid = false;
703                         if(block != NULL)
704                         {
705                                 // Reset usage timer, this block will be of use in the future.
706                                 block->resetUsageTimer();
707
708                                 // Block is dummy if data doesn't exist.
709                                 // It means it has been not found from disk and not generated
710                                 if(block->isDummy())
711                                 {
712                                         surely_not_found_on_disk = true;
713                                 }
714                                 
715                                 // Block is valid if lighting is up-to-date and data exists
716                                 if(block->isValid() == false)
717                                 {
718                                         block_is_invalid = true;
719                                 }
720                                 
721                                 /*if(block->isFullyGenerated() == false)
722                                 {
723                                         block_is_invalid = true;
724                                 }*/
725
726 #if 0
727                                 v2s16 p2d(p.X, p.Z);
728                                 ServerMap *map = (ServerMap*)(&server->m_env->getMap());
729                                 v2s16 chunkpos = map->sector_to_chunk(p2d);
730                                 if(map->chunkNonVolatile(chunkpos) == false)
731                                         block_is_invalid = true;
732 #endif
733                                 if(block->isGenerated() == false)
734                                         block_is_invalid = true;
735 #if 1
736                                 /*
737                                         If block is not close, don't send it unless it is near
738                                         ground level.
739
740                                         Block is near ground level if night-time mesh
741                                         differs from day-time mesh.
742                                 */
743                                 if(d >= 4)
744                                 {
745                                         if(block->getDayNightDiff() == false)
746                                                 continue;
747                                 }
748 #endif
749                         }
750
751                         /*
752                                 If block has been marked to not exist on disk (dummy)
753                                 and generating new ones is not wanted, skip block.
754                         */
755                         if(generate == false && surely_not_found_on_disk == true)
756                         {
757                                 // get next one.
758                                 continue;
759                         }
760
761                         /*
762                                 Add inexistent block to emerge queue.
763                         */
764                         if(block == NULL || surely_not_found_on_disk || block_is_invalid)
765                         {
766                                 //TODO: Get value from somewhere
767                                 // Allow only one block in emerge queue
768                                 //if(server->m_emerge_queue.peerItemCount(peer_id) < 1)
769                                 // Allow two blocks in queue per client
770                                 //if(server->m_emerge_queue.peerItemCount(peer_id) < 2)
771                                 u32 max_emerge = 5;
772                                 // Make it more responsive when needing to generate stuff
773                                 if(surely_not_found_on_disk)
774                                         max_emerge = 1;
775                                 if(server->m_emerge_queue.peerItemCount(peer_id) < max_emerge)
776                                 {
777                                         //infostream<<"Adding block to emerge queue"<<std::endl;
778                                         
779                                         // Add it to the emerge queue and trigger the thread
780                                         
781                                         u8 flags = 0;
782                                         if(generate == false)
783                                                 flags |= BLOCK_EMERGE_FLAG_FROMDISK;
784                                         
785                                         server->m_emerge_queue.addBlock(peer_id, p, flags);
786                                         server->m_emergethread.trigger();
787
788                                         if(nearest_emerged_d == -1)
789                                                 nearest_emerged_d = d;
790                                 } else {
791                                         if(nearest_emergefull_d == -1)
792                                                 nearest_emergefull_d = d;
793                                 }
794                                 
795                                 // get next one.
796                                 continue;
797                         }
798
799                         if(nearest_sent_d == -1)
800                                 nearest_sent_d = d;
801
802                         /*
803                                 Add block to send queue
804                         */
805
806                         /*errorstream<<"sending from d="<<d<<" to "
807                                         <<server->getPlayerName(peer_id)<<std::endl;*/
808
809                         PrioritySortedBlockTransfer q((float)d, p, peer_id);
810
811                         dest.push_back(q);
812
813                         num_blocks_selected += 1;
814                 }
815         }
816 queue_full_break:
817
818         //infostream<<"Stopped at "<<d<<std::endl;
819         
820         // If nothing was found for sending and nothing was queued for
821         // emerging, continue next time browsing from here
822         if(nearest_emerged_d != -1){
823                 new_nearest_unsent_d = nearest_emerged_d;
824         } else if(nearest_emergefull_d != -1){
825                 new_nearest_unsent_d = nearest_emergefull_d;
826         } else {
827                 if(d > g_settings->getS16("max_block_send_distance")){
828                         new_nearest_unsent_d = 0;
829                         m_nothing_to_send_pause_timer = 2.0;
830                         /*infostream<<"GetNextBlocks(): d wrapped around for "
831                                         <<server->getPlayerName(peer_id)
832                                         <<"; setting to 0 and pausing"<<std::endl;*/
833                 } else {
834                         if(nearest_sent_d != -1)
835                                 new_nearest_unsent_d = nearest_sent_d;
836                         else
837                                 new_nearest_unsent_d = d;
838                 }
839         }
840
841         if(new_nearest_unsent_d != -1)
842                 m_nearest_unsent_d = new_nearest_unsent_d;
843
844         /*timer_result = timer.stop(true);
845         if(timer_result != 0)
846                 infostream<<"GetNextBlocks timeout: "<<timer_result<<" (!=0)"<<std::endl;*/
847 }
848
849 void RemoteClient::GotBlock(v3s16 p)
850 {
851         if(m_blocks_sending.find(p) != NULL)
852                 m_blocks_sending.remove(p);
853         else
854         {
855                 /*infostream<<"RemoteClient::GotBlock(): Didn't find in"
856                                 " m_blocks_sending"<<std::endl;*/
857                 m_excess_gotblocks++;
858         }
859         m_blocks_sent.insert(p, true);
860 }
861
862 void RemoteClient::SentBlock(v3s16 p)
863 {
864         if(m_blocks_sending.find(p) == NULL)
865                 m_blocks_sending.insert(p, 0.0);
866         else
867                 infostream<<"RemoteClient::SentBlock(): Sent block"
868                                 " already in m_blocks_sending"<<std::endl;
869 }
870
871 void RemoteClient::SetBlockNotSent(v3s16 p)
872 {
873         m_nearest_unsent_d = 0;
874         
875         if(m_blocks_sending.find(p) != NULL)
876                 m_blocks_sending.remove(p);
877         if(m_blocks_sent.find(p) != NULL)
878                 m_blocks_sent.remove(p);
879 }
880
881 void RemoteClient::SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks)
882 {
883         m_nearest_unsent_d = 0;
884         
885         for(core::map<v3s16, MapBlock*>::Iterator
886                         i = blocks.getIterator();
887                         i.atEnd()==false; i++)
888         {
889                 v3s16 p = i.getNode()->getKey();
890
891                 if(m_blocks_sending.find(p) != NULL)
892                         m_blocks_sending.remove(p);
893                 if(m_blocks_sent.find(p) != NULL)
894                         m_blocks_sent.remove(p);
895         }
896 }
897
898 /*
899         PlayerInfo
900 */
901
902 PlayerInfo::PlayerInfo()
903 {
904         name[0] = 0;
905         avg_rtt = 0;
906 }
907
908 void PlayerInfo::PrintLine(std::ostream *s)
909 {
910         (*s)<<id<<": ";
911         (*s)<<"\""<<name<<"\" ("
912                         <<(position.X/10)<<","<<(position.Y/10)
913                         <<","<<(position.Z/10)<<") ";
914         address.print(s);
915         (*s)<<" avg_rtt="<<avg_rtt;
916         (*s)<<std::endl;
917 }
918
919 /*
920         Server
921 */
922
923 Server::Server(
924                 const std::string &path_world,
925                 const std::string &path_config,
926                 const SubgameSpec &gamespec,
927                 bool simple_singleplayer_mode
928         ):
929         m_path_world(path_world),
930         m_path_config(path_config),
931         m_gamespec(gamespec),
932         m_simple_singleplayer_mode(simple_singleplayer_mode),
933         m_async_fatal_error(""),
934         m_env(NULL),
935         m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
936         m_banmanager(path_world+DIR_DELIM+"ipban.txt"),
937         m_rollback(NULL),
938         m_rollback_sink_enabled(true),
939         m_enable_rollback_recording(false),
940         m_lua(NULL),
941         m_itemdef(createItemDefManager()),
942         m_nodedef(createNodeDefManager()),
943         m_craftdef(createCraftDefManager()),
944         m_event(new EventManager()),
945         m_thread(this),
946         m_emergethread(this),
947         m_time_of_day_send_timer(0),
948         m_uptime(0),
949         m_shutdown_requested(false),
950         m_ignore_map_edit_events(false),
951         m_ignore_map_edit_events_peer_id(0)
952 {
953         m_liquid_transform_timer = 0.0;
954         m_print_info_timer = 0.0;
955         m_objectdata_timer = 0.0;
956         m_emergethread_trigger_timer = 0.0;
957         m_savemap_timer = 0.0;
958         
959         m_env_mutex.Init();
960         m_con_mutex.Init();
961         m_step_dtime_mutex.Init();
962         m_step_dtime = 0.0;
963
964         if(path_world == "")
965                 throw ServerError("Supplied empty world path");
966         
967         if(!gamespec.isValid())
968                 throw ServerError("Supplied invalid gamespec");
969         
970         infostream<<"Server created for gameid \""<<m_gamespec.id<<"\"";
971         if(m_simple_singleplayer_mode)
972                 infostream<<" in simple singleplayer mode"<<std::endl;
973         else
974                 infostream<<std::endl;
975         infostream<<"- world:  "<<m_path_world<<std::endl;
976         infostream<<"- config: "<<m_path_config<<std::endl;
977         infostream<<"- game:   "<<m_gamespec.path<<std::endl;
978
979         // Create rollback manager
980         std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
981         m_rollback = createRollbackManager(rollback_path, this);
982
983         // Add world mod search path
984         m_modspaths.push_front(m_path_world + DIR_DELIM + "worldmods");
985         // Add addon mod search path
986         for(std::set<std::string>::const_iterator i = m_gamespec.mods_paths.begin();
987                         i != m_gamespec.mods_paths.end(); i++)
988                 m_modspaths.push_front((*i));
989
990         // Print out mod search paths
991         for(core::list<std::string>::Iterator i = m_modspaths.begin();
992                         i != m_modspaths.end(); i++){
993                 std::string modspath = *i;
994                 infostream<<"- mods:   "<<modspath<<std::endl;
995         }
996         
997         // Path to builtin.lua
998         std::string builtinpath = getBuiltinLuaPath() + DIR_DELIM + "builtin.lua";
999
1000         // Create world if it doesn't exist
1001         if(!initializeWorld(m_path_world, m_gamespec.id))
1002                 throw ServerError("Failed to initialize world");
1003
1004         // Lock environment
1005         JMutexAutoLock envlock(m_env_mutex);
1006         JMutexAutoLock conlock(m_con_mutex);
1007
1008         // Initialize scripting
1009         
1010         infostream<<"Server: Initializing Lua"<<std::endl;
1011         m_lua = script_init();
1012         assert(m_lua);
1013         // Export API
1014         scriptapi_export(m_lua, this);
1015         // Load and run builtin.lua
1016         infostream<<"Server: Loading builtin.lua [\""
1017                         <<builtinpath<<"\"]"<<std::endl;
1018         bool success = scriptapi_loadmod(m_lua, builtinpath, "__builtin");
1019         if(!success){
1020                 errorstream<<"Server: Failed to load and run "
1021                                 <<builtinpath<<std::endl;
1022                 throw ModError("Failed to load and run "+builtinpath);
1023         }
1024         // Find mods in mod search paths
1025         m_mods = getMods(m_modspaths);
1026         // Print 'em
1027         infostream<<"Server: Loading mods: ";
1028         for(core::list<ModSpec>::Iterator i = m_mods.begin();
1029                         i != m_mods.end(); i++){
1030                 const ModSpec &mod = *i;
1031                 infostream<<mod.name<<" ";
1032         }
1033         infostream<<std::endl;
1034         // Load and run "mod" scripts
1035         for(core::list<ModSpec>::Iterator i = m_mods.begin();
1036                         i != m_mods.end(); i++){
1037                 const ModSpec &mod = *i;
1038                 std::string scriptpath = mod.path + DIR_DELIM + "init.lua";
1039                 infostream<<"  ["<<padStringRight(mod.name, 12)<<"] [\""
1040                                 <<scriptpath<<"\"]"<<std::endl;
1041                 bool success = scriptapi_loadmod(m_lua, scriptpath, mod.name);
1042                 if(!success){
1043                         errorstream<<"Server: Failed to load and run "
1044                                         <<scriptpath<<std::endl;
1045                         throw ModError("Failed to load and run "+scriptpath);
1046                 }
1047         }
1048         
1049         // Read Textures and calculate sha1 sums
1050         fillMediaCache();
1051
1052         // Apply item aliases in the node definition manager
1053         m_nodedef->updateAliases(m_itemdef);
1054
1055         // Initialize Environment
1056         
1057         m_env = new ServerEnvironment(new ServerMap(path_world, this), m_lua,
1058                         this, this);
1059         
1060         // Give environment reference to scripting api
1061         scriptapi_add_environment(m_lua, m_env);
1062         
1063         // Register us to receive map edit events
1064         m_env->getMap().addEventReceiver(this);
1065
1066         // If file exists, load environment metadata
1067         if(fs::PathExists(m_path_world+DIR_DELIM+"env_meta.txt"))
1068         {
1069                 infostream<<"Server: Loading environment metadata"<<std::endl;
1070                 m_env->loadMeta(m_path_world);
1071         }
1072
1073         // Load players
1074         infostream<<"Server: Loading players"<<std::endl;
1075         m_env->deSerializePlayers(m_path_world);
1076
1077         /*
1078                 Add some test ActiveBlockModifiers to environment
1079         */
1080         add_legacy_abms(m_env, m_nodedef);
1081 }
1082
1083 Server::~Server()
1084 {
1085         infostream<<"Server destructing"<<std::endl;
1086
1087         /*
1088                 Send shutdown message
1089         */
1090         {
1091                 JMutexAutoLock conlock(m_con_mutex);
1092                 
1093                 std::wstring line = L"*** Server shutting down";
1094
1095                 /*
1096                         Send the message to clients
1097                 */
1098                 for(core::map<u16, RemoteClient*>::Iterator
1099                         i = m_clients.getIterator();
1100                         i.atEnd() == false; i++)
1101                 {
1102                         // Get client and check that it is valid
1103                         RemoteClient *client = i.getNode()->getValue();
1104                         assert(client->peer_id == i.getNode()->getKey());
1105                         if(client->serialization_version == SER_FMT_VER_INVALID)
1106                                 continue;
1107
1108                         try{
1109                                 SendChatMessage(client->peer_id, line);
1110                         }
1111                         catch(con::PeerNotFoundException &e)
1112                         {}
1113                 }
1114         }
1115         
1116         {
1117                 JMutexAutoLock envlock(m_env_mutex);
1118
1119                 /*
1120                         Save players
1121                 */
1122                 infostream<<"Server: Saving players"<<std::endl;
1123                 m_env->serializePlayers(m_path_world);
1124
1125                 /*
1126                         Save environment metadata
1127                 */
1128                 infostream<<"Server: Saving environment metadata"<<std::endl;
1129                 m_env->saveMeta(m_path_world);
1130         }
1131                 
1132         /*
1133                 Stop threads
1134         */
1135         stop();
1136         
1137         /*
1138                 Delete clients
1139         */
1140         {
1141                 JMutexAutoLock clientslock(m_con_mutex);
1142
1143                 for(core::map<u16, RemoteClient*>::Iterator
1144                         i = m_clients.getIterator();
1145                         i.atEnd() == false; i++)
1146                 {
1147                         /*// Delete player
1148                         // NOTE: These are removed by env destructor
1149                         {
1150                                 u16 peer_id = i.getNode()->getKey();
1151                                 JMutexAutoLock envlock(m_env_mutex);
1152                                 m_env->removePlayer(peer_id);
1153                         }*/
1154                         
1155                         // Delete client
1156                         delete i.getNode()->getValue();
1157                 }
1158         }
1159         
1160         // Delete things in the reverse order of creation
1161         delete m_env;
1162         delete m_rollback;
1163         delete m_event;
1164         delete m_itemdef;
1165         delete m_nodedef;
1166         delete m_craftdef;
1167         
1168         // Deinitialize scripting
1169         infostream<<"Server: Deinitializing scripting"<<std::endl;
1170         script_deinit(m_lua);
1171
1172         // Delete detached inventories
1173         {
1174                 for(std::map<std::string, Inventory*>::iterator
1175                                 i = m_detached_inventories.begin();
1176                                 i != m_detached_inventories.end(); i++){
1177                         delete i->second;
1178                 }
1179         }
1180 }
1181
1182 void Server::start(unsigned short port)
1183 {
1184         DSTACK(__FUNCTION_NAME);
1185         infostream<<"Starting server on port "<<port<<"..."<<std::endl;
1186
1187         // Stop thread if already running
1188         m_thread.stop();
1189         
1190         // Initialize connection
1191         m_con.SetTimeoutMs(30);
1192         m_con.Serve(port);
1193
1194         // Start thread
1195         m_thread.setRun(true);
1196         m_thread.Start();
1197         
1198         // ASCII art for the win!
1199         actionstream
1200         <<"        .__               __                   __   "<<std::endl
1201         <<"  _____ |__| ____   _____/  |_  ____   _______/  |_ "<<std::endl
1202         <<" /     \\|  |/    \\_/ __ \\   __\\/ __ \\ /  ___/\\   __\\"<<std::endl
1203         <<"|  Y Y  \\  |   |  \\  ___/|  | \\  ___/ \\___ \\  |  |  "<<std::endl
1204         <<"|__|_|  /__|___|  /\\___  >__|  \\___  >____  > |__|  "<<std::endl
1205         <<"      \\/        \\/     \\/          \\/     \\/        "<<std::endl;
1206         actionstream<<"World at ["<<m_path_world<<"]"<<std::endl;
1207         actionstream<<"Server for gameid=\""<<m_gamespec.id
1208                         <<"\" listening on port "<<port<<"."<<std::endl;
1209 }
1210
1211 void Server::stop()
1212 {
1213         DSTACK(__FUNCTION_NAME);
1214         
1215         infostream<<"Server: Stopping and waiting threads"<<std::endl;
1216
1217         // Stop threads (set run=false first so both start stopping)
1218         m_thread.setRun(false);
1219         m_emergethread.setRun(false);
1220         m_thread.stop();
1221         m_emergethread.stop();
1222         
1223         infostream<<"Server: Threads stopped"<<std::endl;
1224 }
1225
1226 void Server::step(float dtime)
1227 {
1228         DSTACK(__FUNCTION_NAME);
1229         // Limit a bit
1230         if(dtime > 2.0)
1231                 dtime = 2.0;
1232         {
1233                 JMutexAutoLock lock(m_step_dtime_mutex);
1234                 m_step_dtime += dtime;
1235         }
1236         // Throw if fatal error occurred in thread
1237         std::string async_err = m_async_fatal_error.get();
1238         if(async_err != ""){
1239                 throw ServerError(async_err);
1240         }
1241 }
1242
1243 void Server::AsyncRunStep()
1244 {
1245         DSTACK(__FUNCTION_NAME);
1246         
1247         g_profiler->add("Server::AsyncRunStep (num)", 1);
1248         
1249         float dtime;
1250         {
1251                 JMutexAutoLock lock1(m_step_dtime_mutex);
1252                 dtime = m_step_dtime;
1253         }
1254         
1255         {
1256                 // Send blocks to clients
1257                 SendBlocks(dtime);
1258         }
1259         
1260         if(dtime < 0.001)
1261                 return;
1262         
1263         g_profiler->add("Server::AsyncRunStep with dtime (num)", 1);
1264
1265         //infostream<<"Server steps "<<dtime<<std::endl;
1266         //infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
1267         
1268         {
1269                 JMutexAutoLock lock1(m_step_dtime_mutex);
1270                 m_step_dtime -= dtime;
1271         }
1272
1273         /*
1274                 Update uptime
1275         */
1276         {
1277                 m_uptime.set(m_uptime.get() + dtime);
1278         }
1279         
1280         {
1281                 // Process connection's timeouts
1282                 JMutexAutoLock lock2(m_con_mutex);
1283                 ScopeProfiler sp(g_profiler, "Server: connection timeout processing");
1284                 m_con.RunTimeouts(dtime);
1285         }
1286         
1287         {
1288                 // This has to be called so that the client list gets synced
1289                 // with the peer list of the connection
1290                 handlePeerChanges();
1291         }
1292
1293         /*
1294                 Update time of day and overall game time
1295         */
1296         {
1297                 JMutexAutoLock envlock(m_env_mutex);
1298
1299                 m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
1300
1301                 /*
1302                         Send to clients at constant intervals
1303                 */
1304
1305                 m_time_of_day_send_timer -= dtime;
1306                 if(m_time_of_day_send_timer < 0.0)
1307                 {
1308                         m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
1309
1310                         //JMutexAutoLock envlock(m_env_mutex);
1311                         JMutexAutoLock conlock(m_con_mutex);
1312
1313                         for(core::map<u16, RemoteClient*>::Iterator
1314                                 i = m_clients.getIterator();
1315                                 i.atEnd() == false; i++)
1316                         {
1317                                 RemoteClient *client = i.getNode()->getValue();
1318                                 SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
1319                                                 m_env->getTimeOfDay(), g_settings->getFloat("time_speed"));
1320                                 // Send as reliable
1321                                 m_con.Send(client->peer_id, 0, data, true);
1322                         }
1323                 }
1324         }
1325
1326         {
1327                 JMutexAutoLock lock(m_env_mutex);
1328                 // Step environment
1329                 ScopeProfiler sp(g_profiler, "SEnv step");
1330                 ScopeProfiler sp2(g_profiler, "SEnv step avg", SPT_AVG);
1331                 m_env->step(dtime);
1332         }
1333                 
1334         const float map_timer_and_unload_dtime = 2.92;
1335         if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
1336         {
1337                 JMutexAutoLock lock(m_env_mutex);
1338                 // Run Map's timers and unload unused data
1339                 ScopeProfiler sp(g_profiler, "Server: map timer and unload");
1340                 m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
1341                                 g_settings->getFloat("server_unload_unused_data_timeout"));
1342         }
1343         
1344         /*
1345                 Do background stuff
1346         */
1347
1348         /*
1349                 Handle players
1350         */
1351         {
1352                 JMutexAutoLock lock(m_env_mutex);
1353                 JMutexAutoLock lock2(m_con_mutex);
1354
1355                 ScopeProfiler sp(g_profiler, "Server: handle players");
1356
1357                 for(core::map<u16, RemoteClient*>::Iterator
1358                         i = m_clients.getIterator();
1359                         i.atEnd() == false; i++)
1360                 {
1361                         RemoteClient *client = i.getNode()->getValue();
1362                         PlayerSAO *playersao = getPlayerSAO(client->peer_id);
1363                         if(playersao == NULL)
1364                                 continue;
1365
1366                         /*
1367                                 Handle player HPs (die if hp=0)
1368                         */
1369                         if(playersao->getHP() == 0 && playersao->m_hp_not_sent)
1370                                 DiePlayer(client->peer_id);
1371
1372                         /*
1373                                 Send player inventories and HPs if necessary
1374                         */
1375                         if(playersao->m_moved){
1376                                 SendMovePlayer(client->peer_id);
1377                                 playersao->m_moved = false;
1378                         }
1379                         if(playersao->m_inventory_not_sent){
1380                                 UpdateCrafting(client->peer_id);
1381                                 SendInventory(client->peer_id);
1382                         }
1383                         if(playersao->m_hp_not_sent){
1384                                 SendPlayerHP(client->peer_id);
1385                         }
1386                 }
1387         }
1388         
1389         /* Transform liquids */
1390         m_liquid_transform_timer += dtime;
1391         if(m_liquid_transform_timer >= 1.00)
1392         {
1393                 m_liquid_transform_timer -= 1.00;
1394                 
1395                 JMutexAutoLock lock(m_env_mutex);
1396
1397                 ScopeProfiler sp(g_profiler, "Server: liquid transform");
1398
1399                 core::map<v3s16, MapBlock*> modified_blocks;
1400                 m_env->getMap().transformLiquids(modified_blocks);
1401 #if 0           
1402                 /*
1403                         Update lighting
1404                 */
1405                 core::map<v3s16, MapBlock*> lighting_modified_blocks;
1406                 ServerMap &map = ((ServerMap&)m_env->getMap());
1407                 map.updateLighting(modified_blocks, lighting_modified_blocks);
1408                 
1409                 // Add blocks modified by lighting to modified_blocks
1410                 for(core::map<v3s16, MapBlock*>::Iterator
1411                                 i = lighting_modified_blocks.getIterator();
1412                                 i.atEnd() == false; i++)
1413                 {
1414                         MapBlock *block = i.getNode()->getValue();
1415                         modified_blocks.insert(block->getPos(), block);
1416                 }
1417 #endif
1418                 /*
1419                         Set the modified blocks unsent for all the clients
1420                 */
1421                 
1422                 JMutexAutoLock lock2(m_con_mutex);
1423
1424                 for(core::map<u16, RemoteClient*>::Iterator
1425                                 i = m_clients.getIterator();
1426                                 i.atEnd() == false; i++)
1427                 {
1428                         RemoteClient *client = i.getNode()->getValue();
1429                         
1430                         if(modified_blocks.size() > 0)
1431                         {
1432                                 // Remove block from sent history
1433                                 client->SetBlocksNotSent(modified_blocks);
1434                         }
1435                 }
1436         }
1437
1438         // Periodically print some info
1439         {
1440                 float &counter = m_print_info_timer;
1441                 counter += dtime;
1442                 if(counter >= 30.0)
1443                 {
1444                         counter = 0.0;
1445
1446                         JMutexAutoLock lock2(m_con_mutex);
1447                         
1448                         if(m_clients.size() != 0)
1449                                 infostream<<"Players:"<<std::endl;
1450                         for(core::map<u16, RemoteClient*>::Iterator
1451                                 i = m_clients.getIterator();
1452                                 i.atEnd() == false; i++)
1453                         {
1454                                 //u16 peer_id = i.getNode()->getKey();
1455                                 RemoteClient *client = i.getNode()->getValue();
1456                                 Player *player = m_env->getPlayer(client->peer_id);
1457                                 if(player==NULL)
1458                                         continue;
1459                                 infostream<<"* "<<player->getName()<<"\t";
1460                                 client->PrintInfo(infostream);
1461                         }
1462                 }
1463         }
1464
1465         //if(g_settings->getBool("enable_experimental"))
1466         {
1467
1468         /*
1469                 Check added and deleted active objects
1470         */
1471         {
1472                 //infostream<<"Server: Checking added and deleted active objects"<<std::endl;
1473                 JMutexAutoLock envlock(m_env_mutex);
1474                 JMutexAutoLock conlock(m_con_mutex);
1475
1476                 ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
1477
1478                 // Radius inside which objects are active
1479                 s16 radius = g_settings->getS16("active_object_send_range_blocks");
1480                 radius *= MAP_BLOCKSIZE;
1481
1482                 for(core::map<u16, RemoteClient*>::Iterator
1483                         i = m_clients.getIterator();
1484                         i.atEnd() == false; i++)
1485                 {
1486                         RemoteClient *client = i.getNode()->getValue();
1487
1488                         // If definitions and textures have not been sent, don't
1489                         // send objects either
1490                         if(!client->definitions_sent)
1491                                 continue;
1492
1493                         Player *player = m_env->getPlayer(client->peer_id);
1494                         if(player==NULL)
1495                         {
1496                                 // This can happen if the client timeouts somehow
1497                                 /*infostream<<"WARNING: "<<__FUNCTION_NAME<<": Client "
1498                                                 <<client->peer_id
1499                                                 <<" has no associated player"<<std::endl;*/
1500                                 continue;
1501                         }
1502                         v3s16 pos = floatToInt(player->getPosition(), BS);
1503
1504                         core::map<u16, bool> removed_objects;
1505                         core::map<u16, bool> added_objects;
1506                         m_env->getRemovedActiveObjects(pos, radius,
1507                                         client->m_known_objects, removed_objects);
1508                         m_env->getAddedActiveObjects(pos, radius,
1509                                         client->m_known_objects, added_objects);
1510                         
1511                         // Ignore if nothing happened
1512                         if(removed_objects.size() == 0 && added_objects.size() == 0)
1513                         {
1514                                 //infostream<<"active objects: none changed"<<std::endl;
1515                                 continue;
1516                         }
1517                         
1518                         std::string data_buffer;
1519
1520                         char buf[4];
1521                         
1522                         // Handle removed objects
1523                         writeU16((u8*)buf, removed_objects.size());
1524                         data_buffer.append(buf, 2);
1525                         for(core::map<u16, bool>::Iterator
1526                                         i = removed_objects.getIterator();
1527                                         i.atEnd()==false; i++)
1528                         {
1529                                 // Get object
1530                                 u16 id = i.getNode()->getKey();
1531                                 ServerActiveObject* obj = m_env->getActiveObject(id);
1532
1533                                 // Add to data buffer for sending
1534                                 writeU16((u8*)buf, i.getNode()->getKey());
1535                                 data_buffer.append(buf, 2);
1536                                 
1537                                 // Remove from known objects
1538                                 client->m_known_objects.remove(i.getNode()->getKey());
1539
1540                                 if(obj && obj->m_known_by_count > 0)
1541                                         obj->m_known_by_count--;
1542                         }
1543
1544                         // Handle added objects
1545                         writeU16((u8*)buf, added_objects.size());
1546                         data_buffer.append(buf, 2);
1547                         for(core::map<u16, bool>::Iterator
1548                                         i = added_objects.getIterator();
1549                                         i.atEnd()==false; i++)
1550                         {
1551                                 // Get object
1552                                 u16 id = i.getNode()->getKey();
1553                                 ServerActiveObject* obj = m_env->getActiveObject(id);
1554                                 
1555                                 // Get object type
1556                                 u8 type = ACTIVEOBJECT_TYPE_INVALID;
1557                                 if(obj == NULL)
1558                                         infostream<<"WARNING: "<<__FUNCTION_NAME
1559                                                         <<": NULL object"<<std::endl;
1560                                 else
1561                                         type = obj->getSendType();
1562
1563                                 // Add to data buffer for sending
1564                                 writeU16((u8*)buf, id);
1565                                 data_buffer.append(buf, 2);
1566                                 writeU8((u8*)buf, type);
1567                                 data_buffer.append(buf, 1);
1568                                 
1569                                 if(obj)
1570                                         data_buffer.append(serializeLongString(
1571                                                         obj->getClientInitializationData()));
1572                                 else
1573                                         data_buffer.append(serializeLongString(""));
1574
1575                                 // Add to known objects
1576                                 client->m_known_objects.insert(i.getNode()->getKey(), false);
1577
1578                                 if(obj)
1579                                         obj->m_known_by_count++;
1580                         }
1581
1582                         // Send packet
1583                         SharedBuffer<u8> reply(2 + data_buffer.size());
1584                         writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD);
1585                         memcpy((char*)&reply[2], data_buffer.c_str(),
1586                                         data_buffer.size());
1587                         // Send as reliable
1588                         m_con.Send(client->peer_id, 0, reply, true);
1589
1590                         verbosestream<<"Server: Sent object remove/add: "
1591                                         <<removed_objects.size()<<" removed, "
1592                                         <<added_objects.size()<<" added, "
1593                                         <<"packet size is "<<reply.getSize()<<std::endl;
1594                 }
1595
1596 #if 0
1597                 /*
1598                         Collect a list of all the objects known by the clients
1599                         and report it back to the environment.
1600                 */
1601
1602                 core::map<u16, bool> all_known_objects;
1603
1604                 for(core::map<u16, RemoteClient*>::Iterator
1605                         i = m_clients.getIterator();
1606                         i.atEnd() == false; i++)
1607                 {
1608                         RemoteClient *client = i.getNode()->getValue();
1609                         // Go through all known objects of client
1610                         for(core::map<u16, bool>::Iterator
1611                                         i = client->m_known_objects.getIterator();
1612                                         i.atEnd()==false; i++)
1613                         {
1614                                 u16 id = i.getNode()->getKey();
1615                                 all_known_objects[id] = true;
1616                         }
1617                 }
1618                 
1619                 m_env->setKnownActiveObjects(whatever);
1620 #endif
1621
1622         }
1623
1624         /*
1625                 Send object messages
1626         */
1627         {
1628                 JMutexAutoLock envlock(m_env_mutex);
1629                 JMutexAutoLock conlock(m_con_mutex);
1630
1631                 ScopeProfiler sp(g_profiler, "Server: sending object messages");
1632
1633                 // Key = object id
1634                 // Value = data sent by object
1635                 core::map<u16, core::list<ActiveObjectMessage>* > buffered_messages;
1636
1637                 // Get active object messages from environment
1638                 for(;;)
1639                 {
1640                         ActiveObjectMessage aom = m_env->getActiveObjectMessage();
1641                         if(aom.id == 0)
1642                                 break;
1643                         
1644                         core::list<ActiveObjectMessage>* message_list = NULL;
1645                         core::map<u16, core::list<ActiveObjectMessage>* >::Node *n;
1646                         n = buffered_messages.find(aom.id);
1647                         if(n == NULL)
1648                         {
1649                                 message_list = new core::list<ActiveObjectMessage>;
1650                                 buffered_messages.insert(aom.id, message_list);
1651                         }
1652                         else
1653                         {
1654                                 message_list = n->getValue();
1655                         }
1656                         message_list->push_back(aom);
1657                 }
1658                 
1659                 // Route data to every client
1660                 for(core::map<u16, RemoteClient*>::Iterator
1661                         i = m_clients.getIterator();
1662                         i.atEnd()==false; i++)
1663                 {
1664                         RemoteClient *client = i.getNode()->getValue();
1665                         std::string reliable_data;
1666                         std::string unreliable_data;
1667                         // Go through all objects in message buffer
1668                         for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
1669                                         j = buffered_messages.getIterator();
1670                                         j.atEnd()==false; j++)
1671                         {
1672                                 // If object is not known by client, skip it
1673                                 u16 id = j.getNode()->getKey();
1674                                 if(client->m_known_objects.find(id) == NULL)
1675                                         continue;
1676                                 // Get message list of object
1677                                 core::list<ActiveObjectMessage>* list = j.getNode()->getValue();
1678                                 // Go through every message
1679                                 for(core::list<ActiveObjectMessage>::Iterator
1680                                                 k = list->begin(); k != list->end(); k++)
1681                                 {
1682                                         // Compose the full new data with header
1683                                         ActiveObjectMessage aom = *k;
1684                                         std::string new_data;
1685                                         // Add object id
1686                                         char buf[2];
1687                                         writeU16((u8*)&buf[0], aom.id);
1688                                         new_data.append(buf, 2);
1689                                         // Add data
1690                                         new_data += serializeString(aom.datastring);
1691                                         // Add data to buffer
1692                                         if(aom.reliable)
1693                                                 reliable_data += new_data;
1694                                         else
1695                                                 unreliable_data += new_data;
1696                                 }
1697                         }
1698                         /*
1699                                 reliable_data and unreliable_data are now ready.
1700                                 Send them.
1701                         */
1702                         if(reliable_data.size() > 0)
1703                         {
1704                                 SharedBuffer<u8> reply(2 + reliable_data.size());
1705                                 writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
1706                                 memcpy((char*)&reply[2], reliable_data.c_str(),
1707                                                 reliable_data.size());
1708                                 // Send as reliable
1709                                 m_con.Send(client->peer_id, 0, reply, true);
1710                         }
1711                         if(unreliable_data.size() > 0)
1712                         {
1713                                 SharedBuffer<u8> reply(2 + unreliable_data.size());
1714                                 writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES);
1715                                 memcpy((char*)&reply[2], unreliable_data.c_str(),
1716                                                 unreliable_data.size());
1717                                 // Send as unreliable
1718                                 m_con.Send(client->peer_id, 0, reply, false);
1719                         }
1720
1721                         /*if(reliable_data.size() > 0 || unreliable_data.size() > 0)
1722                         {
1723                                 infostream<<"Server: Size of object message data: "
1724                                                 <<"reliable: "<<reliable_data.size()
1725                                                 <<", unreliable: "<<unreliable_data.size()
1726                                                 <<std::endl;
1727                         }*/
1728                 }
1729
1730                 // Clear buffered_messages
1731                 for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
1732                                 i = buffered_messages.getIterator();
1733                                 i.atEnd()==false; i++)
1734                 {
1735                         delete i.getNode()->getValue();
1736                 }
1737         }
1738
1739         } // enable_experimental
1740
1741         /*
1742                 Send queued-for-sending map edit events.
1743         */
1744         {
1745                 // We will be accessing the environment and the connection
1746                 JMutexAutoLock lock(m_env_mutex);
1747                 JMutexAutoLock conlock(m_con_mutex);
1748
1749                 // Don't send too many at a time
1750                 //u32 count = 0;
1751
1752                 // Single change sending is disabled if queue size is not small
1753                 bool disable_single_change_sending = false;
1754                 if(m_unsent_map_edit_queue.size() >= 4)
1755                         disable_single_change_sending = true;
1756
1757                 int event_count = m_unsent_map_edit_queue.size();
1758
1759                 // We'll log the amount of each
1760                 Profiler prof;
1761
1762                 while(m_unsent_map_edit_queue.size() != 0)
1763                 {
1764                         MapEditEvent* event = m_unsent_map_edit_queue.pop_front();
1765                         
1766                         // Players far away from the change are stored here.
1767                         // Instead of sending the changes, MapBlocks are set not sent
1768                         // for them.
1769                         core::list<u16> far_players;
1770
1771                         if(event->type == MEET_ADDNODE)
1772                         {
1773                                 //infostream<<"Server: MEET_ADDNODE"<<std::endl;
1774                                 prof.add("MEET_ADDNODE", 1);
1775                                 if(disable_single_change_sending)
1776                                         sendAddNode(event->p, event->n, event->already_known_by_peer,
1777                                                         &far_players, 5);
1778                                 else
1779                                         sendAddNode(event->p, event->n, event->already_known_by_peer,
1780                                                         &far_players, 30);
1781                         }
1782                         else if(event->type == MEET_REMOVENODE)
1783                         {
1784                                 //infostream<<"Server: MEET_REMOVENODE"<<std::endl;
1785                                 prof.add("MEET_REMOVENODE", 1);
1786                                 if(disable_single_change_sending)
1787                                         sendRemoveNode(event->p, event->already_known_by_peer,
1788                                                         &far_players, 5);
1789                                 else
1790                                         sendRemoveNode(event->p, event->already_known_by_peer,
1791                                                         &far_players, 30);
1792                         }
1793                         else if(event->type == MEET_BLOCK_NODE_METADATA_CHANGED)
1794                         {
1795                                 infostream<<"Server: MEET_BLOCK_NODE_METADATA_CHANGED"<<std::endl;
1796                                 prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
1797                                 setBlockNotSent(event->p);
1798                         }
1799                         else if(event->type == MEET_OTHER)
1800                         {
1801                                 infostream<<"Server: MEET_OTHER"<<std::endl;
1802                                 prof.add("MEET_OTHER", 1);
1803                                 for(core::map<v3s16, bool>::Iterator
1804                                                 i = event->modified_blocks.getIterator();
1805                                                 i.atEnd()==false; i++)
1806                                 {
1807                                         v3s16 p = i.getNode()->getKey();
1808                                         setBlockNotSent(p);
1809                                 }
1810                         }
1811                         else
1812                         {
1813                                 prof.add("unknown", 1);
1814                                 infostream<<"WARNING: Server: Unknown MapEditEvent "
1815                                                 <<((u32)event->type)<<std::endl;
1816                         }
1817                         
1818                         /*
1819                                 Set blocks not sent to far players
1820                         */
1821                         if(far_players.size() > 0)
1822                         {
1823                                 // Convert list format to that wanted by SetBlocksNotSent
1824                                 core::map<v3s16, MapBlock*> modified_blocks2;
1825                                 for(core::map<v3s16, bool>::Iterator
1826                                                 i = event->modified_blocks.getIterator();
1827                                                 i.atEnd()==false; i++)
1828                                 {
1829                                         v3s16 p = i.getNode()->getKey();
1830                                         modified_blocks2.insert(p,
1831                                                         m_env->getMap().getBlockNoCreateNoEx(p));
1832                                 }
1833                                 // Set blocks not sent
1834                                 for(core::list<u16>::Iterator
1835                                                 i = far_players.begin();
1836                                                 i != far_players.end(); i++)
1837                                 {
1838                                         u16 peer_id = *i;
1839                                         RemoteClient *client = getClient(peer_id);
1840                                         if(client==NULL)
1841                                                 continue;
1842                                         client->SetBlocksNotSent(modified_blocks2);
1843                                 }
1844                         }
1845
1846                         delete event;
1847
1848                         /*// Don't send too many at a time
1849                         count++;
1850                         if(count >= 1 && m_unsent_map_edit_queue.size() < 100)
1851                                 break;*/
1852                 }
1853
1854                 if(event_count >= 5){
1855                         infostream<<"Server: MapEditEvents:"<<std::endl;
1856                         prof.print(infostream);
1857                 } else if(event_count != 0){
1858                         verbosestream<<"Server: MapEditEvents:"<<std::endl;
1859                         prof.print(verbosestream);
1860                 }
1861                 
1862         }
1863
1864         /*
1865                 Trigger emergethread (it somehow gets to a non-triggered but
1866                 bysy state sometimes)
1867         */
1868         {
1869                 float &counter = m_emergethread_trigger_timer;
1870                 counter += dtime;
1871                 if(counter >= 2.0)
1872                 {
1873                         counter = 0.0;
1874                         
1875                         m_emergethread.trigger();
1876
1877                         // Update m_enable_rollback_recording here too
1878                         m_enable_rollback_recording =
1879                                         g_settings->getBool("enable_rollback_recording");
1880                 }
1881         }
1882
1883         // Save map, players and auth stuff
1884         {
1885                 float &counter = m_savemap_timer;
1886                 counter += dtime;
1887                 if(counter >= g_settings->getFloat("server_map_save_interval"))
1888                 {
1889                         counter = 0.0;
1890                         JMutexAutoLock lock(m_env_mutex);
1891
1892                         ScopeProfiler sp(g_profiler, "Server: saving stuff");
1893
1894                         //Ban stuff
1895                         if(m_banmanager.isModified())
1896                                 m_banmanager.save();
1897                         
1898                         // Save changed parts of map
1899                         m_env->getMap().save(MOD_STATE_WRITE_NEEDED);
1900
1901                         // Save players
1902                         m_env->serializePlayers(m_path_world);
1903                         
1904                         // Save environment metadata
1905                         m_env->saveMeta(m_path_world);
1906                 }
1907         }
1908 }
1909
1910 void Server::Receive()
1911 {
1912         DSTACK(__FUNCTION_NAME);
1913         SharedBuffer<u8> data;
1914         u16 peer_id;
1915         u32 datasize;
1916         try{
1917                 {
1918                         JMutexAutoLock conlock(m_con_mutex);
1919                         datasize = m_con.Receive(peer_id, data);
1920                 }
1921
1922                 // This has to be called so that the client list gets synced
1923                 // with the peer list of the connection
1924                 handlePeerChanges();
1925
1926                 ProcessData(*data, datasize, peer_id);
1927         }
1928         catch(con::InvalidIncomingDataException &e)
1929         {
1930                 infostream<<"Server::Receive(): "
1931                                 "InvalidIncomingDataException: what()="
1932                                 <<e.what()<<std::endl;
1933         }
1934         catch(con::PeerNotFoundException &e)
1935         {
1936                 //NOTE: This is not needed anymore
1937                 
1938                 // The peer has been disconnected.
1939                 // Find the associated player and remove it.
1940
1941                 /*JMutexAutoLock envlock(m_env_mutex);
1942
1943                 infostream<<"ServerThread: peer_id="<<peer_id
1944                                 <<" has apparently closed connection. "
1945                                 <<"Removing player."<<std::endl;
1946
1947                 m_env->removePlayer(peer_id);*/
1948         }
1949 }
1950
1951 void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
1952 {
1953         DSTACK(__FUNCTION_NAME);
1954         // Environment is locked first.
1955         JMutexAutoLock envlock(m_env_mutex);
1956         JMutexAutoLock conlock(m_con_mutex);
1957         
1958         ScopeProfiler sp(g_profiler, "Server::ProcessData");
1959         
1960         try{
1961                 Address address = m_con.GetPeerAddress(peer_id);
1962                 std::string addr_s = address.serializeString();
1963
1964                 // drop player if is ip is banned
1965                 if(m_banmanager.isIpBanned(addr_s)){
1966                         infostream<<"Server: A banned client tried to connect from "
1967                                         <<addr_s<<"; banned name was "
1968                                         <<m_banmanager.getBanName(addr_s)<<std::endl;
1969                         // This actually doesn't seem to transfer to the client
1970                         SendAccessDenied(m_con, peer_id,
1971                                         L"Your ip is banned. Banned name was "
1972                                         +narrow_to_wide(m_banmanager.getBanName(addr_s)));
1973                         m_con.DeletePeer(peer_id);
1974                         return;
1975                 }
1976         }
1977         catch(con::PeerNotFoundException &e)
1978         {
1979                 infostream<<"Server::ProcessData(): Cancelling: peer "
1980                                 <<peer_id<<" not found"<<std::endl;
1981                 return;
1982         }
1983         
1984         std::string addr_s = m_con.GetPeerAddress(peer_id).serializeString();
1985
1986         u8 peer_ser_ver = getClient(peer_id)->serialization_version;
1987
1988         try
1989         {
1990
1991         if(datasize < 2)
1992                 return;
1993
1994         ToServerCommand command = (ToServerCommand)readU16(&data[0]);
1995         
1996         if(command == TOSERVER_INIT)
1997         {
1998                 // [0] u16 TOSERVER_INIT
1999                 // [2] u8 SER_FMT_VER_HIGHEST
2000                 // [3] u8[20] player_name
2001                 // [23] u8[28] password <--- can be sent without this, from old versions
2002
2003                 if(datasize < 2+1+PLAYERNAME_SIZE)
2004                         return;
2005
2006                 verbosestream<<"Server: Got TOSERVER_INIT from "
2007                                 <<peer_id<<std::endl;
2008
2009                 // First byte after command is maximum supported
2010                 // serialization version
2011                 u8 client_max = data[2];
2012                 u8 our_max = SER_FMT_VER_HIGHEST;
2013                 // Use the highest version supported by both
2014                 u8 deployed = core::min_(client_max, our_max);
2015                 // If it's lower than the lowest supported, give up.
2016                 if(deployed < SER_FMT_VER_LOWEST)
2017                         deployed = SER_FMT_VER_INVALID;
2018
2019                 //peer->serialization_version = deployed;
2020                 getClient(peer_id)->pending_serialization_version = deployed;
2021                 
2022                 if(deployed == SER_FMT_VER_INVALID)
2023                 {
2024                         actionstream<<"Server: A mismatched client tried to connect from "
2025                                         <<addr_s<<std::endl;
2026                         infostream<<"Server: Cannot negotiate "
2027                                         "serialization version with peer "
2028                                         <<peer_id<<std::endl;
2029                         SendAccessDenied(m_con, peer_id, std::wstring(
2030                                         L"Your client's version is not supported.\n"
2031                                         L"Server version is ")
2032                                         + narrow_to_wide(VERSION_STRING) + L"."
2033                         );
2034                         return;
2035                 }
2036                 
2037                 /*
2038                         Read and check network protocol version
2039                 */
2040
2041                 u16 min_net_proto_version = 0;
2042                 if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2)
2043                         min_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE]);
2044
2045                 // Use min if version field doesn't exist (backwards compatibility)
2046                 u16 max_net_proto_version = min_net_proto_version;
2047                 if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2)
2048                         max_net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2]);
2049
2050                 u16 net_proto_version = max_net_proto_version;
2051                 if(max_net_proto_version != SERVER_PROTOCOL_VERSION && min_net_proto_version <= SERVER_PROTOCOL_VERSION)
2052                         net_proto_version = SERVER_PROTOCOL_VERSION;
2053
2054                 verbosestream<<"Server: "<<peer_id<<" Protocol version: min: "
2055                                 <<min_net_proto_version<<", max: "<<max_net_proto_version
2056                                 <<", chosen: "<<net_proto_version<<std::endl;
2057
2058                 getClient(peer_id)->net_proto_version = net_proto_version;
2059
2060                 if(net_proto_version == 0)
2061                 {
2062                         actionstream<<"Server: An old tried to connect from "<<addr_s
2063                                         <<std::endl;
2064                         SendAccessDenied(m_con, peer_id, std::wstring(
2065                                         L"Your client's version is not supported.\n"
2066                                         L"Server version is ")
2067                                         + narrow_to_wide(VERSION_STRING) + L"."
2068                         );
2069                         return;
2070                 }
2071                 
2072                 if(g_settings->getBool("strict_protocol_version_checking"))
2073                 {
2074                         if(net_proto_version != SERVER_PROTOCOL_VERSION)
2075                         {
2076                                 actionstream<<"Server: A mismatched client tried to connect"
2077                                                 <<" from "<<addr_s<<std::endl;
2078                                 SendAccessDenied(m_con, peer_id, std::wstring(
2079                                                 L"Your client's version is not supported.\n"
2080                                                 L"Server version is ")
2081                                                 + narrow_to_wide(VERSION_STRING) + L",\n"
2082                                                 + L"server's PROTOCOL_VERSION is "
2083                                                 + narrow_to_wide(itos(SERVER_PROTOCOL_VERSION))
2084                                                 + L", client's PROTOCOL_VERSION is "
2085                                                 + narrow_to_wide(itos(net_proto_version))
2086                                 );
2087                                 return;
2088                         }
2089                 }
2090
2091                 /*
2092                         Set up player
2093                 */
2094                 
2095                 // Get player name
2096                 char playername[PLAYERNAME_SIZE];
2097                 for(u32 i=0; i<PLAYERNAME_SIZE-1; i++)
2098                 {
2099                         playername[i] = data[3+i];
2100                 }
2101                 playername[PLAYERNAME_SIZE-1] = 0;
2102                 
2103                 if(playername[0]=='\0')
2104                 {
2105                         actionstream<<"Server: Player with an empty name "
2106                                         <<"tried to connect from "<<addr_s<<std::endl;
2107                         SendAccessDenied(m_con, peer_id,
2108                                         L"Empty name");
2109                         return;
2110                 }
2111
2112                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
2113                 {
2114                         actionstream<<"Server: Player with an invalid name "
2115                                         <<"tried to connect from "<<addr_s<<std::endl;
2116                         SendAccessDenied(m_con, peer_id,
2117                                         L"Name contains unallowed characters");
2118                         return;
2119                 }
2120
2121                 infostream<<"Server: New connection: \""<<playername<<"\" from "
2122                                 <<m_con.GetPeerAddress(peer_id).serializeString()<<std::endl;
2123
2124                 // Get password
2125                 char given_password[PASSWORD_SIZE];
2126                 if(datasize < 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE)
2127                 {
2128                         // old version - assume blank password
2129                         given_password[0] = 0;
2130                 }
2131                 else
2132                 {
2133                         for(u32 i=0; i<PASSWORD_SIZE-1; i++)
2134                         {
2135                                 given_password[i] = data[23+i];
2136                         }
2137                         given_password[PASSWORD_SIZE-1] = 0;
2138                 }
2139
2140                 if(!base64_is_valid(given_password)){
2141                         infostream<<"Server: "<<playername
2142                                         <<" supplied invalid password hash"<<std::endl;
2143                         SendAccessDenied(m_con, peer_id, L"Invalid password hash");
2144                         return;
2145                 }
2146                 
2147                 std::string checkpwd; // Password hash to check against
2148                 bool has_auth = scriptapi_get_auth(m_lua, playername, &checkpwd, NULL);
2149                 
2150                 // If no authentication info exists for user, create it
2151                 if(!has_auth){
2152                         if(!isSingleplayer() &&
2153                                         g_settings->getBool("disallow_empty_password") &&
2154                                         std::string(given_password) == ""){
2155                                 SendAccessDenied(m_con, peer_id, L"Empty passwords are "
2156                                                 L"disallowed. Set a password and try again.");
2157                                 return;
2158                         }
2159                         std::wstring raw_default_password =
2160                                 narrow_to_wide(g_settings->get("default_password"));
2161                         std::string initial_password =
2162                                 translatePassword(playername, raw_default_password);
2163
2164                         // If default_password is empty, allow any initial password
2165                         if (raw_default_password.length() == 0)
2166                                 initial_password = given_password;
2167
2168                         scriptapi_create_auth(m_lua, playername, initial_password);
2169                 }
2170                 
2171                 has_auth = scriptapi_get_auth(m_lua, playername, &checkpwd, NULL);
2172
2173                 if(!has_auth){
2174                         SendAccessDenied(m_con, peer_id, L"Not allowed to login");
2175                         return;
2176                 }
2177
2178                 if(given_password != checkpwd){
2179                         infostream<<"Server: peer_id="<<peer_id
2180                                         <<": supplied invalid password for "
2181                                         <<playername<<std::endl;
2182                         SendAccessDenied(m_con, peer_id, L"Invalid password");
2183                         return;
2184                 }
2185
2186                 // Do not allow multiple players in simple singleplayer mode.
2187                 // This isn't a perfect way to do it, but will suffice for now.
2188                 if(m_simple_singleplayer_mode && m_clients.size() > 1){
2189                         infostream<<"Server: Not allowing another client to connect in"
2190                                         <<" simple singleplayer mode"<<std::endl;
2191                         SendAccessDenied(m_con, peer_id,
2192                                         L"Running in simple singleplayer mode.");
2193                         return;
2194                 }
2195                 
2196                 // Enforce user limit.
2197                 // Don't enforce for users that have some admin right
2198                 if(m_clients.size() >= g_settings->getU16("max_users") &&
2199                                 !checkPriv(playername, "server") &&
2200                                 !checkPriv(playername, "ban") &&
2201                                 !checkPriv(playername, "privs") &&
2202                                 !checkPriv(playername, "password") &&
2203                                 playername != g_settings->get("name"))
2204                 {
2205                         actionstream<<"Server: "<<playername<<" tried to join, but there"
2206                                         <<" are already max_users="
2207                                         <<g_settings->getU16("max_users")<<" players."<<std::endl;
2208                         SendAccessDenied(m_con, peer_id, L"Too many users.");
2209                         return;
2210                 }
2211
2212                 // Get player
2213                 PlayerSAO *playersao = emergePlayer(playername, peer_id);
2214
2215                 // If failed, cancel
2216                 if(playersao == NULL)
2217                 {
2218                         errorstream<<"Server: peer_id="<<peer_id
2219                                         <<": failed to emerge player"<<std::endl;
2220                         return;
2221                 }
2222
2223                 /*
2224                         Answer with a TOCLIENT_INIT
2225                 */
2226                 {
2227                         SharedBuffer<u8> reply(2+1+6+8+4);
2228                         writeU16(&reply[0], TOCLIENT_INIT);
2229                         writeU8(&reply[2], deployed);
2230                         writeV3S16(&reply[2+1], floatToInt(playersao->getPlayer()->getPosition()+v3f(0,BS/2,0), BS));
2231                         writeU64(&reply[2+1+6], m_env->getServerMap().getSeed());
2232                         writeF1000(&reply[2+1+6+8], g_settings->getFloat("dedicated_server_step"));
2233                         
2234                         // Send as reliable
2235                         m_con.Send(peer_id, 0, reply, true);
2236                 }
2237
2238                 /*
2239                         Send complete position information
2240                 */
2241                 SendMovePlayer(peer_id);
2242
2243                 return;
2244         }
2245
2246         if(command == TOSERVER_INIT2)
2247         {
2248                 verbosestream<<"Server: Got TOSERVER_INIT2 from "
2249                                 <<peer_id<<std::endl;
2250
2251