Fix stale states for inventory interaction when using API to force login

.gitignore

@@ -115,3 +115,5 @@ nb-configuration.xml
 # Don't exclude the .gitignore itself
 !.gitignore
 /samples/
+
+.factorypath

src/main/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManager.java

@@ -5,6 +5,7 @@
 import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.message.Messages;
+import fr.xephi.authme.process.login.ForceLoginRequestService;
 import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
@@ -34,6 +35,9 @@ class LimboPlayerTaskManager {
     @Inject
     private PlayerCache playerCache;
 
+    @Inject
+    private ForceLoginRequestService forceLoginRequestService;
+
     @Inject
     private RegistrationCaptchaManager registrationCaptchaManager;
 
@@ -52,7 +56,7 @@ void registerMessageTask(Player player, LimboPlayer limbo, LimboMessageType mess
         MessageResult result = getMessageKey(player.getName(), messageType);
         if (interval > 0) {
             String[] joinMessage = messages.retrieveSingle(player, result.messageKey, result.args).split("\n");
-            MessageTask messageTask = new MessageTask(player, joinMessage);
+            MessageTask messageTask = new MessageTask(player, joinMessage, playerCache, forceLoginRequestService);
             bukkitService.runTaskTimer(messageTask, 2 * TICKS_PER_SECOND, (long) interval * TICKS_PER_SECOND);
             limbo.setMessageTask(messageTask);
         }

src/main/java/fr/xephi/authme/data/limbo/LimboService.java

@@ -116,16 +116,16 @@ public void restoreData(Player player) {
         LimboPlayer limbo = entries.remove(lowerName);
 
         if (limbo == null) {
-            logger.debug("No LimboPlayer found for `{0}` - cannot restore", lowerName);
+            logger.debug("No LimboPlayer found for `{0}` - only clearing persisted limbo state", lowerName);
         } else {
             player.setOp(limbo.isOperator());
             settings.getProperty(RESTORE_ALLOW_FLIGHT).restoreAllowFlight(player, limbo);
             settings.getProperty(RESTORE_FLY_SPEED).restoreFlySpeed(player, limbo);
             settings.getProperty(RESTORE_WALK_SPEED).restoreWalkSpeed(player, limbo);
             limbo.clearTasks();
             logger.debug("Restored LimboPlayer stats for `{0}`", lowerName);
-            persistence.removeLimboPlayer(player);
         }
+        persistence.removeLimboPlayer(player);
         authGroupHandler.setGroup(player, limbo, AuthGroupType.LOGGED_IN);
     }
 

src/main/java/fr/xephi/authme/listener/ListenerService.java

@@ -17,7 +17,7 @@
 /**
  * Service class for the AuthMe listeners to determine whether an event should be canceled.
  */
-class ListenerService implements SettingsDependent {
+public class ListenerService implements SettingsDependent {
     private final DataSource dataSource;
     private final PlayerCache playerCache;
     private final ValidationService validationService;
@@ -91,7 +91,7 @@ public void reload(Settings settings) {
      * @return true if the player may play, false otherwise
      */
     private boolean checkAuth(String name) {
-        if (validationService.isUnrestricted(name) || playerCache.isAuthenticated(name)){
+        if (validationService.isUnrestricted(name) || playerCache.isAuthenticated(name)) {
             return true;
         }
         if (!isRegistrationForced && !dataSource.isAuthAvailable(name)) {

src/main/java/fr/xephi/authme/listener/PlayerListener.java

@@ -2,6 +2,7 @@
 
 import fr.xephi.authme.data.QuickCommandsProtectionManager;
 import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.message.Messages;
@@ -32,6 +33,7 @@
 import org.bukkit.event.block.SignChangeEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.inventory.InventoryOpenEvent;
 import org.bukkit.event.player.AsyncPlayerChatEvent;
 import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
@@ -73,6 +75,8 @@ public class PlayerListener implements Listener {
     @Inject
     private DataSource dataSource;
     @Inject
+    private PlayerCache playerCache;
+    @Inject
     private AntiBotService antiBotService;
     @Inject
     private Management management;
@@ -517,25 +521,44 @@ private boolean isInventoryWhitelisted(InventoryView inventory) {
         return false;
     }
 
+    private boolean shouldCancelInventoryInteraction(HumanEntity humanEntity, InventoryView inventory) {
+        if (!(humanEntity instanceof Player)) {
+            return false;
+        }
+        final Player player = (Player) humanEntity;
+        return listenerService.shouldCancelEvent(player) && !isInventoryWhitelisted(inventory);
+    }
+
+    private void closeInventoryIfStillRestricted(HumanEntity player) {
+        if (shouldCancelInventoryInteraction(player, player.getOpenInventory())) {
+            player.closeInventory();
+        }
+    }
+
     @EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
     public void onPlayerInventoryOpen(InventoryOpenEvent event) {
         final HumanEntity player = event.getPlayer();
-        if (listenerService.shouldCancelEvent(player)
-            && !isInventoryWhitelisted(event.getView())) {
+        if (shouldCancelInventoryInteraction(player, event.getView())) {
             event.setCancelled(true);
 
             /*
              * @note little hack cause InventoryOpenEvent cannot be cancelled for
              * real, cause no packet is sent to server by client for the main inv
              */
-            bukkitService.scheduleSyncDelayedTask(player::closeInventory, 1);
+            bukkitService.runTaskLater((Player) player, () -> closeInventoryIfStillRestricted(player), 1);
         }
     }
 
     @EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
     public void onPlayerInventoryClick(InventoryClickEvent event) {
-        if (listenerService.shouldCancelEvent(event.getWhoClicked())
-            && !isInventoryWhitelisted(event.getView())) {
+        if (shouldCancelInventoryInteraction(event.getWhoClicked(), event.getView())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
+    public void onPlayerInventoryDrag(InventoryDragEvent event) {
+        if (shouldCancelInventoryInteraction(event.getWhoClicked(), event.getView())) {
             event.setCancelled(true);
         }
     }

src/main/java/fr/xephi/authme/listener/protocollib/InventoryPacketAdapter.java

@@ -26,8 +26,7 @@
 import com.comphenix.protocol.reflect.StructureModifier;
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.ConsoleLogger;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.listener.ListenerService;
 import fr.xephi.authme.output.ConsoleLoggerFactory;
 import fr.xephi.authme.service.BukkitService;
 import org.bukkit.Material;
@@ -48,13 +47,11 @@ class InventoryPacketAdapter extends PacketAdapter {
     private static final int HOTBAR_SIZE = 9;
 
     private final ConsoleLogger logger = ConsoleLoggerFactory.get(InventoryPacketAdapter.class);
-    private final PlayerCache playerCache;
-    private final DataSource dataSource;
+    private final ListenerService listenerService;
 
-    InventoryPacketAdapter(AuthMe plugin, PlayerCache playerCache, DataSource dataSource) {
+    InventoryPacketAdapter(AuthMe plugin, ListenerService listenerService) {
         super(plugin, PacketType.Play.Server.SET_SLOT, PacketType.Play.Server.WINDOW_ITEMS);
-        this.playerCache = playerCache;
-        this.dataSource = dataSource;
+        this.listenerService = listenerService;
     }
 
     @Override
@@ -63,7 +60,7 @@ public void onPacketSending(PacketEvent packetEvent) {
         PacketContainer packet = packetEvent.getPacket();
 
         int windowId = packet.getIntegers().read(0);
-        if (windowId == PLAYER_INVENTORY && shouldHideInventory(player.getName())) {
+        if (windowId == PLAYER_INVENTORY && shouldHideInventory(player)) {
             packetEvent.setCancelled(true);
         }
     }
@@ -77,12 +74,12 @@ public void register(BukkitService bukkitService) {
         ProtocolLibrary.getProtocolManager().addPacketListener(this);
 
         bukkitService.getOnlinePlayers().stream()
-            .filter(player -> shouldHideInventory(player.getName()))
+            .filter(this::shouldHideInventory)
             .forEach(this::sendBlankInventoryPacket);
     }
 
-    private boolean shouldHideInventory(String playerName) {
-        return !playerCache.isAuthenticated(playerName) && dataSource.isAuthAvailable(playerName);
+    private boolean shouldHideInventory(Player player) {
+        return listenerService.shouldCancelEvent(player);
     }
 
     public void unregister() {

src/main/java/fr/xephi/authme/listener/protocollib/ProtocolLibService.java

@@ -4,9 +4,9 @@
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.initialization.SettingsDependent;
 import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.listener.ListenerService;
 import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.PluginSettings;
@@ -36,15 +36,15 @@ public class ProtocolLibService implements SettingsDependent {
     private final AuthMe plugin;
     private final BukkitService bukkitService;
     private final PlayerCache playerCache;
-    private final DataSource dataSource;
+    private final ListenerService listenerService;
 
     @Inject
     ProtocolLibService(AuthMe plugin, Settings settings, BukkitService bukkitService, PlayerCache playerCache,
-                       DataSource dataSource) {
+                       ListenerService listenerService) {
         this.plugin = plugin;
         this.bukkitService = bukkitService;
         this.playerCache = playerCache;
-        this.dataSource = dataSource;
+        this.listenerService = listenerService;
         reload(settings);
     }
 
@@ -74,7 +74,7 @@ public void setup() {
         if (protectInvBeforeLogin) {
             if (inventoryPacketAdapter == null) {
                 // register the packet listener and start hiding it for all already online players (reload)
-                inventoryPacketAdapter = new InventoryPacketAdapter(plugin, playerCache, dataSource);
+                inventoryPacketAdapter = new InventoryPacketAdapter(plugin, listenerService);
                 inventoryPacketAdapter.register(bukkitService);
             }
         } else if (inventoryPacketAdapter != null) {

src/main/java/fr/xephi/authme/process/Management.java

@@ -1,10 +1,12 @@
 package fr.xephi.authme.process;
 
+import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.process.changepassword.AsyncChangePassword;
 import fr.xephi.authme.process.email.AsyncAddEmail;
 import fr.xephi.authme.process.email.AsyncChangeEmail;
 import fr.xephi.authme.process.join.AsynchronousJoin;
 import fr.xephi.authme.process.login.AsynchronousLogin;
+import fr.xephi.authme.process.login.ForceLoginRequestService;
 import fr.xephi.authme.process.logout.AsynchronousLogout;
 import fr.xephi.authme.process.quit.AsynchronousQuit;
 import fr.xephi.authme.process.register.AsyncRegister;
@@ -25,6 +27,9 @@ public class Management {
     @Inject
     private BukkitService bukkitService;
 
+    @Inject
+    private PlayerCache playerCache;
+
     // Processes
     @Inject
     private AsyncAddEmail asyncAddEmail;
@@ -41,6 +46,8 @@ public class Management {
     @Inject
     private AsynchronousLogin asynchronousLogin;
     @Inject
+    private ForceLoginRequestService forceLoginRequestService;
+    @Inject
     private AsynchronousUnregister asynchronousUnregister;
     @Inject
     private AsyncChangePassword asyncChangePassword;
@@ -54,10 +61,26 @@ public void performLogin(Player player, String password) {
     }
 
     public void forceLogin(Player player) {
+        if (player == null) {
+            return;
+        }
+        if (playerCache.isAuthenticated(player.getName())) {
+            forceLoginRequestService.clear(player);
+            return;
+        }
+        forceLoginRequestService.markPending(player);
         runTask(() -> asynchronousLogin.forceLogin(player));
     }
 
     public void forceLogin(Player player, boolean quiet) {
+        if (player == null) {
+            return;
+        }
+        if (playerCache.isAuthenticated(player.getName())) {
+            forceLoginRequestService.clear(player);
+            return;
+        }
+        forceLoginRequestService.markPending(player);
         runTask(() -> asynchronousLogin.forceLogin(player, quiet));
     }
 

src/main/java/fr/xephi/authme/process/join/AsynchronousJoin.java

@@ -1,6 +1,7 @@
 package fr.xephi.authme.process.join;
 
 import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.data.ProxySessionManager;
 import fr.xephi.authme.data.limbo.LimboService;
 import fr.xephi.authme.datasource.DataSource;
@@ -52,6 +53,9 @@ public class AsynchronousJoin implements AsynchronousProcess {
     @Inject
     private DataSource database;
 
+    @Inject
+    private PlayerCache playerCache;
+
     @Inject
     private CommonService service;
 
@@ -122,6 +126,10 @@ public void processJoin(Player player) {
 
         boolean isAuthAvailable = database.isAuthAvailable(name);
 
+        if (playerCache.isAuthenticated(name)) {
+            return;
+        }
+
         if (isAuthAvailable) {
             // Protect inventory
             if (service.getProperty(PROTECT_INVENTORY_BEFORE_LOGIN)) {
@@ -195,6 +203,9 @@ private void processJoinSync(Player player, boolean isAuthAvailable) {
         int registrationTimeout = service.getProperty(RestrictionSettings.TIMEOUT) * TICKS_PER_SECOND;
 
         bukkitService.scheduleSyncTaskFromOptionallyAsyncTask(() -> {
+            if (playerCache.isAuthenticated(player.getName())) {
+                return;
+            }
             limboService.createLimboPlayer(player, isAuthAvailable);
 
             player.setNoDamageTicks(registrationTimeout);