2.1 prerelease, part 2 of 3

git-svn-id: https://svn.java.net/svn/essentials~svn/trunk2.1@1015 e251c2fe-e539-e718-e476-b85c1f46cddb

15 files changed, 1978 insertions, 0 deletions

diff --git a/EssentialsProtect/src/README.TXT b/EssentialsProtect/src/README.TXT
new file mode 100644
index 000000000..4bb1b5c05
--- /dev/null
+++ b/EssentialsProtect/src/README.TXT
@@ -0,0 +1,30 @@
+EssentialsProtect:

+

+REQUIRED : Essentials.jar. Also sqlite.jar, mysql.jar in the bukkit lib folder.

+

+Config Settings in plugins/Essentials/config.yml

+

+protect:

+  datatype: 'sqlite' type of db, options sqlite or mysql

+  username: 'root'  mysql username

+  pasword: 'root' mysql password

+  mysqlDb: 'jdbc:mysql://localhost:3306/minecraft'  mysql database location

+  protectSigns: true

+  protectRails: true

+  protectBlockBelow: true

+  preventBlockOnRail: false prevents block placement on protected rails

+

+On startup creates a sqlite database under /plugins/essentials called EssentialsProtect.db

+

+Permissions:

+

+"essentials.protect" - allows protection

+"essentials.protect.admin" can delete protected blocks / query protection by right clicking a protected item.

+

+Usage:

+

+Place a sign or rail and they (plus optionally the block below) will be protected. Only the owners and those with admin permissions can destroy.

+

+

+

+

diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtect.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtect.java
new file mode 100644
index 000000000..d6869519b
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtect.java
@@ -0,0 +1,154 @@
+package com.earth2me.essentials.protect;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.IConf;
+import com.earth2me.essentials.User;
+import com.earth2me.essentials.protect.data.IProtectedBlock;
+import com.earth2me.essentials.protect.data.ProtectedBlockMemory;
+import com.earth2me.essentials.protect.data.ProtectedBlockMySQL;
+import com.earth2me.essentials.protect.data.ProtectedBlockSQLite;
+import java.beans.PropertyVetoException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event.Priority;
+import org.bukkit.event.Event.Type;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+
+public class EssentialsProtect extends JavaPlugin implements IConf
+{
+	private EssentialsProtectBlockListener blockListener = null;
+	private EssentialsProtectPlayerListener playerListener = null;
+	private EssentialsProtectEntityListener entityListener = null;
+	public static final String AUTHORS = Essentials.AUTHORS;
+	private static final Logger logger = Logger.getLogger("Minecraft");
+	public static HashMap<String, Boolean> genSettings = null;
+	public static HashMap<String, String> dataSettings = null;
+	public static HashMap<String, Boolean> guardSettings = null;
+	public static HashMap<String, Boolean> playerSettings = null;
+	public static ArrayList usageList = null;
+	public static ArrayList blackListPlace = null;
+	public static ArrayList breakBlackList = null;
+	public static ArrayList onPlaceAlert = null;
+	public static ArrayList onUseAlert = null;
+	public static ArrayList onBreakAlert = null;
+
+	private IProtectedBlock storage = null;
+	private static EssentialsProtect instance = null;
+
+	public EssentialsProtect()
+	{
+	}
+
+	public void onEnable()
+	{
+		PluginManager pm = this.getServer().getPluginManager();
+		Essentials ess = (Essentials)pm.getPlugin("Essentials");
+		if (!ess.isEnabled()) {
+			pm.enablePlugin(ess);
+		}
+
+		instance = this;
+		reloadConfig();
+
+		playerListener = new EssentialsProtectPlayerListener(this);
+		blockListener = new EssentialsProtectBlockListener(this);
+		entityListener = new EssentialsProtectEntityListener(this);
+		pm.registerEvent(Type.PLAYER_PICKUP_ITEM, playerListener, Priority.Low, this);
+		pm.registerEvent(Type.PLAYER_INTERACT, playerListener, Priority.Low, this);
+		pm.registerEvent(Type.BLOCK_PLACE, blockListener, Priority.Highest, this);
+		pm.registerEvent(Type.BLOCK_FROMTO, blockListener, Priority.Highest, this);
+		pm.registerEvent(Type.BLOCK_IGNITE, blockListener, Priority.Highest, this);
+		pm.registerEvent(Type.BLOCK_BURN, blockListener, Priority.Highest, this);
+		pm.registerEvent(Type.ENTITY_EXPLODE, entityListener, Priority.Highest, this);
+		pm.registerEvent(Type.ENTITY_DAMAGE, entityListener, Priority.Highest, this);
+		pm.registerEvent(Type.BLOCK_BREAK, blockListener, Priority.Highest, this);
+		pm.registerEvent(Type.CREATURE_SPAWN, entityListener, Priority.Highest, this);
+
+		if (!this.getDescription().getVersion().equals(Essentials.getStatic().getDescription().getVersion())) {
+			logger.log(Level.WARNING, "Version mismatch! Please update all Essentials jars to the same version.");
+		}
+		logger.info("Loaded " + this.getDescription().getName() + " build " + this.getDescription().getVersion() + " maintained by " + AUTHORS);
+	}
+
+	public static boolean checkProtectionItems(ArrayList itemList, int id)
+	{
+		return !itemList.isEmpty() && itemList.contains(String.valueOf(id));
+	}
+
+	@Override
+	public void onDisable()
+	{
+		genSettings.clear();
+		dataSettings.clear();
+		
+		blockListener = null;
+		playerListener = null;
+		entityListener = null;
+		genSettings = null;
+		dataSettings = null;
+		guardSettings = null;
+		playerSettings = null;
+		usageList = null;
+		blackListPlace = null;
+		onPlaceAlert = null;
+		onUseAlert = null;
+		onBreakAlert = null;
+	}
+
+	public void alert(User user, String item, String type)
+	{
+		Location loc = user.getLocation();
+		for (Player p : this.getServer().getOnlinePlayers())
+		{
+			User alertUser = User.get(p);
+			if (alertUser.isAuthorized("essentials.protect.alerts"))
+				alertUser.sendMessage(ChatColor.DARK_AQUA + "[" + user.getName() + "] " + ChatColor.WHITE + type + ChatColor.GOLD + item + " at: " + formatCoords(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+		}
+	}
+	
+	public static String formatCoords(int x, int y, int z)
+	{
+		return x + "," + y + "," + z;
+	}
+
+	public void reloadConfig() {
+		dataSettings = Essentials.getSettings().getEpDBSettings();
+		genSettings = Essentials.getSettings().getEpSettings();
+		guardSettings = Essentials.getSettings().getEpGuardSettings();
+		usageList = Essentials.getSettings().epBlackListUsage();
+		blackListPlace = Essentials.getSettings().epBlackListPlacement();
+		breakBlackList = Essentials.getSettings().epBlockBreakingBlacklist();
+		onPlaceAlert = Essentials.getSettings().getEpAlertOnPlacement();
+		onUseAlert = Essentials.getSettings().getEpAlertOnUse();
+		onBreakAlert = Essentials.getSettings().getEpAlertOnBreak();
+		playerSettings = Essentials.getSettings().getEpPlayerSettings();
+		
+		if (dataSettings.get("protect.datatype").equals("mysql")) {
+			try {
+				storage = new ProtectedBlockMySQL(dataSettings.get("protect.mysqlDb"), dataSettings.get("protect.username"), dataSettings.get("protect.password"));
+			} catch (PropertyVetoException ex) {
+				logger.log(Level.SEVERE, null, ex);
+			}
+		} else {
+			try {
+				storage = new ProtectedBlockSQLite("jdbc:sqlite:plugins/Essentials/EssentialsProtect.db");
+			} catch (PropertyVetoException ex) {
+				logger.log(Level.SEVERE, null, ex);
+			}
+		}
+		if (genSettings.get("protect.memstore")) {
+			storage = new ProtectedBlockMemory(storage);
+		}
+	}
+	
+	public static IProtectedBlock getStorage() {
+		return EssentialsProtect.instance.storage;
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectBlockListener.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectBlockListener.java
new file mode 100644
index 000000000..2028edf42
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectBlockListener.java
@@ -0,0 +1,272 @@
+package com.earth2me.essentials.protect;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.User;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockListener;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.inventory.ItemStack;
+
+
+public class EssentialsProtectBlockListener extends BlockListener
+{
+	private EssentialsProtect parent;
+
+	public EssentialsProtectBlockListener(EssentialsProtect parent)
+	{
+		Essentials.loadClasses();
+		this.parent = parent;
+	}
+
+	@Override
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		if (event.isCancelled()) return;
+		ItemStack item = event.getItemInHand();
+		User user = User.get(event.getPlayer());
+
+		if (EssentialsProtect.playerSettings.get("protect.disable.build") && !user.canBuild())
+		{
+			event.setCancelled(true);
+			return;
+		}
+
+		int id = event.getBlockPlaced().getTypeId();
+
+		if (EssentialsProtect.checkProtectionItems(EssentialsProtect.blackListPlace, id) && !user.isAuthorized("essentials.protect.exemptplacement"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+
+		if (!EssentialsProtect.onPlaceAlert.isEmpty() && EssentialsProtect.onPlaceAlert.contains(String.valueOf(item.getTypeId())))
+		{
+			parent.alert(user, item.getType().toString(), "placed: ");
+		}
+
+		Block blockPlaced = event.getBlockPlaced();
+		Block below = blockPlaced.getFace(BlockFace.DOWN);
+		if (below.getType() == Material.RAILS) {
+			if (EssentialsProtect.genSettings.get("protect.protect.prevent.block-on-rail"))
+			{
+				if (EssentialsProtect.getStorage().isProtected(below, user.getName())) {
+					event.setCancelled(true);
+					return;
+				}
+			}
+		}
+
+		List<Block> protect = new ArrayList<Block>();
+		if (blockPlaced.getType() == Material.RAILS) {
+			if (EssentialsProtect.genSettings.get("protect.protect.rails"))
+			{
+				if (user.isAuthorized("essentials.protect"))
+				{
+					protect.add(blockPlaced);
+					if (EssentialsProtect.genSettings.get("protect.protect.block-below"))
+					{
+						protect.add(blockPlaced.getFace(BlockFace.DOWN));
+					}
+				}
+			}
+		}
+		if (blockPlaced.getType() == Material.SIGN_POST || blockPlaced.getType() == Material.WALL_SIGN) {
+			if (EssentialsProtect.genSettings.get("protect.protect.signs"))
+			{
+				if (user.isAuthorized("essentials.protect"))
+				{
+					protect.add(blockPlaced);
+					if (EssentialsProtect.genSettings.get("protect.protect.block-below"))
+					{
+						protect.add(event.getBlockAgainst());
+					}
+				}
+			}
+		}
+		for (Block block : protect) {
+			EssentialsProtect.getStorage().protectBlock(block, user.getName());
+		}
+	}
+
+	@Override
+	public void onBlockIgnite(BlockIgniteEvent event)
+	{
+		Block block = event.getBlock();
+		if (block.getType() == Material.RAILS && EssentialsProtect.genSettings.get("protect.protect.rails"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if ((block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST) && EssentialsProtect.genSettings.get("protect.protect.signs"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if ((event.getCause().equals(BlockIgniteEvent.IgniteCause.SPREAD)))
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.fire-spread"));
+			return;
+		}
+
+		if (event.getCause().equals(BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL))
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.flint-fire"));
+			return;
+		}
+
+		if (event.getCause().equals(BlockIgniteEvent.IgniteCause.LAVA))
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.lava-fire-spread"));
+			return;
+		}
+	}
+
+	@Override
+	public void onBlockFromTo(BlockFromToEvent event)
+	{
+		if (event.isCancelled()) return;
+		Block block = event.getBlock();
+		Block toBlock = event.getToBlock();
+		if (toBlock.getType() == Material.RAILS && EssentialsProtect.genSettings.get("protect.protect.rails"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if ((toBlock.getType() == Material.WALL_SIGN || toBlock.getType() == Material.SIGN_POST) && EssentialsProtect.genSettings.get("protect.protect.signs"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if (block.getType() == Material.WATER || block.getType() == Material.STATIONARY_WATER)
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.water-flow"));
+			return;
+		}
+
+		if (block.getType() == Material.LAVA || block.getType() == Material.STATIONARY_LAVA)
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.lava-flow"));
+			return;
+		}
+
+		if (block.getType() == Material.AIR)
+		{
+			event.setCancelled(EssentialsProtect.guardSettings.get("protect.prevent.water-bucket-flow"));
+			return;
+		}
+	}
+
+	@Override
+	public void onBlockBurn(BlockBurnEvent event)
+	{
+		Block block = event.getBlock();
+		if (block.getType() == Material.RAILS && EssentialsProtect.genSettings.get("protect.protect.rails"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if ((block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST) && EssentialsProtect.genSettings.get("protect.protect.signs"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+		if (EssentialsProtect.guardSettings.get("protect.prevent.fire-spread"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+	}
+
+	@Override
+	public void onBlockBreak(BlockBreakEvent event)
+	{
+		if (event.isCancelled()) return;
+		User user = User.get(event.getPlayer());
+		Block block = event.getBlock();
+		if (EssentialsProtect.playerSettings.get("protect.disable.build") && !user.canBuild())
+		{
+			event.setCancelled(true);
+			return;
+		}
+
+		if(EssentialsProtect.breakBlackList.contains(String.valueOf(block.getTypeId())) && !user.isAuthorized("essentials.protect.exemptbreak"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+
+		if (!EssentialsProtect.onBreakAlert.isEmpty() && EssentialsProtect.onBreakAlert.contains(String.valueOf(block.getTypeId())))
+		{
+			parent.alert(user, block.getType().toString(), "broke: ");
+		}
+
+		if (user.isAuthorized("essentials.protect.admin"))
+		{
+			if (block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST || block.getType() == Material.RAILS)
+			{
+				EssentialsProtect.getStorage().unprotectBlock(block);
+				if (block.getType() == Material.RAILS || block.getType() == Material.SIGN_POST) {
+					Block below = block.getFace(BlockFace.DOWN);
+					EssentialsProtect.getStorage().unprotectBlock(below);
+				} else {
+					BlockFace[] faces = new BlockFace[] {
+						BlockFace.NORTH,
+						BlockFace.EAST,
+						BlockFace.SOUTH,
+						BlockFace.WEST
+					};
+					for (BlockFace blockFace : faces) {
+						Block against = block.getFace(blockFace);
+						EssentialsProtect.getStorage().unprotectBlock(against);
+					}
+				}
+			}
+			else
+			{
+				EssentialsProtect.getStorage().unprotectBlock(block);
+			}
+			return;
+		}
+		else
+		{
+
+			boolean isProtected = EssentialsProtect.getStorage().isProtected(block, user.getName());
+			if (!isProtected) {
+				if (block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST || block.getType() == Material.RAILS)
+				{		
+					EssentialsProtect.getStorage().unprotectBlock(block);
+					if (block.getType() == Material.RAILS || block.getType() == Material.SIGN_POST) {
+						Block below = block.getFace(BlockFace.DOWN);
+						EssentialsProtect.getStorage().unprotectBlock(below);
+					} else {
+						BlockFace[] faces = new BlockFace[] {
+							BlockFace.NORTH,
+							BlockFace.EAST,
+							BlockFace.SOUTH,
+							BlockFace.WEST
+						};
+						for (BlockFace blockFace : faces) {
+							Block against = block.getFace(blockFace);
+							EssentialsProtect.getStorage().unprotectBlock(against);
+						}
+					}
+				}
+				else
+				{
+					EssentialsProtect.getStorage().unprotectBlock(block);
+				}
+			}
+			event.setCancelled(true);
+			return;
+		}
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectData.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectData.java
new file mode 100644
index 000000000..76b36d810
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectData.java
@@ -0,0 +1,533 @@
+package com.earth2me.essentials.protect;
+
+import com.earth2me.essentials.Essentials;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.block.Block;
+
+
+public class EssentialsProtectData
+{
+	private static final Logger logger = Logger.getLogger("Minecraft");
+	private static final String mysqlDriver = "com.mysql.jdbc.Driver";
+	private static String mysqlUsername;
+	private static String mysqlPassword;
+	private static String mysqlDatabase;
+	private static String dataType;
+	private static final String sqlite = "jdbc:sqlite:plugins/Essentials/EssentialsProtect.db";
+	private static final String mysqlTable;
+	private static final String sqliteTable;
+	private static final String insertQuery;
+	private static final String countByLocationQuery;
+	private static final String countByPlayerLocationQuery;
+	private static final String playerByLocationQuery;
+	private static final String deleteByLocationQuery;
+
+	static
+	{
+		mysqlTable = EssentialsProtectSqlProperties.EssentialsProtect;
+		sqliteTable = EssentialsProtectSqlProperties.EssentialsProtect_sqlite;
+		insertQuery = EssentialsProtectSqlProperties.Insert;
+		countByLocationQuery = EssentialsProtectSqlProperties.CountByLocation;
+		countByPlayerLocationQuery = EssentialsProtectSqlProperties.CountByPLayerLocation;
+		playerByLocationQuery = EssentialsProtectSqlProperties.PlayerByLocation;
+		deleteByLocationQuery = EssentialsProtectSqlProperties.DeleteByLocation;
+		mysqlUsername = EssentialsProtect.dataSettings.get("protect.username");
+		mysqlPassword = EssentialsProtect.dataSettings.get("protect.password");
+		mysqlDatabase = EssentialsProtect.dataSettings.get("protect.mysqlDb");
+		dataType = EssentialsProtect.dataSettings.get("protect.datatype");
+	}
+
+	public EssentialsProtectData()
+	{
+	}
+
+	public static String formatCoords(int x, int y, int z)
+	{
+		return x + "," + y + "," + z;
+	}
+
+	public void insertProtectionIntoDb(String worldname, String playerName, int x, int y, int z)
+	{
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		try
+		{
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+			ps = conn.prepareStatement(insertQuery);
+			ps.setString(1, worldname);
+			ps.setString(2, playerName);
+			ps.setInt(3, x);
+			ps.setInt(4, y);
+			ps.setInt(5, z);
+			ps.executeUpdate();
+
+		}
+		catch (SQLException ex)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unable to add protection into SQL", ex);
+		}
+		catch (ClassNotFoundException e)
+		{
+			// TODO Auto-generated catch block
+			logger.log(Level.SEVERE, "[EssentialsProtect] Class not found", e);
+		}
+		finally
+		{
+			try
+			{
+				if (ps != null)
+				{
+					ps.close();
+				}
+				if (rs != null)
+				{
+					rs.close();
+				}
+				if (conn != null)
+				{
+					conn.close();
+				}
+			}
+			catch (SQLException ex)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtect] Could not close connection to SQL", ex);
+			}
+		}
+	}
+
+	public boolean canDestroy(String worldName, String playerName, Block block)
+	{
+		int x = block.getX();
+		int y = block.getY();
+		int z = block.getZ();
+
+		int rowCount = 0;
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		try
+		{
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+			conn.setAutoCommit(false);
+			ps = conn.prepareStatement(countByLocationQuery);
+			ps.setString(1, worldName);
+			ps.setInt(2, x);
+			ps.setInt(3, y);
+			ps.setInt(4, z);
+			rs = ps.executeQuery();
+			rs.next();
+			rowCount = rs.getInt(1);
+			rs.close();
+			ps.close();
+
+			if (rowCount == 0)
+			{
+				return true;
+			}
+			else
+			{
+				ps = conn.prepareStatement(countByPlayerLocationQuery);
+				ps.setString(1, worldName);
+				ps.setString(2, playerName);
+				ps.setInt(3, x);
+				ps.setInt(4, y);
+				ps.setInt(5, z);
+				rs = ps.executeQuery();
+				rs.next();
+				rowCount = rs.getInt(1);
+
+				if (rowCount == 0)
+				{
+					return false;
+				}
+
+			}
+
+		}
+		catch (SQLException ex)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unable to query Protection", ex);
+		}
+		catch (Throwable e)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unable to query Protection", e);
+		}
+		finally
+		{
+			try
+			{
+				if (ps != null)
+				{
+					ps.close();
+				}
+				if (rs != null)
+				{
+					rs.close();
+				}
+				if (conn != null)
+				{
+					conn.close();
+				}
+			}
+			catch (SQLException ex)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtection] Could not close connection to SQL", ex);
+			}
+		}
+		return true;
+	}
+
+	@SuppressWarnings("CallToThreadDumpStack")
+	public static void createSqlTable()
+	{
+		Connection conn = null;
+		Statement st = null;
+
+		try
+		{
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+
+			st = conn.createStatement();
+			st.executeUpdate(dataType.contentEquals("mysql") ? mysqlTable : sqliteTable);
+		}
+		catch (SQLException s)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Could not create table for " + dataType, s);
+
+		}
+		catch (ClassNotFoundException ex)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Could not find driver for " + dataType, ex);
+
+		}
+		catch (Throwable e)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unexpected error occured whilst creating table ", e);
+		}
+		finally
+		{
+			try
+			{
+				if (conn != null && !conn.isClosed())
+				{
+					try
+					{
+						conn.close();
+					}
+					catch (SQLException e)
+					{
+						logger.log(Level.SEVERE, "[EssentialsProtect] Unexpected error occured whilst closing the connection", e);
+					}
+				}
+			}
+			catch (SQLException e)
+			{
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+	}
+
+	public String getBlockOwner(String worldName, String playerName, Block block)
+	{
+		String returnPlayerName = null;
+		int x = block.getX();
+		int y = block.getY();
+		int z = block.getZ();
+
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		try
+		{
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+			conn.setAutoCommit(false);
+			ps = conn.prepareStatement(playerByLocationQuery);
+
+			ps.setString(1, worldName);
+			ps.setInt(2, x);
+			ps.setInt(3, y);
+			ps.setInt(4, z);
+			rs = ps.executeQuery();
+			while (rs.next())
+			{
+				returnPlayerName = rs.getString("playerName");
+			}
+			rs.close();
+			ps.close();
+
+		}
+		catch (SQLException ex)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unable to query EssentialsProtection", ex);
+		}
+		catch (Throwable e)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Unable to query EssentialsProtection", e);
+		}
+		finally
+		{
+			try
+			{
+				if (ps != null)
+				{
+					ps.close();
+				}
+				if (rs != null)
+				{
+					rs.close();
+				}
+				if (conn != null)
+				{
+					conn.close();
+				}
+			}
+			catch (SQLException ex)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtection] Could not close connection to SQL", ex);
+			}
+
+		}
+		return returnPlayerName;
+	}
+
+	
+	public void removeProtectionFromDB(Block block)
+	{
+		try
+		{
+			Connection conn = null;
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername,
+												   mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+			PreparedStatement ps = null;
+			try
+			{
+				ps = conn.prepareStatement(deleteByLocationQuery);
+				ps.setString(1, block.getWorld().getName());
+				ps.setInt(2, block.getX());
+				ps.setInt(3, block.getY());
+				ps.setInt(4, block.getZ());
+				ps.executeUpdate();
+
+			}
+			catch (SQLException ex)
+			{
+				logger.log(Level.WARNING,
+						   "[EssentialsProtect] Could not delete block data from database",
+						   ex);
+			}
+			finally
+			{
+				if (conn != null && !conn.isClosed())
+				{
+					conn.close();
+				}
+				if (ps != null)
+				{
+					ps.close();
+				}
+			}
+
+		}
+		catch (Throwable e)
+		{
+			logger.log(Level.SEVERE, " [EssentialsProtect] Exception occured whilst trying to delete data from sql", e);
+		}
+
+	}
+
+	public void removeProtectionFromDB(Block block, boolean removeBelow)
+	{
+		try
+		{
+			Connection conn = null;
+			if (dataType.contentEquals("mysql"))
+			{
+				Class.forName(mysqlDriver);
+				conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+			}
+			else
+			{
+				Class.forName("org.sqlite.JDBC");
+				conn = DriverManager.getConnection(sqlite);
+			}
+			PreparedStatement ps = null;
+			try
+			{
+				ps = conn.prepareStatement(deleteByLocationQuery);
+				ps.setString(1, block.getWorld().getName());
+				ps.setInt(2, block.getX());
+				ps.setInt(3, block.getY());
+				ps.setInt(4, block.getZ());
+				ps.executeUpdate();
+				if (removeBelow)
+				{
+					ps = conn.prepareStatement(deleteByLocationQuery);
+					ps.setString(1, block.getWorld().getName());
+					ps.setInt(2, block.getX());
+					ps.setInt(3, block.getY() - 1);
+					ps.setInt(4, block.getZ());
+					ps.executeUpdate();
+				}
+
+			}
+			catch (SQLException ex)
+			{
+				logger.log(Level.WARNING, "[EssentialsProtect] Could not delete block data from database", ex);
+			}
+			finally
+			{
+				if (conn != null && !conn.isClosed())
+				{
+					conn.close();
+				}
+				if (ps != null)
+				{
+					ps.close();
+				}
+			}
+
+		}
+		catch (Throwable e)
+		{
+			logger.log(Level.SEVERE, "[EssentialsProtect] Exception occured whilst trying to delete data from sql", e);
+		}
+
+	}
+
+	public boolean isBlockAboveProtectedRail(Block block)
+	{
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		if (block.getTypeId() == 66)
+		{
+			try
+			{
+				if (dataType.contentEquals("mysql"))
+				{
+					Class.forName(mysqlDriver);
+					conn = DriverManager.getConnection(mysqlDatabase, mysqlUsername, mysqlPassword);
+				}
+				else
+				{
+					Class.forName("org.sqlite.JDBC");
+					conn = DriverManager.getConnection(sqlite);
+				}
+				int rowCount = 0;
+				conn.setAutoCommit(false);
+				ps = conn.prepareStatement(countByLocationQuery);
+				ps.setString(1, block.getWorld().getName());
+				ps.setInt(2, block.getX());
+				ps.setInt(3, block.getY());
+				ps.setInt(4, block.getZ());
+				rs = ps.executeQuery();
+				rs.next();
+				rowCount = rs.getInt(1);
+				rs.close();
+				ps.close();
+
+				if (rowCount == 0)
+				{
+
+					return false;
+				}
+				else
+				{
+					return true;
+				}
+			}
+			catch (SQLException s)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtect] Could not query protection", s);
+
+			}
+			catch (ClassNotFoundException ex)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtect] Could not find driver for " + dataType, ex);
+
+			}
+			catch (Throwable e)
+			{
+				logger.log(Level.SEVERE, "[EssentialsProtect] Unexpected error occured whilst creating table", e);
+			}
+			finally
+			{
+				try
+				{
+					if (conn != null && !conn.isClosed())
+					{
+						try
+						{
+							conn.close();
+						}
+						catch (SQLException e)
+						{
+							logger.log(Level.SEVERE, "[EssentialsProtect] Unexpected error occured whilst closing the connection", e);
+						}
+
+					}
+				}
+				catch (SQLException e)
+				{
+					// TODO Auto-generated catch block
+					e.printStackTrace();
+				}
+			}
+		}
+		return false;
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectEntityListener.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectEntityListener.java
new file mode 100644
index 000000000..97b5c59e5
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectEntityListener.java
@@ -0,0 +1,197 @@
+package com.earth2me.essentials.protect;

+

+import com.earth2me.essentials.Essentials;

+import com.earth2me.essentials.User;

+import java.util.ArrayList;

+import java.util.HashSet;

+import java.util.List;

+import net.minecraft.server.ChunkPosition;

+import net.minecraft.server.Packet60Explosion;

+import org.bukkit.Location;

+import org.bukkit.block.Block;

+import org.bukkit.craftbukkit.CraftServer;

+import org.bukkit.entity.Creeper;

+import org.bukkit.entity.Entity;

+import org.bukkit.entity.LivingEntity;

+import org.bukkit.entity.Monster;

+import org.bukkit.entity.Player;

+import org.bukkit.event.entity.CreatureSpawnEvent;

+import org.bukkit.event.entity.EntityDamageByBlockEvent;

+import org.bukkit.event.entity.EntityDamageByEntityEvent;

+import org.bukkit.event.entity.EntityDamageByProjectileEvent;

+import org.bukkit.event.entity.EntityDamageEvent;

+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;

+import org.bukkit.event.entity.EntityExplodeEvent;

+import org.bukkit.event.entity.EntityListener;

+

+

+public class EssentialsProtectEntityListener extends EntityListener

+{

+	private EssentialsProtect parent;

+

+	public EssentialsProtectEntityListener(EssentialsProtect parent)

+	{

+		Essentials.loadClasses();

+		this.parent = parent;

+	}

+

+	@Override

+	public void onEntityDamage(EntityDamageEvent event)

+	{

+		if (event.isCancelled()) return;

+		if (event instanceof EntityDamageByBlockEvent)

+		{

+			DamageCause cause = event.getCause();

+

+			if (EssentialsProtect.playerSettings.get("protect.disable.contactdmg") && cause == DamageCause.CONTACT)

+			{

+				event.setCancelled(true);

+				return;

+			}

+			if (EssentialsProtect.playerSettings.get("protect.disable.lavadmg") && cause == DamageCause.LAVA)

+			{

+				event.setCancelled(true);

+				return;

+			}

+			if (EssentialsProtect.guardSettings.get("protect.prevent.tnt-explosion") && cause == DamageCause.BLOCK_EXPLOSION)

+			{

+				event.setCancelled(true);

+				return;

+			}

+		}

+

+		if (event instanceof EntityDamageByEntityEvent)

+		{

+			EntityDamageByEntityEvent edEvent = (EntityDamageByEntityEvent)event;

+			Entity eAttack = edEvent.getDamager();

+			Entity eDefend = edEvent.getEntity();

+

+			// PVP Settings

+			if (eDefend instanceof Player && eAttack instanceof Player)

+			{

+				if (EssentialsProtect.playerSettings.get("protect.disable.pvp"))

+				{

+					User defender = User.get(eDefend);

+					User attacker = User.get(eAttack);

+

+					if (!defender.isAuthorized("essentials.protect.pvp") || !attacker.isAuthorized("essentials.protect.pvp"))

+					{

+						event.setCancelled(true);

+						return;

+					}

+				}

+			}

+			//Creeper explode prevention

+			if (eAttack != null && eAttack instanceof Monster)

+			{

+				if (eAttack instanceof Creeper && EssentialsProtect.guardSettings.get("protect.prevent.creeper-explosion"))

+				{

+					event.setCancelled(true);

+					return;

+				}

+				

+				if (eAttack instanceof Creeper && EssentialsProtect.guardSettings.get("protect.prevent.creeper-playerdamage"))

+				{

+					event.setCancelled(true);

+					return;

+				}

+			}

+		}

+

+		if (event instanceof EntityDamageByProjectileEvent)

+		{

+			if (event.getEntity() instanceof Player)

+			{

+				event.setCancelled(EssentialsProtect.playerSettings.get("protect.disable.projectiles"));

+				return;

+			}

+		}

+

+		DamageCause cause = event.getCause();

+		Entity casualty = event.getEntity();

+		if (casualty instanceof Player)

+		{

+			if (EssentialsProtect.playerSettings.get("protect.disable.fall") && cause == DamageCause.FALL)

+			{

+				event.setCancelled(true);

+				return;

+			}

+

+			if (EssentialsProtect.playerSettings.get("protect.disable.suffocate") && cause == DamageCause.SUFFOCATION)

+			{

+				event.setCancelled(true);

+				return;

+			}

+			if (EssentialsProtect.playerSettings.get("protect.disable.firedmg") && (cause == DamageCause.FIRE

+																					|| cause == DamageCause.FIRE_TICK))

+			{

+				event.setCancelled(true);

+				return;

+			}

+			if (EssentialsProtect.playerSettings.get("protect.disable.drown") && cause == DamageCause.DROWNING)

+			{

+				event.setCancelled(true);

+				return;

+			}

+		}

+	}

+

+	@Override

+	public void onEntityExplode(EntityExplodeEvent event)

+	{

+		if (event.isCancelled()) return;

+		if (event.getEntity() instanceof LivingEntity)

+		{

+			//Nicccccccccce plaaacccccccccce..

+			int maxHeight = Essentials.getSettings().getEpCreeperMaxHeight();

+			if (	EssentialsProtect.guardSettings.get("protect.prevent.creeper-explosion") ||

+				EssentialsProtect.guardSettings.get("protect.prevent.creeper-blockdamage") || 

+				(maxHeight >= 0 && event.getLocation().getBlockY() > maxHeight))

+			{

+				HashSet<ChunkPosition> set = new HashSet<ChunkPosition>(event.blockList().size());

+				Player[] players = parent.getServer().getOnlinePlayers();

+				List<ChunkPosition> blocksUnderPlayers = new ArrayList<ChunkPosition>(players.length);

+				Location loc = event.getLocation();

+				for (Player player : players) {

+					if (player.getWorld().equals(loc.getWorld())) {

+						blocksUnderPlayers.add(

+							new ChunkPosition(

+								player.getLocation().getBlockX(),

+								player.getLocation().getBlockY() - 1,

+								player.getLocation().getBlockZ()));

+					}

+				}

+				for (Block block : event.blockList()) {

+					ChunkPosition cp = new ChunkPosition(block.getX(), block.getY(), block.getZ());

+					if (!blocksUnderPlayers.contains(cp)) {

+						set.add(cp);

+					}

+				}

+				

+				((CraftServer)parent.getServer()).getServer().f.a(loc.getX(), loc.getY(), loc.getZ(), 64.0D, 

+					new Packet60Explosion(loc.getX(), loc.getY(), loc.getZ(), 3.0f, set));

+				event.setCancelled(true);

+				return;

+			}

+		}

+		else

+		{ //OH NOES TNT

+			if (EssentialsProtect.guardSettings.get("protect.prevent.tnt-explosion"))

+			{

+				event.setCancelled(true);

+				return;

+			}

+		}

+	}

+

+	@Override

+	public void onCreatureSpawn(CreatureSpawnEvent event) {

+		String creatureName = event.getCreatureType().toString().toLowerCase();

+		if (creatureName == null || creatureName.isEmpty()) {

+			return;

+		}

+		if (EssentialsProtect.guardSettings.get("protect.prevent.spawn."+creatureName)) {

+			event.setCancelled(true);

+		}

+	}

+}

diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectPlayerListener.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectPlayerListener.java
new file mode 100644
index 000000000..2497a733d
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectPlayerListener.java
@@ -0,0 +1,70 @@
+package com.earth2me.essentials.protect;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.User;
+import org.bukkit.ChatColor;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerListener;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+import org.bukkit.inventory.ItemStack;
+
+
+public class EssentialsProtectPlayerListener extends PlayerListener
+{
+	private EssentialsProtect parent;
+	
+	public EssentialsProtectPlayerListener(EssentialsProtect parent)
+	{
+		Essentials.loadClasses();
+		this.parent = parent;
+	}
+
+	@Override
+	public void onPlayerInteract(PlayerInteractEvent event)
+	{
+		if (event.isCancelled()) return;
+		User user = User.get(event.getPlayer());
+
+		if (EssentialsProtect.playerSettings.get("protect.disable.build") && !user.canBuild())
+		{
+			event.setCancelled(true);
+			return;
+		}
+		
+		if (user.isAuthorized("essentials.protect.admin"))
+		{
+			StringBuilder sb = new StringBuilder();
+			boolean first = true;
+			for (String owner : EssentialsProtect.getStorage().getOwners(event.getClickedBlock())) {
+				if (!first) {
+					sb.append(", ");
+				}
+				first = false;
+				sb.append(owner);
+			}
+			String ownerNames = sb.toString();
+			if (ownerNames != null)
+			{
+				user.sendMessage(ChatColor.GOLD + "[EssentialsProtect] Protection owners: " + ownerNames);
+			}
+		}
+	}
+
+	@Override
+	public void onPlayerPickupItem(PlayerPickupItemEvent event)
+	{
+		if(event.isCancelled()) return;
+		ItemStack item = event.getItem().getItemStack();
+		User user = User.get(event.getPlayer());
+		if (EssentialsProtect.checkProtectionItems(EssentialsProtect.usageList, item.getTypeId()) && !user.isAuthorized("essentials.protect.exemptusage"))
+		{
+			event.setCancelled(true);
+			return;
+		}
+
+		if (EssentialsProtect.onUseAlert.contains(String.valueOf(item.getTypeId())))
+		{
+			parent.alert(user, item.getType().toString(), "used: ");
+		}
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectRegions.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectRegions.java
new file mode 100644
index 000000000..6a640f3e1
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectRegions.java
@@ -0,0 +1,5 @@
+package com.earth2me.essentials.protect;
+
+public class EssentialsProtectRegions {
+
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectSqlProperties.java b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectSqlProperties.java
new file mode 100644
index 000000000..30b2a7032
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectSqlProperties.java
@@ -0,0 +1,12 @@
+package com.earth2me.essentials.protect;
+
+public class EssentialsProtectSqlProperties {
+
+	public static String EssentialsProtect="CREATE TABLE IF NOT EXISTS `EssentialsProtect` (`id` int(11) NOT NULL AUTO_INCREMENT, `worldName` varchar(150) NOT NULL, `playerName` varchar(150) NOT NULL, `x` int(11) NOT NULL, `y` int(11) NOT NULL, `z` int(11) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=205 DEFAULT CHARSET=latin1";
+	public static String EssentialsProtect_sqlite = "CREATE TABLE IF NOT EXISTS EssentialsProtect (id INTEGER PRIMARY KEY, worldName TEXT ,playerName TEXT, x NUMERIC, y NUMERIC, z NUMERIC)";
+    public static String CountByLocation="SELECT COUNT(*) from EssentialsProtect where worldName = ? and x = ? and y = ? and z = ? limit 10";
+	public static String CountByPLayerLocation="SELECT COUNT(*) from EssentialsProtect where worldName = ? and playerName =? and  x = ? and y = ? and z = ? limit 10";
+	public static String DeleteByLocation="DELETE FROM EssentialsProtect WHERE worldName=? and x=? and y=? and z=?";
+	public static String Insert="INSERT INTO EssentialsProtect (worldName, playerName, x, y, z) VALUES (?,?,?,?,?)";
+	public static String PlayerByLocation="SELECT playerName FROM EssentialsProtect WHERE worldname = ? and x = ? and y = ? and z = ? LIMIT 10";
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/IProtectedBlock.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/IProtectedBlock.java
new file mode 100644
index 000000000..28b7e425b
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/IProtectedBlock.java
@@ -0,0 +1,15 @@
+package com.earth2me.essentials.protect.data;
+
+import java.util.List;
+import java.util.Set;
+import org.bukkit.block.Block;
+
+public interface  IProtectedBlock {
+	public void clearProtections();
+	public void importProtections(List<OwnedBlock> blocks);
+	public List<OwnedBlock> exportProtections();
+	public void protectBlock(Block block, String playerName);
+	public boolean isProtected(Block block, String playerName);
+	public List<String> getOwners(Block block);
+	public int unprotectBlock(Block block);
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/OwnedBlock.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/OwnedBlock.java
new file mode 100644
index 000000000..b9b036798
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/OwnedBlock.java
@@ -0,0 +1,9 @@
+package com.earth2me.essentials.protect.data;
+
+public class OwnedBlock {
+	int x;
+	int y;
+	int z;
+	String world;
+	String playerName;
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockJDBC.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockJDBC.java
new file mode 100644
index 000000000..dec0231b9
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockJDBC.java
@@ -0,0 +1,292 @@
+package com.earth2me.essentials.protect.data;
+
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import java.beans.PropertyVetoException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.block.Block;
+
+public abstract class ProtectedBlockJDBC implements IProtectedBlock {
+	protected static final Logger logger = Logger.getLogger("Minecraft");
+	protected ComboPooledDataSource cpds;
+
+	protected abstract PreparedStatement getStatementCreateTable(Connection conn) throws SQLException;
+	protected abstract PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException;
+	protected abstract PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException;
+	protected abstract PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException;
+	protected abstract PreparedStatement getStatementPlayersByLocation(Connection conn, String name, int x, int y, int z) throws SQLException;
+	protected abstract PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException;
+	protected abstract PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException;
+	
+	public ProtectedBlockJDBC(String driver, String url) throws PropertyVetoException {
+		this(driver, url, null, null);
+	}
+	
+	public ProtectedBlockJDBC(String driver, String url, String username, String password) throws PropertyVetoException {
+		cpds = new ComboPooledDataSource();
+		cpds.setDriverClass(driver);
+		cpds.setJdbcUrl(url);
+		if (username != null) {
+			cpds.setUser(username);
+			cpds.setPassword(password);
+		}
+		cpds.setMaxStatements(20);
+		createAndConvertTable();
+	}
+	
+	
+	private void createAndConvertTable() {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementCreateTable(conn);
+			ps.execute();
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+		} finally {
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+	public void clearProtections() {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementDeleteAll(conn);
+			ps.executeUpdate();
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+		} finally {
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+	public void importProtections(List<OwnedBlock> blocks) {
+		for (OwnedBlock ownedBlock : blocks) {
+			if (ownedBlock.playerName == null) {
+				continue;
+			}
+			protectBlock(ownedBlock.world, ownedBlock.x, ownedBlock.y, ownedBlock.z, ownedBlock.playerName);
+		}
+	}
+	
+	public List<OwnedBlock> exportProtections() {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		List<OwnedBlock> blocks = new ArrayList<OwnedBlock>();
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementAllBlocks(conn);
+			rs = ps.executeQuery();
+			while (rs.next()) {
+				OwnedBlock ob = new OwnedBlock();
+				ob.world = rs.getString(1);
+				ob.x = rs.getInt(2);
+				ob.y = rs.getInt(3);
+				ob.z = rs.getInt(4);
+				ob.playerName = rs.getString(5);
+				blocks.add(ob);
+			}
+			return blocks;
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+			return blocks;
+		} finally {
+			if (rs != null) {
+				try {
+					rs.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+	public void protectBlock(Block block, String playerName) {
+		protectBlock(block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), playerName);
+	}
+	
+	private void protectBlock(String world, int x, int y, int z, String playerName) {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementInsert(conn, world, x, y, z, playerName);
+			ps.executeUpdate();
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+		} finally {
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+	public boolean isProtected(Block block, String playerName) {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementPlayerCountByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), playerName);
+			rs = ps.executeQuery();
+			rs.next();
+			return rs.getInt(1) > 0 && rs.getInt(2) == 0;
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+			return true;
+		} finally {
+			if (rs != null) {
+				try {
+					rs.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+	public List<String> getOwners(Block block) {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		ResultSet rs = null;
+		List<String> owners = new ArrayList<String>();
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementPlayersByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ());
+			rs = ps.executeQuery();
+			while (rs.next()) {
+				owners.add(rs.getString(1));
+			}
+			return owners;
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+			return owners;
+		} finally {
+			if (rs != null) {
+				try {
+					rs.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+
+	public int unprotectBlock(Block block) {
+		Connection conn = null;
+		PreparedStatement ps = null;
+		try {
+			conn = cpds.getConnection();
+			ps = getStatementDeleteByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ());
+			return ps.executeUpdate();
+		} catch (SQLException ex) {
+			logger.log(Level.SEVERE, null, ex);
+			return 0;
+		} finally {
+			if (ps != null) {
+				try {
+					ps.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+			if (conn != null) {
+				try {
+					conn.close();
+				} catch (SQLException ex) {
+					logger.log(Level.SEVERE, null, ex);
+				}
+			}
+		}
+	}
+	
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMemory.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMemory.java
new file mode 100644
index 000000000..53dee66d2
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMemory.java
@@ -0,0 +1,205 @@
+package com.earth2me.essentials.protect.data;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.plugin.Plugin;
+
+public class ProtectedBlockMemory implements IProtectedBlock {
+
+	List<String> worlds = new ArrayList<String>();
+	List<String> playerNames = new ArrayList<String>();
+	IProtectedBlock storage;
+	Plugin plugin;
+
+	class ProtectedLocation {
+
+		int x;
+		int y;
+		int z;
+		int w;
+
+		private ProtectedLocation(Block block, int worldId) {
+			this.x = block.getX();
+			this.y = block.getY();
+			this.z = block.getZ();
+			this.w = worldId;
+		}
+
+		private ProtectedLocation(OwnedBlock ownedBlock, int worldId) {
+			this.x = ownedBlock.x;
+			this.y = ownedBlock.y;
+			this.z = ownedBlock.z;
+			this.w = worldId;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (o instanceof ProtectedLocation) {
+				ProtectedLocation pl = (ProtectedLocation) o;
+				return x == pl.x && y == pl.y && z == pl.z && w == pl.w;
+			}
+			return false;
+		}
+
+		@Override
+		public int hashCode() {
+			return x ^ y ^ z ^ w;
+		}
+	}
+
+	class ProtectedBy {
+
+		private int playerId = -1;
+		private Set<Integer> playerIds;
+
+		private ProtectedBy() {
+		}
+
+		private void add(int playerId) {
+			if (this.playerId == -1 || this.playerId == playerId) {
+				this.playerId = playerId;
+			} else {
+				if (playerIds == null) {
+					playerIds = new HashSet<Integer>(4);
+					playerIds.add(this.playerId);
+				}
+				playerIds.add(playerId);
+			}
+		}
+
+		private boolean contains(int playerId) {
+			if (playerIds == null) {
+				return this.playerId == playerId;
+			}
+			return playerIds.contains(playerId);
+		}
+
+		private List<String> getPlayers(List<String> playerNames) {
+			if (playerIds == null) {
+				List<String> list = new ArrayList<String>(2);
+				list.add(playerNames.get(playerId));
+				return list;
+			}
+			List<String> list = new ArrayList<String>(playerIds.size());
+			for (Integer integer : playerIds) {
+				list.add(playerNames.get(integer));
+			}
+			return list;
+		}
+
+		private int size() {
+			if (playerIds == null) {
+				return 1;
+			}
+			return playerIds.size();
+		}
+	}
+	HashMap<ProtectedLocation, ProtectedBy> blocks = new HashMap<ProtectedLocation, ProtectedBy>();
+
+	public ProtectedBlockMemory(IProtectedBlock storage) {
+		this.storage = storage;
+		importProtections(storage.exportProtections());
+	}
+
+	public void clearProtections() {
+		blocks.clear();
+	}
+
+	public final void importProtections(List<OwnedBlock> blocks) {
+		for (OwnedBlock ownedBlock : blocks) {
+			ProtectedLocation pl = new ProtectedLocation(ownedBlock, getWorldId(ownedBlock.world));
+			if (ownedBlock.playerName == null) {
+				continue;
+			}
+			protectBlock(pl, ownedBlock.playerName);
+		}
+	}
+
+	public List<OwnedBlock> exportProtections() {
+		List<OwnedBlock> blockList = new ArrayList<OwnedBlock>(blocks.size());
+		for (Entry<ProtectedLocation, ProtectedBy> entry : blocks.entrySet()) {
+			for (String name : entry.getValue().getPlayers(playerNames)) {
+				OwnedBlock ob = new OwnedBlock();
+				ob.x = entry.getKey().x;
+				ob.y = entry.getKey().y;
+				ob.z = entry.getKey().z;
+				ob.world = worlds.get(entry.getKey().w);
+				ob.playerName = name;
+				blockList.add(ob);
+			}
+		}
+		return blockList;
+	}
+
+	public void protectBlock(final Block block, final String playerName) {
+		ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
+		protectBlock(pl, playerName);
+		plugin.getServer().getScheduler().scheduleAsyncDelayedTask(plugin, new Runnable() {
+			public void run() {
+				storage.protectBlock(block, playerName);
+			}
+		});
+	}
+
+	private void protectBlock(ProtectedLocation pl, String playerName) {
+		int playerId = getPlayerId(playerName);
+		ProtectedBy pb = blocks.get(pl);
+		if (pb == null) {
+			pb = new ProtectedBy();
+			blocks.put(pl, pb);
+		}
+		pb.add(playerId);
+	}
+
+	public boolean isProtected(Block block, String playerName) {
+		int playerId = getPlayerId(playerName);
+		ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
+		ProtectedBy pb = blocks.get(pl);
+		return !pb.contains(playerId);
+	}
+
+	public List<String> getOwners(Block block) {
+		ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
+		ProtectedBy pb = blocks.get(pl);
+		return pb.getPlayers(playerNames);
+	}
+
+	public int unprotectBlock(final Block block) {
+		ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
+		ProtectedBy pb = blocks.remove(pl);
+		plugin.getServer().getScheduler().scheduleAsyncDelayedTask(plugin, new Runnable() {
+			public void run() {
+				storage.unprotectBlock(block);
+			}
+		});
+		return pb.size();
+	}
+
+	private int getPlayerId(String playername) {
+		int id = playerNames.indexOf(playername);
+		if (id < 0) {
+			playerNames.add(playername);
+			id = playerNames.indexOf(playername);
+		}
+		return id;
+	}
+
+	private int getWorldId(World world) {
+		return getWorldId(world.getName());
+	}
+
+	private int getWorldId(String name) {
+		int id = worlds.indexOf(name);
+		if (id < 0) {
+			worlds.add(name);
+			id = worlds.indexOf(name);
+		}
+		return id;
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMySQL.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMySQL.java
new file mode 100644
index 000000000..8824f4040
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMySQL.java
@@ -0,0 +1,89 @@
+package com.earth2me.essentials.protect.data;
+
+import java.beans.PropertyVetoException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class ProtectedBlockMySQL extends ProtectedBlockJDBC {
+
+	public ProtectedBlockMySQL(String url, String username, String password) throws PropertyVetoException {
+		super("com.mysql.jdbc.Driver", url, username, password);
+	}
+
+	private static final String QueryCreateTable =
+		"CREATE TABLE IF NOT EXISTS `EssentialsProtectedBlocks` ("
+		+ "`worldName` varchar(150) NOT NULL,"
+		+ "`x` int(11) NOT NULL, `y` int(11) NOT NULL, `z` int(11) NOT NULL,"
+		+ "`playerName` varchar(150) NOT NULL,"
+		+ ") ENGINE=MyISAM DEFAULT CHARSET=utf8";
+
+	@Override
+	protected PreparedStatement getStatementCreateTable(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryCreateTable);
+	}
+	private static final String QueryDeleteAll = "DELETE FROM EssentialsProtectedBlocks;";
+
+	@Override
+	protected PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryDeleteAll);
+	}
+	private static final String QueryInsert =
+		"INSERT INTO EssentialsProtectedBlocks (worldName, x, y, z, playerName) VALUES (?, ?, ?, ?, ?);";
+
+	@Override
+	protected PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryInsert);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		ps.setString(5, playerName);
+		return ps;
+	}
+	private static final String QueryCountByPlayer =
+		"SELECT COUNT(playerName), SUM(playerName = ?) FROM EssentialsProtectedBlocks "
+		+ "WHERE worldName = ? AND x = ? AND y = ? AND z = ? GROUP BY x;";
+
+	@Override
+	protected PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryCountByPlayer);
+		ps.setString(1, playerName);
+		ps.setString(2, world);
+		ps.setInt(3, x);
+		ps.setInt(4, y);
+		ps.setInt(5, z);
+		return ps;
+	}
+	private static final String QueryPlayersByLocation =
+		"SELECT playerName FROM EssentialsProtectedBlocks WHERE worldname = ? AND x = ? AND y = ? AND z = ?;";
+
+	@Override
+	protected PreparedStatement getStatementPlayersByLocation(Connection conn, String world, int x, int y, int z) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryPlayersByLocation);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		return ps;
+	}
+	private static final String QueryDeleteByLocation =
+		"DELETE FROM EssentialsProtectedBlocks WHERE worldName = ? AND x = ? AND y = ? AND z = ?;";
+
+	@Override
+	protected PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryDeleteByLocation);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		return ps;
+	}
+	private static final String QueryAllBlocks =
+		"SELECT worldName, x, y, z, playerName FROM EssentialsProtectedBlocks;";
+
+	@Override
+	protected PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryAllBlocks);
+	}
+}
diff --git a/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockSQLite.java b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockSQLite.java
new file mode 100644
index 000000000..ff96a8952
--- /dev/null
+++ b/EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockSQLite.java
@@ -0,0 +1,87 @@
+package com.earth2me.essentials.protect.data;
+
+import java.beans.PropertyVetoException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class ProtectedBlockSQLite extends ProtectedBlockJDBC {
+
+	public ProtectedBlockSQLite(String url) throws PropertyVetoException {
+		super("org.sqlite.JDBC", url);
+	}
+   
+	private static final String QueryCreateTable =
+		"CREATE TABLE IF NOT EXISTS EssentialsProtect ("
+		+ "worldName TEXT ,playerName TEXT, "
+		+ "x NUMERIC, y NUMERIC, z NUMERIC)";
+
+	@Override
+	protected PreparedStatement getStatementCreateTable(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryCreateTable);
+	}
+	private static final String QueryDeleteAll = "DELETE FROM EssentialsProtectedBlocks;";
+
+	@Override
+	protected PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryDeleteAll);
+	}
+	private static final String QueryInsert =
+		"INSERT INTO EssentialsProtectedBlocks (worldName, x, y, z, playerName) VALUES (?, ?, ?, ?, ?);";
+
+	@Override
+	protected PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryInsert);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		ps.setString(5, playerName);
+		return ps;
+	}
+	private static final String QueryPlayerCountByLocation =
+		"SELECT COUNT(playerName), SUM(playerName = ?) FROM EssentialsProtectedBlocks "
+		+ "WHERE worldName = ? AND x = ? AND y = ? AND z = ? GROUP BY x;";
+
+	@Override
+	protected PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryPlayerCountByLocation);
+		ps.setString(1, playerName);
+		ps.setString(2, world);
+		ps.setInt(3, x);
+		ps.setInt(4, y);
+		ps.setInt(5, z);
+		return ps;
+	}
+	private static final String QueryPlayersByLocation =
+		"SELECT playerName FROM EssentialsProtectedBlocks WHERE worldname = ? AND x = ? AND y = ? AND z = ?;";
+
+	@Override
+	protected PreparedStatement getStatementPlayersByLocation(Connection conn, String world, int x, int y, int z) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryPlayersByLocation);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		return ps;
+	}
+	private static final String QueryDeleteByLocation =
+		"DELETE FROM EssentialsProtectedBlocks WHERE worldName = ? AND x = ? AND y = ? AND z = ?;";
+
+	@Override
+	protected PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException {
+		PreparedStatement ps = conn.prepareStatement(QueryDeleteByLocation);
+		ps.setString(1, world);
+		ps.setInt(2, x);
+		ps.setInt(3, y);
+		ps.setInt(4, z);
+		return ps;
+	}
+	private static final String QueryAllBlocks =
+		"SELECT worldName, x, y, z, playerName FROM EssentialsProtectedBlocks;";
+
+	@Override
+	protected PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException {
+		return conn.prepareStatement(QueryAllBlocks);
+	}
+}
diff --git a/EssentialsProtect/src/plugin.yml b/EssentialsProtect/src/plugin.yml
new file mode 100644
index 000000000..c6f7830c1
--- /dev/null
+++ b/EssentialsProtect/src/plugin.yml
@@ -0,0 +1,8 @@
+# This determines the command prefix when there are conflicts (/name:home, /name:help, etc.)

+name: EssentialsProtect

+main: com.earth2me.essentials.protect.EssentialsProtect

+# Note to developers: This next line cannot change, or the automatic versioning system will break.

+version: TeamCity

+website: http://www.earth2me.net:8001/

+description: Provides protection for various parts of the world.

+authors: [Zenexer, ementalo, Aelux, Brettflan, KimKandor, snowleo]
\ No newline at end of file