public void process() {
    preLogout();
    if (!canLogout) return;
    final Player p = player;
    BukkitScheduler sched = p.getServer().getScheduler();
    PlayerAuth auth = PlayerCache.getInstance().getAuth(name);
    database.updateSession(auth);
    auth.setQuitLocX(p.getLocation().getX());
    auth.setQuitLocY(p.getLocation().getY());
    auth.setQuitLocZ(p.getLocation().getZ());
    auth.setWorld(p.getWorld().getName());
    database.updateQuitLoc(auth);

    PlayerCache.getInstance().removePlayer(name);
    database.setUnlogged(name);
    sched.scheduleSyncDelayedTask(
        plugin,
        new Runnable() {
          @Override
          public void run() {
            Utils.teleportToSpawn(p);
          }
        });
    if (LimboCache.getInstance().hasLimboPlayer(name))
      LimboCache.getInstance().deleteLimboPlayer(name);
    LimboCache.getInstance().addLimboPlayer(player);
    Utils.setGroup(player, GroupType.NOTLOGGEDIN);

    sched.scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerLogout(p, plugin));
  }
  public void process() {
    preLogout();
    if (!canLogout) return;
    final Player p = player;
    BukkitScheduler sched = p.getServer().getScheduler();
    PlayerAuth auth = PlayerCache.getInstance().getAuth(name);
    database.updateSession(auth);
    auth.setQuitLocX(p.getLocation().getX());
    auth.setQuitLocY(p.getLocation().getY());
    auth.setQuitLocZ(p.getLocation().getZ());
    auth.setWorld(p.getWorld().getName());
    database.updateQuitLoc(auth);

    PlayerCache.getInstance().removePlayer(name);
    database.setUnlogged(name);
    if (Settings.isTeleportToSpawnEnabled && !Settings.noTeleport) {
      Location spawnLoc = plugin.getSpawnLocation(p);
      final AuthMeTeleportEvent tpEvent = new AuthMeTeleportEvent(p, spawnLoc);
      sched.scheduleSyncDelayedTask(
          plugin,
          new Runnable() {

            @Override
            public void run() {
              plugin.getServer().getPluginManager().callEvent(tpEvent);
              if (!tpEvent.isCancelled()) {
                if (tpEvent.getTo() != null) p.teleport(tpEvent.getTo());
              }
            }
          });
    }

    if (LimboCache.getInstance().hasLimboPlayer(name))
      LimboCache.getInstance().deleteLimboPlayer(name);
    LimboCache.getInstance().addLimboPlayer(player);
    utils.setGroup(player, GroupType.NOTLOGGEDIN);
    if (Settings.protectInventoryBeforeLogInEnabled) {
      player.getInventory().clear();
      // create cache file for handling lost of inventories on unlogged in
      // status
      DataFileCache playerData =
          new DataFileCache(
              LimboCache.getInstance().getLimboPlayer(name).getInventory(),
              LimboCache.getInstance().getLimboPlayer(name).getArmour());
      playerBackup.createCache(player, playerData);
    }
    sched.scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerLogout(p, plugin));
  }
  private void passwordRegister() throws Exception {
    final String hashNew = PasswordSecurity.getHash(Settings.getPasswordHash, password, name);
    final String salt = PasswordSecurity.userSalt.get(name);
    PlayerAuth auth =
        PlayerAuth.builder()
            .name(name)
            .realName(player.getName())
            .hash(hashNew)
            .ip(ip)
            .locWorld(player.getLocation().getWorld().getName())
            .locX(player.getLocation().getX())
            .locY(player.getLocation().getY())
            .locZ(player.getLocation().getZ())
            .salt(salt != null ? salt : "")
            .build();

    if (!database.saveAuth(auth)) {
      m.send(player, MessageKey.ERROR);
      return;
    }
    if (!Settings.forceRegLogin) {
      PlayerCache.getInstance().addPlayer(auth);
      database.setLogged(name);
    }
    plugin.otherAccounts.addPlayer(player.getUniqueId());
    ProcessSyncronousPasswordRegister sync = new ProcessSyncronousPasswordRegister(player, plugin);
    plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, sync);
  }
 private boolean preRegisterCheck() throws Exception {
   String passLow = password.toLowerCase();
   if (PlayerCache.getInstance().isAuthenticated(name)) {
     m.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
     return false;
   } else if (!Settings.isRegistrationEnabled) {
     m.send(player, MessageKey.REGISTRATION_DISABLED);
     return false;
   } else if (passLow.contains("delete")
       || passLow.contains("where")
       || passLow.contains("insert")
       || passLow.contains("modify")
       || passLow.contains("from")
       || passLow.contains("select")
       || passLow.contains(";")
       || passLow.contains("null")
       || !passLow.matches(Settings.getPassRegex)) {
     m.send(player, MessageKey.PASSWORD_MATCH_ERROR);
     return false;
   } else if (passLow.equalsIgnoreCase(player.getName())) {
     m.send(player, MessageKey.PASSWORD_IS_USERNAME_ERROR);
     return false;
   } else if (password.length() < Settings.getPasswordMinLen
       || password.length() > Settings.passwordMaxLength) {
     m.send(player, MessageKey.INVALID_PASSWORD_LENGTH);
     return false;
   } else if (!Settings.unsafePasswords.isEmpty()
       && Settings.unsafePasswords.contains(password.toLowerCase())) {
     m.send(player, MessageKey.PASSWORD_UNSAFE_ERROR);
     return false;
   } else if (database.isAuthAvailable(name)) {
     m.send(player, MessageKey.NAME_ALREADY_REGISTERED);
     return false;
   } else if (Settings.getmaxRegPerIp > 0
       && !plugin
           .getPermissionsManager()
           .hasPermission(player, PlayerPermission.ALLOW_MULTIPLE_ACCOUNTS)
       && !ip.equalsIgnoreCase("127.0.0.1")
       && !ip.equalsIgnoreCase("localhost")
       && database.getAllAuthsByIp(ip).size() >= Settings.getmaxRegPerIp) {
     m.send(player, MessageKey.MAX_REGISTER_EXCEEDED);
     return false;
   }
   return true;
 }
  @Override
  public void runCommand(Player player, List<String> arguments) {
    String oldPassword = arguments.get(0);
    String newPassword = arguments.get(1);

    String name = player.getName().toLowerCase();
    if (!playerCache.isAuthenticated(name)) {
      commandService.send(player, MessageKey.NOT_LOGGED_IN);
      return;
    }

    // Make sure the password is allowed
    ValidationResult passwordValidation = validationService.validatePassword(newPassword, name);
    if (passwordValidation.hasError()) {
      commandService.send(player, passwordValidation.getMessageKey(), passwordValidation.getArgs());
      return;
    }

    // TODO ljacqu 20160117: Call async task via Management
    management.performPasswordChange(player, oldPassword, newPassword);
  }
 @Override
 public List<PlayerAuth> getLoggedPlayers() {
   return new ArrayList<>(PlayerCache.getInstance().getCache().values());
 }
 @Override
 public boolean isLogged(String user) {
   return PlayerCache.getInstance().isAuthenticated(user);
 }
 private void preLogout() {
   if (!PlayerCache.getInstance().isAuthenticated(name)) {
     m.send(player, "not_logged_in");
     canLogout = false;
   }
 }
 @Override
 public boolean isLogged(String user) {
   user = user.toLowerCase();
   return PlayerCache.getInstance().getCache().containsKey(user);
 }
  /**
   * Execute the command.
   *
   * @param sender The command sender.
   * @param commandReference The command reference.
   * @param commandArguments The command arguments.
   * @return True if the command was executed successfully, false otherwise.
   */
  @Override
  public boolean executeCommand(
      CommandSender sender, CommandParts commandReference, CommandParts commandArguments) {
    // AuthMe plugin instance
    final AuthMe plugin = AuthMe.getInstance();

    // Messages instance
    final Messages m = Messages.getInstance();

    // Get the parameter values
    String playerMail = commandArguments.get(0);

    // Make sure the current command executor is a player
    if (!(sender instanceof Player)) {
      return true;
    }

    // Get the player instance and name
    final Player player = (Player) sender;
    final String playerName = player.getName();

    // Command logic
    if (plugin.mail == null) {
      m.send(player, "error");
      return true;
    }
    if (plugin.database.isAuthAvailable(playerName)) {
      if (PlayerCache.getInstance().isAuthenticated(playerName)) {
        m.send(player, "logged_in");
        return true;
      }
      try {
        RandomString rand = new RandomString(Settings.getRecoveryPassLength);
        String thePass = rand.nextString();
        String hashNew = PasswordSecurity.getHash(Settings.getPasswordHash, thePass, playerName);
        PlayerAuth auth;
        if (PlayerCache.getInstance().isAuthenticated(playerName)) {
          auth = PlayerCache.getInstance().getAuth(playerName);
        } else if (plugin.database.isAuthAvailable(playerName)) {
          auth = plugin.database.getAuth(playerName);
        } else {
          m.send(player, "unknown_user");
          return true;
        }
        if (Settings.getmailAccount.equals("") || Settings.getmailAccount.isEmpty()) {
          m.send(player, "error");
          return true;
        }

        if (!playerMail.equalsIgnoreCase(auth.getEmail())
            || playerMail.equalsIgnoreCase("*****@*****.**")
            || auth.getEmail().equalsIgnoreCase("*****@*****.**")) {
          m.send(player, "email_invalid");
          return true;
        }
        auth.setHash(hashNew);
        plugin.database.updatePassword(auth);
        plugin.mail.main(auth, thePass);
        m.send(player, "email_send");
      } catch (NoSuchAlgorithmException | NoClassDefFoundError ex) {
        ex.printStackTrace();
        ConsoleLogger.showError(ex.getMessage());
        m.send(sender, "error");
      }
    } else {
      m.send(player, "reg_email_msg");
    }

    return true;
  }
  public void process() {
    if (AuthMePlayerListener.gameMode.containsKey(name)) AuthMePlayerListener.gameMode.remove(name);
    AuthMePlayerListener.gameMode.putIfAbsent(name, player.getGameMode());
    BukkitScheduler sched = plugin.getServer().getScheduler();

    if (Utils.isNPC(player) || Utils.isUnrestricted(player)) {
      return;
    }

    if (plugin.ess != null && Settings.disableSocialSpy) {
      plugin.ess.getUser(player).setSocialSpyEnabled(false);
    }

    if (!plugin.canConnect()) {
      final GameMode gM = AuthMePlayerListener.gameMode.get(name);
      sched.scheduleSyncDelayedTask(
          plugin,
          new Runnable() {

            @Override
            public void run() {
              AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
              player.setGameMode(gM);
              player.kickPlayer("Server is loading, please wait before joining!");
            }
          });
      return;
    }

    final String ip = plugin.getIP(player);
    if (Settings.isAllowRestrictedIp && !Settings.getRestrictedIp(name, ip)) {
      final GameMode gM = AuthMePlayerListener.gameMode.get(name);
      sched.scheduleSyncDelayedTask(
          plugin,
          new Runnable() {

            @Override
            public void run() {
              AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
              player.setGameMode(gM);
              player.kickPlayer("You are not the Owner of this account, please try another name!");
              if (Settings.banUnsafeIp) plugin.getServer().banIP(ip);
            }
          });
      return;
    }
    if (Settings.getMaxJoinPerIp > 0
        && !plugin.authmePermissible(player, "authme.allow2accounts")
        && !ip.equalsIgnoreCase("127.0.0.1")
        && !ip.equalsIgnoreCase("localhost")) {
      if (plugin.hasJoinedIp(player.getName(), ip)) {
        sched.scheduleSyncDelayedTask(
            plugin,
            new Runnable() {

              @Override
              public void run() {
                player.kickPlayer("A player with the same IP is already in game!");
              }
            });
        return;
      }
    }
    final Location spawnLoc = plugin.getSpawnLocation(player);
    final boolean isAuthAvailable = database.isAuthAvailable(name);
    if (isAuthAvailable) {
      if (Settings.isForceSurvivalModeEnabled && !Settings.forceOnlyAfterLogin) {
        sched.scheduleSyncDelayedTask(
            plugin,
            new Runnable() {

              @Override
              public void run() {
                AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
                Utils.forceGM(player);
              }
            });
      }
      if (!Settings.noTeleport)
        if (Settings.isTeleportToSpawnEnabled
            || (Settings.isForceSpawnLocOnJoinEnabled
                && Settings.getForcedWorlds.contains(player.getWorld().getName()))) {
          sched.scheduleSyncDelayedTask(
              plugin,
              new Runnable() {

                @Override
                public void run() {
                  SpawnTeleportEvent tpEvent =
                      new SpawnTeleportEvent(
                          player,
                          player.getLocation(),
                          spawnLoc,
                          PlayerCache.getInstance().isAuthenticated(name));
                  plugin.getServer().getPluginManager().callEvent(tpEvent);
                  if (!tpEvent.isCancelled()) {
                    if (player.isOnline() && tpEvent.getTo() != null) {
                      if (tpEvent.getTo().getWorld() != null) player.teleport(tpEvent.getTo());
                    }
                  }
                }
              });
        }
      placePlayerSafely(player, spawnLoc);
      LimboCache.getInstance().updateLimboPlayer(player);
      // protect inventory
      if (Settings.protectInventoryBeforeLogInEnabled && plugin.inventoryProtector != null) {
        ProtectInventoryEvent ev = new ProtectInventoryEvent(player);
        plugin.getServer().getPluginManager().callEvent(ev);
        if (ev.isCancelled()) {
          plugin.inventoryProtector.sendInventoryPacket(player);
          if (!Settings.noConsoleSpam)
            ConsoleLogger.info(
                "ProtectInventoryEvent has been cancelled for " + player.getName() + " ...");
        }
      }
    } else {
      if (Settings.isForceSurvivalModeEnabled && !Settings.forceOnlyAfterLogin) {
        sched.scheduleSyncDelayedTask(
            plugin,
            new Runnable() {

              @Override
              public void run() {
                AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
                Utils.forceGM(player);
              }
            });
      }
      if (!Settings.unRegisteredGroup.isEmpty()) {
        Utils.setGroup(player, Utils.GroupType.UNREGISTERED);
      }
      if (!Settings.isForcedRegistrationEnabled) {
        return;
      }
      if (!Settings.noTeleport)
        if (!needFirstspawn() && Settings.isTeleportToSpawnEnabled
            || (Settings.isForceSpawnLocOnJoinEnabled
                && Settings.getForcedWorlds.contains(player.getWorld().getName()))) {
          sched.scheduleSyncDelayedTask(
              plugin,
              new Runnable() {

                @Override
                public void run() {
                  SpawnTeleportEvent tpEvent =
                      new SpawnTeleportEvent(
                          player,
                          player.getLocation(),
                          spawnLoc,
                          PlayerCache.getInstance().isAuthenticated(name));
                  plugin.getServer().getPluginManager().callEvent(tpEvent);
                  if (!tpEvent.isCancelled()) {
                    if (player.isOnline() && tpEvent.getTo() != null) {
                      if (tpEvent.getTo().getWorld() != null) player.teleport(tpEvent.getTo());
                    }
                  }
                }
              });
        }
    }
    String[] msg;
    if (Settings.emailRegistration) {
      msg = isAuthAvailable ? m.send("login_msg") : m.send("reg_email_msg");
    } else {
      msg = isAuthAvailable ? m.send("login_msg") : m.send("reg_msg");
    }
    int time = Settings.getRegistrationTimeout * 20;
    int msgInterval = Settings.getWarnMessageInterval;
    if (time != 0) {
      BukkitTask id =
          sched.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, name, player), time);
      if (!LimboCache.getInstance().hasLimboPlayer(name))
        LimboCache.getInstance().addLimboPlayer(player);
      LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id);
    }
    if (!LimboCache.getInstance().hasLimboPlayer(name))
      LimboCache.getInstance().addLimboPlayer(player);
    if (isAuthAvailable) {
      Utils.setGroup(player, GroupType.NOTLOGGEDIN);
    } else {
      Utils.setGroup(player, GroupType.UNREGISTERED);
    }
    sched.scheduleSyncDelayedTask(
        plugin,
        new Runnable() {

          @Override
          public void run() {
            if (player.isOp()) player.setOp(false);
            if (player.getGameMode() != GameMode.CREATIVE && !Settings.isMovementAllowed) {
              player.setAllowFlight(true);
              player.setFlying(true);
            }
            player.setNoDamageTicks(Settings.getRegistrationTimeout * 20);
            if (Settings.useEssentialsMotd) player.performCommand("motd");
            if (Settings.applyBlindEffect)
              player.addPotionEffect(
                  new PotionEffect(
                      PotionEffectType.BLINDNESS, Settings.getRegistrationTimeout * 20, 2));
            if (!Settings.isMovementAllowed && Settings.isRemoveSpeedEnabled) {
              player.setWalkSpeed(0.0f);
              player.setFlySpeed(0.0f);
            }
          }
        });
    if (Settings.isSessionsEnabled
        && isAuthAvailable
        && (PlayerCache.getInstance().isAuthenticated(name) || database.isLogged(name))) {
      if (plugin.sessions.containsKey(name)) plugin.sessions.get(name).cancel();
      plugin.sessions.remove(name);
      PlayerAuth auth = database.getAuth(name);
      if (auth != null && auth.getIp().equals(ip)) {
        m.send(player, "valid_session");
        PlayerCache.getInstance().removePlayer(name);
        database.setUnlogged(name);
        plugin.management.performLogin(player, "dontneed", true);
      } else if (Settings.sessionExpireOnIpChange) {
        PlayerCache.getInstance().removePlayer(name);
        database.setUnlogged(name);
        m.send(player, "invalid_session");
      }
      return;
    }
    BukkitTask msgT =
        sched.runTaskAsynchronously(plugin, new MessageTask(plugin, name, msg, msgInterval));
    LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT);
  }
 private Player initPlayerWithName(String name, boolean loggedIn) {
   Player player = mock(Player.class);
   when(player.getName()).thenReturn(name);
   when(cacheMock.isAuthenticated(name)).thenReturn(loggedIn);
   return player;
 }