]> git.lizzy.rs Git - dragonfireclient.git/blobdiff - src/clientiface.cpp
projects / dragonfireclient.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Document zoom_fov in settingtypes.txt and minetest.conf.example
[dragonfireclient.git] / src / clientiface.cpp
diff --git a/src/clientiface.cpp b/src/clientiface.cpp
index 7649be29eff7586f7ced78f1bd0e4145c9a0bfcf..a3a17d435f3d77a3067e8a83967fccd06f790c36 100644 (file)
--- a/src/clientiface.cpp
+++ b/src/clientiface.cpp
@@ -31,16 +31,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "emerge.h"
 #include "serverobject.h"              // TODO this is used for cleanup of only
 #include "log.h"
+#include "util/srp.h"
 
 const char *ClientInterface::statenames[] = {
        "Invalid",
        "Disconnecting",
        "Denied",
        "Created",
-       "InitSent",
+       "AwaitingInit2",
+       "HelloSent",
        "InitDone",
        "DefinitionsSent",
-       "Active"
+       "Active",
+       "SudoMode",
 };
 
 
@@ -64,7 +67,7 @@ void RemoteClient::GetNextBlocks (
                float dtime,
                std::vector<PrioritySortedBlockTransfer> &dest)
 {
-       DSTACK(__FUNCTION_NAME);
+       DSTACK(FUNCTION_NAME);
 
 
        // Increment timers
@@ -208,25 +211,19 @@ void RemoteClient::GetNextBlocks (
                                max_simul_dynamic = max_simul_sends_setting;
 
                        // Don't select too many blocks for sending
-                       if(num_blocks_selected >= max_simul_dynamic)
-                       {
+                       if (num_blocks_selected >= max_simul_dynamic) {
                                //queue_is_full = true;
                                goto queue_full_break;
                        }
 
                        // Don't send blocks that are currently being transferred
-                       if(m_blocks_sending.find(p) != m_blocks_sending.end())
+                       if (m_blocks_sending.find(p) != m_blocks_sending.end())
                                continue;
 
                        /*
                                Do not go over-limit
                        */
-                       if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-                       || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-                       || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-                       || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-                       || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
-                       || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+                       if (blockpos_over_limit(p))
                                continue;
 
                        // If this is true, inexistent block will be made from scratch
@@ -238,7 +235,7 @@ void RemoteClient::GetNextBlocks (
                                        generate = false;*/
 
                                // Limit the send area vertically to 1/2
-                               if(abs(p.Y - center.Y) > full_d_max / 2)
+                               if (abs(p.Y - center.Y) > full_d_max / 2)
                                        continue;
                        }
 
@@ -373,17 +370,21 @@ void RemoteClient::GetNextBlocks (
 
 void RemoteClient::GotBlock(v3s16 p)
 {
-       if(m_blocks_sending.find(p) != m_blocks_sending.end())
-               m_blocks_sending.erase(p);
-       else
-       {
-               m_excess_gotblocks++;
+       if (m_blocks_modified.find(p) == m_blocks_modified.end()) {
+               if (m_blocks_sending.find(p) != m_blocks_sending.end())
+                       m_blocks_sending.erase(p);
+               else
+                       m_excess_gotblocks++;
+
+               m_blocks_sent.insert(p);
        }
-       m_blocks_sent.insert(p);
 }
 
 void RemoteClient::SentBlock(v3s16 p)
 {
+       if (m_blocks_modified.find(p) != m_blocks_modified.end())
+               m_blocks_modified.erase(p);
+
        if(m_blocks_sending.find(p) == m_blocks_sending.end())
                m_blocks_sending[p] = 0.0;
        else
@@ -394,22 +395,26 @@ void RemoteClient::SentBlock(v3s16 p)
 void RemoteClient::SetBlockNotSent(v3s16 p)
 {
        m_nearest_unsent_d = 0;
+       m_nothing_to_send_pause_timer = 0;
 
        if(m_blocks_sending.find(p) != m_blocks_sending.end())
                m_blocks_sending.erase(p);
        if(m_blocks_sent.find(p) != m_blocks_sent.end())
                m_blocks_sent.erase(p);
+       m_blocks_modified.insert(p);
 }
 
 void RemoteClient::SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks)
 {
        m_nearest_unsent_d = 0;
+       m_nothing_to_send_pause_timer = 0;
 
        for(std::map<v3s16, MapBlock*>::iterator
                        i = blocks.begin();
                        i != blocks.end(); ++i)
        {
                v3s16 p = i->first;
+               m_blocks_modified.insert(p);
 
                if(m_blocks_sending.find(p) != m_blocks_sending.end())
                        m_blocks_sending.erase(p);
@@ -427,10 +432,12 @@ void RemoteClient::notifyEvent(ClientStateEvent event)
                //intentionally do nothing
                break;
        case CS_Created:
-               switch(event)
-               {
-               case CSE_Init:
-                       m_state = CS_InitSent;
+               switch (event) {
+               case CSE_Hello:
+                       m_state = CS_HelloSent;
+                       break;
+               case CSE_InitLegacy:
+                       m_state = CS_AwaitingInit2;
                        break;
                case CSE_Disconnect:
                        m_state = CS_Disconnecting;
@@ -447,7 +454,32 @@ void RemoteClient::notifyEvent(ClientStateEvent event)
        case CS_Denied:
                /* don't do anything if in denied state */
                break;
-       case CS_InitSent:
+       case CS_HelloSent:
+               switch(event)
+               {
+               case CSE_AuthAccept:
+                       m_state = CS_AwaitingInit2;
+                       if ((chosen_mech == AUTH_MECHANISM_SRP)
+                                       || (chosen_mech == AUTH_MECHANISM_LEGACY_PASSWORD))
+                               srp_verifier_delete((SRPVerifier *) auth_data);
+                       chosen_mech = AUTH_MECHANISM_NONE;
+                       break;
+               case CSE_Disconnect:
+                       m_state = CS_Disconnecting;
+                       break;
+               case CSE_SetDenied:
+                       m_state = CS_Denied;
+                       if ((chosen_mech == AUTH_MECHANISM_SRP)
+                                       || (chosen_mech == AUTH_MECHANISM_LEGACY_PASSWORD))
+                               srp_verifier_delete((SRPVerifier *) auth_data);
+                       chosen_mech = AUTH_MECHANISM_NONE;
+                       break;
+               default:
+                       myerror << "HelloSent: Invalid client state transition! " << event;
+                       throw ClientStateError(myerror.str());
+               }
+               break;
+       case CS_AwaitingInit2:
                switch(event)
                {
                case CSE_GotInit2:
@@ -514,6 +546,13 @@ void RemoteClient::notifyEvent(ClientStateEvent event)
                case CSE_Disconnect:
                        m_state = CS_Disconnecting;
                        break;
+               case CSE_SudoSuccess:
+                       m_state = CS_SudoMode;
+                       if ((chosen_mech == AUTH_MECHANISM_SRP)
+                                       || (chosen_mech == AUTH_MECHANISM_LEGACY_PASSWORD))
+                               srp_verifier_delete((SRPVerifier *) auth_data);
+                       chosen_mech = AUTH_MECHANISM_NONE;
+                       break;
                /* Init GotInit2 SetDefinitionsSent SetMediaSent SetDenied */
                default:
                        myerror << "Active: Invalid client state transition! " << event;
@@ -521,6 +560,24 @@ void RemoteClient::notifyEvent(ClientStateEvent event)
                        break;
                }
                break;
+       case CS_SudoMode:
+               switch(event)
+               {
+               case CSE_SetDenied:
+                       m_state = CS_Denied;
+                       break;
+               case CSE_Disconnect:
+                       m_state = CS_Disconnecting;
+                       break;
+               case CSE_SudoLeave:
+                       m_state = CS_Active;
+                       break;
+               default:
+                       myerror << "Active: Invalid client state transition! " << event;
+                       throw ClientStateError(myerror.str());
+                       break;
+               }
+               break;
        case CS_Disconnecting:
                /* we are already disconnecting */
                break;
@@ -546,7 +603,7 @@ ClientInterface::~ClientInterface()
                Delete clients
        */
        {
-               JMutexAutoLock clientslock(m_clients_mutex);
+               MutexAutoLock clientslock(m_clients_mutex);
 
                for(std::map<u16, RemoteClient*>::iterator
                        i = m_clients.begin();
@@ -562,7 +619,7 @@ ClientInterface::~ClientInterface()
 std::vector<u16> ClientInterface::getClientIDs(ClientState min_state)
 {
        std::vector<u16> reply;
-       JMutexAutoLock clientslock(m_clients_mutex);
+       MutexAutoLock clientslock(m_clients_mutex);
 
        for(std::map<u16, RemoteClient*>::iterator
                i = m_clients.begin();
@@ -613,7 +670,7 @@ void ClientInterface::UpdatePlayerList()
                        infostream << "* " << player->getName() << "\t";
 
                        {
-                               JMutexAutoLock clientslock(m_clients_mutex);
+                               MutexAutoLock clientslock(m_clients_mutex);
                                RemoteClient* client = lockedGetClientNoEx(*i);
                                if(client != NULL)
                                        client->PrintInfo(infostream);
@@ -633,7 +690,7 @@ void ClientInterface::send(u16 peer_id, u8 channelnum,
 void ClientInterface::sendToAll(u16 channelnum,
                NetworkPacket* pkt, bool reliable)
 {
-       JMutexAutoLock clientslock(m_clients_mutex);
+       MutexAutoLock clientslock(m_clients_mutex);
        for(std::map<u16, RemoteClient*>::iterator
                i = m_clients.begin();
                i != m_clients.end(); ++i) {
@@ -647,7 +704,7 @@ void ClientInterface::sendToAll(u16 channelnum,
 
 RemoteClient* ClientInterface::getClientNoEx(u16 peer_id, ClientState state_min)
 {
-       JMutexAutoLock clientslock(m_clients_mutex);
+       MutexAutoLock clientslock(m_clients_mutex);
        std::map<u16, RemoteClient*>::iterator n;
        n = m_clients.find(peer_id);
        // The client may not exist; clients are immediately removed if their
@@ -678,7 +735,7 @@ RemoteClient* ClientInterface::lockedGetClientNoEx(u16 peer_id, ClientState stat
 
 ClientState ClientInterface::getClientState(u16 peer_id)
 {
-       JMutexAutoLock clientslock(m_clients_mutex);
+       MutexAutoLock clientslock(m_clients_mutex);
        std::map<u16, RemoteClient*>::iterator n;
        n = m_clients.find(peer_id);
        // The client may not exist; clients are immediately removed if their
@@ -691,7 +748,7 @@ ClientState ClientInterface::getClientState(u16 peer_id)
 
 void ClientInterface::setPlayerName(u16 peer_id,std::string name)
 {
-       JMutexAutoLock clientslock(m_clients_mutex);
+       MutexAutoLock clientslock(m_clients_mutex);
        std::map<u16, RemoteClient*>::iterator n;
        n = m_clients.find(peer_id);
        // The client may not exist; clients are immediately removed if their
@@ -702,7 +759,7 @@ void ClientInterface::setPlayerName(u16 peer_id,std::string name)
 
 void ClientInterface::DeleteClient(u16 peer_id)
 {
-       JMutexAutoLock conlock(m_clients_mutex);
+       MutexAutoLock conlock(m_clients_mutex);
 
        // Error check
        std::map<u16, RemoteClient*>::iterator n;
@@ -737,7 +794,7 @@ void ClientInterface::DeleteClient(u16 peer_id)
 
 void ClientInterface::CreateClient(u16 peer_id)
 {
-       JMutexAutoLock conlock(m_clients_mutex);
+       MutexAutoLock conlock(m_clients_mutex);
 
        // Error check
        std::map<u16, RemoteClient*>::iterator n;
@@ -754,7 +811,7 @@ void ClientInterface::CreateClient(u16 peer_id)
 void ClientInterface::event(u16 peer_id, ClientStateEvent event)
 {
        {
-               JMutexAutoLock clientlock(m_clients_mutex);
+               MutexAutoLock clientlock(m_clients_mutex);
 
                // Error check
                std::map<u16, RemoteClient*>::iterator n;
@@ -776,7 +833,7 @@ void ClientInterface::event(u16 peer_id, ClientStateEvent event)
 
 u16 ClientInterface::getProtocolVersion(u16 peer_id)
 {
-       JMutexAutoLock conlock(m_clients_mutex);
+       MutexAutoLock conlock(m_clients_mutex);
 
        // Error check
        std::map<u16, RemoteClient*>::iterator n;
@@ -791,7 +848,7 @@ u16 ClientInterface::getProtocolVersion(u16 peer_id)
 
 void ClientInterface::setClientVersion(u16 peer_id, u8 major, u8 minor, u8 patch, std::string full)
 {
-       JMutexAutoLock conlock(m_clients_mutex);
+       MutexAutoLock conlock(m_clients_mutex);
 
        // Error check
        std::map<u16, RemoteClient*>::iterator n;
Dragonfireclient is an utility client for the Voxelengine minetest (http://minetest.net/). The client was created by Elias Fleckenstein and is inspired by the Minecraft clients Liquid Bounce and Impact. Discord: https://discord.gg/kab99uu for more information.