Release version 4.2.1

Branch hiccup

modules/API/pom.xml

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <artifactId>ProtocolLib-API</artifactId>
   <name>ProtocolLib-API</name>
-  <version>4.2.0</version>
+  <version>4.2.1</version>
 
   <description>Provides read/write access to the Minecraft protocol.</description>
   <url>http://www.spigotmc.org/resources/protocollib.1997/</url>

modules/API/src/main/java/com/comphenix/protocol/PacketType.java

@@ -176,12 +176,12 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
 			public static final PacketType SPAWN_POSITION =               new PacketType(PROTOCOL, SENDER, 0x43, 0x05, "SpawnPosition");
 			public static final PacketType UPDATE_TIME =                  new PacketType(PROTOCOL, SENDER, 0x44, 0x03, "UpdateTime");
 			public static final PacketType TITLE =                        new PacketType(PROTOCOL, SENDER, 0x45, 0x45, "Title");
-			public static final PacketType NAMED_SOUND_EFFECT =           new PacketType(PROTOCOL, SENDER, 0x47, 0x29, "NamedSoundEffect");
-			public static final PacketType PLAYER_LIST_HEADER_FOOTER =    new PacketType(PROTOCOL, SENDER, 0x48, 0x47, "PlayerListHeaderFooter");
-			public static final PacketType COLLECT =                      new PacketType(PROTOCOL, SENDER, 0x49, 0x0D, "Collect");
-			public static final PacketType ENTITY_TELEPORT =              new PacketType(PROTOCOL, SENDER, 0x4A, 0x18, "EntityTeleport");
-			public static final PacketType UPDATE_ATTRIBUTES =            new PacketType(PROTOCOL, SENDER, 0x4B, 0x20, "UpdateAttributes");
-			public static final PacketType ENTITY_EFFECT =                new PacketType(PROTOCOL, SENDER, 0x4C, 0x1D, "EntityEffect");
+			public static final PacketType NAMED_SOUND_EFFECT =           new PacketType(PROTOCOL, SENDER, 0x46, 0x47, "NamedSoundEffect");
+			public static final PacketType PLAYER_LIST_HEADER_FOOTER =    new PacketType(PROTOCOL, SENDER, 0x47, 0x48, "PlayerListHeaderFooter");
+			public static final PacketType COLLECT =                      new PacketType(PROTOCOL, SENDER, 0x48, 0x49, "Collect");
+			public static final PacketType ENTITY_TELEPORT =              new PacketType(PROTOCOL, SENDER, 0x49, 0x4A, "EntityTeleport");
+			public static final PacketType UPDATE_ATTRIBUTES =            new PacketType(PROTOCOL, SENDER, 0x4A, 0x4B, "UpdateAttributes");
+			public static final PacketType ENTITY_EFFECT =                new PacketType(PROTOCOL, SENDER, 0x4B, 0x4C, "EntityEffect");
 
 			// ---- Removed in 1.9
 
@@ -715,11 +715,11 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
 		}
 	}
 
-	private static String format(Protocol protocol, Sender sender, String name) {
+	public static String format(Protocol protocol, Sender sender, String name) {
 		if (name.contains("Packet"))
 			return name;
 
-		return String.format("Packet%s%s%s", protocol.getPacketName(), sender.getPacketName(), name);
+		return String.format("Packet%s%s%s", protocol.getPacketName(), sender.getPacketName(), WordUtils.capitalize(name));
 	}
 
 	/**
@@ -797,24 +797,11 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
 		Map<String, PacketType> map = lookup.getMap(protocol, sender);
 
 		// Check the map first
-		String className = packetClass.getSimpleName();
-		PacketType type = map.get(className);
+		String clazz = packetClass.getSimpleName();
+		PacketType type = find(map, clazz);
 		if (type == null) {
-			// Then check any aliases
-			for (PacketType check : map.values()) {
-				String[] aliases = check.getClassNames();
-				if (aliases.length > 1) {
-					for (String alias : aliases) {
-						if (alias.equals(className)) {
-							// We have a match!
-							type = check;
-						}
-					}
-				}
-			}
-
 			// Guess we don't support this packet :/
-			type = new PacketType(protocol, sender, packetId, -1, PROTOCOL_VERSION, className);
+			type = new PacketType(protocol, sender, packetId, -1, PROTOCOL_VERSION, clazz);
 			type.dynamic = true;
 
 			// Many may be scheduled, but only the first will be executed
@@ -824,6 +811,28 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
 		return type;
 	}
 
+	private static PacketType find(Map<String, PacketType> map, String clazz) {
+		PacketType ret = map.get(clazz);
+		if (ret != null) {
+			return ret;
+		}
+
+		// Check any aliases
+		for (PacketType check : map.values()) {
+			String[] aliases = check.getClassNames();
+			if (aliases.length > 1) {
+				for (String alias : aliases) {
+					if (alias.equals(clazz)) {
+						// We have a match!
+						return check;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
 	/**
 	 * Lookup a packet type from a packet class.
 	 * @param packetClass - the packet class.

modules/API/src/main/java/com/comphenix/protocol/ProtocolLibrary.java

@@ -39,12 +39,12 @@ public class ProtocolLibrary {
 	/**
 	 * The maximum version ProtocolLib has been tested with.
 	 */
-	public static final String MAXIMUM_MINECRAFT_VERSION = "1.11.1";
+	public static final String MAXIMUM_MINECRAFT_VERSION = "1.11.2";
 
 	/**
 	 * The date (with ISO 8601 or YYYY-MM-DD) when the most recent version (1.11) was released.
 	 */
-	public static final String MINECRAFT_LAST_RELEASE_DATE = "2016-12-20";
+	public static final String MINECRAFT_LAST_RELEASE_DATE = "2016-12-21";
 
 	/**
 	 * Plugins that are currently incompatible with ProtocolLib.

modules/API/src/main/java/com/comphenix/protocol/injector/netty/WirePacket.java

@@ -149,20 +149,53 @@ public class WirePacket {
 	 * @return The resulting WirePacket
 	 */
 	public static WirePacket fromPacket(PacketContainer packet) {
-		checkNotNull(packet, "packet cannot be null!");
-
 		int id = packet.getType().getCurrentId();
+		return new WirePacket(id, bytesFromPacket(packet));
+	}
 
+	/**
+	 * Creates a byte array from an existing PacketContainer containing all the
+	 * bytes from that packet
+	 * 
+	 * @param packet Existing packet
+	 * @return The ByteBuf
+	 */
+	public static byte[] bytesFromPacket(PacketContainer packet) {
+		checkNotNull(packet, "packet cannot be null!");
+		
 		ByteBuf buffer = PacketContainer.createPacketBuffer();
+		ByteBuf store = PacketContainer.createPacketBuffer();
+		
+		// Read the bytes once
 		Method write = MinecraftMethods.getPacketWriteByteBufMethod();
 
 		try {
 			write.invoke(packet.getHandle(), buffer);
 		} catch (ReflectiveOperationException ex) {
-			throw new RuntimeException("Failed to serialize packet contents.", ex);
+			throw new RuntimeException("Failed to read packet contents.", ex);
 		}
 
-		return new WirePacket(id, getBytes(buffer));
+		byte[] bytes = getBytes(buffer);
+
+		// Rewrite them to the packet to avoid issues with certain packets
+		if (packet.getType() == PacketType.Play.Server.CUSTOM_PAYLOAD
+				|| packet.getType() == PacketType.Play.Client.CUSTOM_PAYLOAD) {
+			// Make a copy of the array before writing
+			byte[] ret = Arrays.copyOf(bytes, bytes.length);
+			store.writeBytes(bytes);
+
+			Method read = MinecraftMethods.getPacketReadByteBufMethod();
+
+			try {
+				read.invoke(packet.getHandle(), store);
+			} catch (ReflectiveOperationException ex) {
+				throw new RuntimeException("Failed to rewrite packet contents.", ex);
+			}
+
+			return ret;
+		}
+
+		return bytes;
 	}
 
 	/**

modules/API/src/main/java/com/comphenix/protocol/utility/MinecraftReflection.java

@@ -1847,6 +1847,10 @@ public class MinecraftReflection {
 		return getMinecraftClass("NonNullList");
 	}
 
+	public static Class<?> getCraftSoundClass() {
+		return getCraftBukkitClass("CraftSound");
+	}
+
 	// ---- ItemStack conversions
 
 	private static Method asNMSCopy = null;

modules/API/src/main/java/com/comphenix/protocol/utility/Util.java

@@ -63,10 +63,14 @@ public class Util {
 
 	/**
 	 * Gets the currently running major Java version.
-	 * @return The version
+	 * @return The version or -1 if it could not be found
 	 */
 	public static int getJavaVersion() {
-		String version = Runtime.class.getPackage().getSpecificationVersion();
-		return (int) (Double.valueOf(version) * 10 % 10);
+		try {
+			String version = Runtime.class.getPackage().getSpecificationVersion();
+			return (int) (Double.parseDouble(version) * 10 % 10);
+		} catch (Throwable ex) {
+			return -1;
+		}
 	}
 }

modules/API/src/main/java/com/comphenix/protocol/wrappers/BukkitConverters.java

@@ -29,6 +29,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.bukkit.Material;
 import org.bukkit.Sound;
@@ -964,10 +965,21 @@ public class BukkitConverters {
 		};
 	}
 
-	private static MethodAccessor soundGetter = null;
+	private static MethodAccessor getSound = null;
+	private static MethodAccessor getSoundEffect = null;
 	private static FieldAccessor soundKey = null;
 
+	private static Map<String, Sound> soundIndex = null;
+
 	public static EquivalentConverter<Sound> getSoundConverter() {
+		if (getSound == null || getSoundEffect == null) {
+			Class<?> craftSound = MinecraftReflection.getCraftSoundClass();
+			FuzzyReflection fuzzy = FuzzyReflection.fromClass(craftSound, true);
+			getSound = Accessors.getMethodAccessor(fuzzy.getMethodByParameters("getSound", String.class, new Class<?>[] { Sound.class }));
+			getSoundEffect = Accessors.getMethodAccessor(fuzzy.getMethodByParameters("getSoundEffect",
+					MinecraftReflection.getSoundEffectClass(), new Class<?>[] { String.class }));
+		}
+
 		return new IgnoreNullConverter<Sound>() {
 
 			@Override
@@ -977,26 +989,42 @@ public class BukkitConverters {
 
 			@Override
 			protected Object getGenericValue(Class<?> genericType, Sound specific) {
-				if (soundGetter == null) {
-					Class<?> soundEffects = MinecraftReflection.getMinecraftClass("SoundEffects");
-					FuzzyReflection fuzzy = FuzzyReflection.fromClass(soundEffects, true);
-					soundGetter = Accessors.getMethodAccessor(fuzzy.getMethodByParameters("getSound", MinecraftReflection.getSoundEffectClass(), new Class<?>[] { String.class }));
-				}
-
-				MinecraftKey key = MinecraftKey.fromEnum(specific);
-				return soundGetter.invoke(null, key.getFullKey());
+				// Getting the SoundEffect is easy, Bukkit provides us the methods
+				String key = (String) getSound.invoke(null, specific);
+				return getSoundEffect.invoke(null, key);
 			}
 
 			@Override
 			protected Sound getSpecificValue(Object generic) {
+				// Getting the Sound is a bit more complicated...
 				if (soundKey == null) {
 					Class<?> soundEffect = generic.getClass();
 					FuzzyReflection fuzzy = FuzzyReflection.fromClass(soundEffect, true);
 					soundKey = Accessors.getFieldAccessor(fuzzy.getFieldByType("key", MinecraftReflection.getMinecraftKeyClass()));
 				}
 
-				MinecraftKey key = MinecraftKey.fromHandle(soundKey.get(generic));
-				return Sound.valueOf(key.getEnumFormat());
+				MinecraftKey minecraftKey = MinecraftKey.fromHandle(soundKey.get(generic));
+				String key = minecraftKey.getKey();
+
+				// Use our index if it already exists
+				if (soundIndex != null) {
+					return soundIndex.get(key);
+				}
+
+				// If it doesn't, try to guess the enum name
+				try {
+					return Sound.valueOf(minecraftKey.getEnumFormat());
+				} catch (IllegalArgumentException ignored) {
+				}
+
+				// Worst case we index all the sounds and use it later
+				soundIndex = new ConcurrentHashMap<>();
+				for (Sound sound : Sound.values()) {
+					String index = (String) getSound.invoke(null, sound);
+					soundIndex.put(index, sound);
+				}
+
+				return soundIndex.get(key);
 			}
 		};
 	}

modules/API/src/main/java/com/comphenix/protocol/wrappers/ComponentParser.java

@@ -17,6 +17,7 @@
 package com.comphenix.protocol.wrappers;
 
 import java.io.IOException;
+import java.io.Reader;
 import java.io.StringReader;
 import java.lang.reflect.Method;
 
@@ -45,7 +46,7 @@ public class ComponentParser {
 	private static Object deserializeLegacy(Object gson, Class<?> component, StringReader str) {
 		try {
 			Class<?> readerClass = Class.forName("org.bukkit.craftbukkit.libs.com.google.gson.stream.JsonReader");
-			Object reader = readerClass.getConstructor(StringReader.class).newInstance(str);
+			Object reader = readerClass.getConstructor(Reader.class).newInstance(str);
 			Method setLenient = readerClass.getMethod("setLenienent", boolean.class);
 			setLenient.invoke(reader, true);
 			Method getAdapter = gson.getClass().getMethod("getAdapter", Class.class);
@@ -56,4 +57,4 @@ public class ComponentParser {
 			throw new RuntimeException("Failed to read JSON", ex);
 		}
 	}
-}
+}

modules/API/src/main/java/com/comphenix/protocol/wrappers/EnumWrappers.java

@@ -217,7 +217,8 @@ public abstract class EnumWrappers {
 		DRAGON_BREATH("dragonbreath", 42, false),
 		END_ROD("endRod", 43, false),
 		DAMAGE_INDICATOR("damageIndicator", 44, true),
-		SWEEP_ATTACK("sweepAttack", 45, true);
+		SWEEP_ATTACK("sweepAttack", 45, true),
+		FALLING_DUST("fallingdust", 46, true);
 
 		private static final Map<String, Particle> BY_NAME;
 		private static final Map<Integer, Particle> BY_ID;

modules/API/src/main/java/com/comphenix/protocol/wrappers/MinecraftKey.java

@@ -69,7 +69,9 @@ public class MinecraftKey {
 	 * is lower case, with underscores replaced by periods.
 	 * @param value The value
 	 * @return The resulting key
+	 * @deprecated This isn't accurate in all cases
 	 */
+	@Deprecated
 	public static MinecraftKey fromEnum(Enum<?> value) {
 		return new MinecraftKey(value.name().toLowerCase(Locale.ENGLISH).replace("_", "."));
 	}
@@ -103,7 +105,9 @@ public class MinecraftKey {
 	 * Returns this key back into Enum format, upper case with periods replaced
 	 * by underscores.
 	 * @return The enum format
+	 * @deprecated This isn't accurate in all cases
 	 */
+	@Deprecated
 	public String getEnumFormat() {
 		return key.toUpperCase(Locale.ENGLISH).replace(".", "_");
 	}

modules/ProtocolLib/pom.xml

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <artifactId>ProtocolLib</artifactId>
   <name>ProtocolLib</name>
-  <version>4.2.0</version>
+  <version>4.2.1</version>
 
   <description>Provides read/write access to the Minecraft protocol.</description>
   <url>http://www.spigotmc.org/resources/protocollib.1997/</url>

modules/ProtocolLib/src/main/java/com/comphenix/protocol/PacketLogging.java

@@ -0,0 +1,274 @@
+/**
+ *  ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
+ *  Copyright (C) 2017 Dan Mulloy
+ *
+ *  This program is free software; you can redistribute it and/or modify it under the terms of the
+ *  GNU General Public License as published by the Free Software Foundation; either version 2 of
+ *  the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with this program;
+ *  if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307 USA
+ */
+package com.comphenix.protocol;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.FileHandler;
+import java.util.logging.Formatter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+import org.apache.commons.io.HexDump;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.Plugin;
+
+import com.comphenix.protocol.PacketType.Protocol;
+import com.comphenix.protocol.PacketType.Sender;
+import com.comphenix.protocol.events.ListeningWhitelist;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.events.PacketListener;
+import com.comphenix.protocol.injector.netty.WirePacket;
+import com.google.common.base.Charsets;
+
+/**
+ * Logs packets to a given stream
+ * @author dmulloy2
+ */
+public class PacketLogging implements CommandExecutor, PacketListener {
+	public static final String NAME = "packetlog";
+
+	private List<PacketType> sendingTypes = new ArrayList<>();
+	private List<PacketType> receivingTypes = new ArrayList<>();
+
+	private ListeningWhitelist sendingWhitelist;
+	private ListeningWhitelist receivingWhitelist;
+
+	private Logger fileLogger;
+	private LogLocation location = LogLocation.FILE;
+
+	private final ProtocolManager manager;
+	private final Plugin plugin;
+
+	PacketLogging(Plugin plugin, ProtocolManager manager) {
+		this.plugin = plugin;
+		this.manager = manager;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+		PacketType type = null;
+
+		try {
+			if (args.length > 2) {
+				Protocol protocol;
+
+				try {
+					protocol = Protocol.valueOf(args[0].toUpperCase());
+				} catch (IllegalArgumentException ex) {
+					sender.sendMessage(ChatColor.RED + "Unknown protocol " + args[0]);
+					return true;
+				}
+
+				Sender pSender;
+
+				try {
+					pSender = Sender.valueOf(args[1].toUpperCase());
+				} catch (IllegalArgumentException ex) {
+					sender.sendMessage(ChatColor.RED + "Unknown sender: " + args[1]);
+					return true;
+				}
+
+				try {
+					try { // Try IDs first
+						int id = Integer.parseInt(args[2]);
+						type = PacketType.findCurrent(protocol, pSender, id);
+					} catch (NumberFormatException ex) { // Check packet names
+						String name = args[2];
+						outer: for (PacketType packet : PacketType.values()) {
+							if (packet.getProtocol() == protocol && packet.getSender() == pSender) {
+								if (packet.name().equalsIgnoreCase(name)) {
+									type = packet;
+									break outer;
+								}
+								for (String className : packet.getClassNames()) {
+									if (className.equalsIgnoreCase(name)) {
+										type = packet;
+										break outer;
+									}
+								}
+							}
+						}
+					}
+				} catch (IllegalArgumentException ex) { // RIP
+					type = null;
+				}
+
+				if (type == null) {
+					sender.sendMessage(ChatColor.RED + "Unknown packet: " + args[2]);
+					return true;
+				}
+
+				if (args.length > 3) {
+					if (args[3].equalsIgnoreCase("console")) {
+						this.location = LogLocation.CONSOLE;
+					} else {
+						this.location = LogLocation.FILE;
+					}
+				}
+
+				if (pSender == Sender.CLIENT) {
+					if (receivingTypes.contains(type)) {
+						receivingTypes.remove(type);
+					} else {
+						receivingTypes.add(type);
+					}
+				} else {
+					if (sendingTypes.contains(type)) {
+						sendingTypes.remove(type);
+					} else {
+						sendingTypes.add(type);
+					}
+				}
+
+				startLogging();
+				sender.sendMessage(ChatColor.GREEN + "Now logging " + type.getPacketClass().getSimpleName());
+				return true;
+			}
+
+			sender.sendMessage(ChatColor.RED + "Invalid syntax: /packetlog <protocol> <sender> <packet> [location]");
+			return true;
+		} catch (Throwable ex) {
+			sender.sendMessage(ChatColor.RED + "Failed to parse command: " + ex.toString());
+			return true;
+		}
+	}
+
+	private void startLogging() {
+		manager.removePacketListener(this);
+
+		if (sendingTypes.isEmpty() && receivingTypes.isEmpty()) {
+			return;
+		}
+
+		this.sendingWhitelist = ListeningWhitelist.newBuilder().types(sendingTypes).build();
+		this.receivingWhitelist = ListeningWhitelist.newBuilder().types(receivingTypes).build();
+
+		// Setup the file logger if it hasn't been already
+		if (location == LogLocation.FILE && fileLogger == null) {
+			fileLogger = Logger.getLogger("ProtocolLib-FileLogging");
+
+			for (Handler handler : fileLogger.getHandlers())
+				fileLogger.removeHandler(handler);
+			fileLogger.setUseParentHandlers(false);
+
+			try {
+				File logFile = new File(plugin.getDataFolder(), "log.log");
+				FileHandler handler = new FileHandler(logFile.getAbsolutePath(), true);
+				handler.setFormatter(new LogFormatter());
+				fileLogger.addHandler(handler);
+			} catch (IOException ex) {
+				plugin.getLogger().log(Level.SEVERE, "Failed to obtain log file:", ex);
+				return;
+			}
+		}
+
+		manager.addPacketListener(this);
+	}
+
+	@Override
+	public void onPacketSending(PacketEvent event) {
+		log(event);
+	}
+
+	@Override
+	public void onPacketReceiving(PacketEvent event) {
+		log(event);
+	}
+
+	// Here's where the magic happens
+
+	private static String hexDump(byte[] bytes) throws IOException {
+		try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
+			HexDump.dump(bytes, 0, output, 0);
+			return new String(output.toByteArray(), Charsets.UTF_8);
+		}
+	}
+
+	private void log(PacketEvent event) {
+		try {
+			byte[] bytes = WirePacket.bytesFromPacket(event.getPacket());
+			String hexDump = hexDump(bytes);
+
+			if (location == LogLocation.FILE) {
+				fileLogger.log(Level.INFO, event.getPacketType() + ":");
+				fileLogger.log(Level.INFO, hexDump);
+				fileLogger.log(Level.INFO, "");
+			} else {
+				System.out.println(event.getPacketType() + ":");
+				System.out.println(hexDump);
+				System.out.println();
+			}
+		} catch (Throwable ex) {
+			plugin.getLogger().log(Level.WARNING, "Failed to log packet " + event.getPacketType() + ":", ex);
+			plugin.getLogger().log(Level.WARNING, "Clearing packet logger...");
+
+			sendingTypes.clear();
+			receivingTypes.clear();
+			startLogging();
+		}
+	}
+
+	@Override
+	public ListeningWhitelist getSendingWhitelist() {
+		return sendingWhitelist;
+	}
+
+	@Override
+	public ListeningWhitelist getReceivingWhitelist() {
+		return receivingWhitelist;
+	}
+
+	@Override
+	public Plugin getPlugin() {
+		return plugin;
+	}
+
+	private static enum LogLocation {
+		CONSOLE,
+		FILE;
+	}
+
+	private static class LogFormatter extends Formatter {
+		private static final SimpleDateFormat DATE = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+		private static final String LINE_SEPARATOR = System.getProperty("line.separator");
+		private static final String FORMAT = "[{0}] {1}";
+
+		@Override
+		public String format(LogRecord record) {
+			String string = formatMessage(record);
+			if (string.isEmpty()) {
+				return LINE_SEPARATOR;
+			}
+
+			StringBuilder message = new StringBuilder();
+			message.append(MessageFormat.format(FORMAT, DATE.format(record.getMillis()), string));
+			message.append(LINE_SEPARATOR);
+			return message.toString();
+		}
+	}
+}

modules/ProtocolLib/src/main/java/com/comphenix/protocol/ProtocolLib.java

@@ -90,7 +90,8 @@ public class ProtocolLib extends JavaPlugin {
 	private enum ProtocolCommand {
 		FILTER,
 		PACKET,
-		PROTOCOL
+		PROTOCOL,
+		LOGGING;
 	}
 
 	/**
@@ -143,6 +144,7 @@ public class ProtocolLib extends JavaPlugin {
 	private CommandProtocol commandProtocol;
 	private CommandPacket commandPacket;
 	private CommandFilter commandFilter;
+	private PacketLogging packetLogging;
 
 	// Whether or not disable is not needed
 	private boolean skipDisable;
@@ -154,7 +156,7 @@ public class ProtocolLib extends JavaPlugin {
 		ProtocolLogger.init(this);
 
 		int java = Util.getJavaVersion();
-		if (java < 8 && !getConfig().getBoolean("ignoreJava", false)) {
+		if (java != -1 && java < 8 && !getConfig().getBoolean("ignoreJava", false)) {
 			logger.warning("Detected outdated Java version: Java " + java);
 			logger.warning("It is recommended that you update to Java 8 as soon as possible.");
 			logger.warning("Future versions of ProtocolLib many not support Java " + java + ".");
@@ -269,6 +271,9 @@ public class ProtocolLib extends JavaPlugin {
 				case PACKET:
 					commandPacket = new CommandPacket(reporter, this, logger, commandFilter, protocolManager);
 					break;
+				case LOGGING:
+					packetLogging = new PacketLogging(this, protocolManager);
+					break;
 				}
 			} catch (OutOfMemoryError e) {
 				throw e;
@@ -404,6 +409,7 @@ public class ProtocolLib extends JavaPlugin {
 			registerCommand(CommandProtocol.NAME, commandProtocol);
 			registerCommand(CommandPacket.NAME, commandPacket);
 			registerCommand(CommandFilter.NAME, commandFilter);
+			registerCommand(PacketLogging.NAME, packetLogging);
 
 			// Player login and logout events
 			protocolManager.registerEvents(manager, this);

modules/ProtocolLib/src/main/java/com/comphenix/protocol/updater/BukkitUpdater.java

@@ -354,11 +354,12 @@ public class BukkitUpdater extends Updater {
                 this.plugin.getLogger().warning("Please double-check your configuration to ensure it is correct.");
                 this.result = UpdateResult.FAIL_APIKEY;
             } else {
-                this.plugin.getLogger().warning("The updater could not contact dev.bukkit.org for updating.");
-                this.plugin.getLogger().warning("If you have not recently modified your configuration and this is the first time you are seeing this message, the site may be experiencing temporary downtime.");
+            	// People don't care
+                // this.plugin.getLogger().warning("The updater could not contact dev.bukkit.org for updating.");
+                // this.plugin.getLogger().warning("If you have not recently modified your configuration and this is the first time you are seeing this message, the site may be experiencing temporary downtime.");
                 this.result = UpdateResult.FAIL_DBO;
             }
-            e.printStackTrace();
+            // e.printStackTrace();
             return false;
         }
     }

modules/ProtocolLib/src/main/java/com/comphenix/protocol/updater/SpigotUpdater.java

@@ -21,7 +21,6 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
-import java.util.logging.Level;
 
 import org.bukkit.plugin.Plugin;
 
@@ -75,7 +74,8 @@ public final class SpigotUpdater extends Updater {
 					ProtocolLibrary.getErrorReporter().reportDetailed(
 							SpigotUpdater.this, Report.newBuilder(REPORT_CANNOT_UPDATE_PLUGIN).error(ex).callerParam(this));
 				} else {
-					plugin.getLogger().log(Level.WARNING, "Failed to check for updates: " + ex);
+					// People don't care
+					// plugin.getLogger().log(Level.WARNING, "Failed to check for updates: " + ex);
 				}
 
 				ProtocolLibrary.disableUpdates();

modules/ProtocolLib/src/main/resources/plugin.yml

@@ -24,6 +24,11 @@ commands:
     aliases: [packet_filter]
     permission: protocol.admin
     permission-message: You don't have <permission>
+  packetlog:
+    description: Logs hex representations of packets to a file or console
+    usage: /<command> <protocol> <sender> <packet> [location]
+    permission: protocol.admin
+    permission-message: You don't have <permission>
 
 permissions:
   protocol.*:

modules/ProtocolLib/src/test/java/com/comphenix/protocol/updater/UpdaterTest.java

@@ -23,21 +23,21 @@ public class UpdaterTest {
 	private static final int BUKKIT_DEV_ID = 45564;
 	private static Plugin plugin;
 
-	//@BeforeClass
+	// @BeforeClass
 	public static void preparePlugin() {
 		Server server = mock(Server.class);
 		when(server.getUpdateFolder()).thenReturn(null);
 
 		plugin = mock(Plugin.class);
 		String version = System.getProperty("projectVersion");
-		if (version == null) version = "4.0.1-SNAPSHOT-b281";
+		if (version == null) version = "4.2.1";
 		when(plugin.getDescription()).thenReturn(new PluginDescriptionFile("ProtocolLib", version, null));
 		when(plugin.getLogger()).thenReturn(Logger.getLogger("ProtocolLib"));
 		when(plugin.getDataFolder()).thenReturn(null);
 		when(plugin.getServer()).thenReturn(server);
 	}
 
-	//@Test
+	// @Test
 	public void testSpigotUpdater() {
 		SpigotUpdater updater = new SpigotUpdater(plugin, UpdateType.NO_DOWNLOAD, true);
 
@@ -54,7 +54,7 @@ public class UpdaterTest {
 		System.out.println("Update available: " + updater.versionCheck(remote));
 	}
 
-	//@Test
+	// @Test
 	public void testBukkitUpdater() {
 		BukkitUpdater updater = new BukkitUpdater(plugin, BUKKIT_DEV_ID, null, UpdateType.NO_DOWNLOAD, true);
 		if (! updater.read()) {