857 lines
32 KiB
Java
857 lines
32 KiB
Java
package fr.xephi.authme;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.OutputStream;
|
|
import java.net.URL;
|
|
import java.net.URLConnection;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
import java.util.logging.Logger;
|
|
import java.util.zip.GZIPInputStream;
|
|
|
|
import me.muizers.Notifications.Notifications;
|
|
import net.citizensnpcs.Citizens;
|
|
import net.milkbowl.vault.permission.Permission;
|
|
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Server;
|
|
import org.bukkit.World;
|
|
import org.bukkit.command.CommandSender;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.plugin.PluginManager;
|
|
import org.bukkit.plugin.RegisteredServiceProvider;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
|
|
import com.earth2me.essentials.Essentials;
|
|
import com.maxmind.geoip.LookupService;
|
|
import com.onarandombox.MultiverseCore.MultiverseCore;
|
|
|
|
import fr.xephi.authme.api.API;
|
|
import fr.xephi.authme.cache.auth.PlayerAuth;
|
|
import fr.xephi.authme.cache.auth.PlayerCache;
|
|
import fr.xephi.authme.cache.backup.FileCache;
|
|
import fr.xephi.authme.cache.limbo.LimboCache;
|
|
import fr.xephi.authme.cache.limbo.LimboPlayer;
|
|
import fr.xephi.authme.commands.AdminCommand;
|
|
import fr.xephi.authme.commands.CaptchaCommand;
|
|
import fr.xephi.authme.commands.ChangePasswordCommand;
|
|
import fr.xephi.authme.commands.ConverterCommand;
|
|
import fr.xephi.authme.commands.EmailCommand;
|
|
import fr.xephi.authme.commands.LoginCommand;
|
|
import fr.xephi.authme.commands.LogoutCommand;
|
|
import fr.xephi.authme.commands.PasspartuCommand;
|
|
import fr.xephi.authme.commands.RegisterCommand;
|
|
import fr.xephi.authme.commands.UnregisterCommand;
|
|
import fr.xephi.authme.datasource.CacheDataSource;
|
|
import fr.xephi.authme.datasource.DataSource;
|
|
import fr.xephi.authme.datasource.FlatFileThread;
|
|
import fr.xephi.authme.datasource.MySQLThread;
|
|
import fr.xephi.authme.datasource.SQLiteThread;
|
|
import fr.xephi.authme.listener.AuthMeBlockListener;
|
|
import fr.xephi.authme.listener.AuthMeChestShopListener;
|
|
import fr.xephi.authme.listener.AuthMeEntityListener;
|
|
import fr.xephi.authme.listener.AuthMePlayerListener;
|
|
import fr.xephi.authme.listener.AuthMeServerListener;
|
|
import fr.xephi.authme.listener.AuthMeSpoutListener;
|
|
import fr.xephi.authme.plugin.manager.BungeeCordMessage;
|
|
import fr.xephi.authme.plugin.manager.CitizensCommunicator;
|
|
import fr.xephi.authme.plugin.manager.CombatTagComunicator;
|
|
import fr.xephi.authme.plugin.manager.EssSpawn;
|
|
import fr.xephi.authme.process.Management;
|
|
import fr.xephi.authme.settings.Messages;
|
|
import fr.xephi.authme.settings.OtherAccounts;
|
|
import fr.xephi.authme.settings.PlayersLogs;
|
|
import fr.xephi.authme.settings.Settings;
|
|
import fr.xephi.authme.settings.Spawn;
|
|
|
|
public class AuthMe extends JavaPlugin {
|
|
|
|
public DataSource database = null;
|
|
private Settings settings;
|
|
private Messages m;
|
|
public PlayersLogs pllog;
|
|
public OtherAccounts otherAccounts;
|
|
public static Server server;
|
|
public static Logger authmeLogger = Logger.getLogger("AuthMe");
|
|
public static AuthMe authme;
|
|
public Permission permission;
|
|
private Utils utils = Utils.getInstance();
|
|
private JavaPlugin plugin;
|
|
private FileCache playerBackup = new FileCache();
|
|
public CitizensCommunicator citizens;
|
|
public SendMailSSL mail = null;
|
|
public int CitizensVersion = 0;
|
|
public int CombatTag = 0;
|
|
public double ChestShop = 0;
|
|
public boolean BungeeCord = false;
|
|
public Essentials ess;
|
|
public Notifications notifications;
|
|
public API api;
|
|
public Management management;
|
|
public HashMap<String, Integer> captcha = new HashMap<String, Integer>();
|
|
public HashMap<String, String> cap = new HashMap<String, String>();
|
|
public HashMap<String, String> realIp = new HashMap<String, String>();
|
|
public MultiverseCore multiverse = null;
|
|
public Location essentialsSpawn;
|
|
public Thread databaseThread = null;
|
|
public LookupService ls = null;
|
|
public boolean antibotMod = false;
|
|
public boolean delayedAntiBot = true;
|
|
protected static String vgUrl = "http://monitor-1.verygames.net/api/?action=ipclean-real-ip&out=raw&ip=%IP%&port=%PORT%";
|
|
public DataManager dataManager;
|
|
|
|
public Settings getSettings() {
|
|
return settings;
|
|
}
|
|
|
|
@Override
|
|
public void onEnable() {
|
|
authme = this;
|
|
|
|
authmeLogger.setParent(this.getLogger());
|
|
|
|
settings = new Settings(this);
|
|
settings.loadConfigOptions();
|
|
|
|
citizens = new CitizensCommunicator(this);
|
|
|
|
if (Settings.enableAntiBot) {
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(this, new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
delayedAntiBot = false;
|
|
}
|
|
}, 2400);
|
|
}
|
|
|
|
m = Messages.getInstance();
|
|
|
|
pllog = PlayersLogs.getInstance();
|
|
|
|
otherAccounts = OtherAccounts.getInstance();
|
|
|
|
server = getServer();
|
|
|
|
// Find Permissions
|
|
checkVault();
|
|
|
|
// Set Console Filter
|
|
if (Settings.removePassword) {
|
|
this.getLogger().setFilter(new ConsoleFilter());
|
|
Bukkit.getLogger().setFilter(new ConsoleFilter());
|
|
Logger.getLogger("Minecraft").setFilter(new ConsoleFilter());
|
|
authmeLogger.setFilter(new ConsoleFilter());
|
|
// Set Log4J Filter
|
|
try {
|
|
Class.forName("org.apache.logging.log4j.core.Filter");
|
|
setLog4JFilter();
|
|
} catch (ClassNotFoundException e) {
|
|
ConsoleLogger
|
|
.info("You're using Minecraft 1.6.x or older, Log4J support is disabled");
|
|
} catch (NoClassDefFoundError e) {
|
|
ConsoleLogger
|
|
.info("You're using Minecraft 1.6.x or older, Log4J support is disabled");
|
|
}
|
|
}
|
|
|
|
// Load MailApi
|
|
if (!Settings.getmailAccount.isEmpty()
|
|
&& !Settings.getmailPassword.isEmpty()) mail = new SendMailSSL(
|
|
this);
|
|
|
|
// Check Citizens Version
|
|
citizensVersion();
|
|
|
|
// Check Combat Tag Version
|
|
combatTag();
|
|
|
|
// Check Notifications
|
|
checkNotifications();
|
|
|
|
// Check Multiverse
|
|
checkMultiverse();
|
|
|
|
// Check ChestShop
|
|
checkChestShop();
|
|
|
|
// Check Essentials
|
|
checkEssentials();
|
|
|
|
/*
|
|
* Back style on start if avalaible
|
|
*/
|
|
if (Settings.isBackupActivated && Settings.isBackupOnStart) {
|
|
Boolean Backup = new PerformBackup(this).DoBackup();
|
|
if (Backup) ConsoleLogger.info("Backup Complete");
|
|
else ConsoleLogger.showError("Error while making Backup");
|
|
}
|
|
|
|
/*
|
|
* Backend MYSQL - FILE - SQLITE
|
|
*/
|
|
switch (Settings.getDataSource) {
|
|
case FILE:
|
|
FlatFileThread fileThread = new FlatFileThread();
|
|
fileThread.start();
|
|
database = fileThread;
|
|
databaseThread = fileThread;
|
|
final int a = database.getAccountsRegistered();
|
|
if (a >= 1000) {
|
|
ConsoleLogger.showError("YOUR USING FILE DATABASE WITH " + a + "+ ACCOUNTS, FOR BETTER PERFORMANCES, PLEASE USE MYSQL!!");
|
|
}
|
|
break;
|
|
case MYSQL:
|
|
MySQLThread sqlThread = new MySQLThread();
|
|
sqlThread.start();
|
|
database = sqlThread;
|
|
databaseThread = sqlThread;
|
|
break;
|
|
case SQLITE:
|
|
SQLiteThread sqliteThread = new SQLiteThread();
|
|
sqliteThread.start();
|
|
database = sqliteThread;
|
|
databaseThread = sqliteThread;
|
|
final int b = database.getAccountsRegistered();
|
|
if (b >= 2000) {
|
|
ConsoleLogger.showError("YOU'RE USING SQLITE DATABASE WITH " + b + "+ ACCOUNTS, FOR BETTER PERFORMANCES, PLEASE USE MYSQL!!");
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (Settings.isCachingEnabled) {
|
|
database = new CacheDataSource(this, database);
|
|
}
|
|
|
|
// Setup API
|
|
api = new API(this, database);
|
|
|
|
// Setup Management
|
|
management = new Management(database, this);
|
|
management.start();
|
|
|
|
PluginManager pm = getServer().getPluginManager();
|
|
if (Settings.bungee) {
|
|
Bukkit.getMessenger().registerOutgoingPluginChannel(this,
|
|
"BungeeCord");
|
|
Bukkit.getMessenger().registerIncomingPluginChannel(this,
|
|
"BungeeCord", new BungeeCordMessage(this));
|
|
}
|
|
if (pm.isPluginEnabled("Spout")) {
|
|
pm.registerEvents(new AuthMeSpoutListener(database), this);
|
|
ConsoleLogger.info("Successfully hook with Spout!");
|
|
}
|
|
pm.registerEvents(new AuthMePlayerListener(this, database), this);
|
|
pm.registerEvents(new AuthMeBlockListener(database, this), this);
|
|
pm.registerEvents(new AuthMeEntityListener(database, this), this);
|
|
pm.registerEvents(new AuthMeServerListener(this), this);
|
|
if (ChestShop != 0) {
|
|
pm.registerEvents(new AuthMeChestShopListener(database, this), this);
|
|
ConsoleLogger.info("Successfully hook with ChestShop!");
|
|
}
|
|
|
|
this.getCommand("authme").setExecutor(new AdminCommand(this, database));
|
|
this.getCommand("register").setExecutor(new RegisterCommand(this));
|
|
this.getCommand("login").setExecutor(new LoginCommand(this));
|
|
this.getCommand("changepassword").setExecutor(
|
|
new ChangePasswordCommand(database, this));
|
|
this.getCommand("logout")
|
|
.setExecutor(new LogoutCommand(this, database));
|
|
this.getCommand("unregister").setExecutor(
|
|
new UnregisterCommand(this, database));
|
|
this.getCommand("passpartu").setExecutor(new PasspartuCommand(this));
|
|
this.getCommand("email").setExecutor(new EmailCommand(this, database));
|
|
this.getCommand("captcha").setExecutor(new CaptchaCommand(this));
|
|
this.getCommand("converter").setExecutor(
|
|
new ConverterCommand(this, database));
|
|
|
|
if (!Settings.isForceSingleSessionEnabled) {
|
|
ConsoleLogger
|
|
.showError("ATTENTION by disabling ForceSingleSession, your server protection is set to low");
|
|
}
|
|
|
|
if (Settings.reloadSupport) try {
|
|
onReload();
|
|
if (server.getOnlinePlayers().length < 1) {
|
|
try {
|
|
database.purgeLogged();
|
|
} catch (NullPointerException npe) {
|
|
}
|
|
}
|
|
} catch (NullPointerException ex) {
|
|
}
|
|
|
|
if (Settings.usePurge) autoPurge();
|
|
|
|
// Download GeoIp.dat file
|
|
downloadGeoIp();
|
|
|
|
// Start Email recall task if needed
|
|
recallEmail();
|
|
|
|
dataManager = new DataManager(this, database);
|
|
dataManager.start();
|
|
|
|
ConsoleLogger.info("Authme " + this.getDescription().getVersion()
|
|
+ " enabled");
|
|
}
|
|
|
|
private void setLog4JFilter() {
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(this, new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
org.apache.logging.log4j.core.Logger coreLogger = (org.apache.logging.log4j.core.Logger) LogManager
|
|
.getRootLogger();
|
|
coreLogger.addFilter(new Log4JFilter());
|
|
}
|
|
});
|
|
}
|
|
|
|
public void checkVault() {
|
|
if (this.getServer().getPluginManager().getPlugin("Vault") != null
|
|
&& this.getServer().getPluginManager().getPlugin("Vault")
|
|
.isEnabled()) {
|
|
RegisteredServiceProvider<Permission> permissionProvider = getServer()
|
|
.getServicesManager().getRegistration(
|
|
net.milkbowl.vault.permission.Permission.class);
|
|
if (permissionProvider != null) {
|
|
permission = permissionProvider.getProvider();
|
|
ConsoleLogger.info("Vault plugin detected, hook with "
|
|
+ permission.getName() + " system");
|
|
} else {
|
|
ConsoleLogger
|
|
.showError("Vault plugin is detected but not the permissions plugin!");
|
|
}
|
|
} else {
|
|
permission = null;
|
|
}
|
|
}
|
|
|
|
public void checkChestShop() {
|
|
if (!Settings.chestshop) {
|
|
this.ChestShop = 0;
|
|
return;
|
|
}
|
|
if (this.getServer().getPluginManager().getPlugin("ChestShop") != null
|
|
&& this.getServer().getPluginManager().getPlugin("ChestShop")
|
|
.isEnabled()) {
|
|
try {
|
|
String ver = com.Acrobot.ChestShop.ChestShop.getVersion();
|
|
try {
|
|
double version = Double.valueOf(ver.split(" ")[0]);
|
|
if (version >= 3.50) {
|
|
this.ChestShop = version;
|
|
} else {
|
|
ConsoleLogger
|
|
.showError("Please Update your ChestShop version!");
|
|
}
|
|
} catch (NumberFormatException nfe) {
|
|
try {
|
|
double version = Double.valueOf(ver.split("t")[0]);
|
|
if (version >= 3.50) {
|
|
this.ChestShop = version;
|
|
} else {
|
|
ConsoleLogger
|
|
.showError("Please Update your ChestShop version!");
|
|
}
|
|
} catch (NumberFormatException nfee) {
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
}
|
|
} else {
|
|
this.ChestShop = 0;
|
|
}
|
|
}
|
|
|
|
public void checkMultiverse() {
|
|
if (!Settings.multiverse) {
|
|
multiverse = null;
|
|
return;
|
|
}
|
|
if (this.getServer().getPluginManager().getPlugin("Multiverse-Core") != null
|
|
&& this.getServer().getPluginManager()
|
|
.getPlugin("Multiverse-Core").isEnabled()) {
|
|
try {
|
|
multiverse = (MultiverseCore) this.getServer()
|
|
.getPluginManager().getPlugin("Multiverse-Core");
|
|
ConsoleLogger
|
|
.info("Hook with Multiverse-Core for SpawnLocations");
|
|
} catch (NullPointerException npe) {
|
|
multiverse = null;
|
|
} catch (ClassCastException cce) {
|
|
multiverse = null;
|
|
} catch (NoClassDefFoundError ncdfe) {
|
|
multiverse = null;
|
|
}
|
|
} else {
|
|
multiverse = null;
|
|
}
|
|
}
|
|
|
|
public void checkEssentials() {
|
|
if (this.getServer().getPluginManager().getPlugin("Essentials") != null
|
|
&& this.getServer().getPluginManager().getPlugin("Essentials")
|
|
.isEnabled()) {
|
|
try {
|
|
ess = (Essentials) this.getServer().getPluginManager()
|
|
.getPlugin("Essentials");
|
|
ConsoleLogger.info("Hook with Essentials plugin");
|
|
} catch (NullPointerException npe) {
|
|
ess = null;
|
|
} catch (ClassCastException cce) {
|
|
ess = null;
|
|
} catch (NoClassDefFoundError ncdfe) {
|
|
ess = null;
|
|
}
|
|
} else {
|
|
ess = null;
|
|
}
|
|
if (this.getServer().getPluginManager().getPlugin("EssentialsSpawn") != null
|
|
&& this.getServer().getPluginManager()
|
|
.getPlugin("EssentialsSpawn").isEnabled()) {
|
|
try {
|
|
essentialsSpawn = new EssSpawn().getLocation();
|
|
ConsoleLogger.info("Hook with EssentialsSpawn plugin");
|
|
} catch (Exception e) {
|
|
essentialsSpawn = null;
|
|
ConsoleLogger
|
|
.showError("Error while reading /plugins/Essentials/spawn.yml file ");
|
|
}
|
|
} else {
|
|
ess = null;
|
|
}
|
|
}
|
|
|
|
public void checkNotifications() {
|
|
if (!Settings.notifications) {
|
|
this.notifications = null;
|
|
return;
|
|
}
|
|
if (this.getServer().getPluginManager().getPlugin("Notifications") != null
|
|
&& this.getServer().getPluginManager()
|
|
.getPlugin("Notifications").isEnabled()) {
|
|
this.notifications = (Notifications) this.getServer()
|
|
.getPluginManager().getPlugin("Notifications");
|
|
ConsoleLogger.info("Successfully hook with Notifications");
|
|
} else {
|
|
this.notifications = null;
|
|
}
|
|
}
|
|
|
|
public void combatTag() {
|
|
if (this.getServer().getPluginManager().getPlugin("CombatTag") != null
|
|
&& this.getServer().getPluginManager().getPlugin("CombatTag")
|
|
.isEnabled()) {
|
|
this.CombatTag = 1;
|
|
} else {
|
|
this.CombatTag = 0;
|
|
}
|
|
}
|
|
|
|
public void citizensVersion() {
|
|
if (this.getServer().getPluginManager().getPlugin("Citizens") != null
|
|
&& this.getServer().getPluginManager().getPlugin("Citizens")
|
|
.isEnabled()) {
|
|
Citizens cit = (Citizens) this.getServer().getPluginManager()
|
|
.getPlugin("Citizens");
|
|
String ver = cit.getDescription().getVersion();
|
|
String[] args = ver.split("\\.");
|
|
if (args[0].contains("1")) {
|
|
this.CitizensVersion = 1;
|
|
} else {
|
|
this.CitizensVersion = 2;
|
|
}
|
|
} else {
|
|
this.CitizensVersion = 0;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDisable() {
|
|
if (Bukkit.getOnlinePlayers().length != 0) for (Player player : Bukkit
|
|
.getOnlinePlayers()) {
|
|
this.savePlayer(player);
|
|
}
|
|
|
|
if (database != null) {
|
|
database.close();
|
|
}
|
|
|
|
if (databaseThread != null) {
|
|
if (databaseThread.isAlive()) databaseThread.interrupt();
|
|
}
|
|
|
|
if (dataManager != null) {
|
|
if (dataManager.isAlive()) dataManager.interrupt();
|
|
}
|
|
|
|
if (Settings.isBackupActivated && Settings.isBackupOnStop) {
|
|
Boolean Backup = new PerformBackup(this).DoBackup();
|
|
if (Backup) ConsoleLogger.info("Backup Complete");
|
|
else ConsoleLogger.showError("Error while making Backup");
|
|
}
|
|
ConsoleLogger.info("Authme " + this.getDescription().getVersion()
|
|
+ " disabled");
|
|
}
|
|
|
|
private void onReload() {
|
|
try {
|
|
if (Bukkit.getServer().getOnlinePlayers() != null) {
|
|
for (Player player : Bukkit.getServer().getOnlinePlayers()) {
|
|
if (database.isLogged(player.getName().toLowerCase())) {
|
|
String name = player.getName().toLowerCase();
|
|
PlayerAuth pAuth = database.getAuth(name);
|
|
if (pAuth == null) break;
|
|
PlayerAuth auth = new PlayerAuth(name, pAuth.getHash(),
|
|
pAuth.getIp(), new Date().getTime(),
|
|
pAuth.getEmail(), player.getName());
|
|
database.updateSession(auth);
|
|
PlayerCache.getInstance().addPlayer(auth);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
} catch (NullPointerException ex) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
public static AuthMe getInstance() {
|
|
return authme;
|
|
}
|
|
|
|
public void savePlayer(Player player) throws IllegalStateException,
|
|
NullPointerException {
|
|
try {
|
|
if ((citizens.isNPC(player, this))
|
|
|| (Utils.getInstance().isUnrestricted(player))
|
|
|| (CombatTagComunicator.isNPC(player))) {
|
|
return;
|
|
}
|
|
} catch (Exception e) {
|
|
}
|
|
try {
|
|
String name = player.getName().toLowerCase();
|
|
if (PlayerCache.getInstance().isAuthenticated(name)
|
|
&& !player.isDead() && Settings.isSaveQuitLocationEnabled) {
|
|
final PlayerAuth auth = new PlayerAuth(player.getName()
|
|
.toLowerCase(), player.getLocation().getX(), player
|
|
.getLocation().getY(), player.getLocation().getZ(),
|
|
player.getWorld().getName());
|
|
database.updateQuitLoc(auth);
|
|
}
|
|
if (LimboCache.getInstance().hasLimboPlayer(name)) {
|
|
LimboPlayer limbo = LimboCache.getInstance().getLimboPlayer(
|
|
name);
|
|
if (Settings.protectInventoryBeforeLogInEnabled.booleanValue()) {
|
|
player.getInventory().setArmorContents(limbo.getArmour());
|
|
player.getInventory().setContents(limbo.getInventory());
|
|
}
|
|
if (!Settings.noTeleport) player.teleport(limbo.getLoc());
|
|
this.utils.addNormal(player, limbo.getGroup());
|
|
player.setOp(limbo.getOperator());
|
|
this.plugin.getServer().getScheduler()
|
|
.cancelTask(limbo.getTimeoutTaskId());
|
|
LimboCache.getInstance().deleteLimboPlayer(name);
|
|
if (this.playerBackup.doesCacheExist(player)) {
|
|
this.playerBackup.removeCache(player);
|
|
}
|
|
}
|
|
PlayerCache.getInstance().removePlayer(name);
|
|
database.setUnlogged(name);
|
|
player.saveData();
|
|
} catch (Exception ex) {
|
|
}
|
|
}
|
|
|
|
public CitizensCommunicator getCitizensCommunicator() {
|
|
return citizens;
|
|
}
|
|
|
|
public void setMessages(Messages m) {
|
|
this.m = m;
|
|
}
|
|
|
|
public Messages getMessages() {
|
|
return m;
|
|
}
|
|
|
|
public Player generateKickPlayer(Player[] players) {
|
|
Player player = null;
|
|
int i;
|
|
for (i = 0; i <= players.length; i++) {
|
|
Random rdm = new Random();
|
|
int a = rdm.nextInt(players.length);
|
|
if (!(authmePermissible(players[a], "authme.vip"))) {
|
|
player = players[a];
|
|
break;
|
|
}
|
|
}
|
|
if (player == null) {
|
|
for (Player p : players) {
|
|
if (!(authmePermissible(p, "authme.vip"))) {
|
|
player = p;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return player;
|
|
}
|
|
|
|
public boolean authmePermissible(Player player, String perm) {
|
|
if (player.hasPermission(perm)) return true;
|
|
else if (permission != null) {
|
|
return permission.playerHas(player, perm);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean authmePermissible(CommandSender sender, String perm) {
|
|
if (sender.hasPermission(perm)) return true;
|
|
else if (permission != null) {
|
|
return permission.has(sender, perm);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void autoPurge() {
|
|
if (!Settings.usePurge) {
|
|
return;
|
|
}
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.add(Calendar.DATE, -(Settings.purgeDelay));
|
|
long until = calendar.getTimeInMillis();
|
|
List<String> cleared = this.database.autoPurgeDatabase(until);
|
|
ConsoleLogger.info("AutoPurgeDatabase : " + cleared.size()
|
|
+ " accounts removed.");
|
|
if (cleared.isEmpty()) return;
|
|
if (Settings.purgeEssentialsFile && this.ess != null) dataManager
|
|
.purgeEssentials(cleared);
|
|
if (Settings.purgePlayerDat) dataManager.purgeDat(cleared);
|
|
if (Settings.purgeLimitedCreative) dataManager
|
|
.purgeLimitedCreative(cleared);
|
|
if (Settings.purgeAntiXray) dataManager.purgeAntiXray(cleared);
|
|
}
|
|
|
|
public Location getSpawnLocation(Player player) {
|
|
World world = player.getWorld();
|
|
String[] spawnPriority = Settings.spawnPriority.split(",");
|
|
if (spawnPriority.length < 4) {
|
|
ConsoleLogger
|
|
.showError("Check your config for spawnPriority, you need to put all of 4 spawn priorities");
|
|
ConsoleLogger.showError("Defaulting Spawn to world's one");
|
|
return world.getSpawnLocation();
|
|
}
|
|
Location spawnLoc = world.getSpawnLocation();
|
|
int i = 3;
|
|
for (i = 3; i >= 0; i--) {
|
|
String s = spawnPriority[i];
|
|
if (s.equalsIgnoreCase("default") && getDefaultSpawn(world) != null) spawnLoc = getDefaultSpawn(world);
|
|
if (s.equalsIgnoreCase("multiverse")
|
|
&& getMultiverseSpawn(world) != null) spawnLoc = getMultiverseSpawn(world);
|
|
if (s.equalsIgnoreCase("essentials")
|
|
&& getEssentialsSpawn() != null) spawnLoc = getEssentialsSpawn();
|
|
if (s.equalsIgnoreCase("authme") && getAuthMeSpawn(player) != null) spawnLoc = getAuthMeSpawn(player);
|
|
}
|
|
if (spawnLoc == null) spawnLoc = world.getSpawnLocation();
|
|
return spawnLoc;
|
|
}
|
|
|
|
private Location getDefaultSpawn(World world) {
|
|
return world.getSpawnLocation();
|
|
}
|
|
|
|
private Location getMultiverseSpawn(World world) {
|
|
if (multiverse != null && Settings.multiverse) {
|
|
try {
|
|
return multiverse.getMVWorldManager().getMVWorld(world)
|
|
.getSpawnLocation();
|
|
} catch (NullPointerException npe) {
|
|
} catch (ClassCastException cce) {
|
|
} catch (NoClassDefFoundError ncdfe) {
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private Location getEssentialsSpawn() {
|
|
if (essentialsSpawn != null) return essentialsSpawn;
|
|
return null;
|
|
}
|
|
|
|
private Location getAuthMeSpawn(Player player) {
|
|
if ((!database.isAuthAvailable(player.getName().toLowerCase()) || !player
|
|
.hasPlayedBefore())
|
|
&& (Spawn.getInstance().getFirstSpawn() != null)) return Spawn
|
|
.getInstance().getFirstSpawn();
|
|
if (Spawn.getInstance().getSpawn() != null) return Spawn.getInstance()
|
|
.getSpawn();
|
|
return null;
|
|
}
|
|
|
|
public void downloadGeoIp() {
|
|
ConsoleLogger
|
|
.info("LICENSE : This product includes GeoLite data created by MaxMind, available from http://www.maxmind.com");
|
|
File file = new File(getDataFolder(), "GeoIP.dat");
|
|
if (!file.exists()) {
|
|
try {
|
|
String url = "http://geolite.maxmind.com/download/geoip/database/GeoLiteCountry/GeoIP.dat.gz";
|
|
URL downloadUrl = new URL(url);
|
|
URLConnection conn = downloadUrl.openConnection();
|
|
conn.setConnectTimeout(10000);
|
|
conn.connect();
|
|
InputStream input = conn.getInputStream();
|
|
if (url.endsWith(".gz")) input = new GZIPInputStream(input);
|
|
OutputStream output = new FileOutputStream(file);
|
|
byte[] buffer = new byte[2048];
|
|
int length = input.read(buffer);
|
|
while (length >= 0) {
|
|
output.write(buffer, 0, length);
|
|
length = input.read(buffer);
|
|
}
|
|
output.close();
|
|
input.close();
|
|
} catch (Exception e) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public String getCountryCode(String ip) {
|
|
try {
|
|
if (ls == null) ls = new LookupService(new File(getDataFolder(),
|
|
"GeoIP.dat"));
|
|
String code = ls.getCountry(ip).getCode();
|
|
if (code != null && !code.isEmpty()) return code;
|
|
} catch (Exception e) {
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getCountryName(String ip) {
|
|
try {
|
|
if (ls == null) ls = new LookupService(new File(getDataFolder(),
|
|
"GeoIP.dat"));
|
|
String code = ls.getCountry(ip).getName();
|
|
if (code != null && !code.isEmpty()) return code;
|
|
} catch (Exception e) {
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void switchAntiBotMod(boolean mode) {
|
|
this.antibotMod = mode;
|
|
Settings.switchAntiBotMod(mode);
|
|
}
|
|
|
|
private void recallEmail() {
|
|
if (!Settings.recallEmail) return;
|
|
Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
for (Player player : Bukkit.getOnlinePlayers()) {
|
|
if (player.isOnline()) {
|
|
String name = player.getName().toLowerCase();
|
|
if (database.isAuthAvailable(name)) if (PlayerCache
|
|
.getInstance().isAuthenticated(name)) {
|
|
String email = database.getAuth(name).getEmail();
|
|
if (email == null || email.isEmpty()
|
|
|| email.equalsIgnoreCase("your@email.com")) m
|
|
._(player, "add_email");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}, 1, 1200 * Settings.delayRecall);
|
|
}
|
|
|
|
public String replaceAllInfos(String message, Player player) {
|
|
try {
|
|
message = message.replace("&", "\u00a7");
|
|
message = message.replace("{PLAYER}", player.getName());
|
|
message = message.replace("{ONLINE}", ""
|
|
+ this.getServer().getOnlinePlayers().length);
|
|
message = message.replace("{MAXPLAYERS}", ""
|
|
+ this.getServer().getMaxPlayers());
|
|
message = message.replace("{IP}", getIP(player));
|
|
message = message.replace("{LOGINS}", ""
|
|
+ PlayerCache.getInstance().getLogged());
|
|
message = message.replace("{WORLD}", player.getWorld().getName());
|
|
message = message.replace("{SERVER}", this.getServer()
|
|
.getServerName());
|
|
message = message.replace("{VERSION}", this.getServer()
|
|
.getBukkitVersion());
|
|
message = message.replace("{COUNTRY}",
|
|
this.getCountryName(getIP(player)));
|
|
} catch (Exception e) {
|
|
}
|
|
return message;
|
|
}
|
|
|
|
public String getIP(Player player) {
|
|
String name = player.getName().toLowerCase();
|
|
String ip = player.getAddress().getAddress().getHostAddress();
|
|
if (Settings.bungee) {
|
|
if (realIp.containsKey(name)) ip = realIp.get(name);
|
|
}
|
|
if (Settings.checkVeryGames) if (getVeryGamesIP(player) != null) ip = getVeryGamesIP(player);
|
|
return ip;
|
|
}
|
|
|
|
public boolean isLoggedIp(String name, String ip) {
|
|
int count = 0;
|
|
for (Player player : this.getServer().getOnlinePlayers()) {
|
|
if (ip.equalsIgnoreCase(getIP(player))
|
|
&& database.isLogged(player.getName().toLowerCase())
|
|
&& !player.getName().equalsIgnoreCase(name)) count++;
|
|
}
|
|
if (count >= Settings.getMaxLoginPerIp) return true;
|
|
return false;
|
|
}
|
|
|
|
public boolean hasJoinedIp(String name, String ip) {
|
|
int count = 0;
|
|
for (Player player : this.getServer().getOnlinePlayers()) {
|
|
if (ip.equalsIgnoreCase(getIP(player))
|
|
&& !player.getName().equalsIgnoreCase(name)) count++;
|
|
}
|
|
if (count >= Settings.getMaxJoinPerIp) return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get Player real IP through VeryGames method
|
|
*
|
|
* @param Player
|
|
* player
|
|
*/
|
|
public String getVeryGamesIP(Player player) {
|
|
String realIP = null;
|
|
String sUrl = vgUrl;
|
|
sUrl = sUrl.replace("%IP%",
|
|
player.getAddress().getAddress().getHostAddress()).replace(
|
|
"%PORT%", "" + player.getAddress().getPort());
|
|
try {
|
|
URL url = new URL(sUrl);
|
|
URLConnection urlc = url.openConnection();
|
|
BufferedReader in = new BufferedReader(new InputStreamReader(
|
|
urlc.getInputStream()));
|
|
String inputLine = in.readLine();
|
|
if (inputLine != null && !inputLine.isEmpty()
|
|
&& !inputLine.equalsIgnoreCase("error")) {
|
|
realIP = inputLine;
|
|
}
|
|
} catch (Exception e) {
|
|
}
|
|
return realIP;
|
|
}
|
|
}
|