Fix how address is logged when a wrong password is supplied

[oweals/minetest.git] / src / database-dummy.cpp

diff --git a/src/database-dummy.cpp b/src/database-dummy.cpp
index 7f715dd19bef81b0929fb2bacd248c44363cceb2..2e5de5ed11fcd57f914d1c56ffca8b78c9937a39 100644 (file)
--- a/src/database-dummy.cpp
+++ b/src/database-dummy.cpp
@@ -18,152 +18,38 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 /*
-Dummy "database" class
+Dummy database class
 */
 
-
 #include "database-dummy.h"
 
-#include "map.h"
-#include "mapsector.h"
-#include "mapblock.h"
-#include "serialization.h"
-#include "main.h"
-#include "settings.h"
-#include "log.h"
 
-Database_Dummy::Database_Dummy(ServerMap *map)
+bool Database_Dummy::saveBlock(const v3s16 &pos, const std::string &data)
 {
-       srvmap = map;
+       m_database[getBlockAsInteger(pos)] = data;
+       return true;
 }
 
-int Database_Dummy::Initialized(void)
+std::string Database_Dummy::loadBlock(const v3s16 &pos)
 {
-       return 1;
+       s64 i = getBlockAsInteger(pos);
+       std::map<s64, std::string>::iterator it = m_database.find(i);
+       if (it == m_database.end())
+               return "";
+       return it->second;
 }
 
-void Database_Dummy::beginSave() {}
-void Database_Dummy::endSave() {}
-
-bool Database_Dummy::saveBlock(MapBlock *block)
+bool Database_Dummy::deleteBlock(const v3s16 &pos)
 {
-       DSTACK(__FUNCTION_NAME);
-       /*
-               Dummy blocks are not written
-       */
-       if(block->isDummy())
-       {
-               v3s16 p = block->getPos();
-               infostream<<"Database_Dummy::saveBlock(): WARNING: Not writing dummy block "
-                               <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
-               return true;
-       }
-
-       // Format used for writing
-       u8 version = SER_FMT_VER_HIGHEST_WRITE;
-       // Get destination
-       v3s16 p3d = block->getPos();
-
-       /*
-               [0] u8 serialization version
-               [1] data
-       */
-
-       std::ostringstream o(std::ios_base::binary);
-       o.write((char*)&version, 1);
-       // Write basic data
-       block->serialize(o, version, true);
-       // Write block to database
-       std::string tmp = o.str();
-
-       m_database[getBlockAsInteger(p3d)] = tmp;
-       // We just wrote it to the disk so clear modified flag
-       block->resetModified();
+       m_database.erase(getBlockAsInteger(pos));
        return true;
 }
 
-MapBlock* Database_Dummy::loadBlock(v3s16 blockpos)
+void Database_Dummy::listAllLoadableBlocks(std::vector<v3s16> &dst)
 {
-       v2s16 p2d(blockpos.X, blockpos.Z);
-
-        if(m_database.count(getBlockAsInteger(blockpos))) {
-                /*
-                        Make sure sector is loaded
-                */
-                MapSector *sector = srvmap->createSector(p2d);
-                /*
-                        Load block
-                */
-                std::string datastr = m_database[getBlockAsInteger(blockpos)];
-//                srvmap->loadBlock(&datastr, blockpos, sector, false);
-
-               try {
-                       std::istringstream is(datastr, std::ios_base::binary);
-                       u8 version = SER_FMT_VER_INVALID;
-                       is.read((char*)&version, 1);
-
-                       if(is.fail())
-                               throw SerializationError("ServerMap::loadBlock(): Failed"
-                                                    " to read MapBlock version");
-
-                       MapBlock *block = NULL;
-                       bool created_new = false;
-                       block = sector->getBlockNoCreateNoEx(blockpos.Y);
-                       if(block == NULL)
-                       {
-                               block = sector->createBlankBlockNoInsert(blockpos.Y);
-                               created_new = true;
-                       }
-                       // Read basic data
-                       block->deSerialize(is, version, true);
-                       // If it's a new block, insert it to the map
-                       if(created_new)
-                               sector->insertBlock(block);
-                       /*
-                               Save blocks loaded in old format in new format
-                       */
-
-                       //if(version < SER_FMT_VER_HIGHEST || save_after_load)
-                       // Only save if asked to; no need to update version
-                       //if(save_after_load)
-                        //             saveBlock(block);
-                       // We just loaded it from, so it's up-to-date.
-                       block->resetModified();
-
-               }
-               catch(SerializationError &e)
-               {
-                       errorstream<<"Invalid block data in database"
-                                     <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
-                                     <<" (SerializationError): "<<e.what()<<std::endl;
-                     // TODO: Block should be marked as invalid in memory so that it is
-                     // not touched but the game can run
-
-                       if(g_settings->getBool("ignore_world_load_errors")){
-                             errorstream<<"Ignoring block load error. Duck and cover! "
-                                             <<"(ignore_world_load_errors)"<<std::endl;
-                       } else {
-                             throw SerializationError("Invalid block data in database");
-                             //assert(0);
-                       }
-               }
-
-                return srvmap->getBlockNoCreateNoEx(blockpos);  // should not be using this here
-        }
-       return(NULL);
-}
-
-void Database_Dummy::listAllLoadableBlocks(std::list<v3s16> &dst)
-{
-       for(std::map<u64, std::string>::iterator x = m_database.begin(); x != m_database.end(); ++x)
-       {
-               v3s16 p = getIntegerAsBlock(x->first);
-               //dstream<<"block_i="<<block_i<<" p="<<PP(p)<<std::endl;
-               dst.push_back(p);
+       for (std::map<s64, std::string>::const_iterator x = m_database.begin();
+                       x != m_database.end(); ++x) {
+               dst.push_back(getIntegerAsBlock(x->first));
        }
 }
 
-Database_Dummy::~Database_Dummy()
-{
-       m_database.clear();
-}