216 lines
8.4 KiB
Java
216 lines
8.4 KiB
Java
/*
|
|
* ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
|
|
* Copyright (C) 2012 Kristian S. Stangeland
|
|
*
|
|
* 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.injector;
|
|
|
|
import java.security.PublicKey;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.function.Supplier;
|
|
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.injector.packet.PacketRegistry;
|
|
import com.comphenix.protocol.reflect.StructureModifier;
|
|
import com.comphenix.protocol.reflect.accessors.Accessors;
|
|
import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
|
|
import com.comphenix.protocol.reflect.instances.DefaultInstances;
|
|
import com.comphenix.protocol.utility.ByteBuddyFactory;
|
|
import com.comphenix.protocol.utility.MinecraftMethods;
|
|
import com.comphenix.protocol.utility.MinecraftReflection;
|
|
import com.comphenix.protocol.utility.MinecraftVersion;
|
|
import com.comphenix.protocol.utility.ZeroBuffer;
|
|
import com.comphenix.protocol.wrappers.WrappedChatComponent;
|
|
import com.google.common.base.Preconditions;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.bytebuddy.dynamic.DynamicType;
|
|
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy.Default;
|
|
import net.bytebuddy.implementation.FixedValue;
|
|
import net.bytebuddy.matcher.ElementMatchers;
|
|
|
|
/**
|
|
* Caches structure modifiers.
|
|
*
|
|
* @author Kristian
|
|
*/
|
|
public class StructureCache {
|
|
|
|
// Structure modifiers
|
|
private static final Map<Class<?>, Supplier<Object>> PACKET_INSTANCE_CREATORS = new ConcurrentHashMap<>();
|
|
private static final Map<PacketType, StructureModifier<Object>> STRUCTURE_MODIFIER_CACHE = new ConcurrentHashMap<>();
|
|
|
|
// packet data serializer which always returns an empty nbt tag compound
|
|
private static final Object TRICK_INIT_LOCK = new Object();
|
|
private static boolean TRICK_TRIED = false;
|
|
|
|
private static ConstructorAccessor TRICKED_DATA_SERIALIZER_BASE;
|
|
private static ConstructorAccessor TRICKED_DATA_SERIALIZER_JSON;
|
|
|
|
public static Object newPacket(Class<?> packetClass) {
|
|
Supplier<Object> packetConstructor = PACKET_INSTANCE_CREATORS.computeIfAbsent(packetClass, clazz -> {
|
|
// prefer construction via PacketDataSerializer constructor on 1.17 and above
|
|
if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
|
|
ConstructorAccessor serializerAccessor = Accessors.getConstructorAccessorOrNull(
|
|
clazz,
|
|
MinecraftReflection.getPacketDataSerializerClass());
|
|
if (serializerAccessor != null) {
|
|
// check if the method is possible
|
|
if (tryInitTrickDataSerializer()) {
|
|
try {
|
|
// first try with the base accessor
|
|
Object serializer = TRICKED_DATA_SERIALIZER_BASE.invoke(new ZeroBuffer());
|
|
serializerAccessor.invoke(serializer); // throwaway instance, for testing
|
|
|
|
// method is working
|
|
return () -> serializerAccessor.invoke(serializer);
|
|
} catch (Exception exception) {
|
|
try {
|
|
// try with the json accessor
|
|
Object serializer = TRICKED_DATA_SERIALIZER_JSON.invoke(new ZeroBuffer());
|
|
serializerAccessor.invoke(serializer); // throwaway instance, for testing
|
|
|
|
// method is working
|
|
return () -> serializerAccessor.invoke(serializer);
|
|
} catch (Exception ignored) {
|
|
// shrug, fall back to default behaviour
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// try via DefaultInstances as fallback
|
|
return () -> {
|
|
Object packetInstance = DefaultInstances.DEFAULT.create(clazz);
|
|
Objects.requireNonNull(packetInstance, "Unable to create packet instance for class " + clazz);
|
|
return packetInstance;
|
|
};
|
|
});
|
|
return packetConstructor.get();
|
|
}
|
|
|
|
/**
|
|
* Creates an empty Minecraft packet of the given type.
|
|
*
|
|
* @param type - packet type.
|
|
* @return Created packet.
|
|
*/
|
|
public static Object newPacket(PacketType type) {
|
|
return newPacket(PacketRegistry.getPacketClassFromType(type));
|
|
}
|
|
|
|
/**
|
|
* Retrieve a cached structure modifier given a packet type.
|
|
*
|
|
* @param packetType - packet type.
|
|
* @return A structure modifier.
|
|
*/
|
|
public static StructureModifier<Object> getStructure(Class<?> packetType) {
|
|
// Get the ID from the class
|
|
PacketType type = PacketRegistry.getPacketType(packetType);
|
|
Preconditions.checkNotNull(type, "No packet type associated with " + packetType);
|
|
return getStructure(type);
|
|
}
|
|
|
|
/**
|
|
* Retrieve a cached structure modifier for the given packet type.
|
|
*
|
|
* @param packetType - packet type.
|
|
* @return A structure modifier.
|
|
*/
|
|
public static StructureModifier<Object> getStructure(final PacketType packetType) {
|
|
Preconditions.checkNotNull(packetType, "type cannot be null");
|
|
|
|
return STRUCTURE_MODIFIER_CACHE.computeIfAbsent(packetType, type -> {
|
|
Class<?> packetClass = PacketRegistry.getPacketClassFromType(type);
|
|
|
|
// We need to map the Bundle Delimiter to the synthetic bundle packet which contains a list of all packets in a bundle
|
|
if (MinecraftReflection.isBundleDelimiter(packetClass)) {
|
|
packetClass = MinecraftReflection.getPackedBundlePacketClass().get();
|
|
}
|
|
|
|
return new StructureModifier<>(packetClass, MinecraftReflection.getPacketClass(), true);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Returns a new mocked null data serializer instance, if possible.
|
|
*
|
|
* @return a new null data serializer instance.
|
|
*/
|
|
public static Object newNullDataSerializer() {
|
|
tryInitTrickDataSerializer();
|
|
return TRICKED_DATA_SERIALIZER_BASE.invoke(new ZeroBuffer());
|
|
}
|
|
|
|
/**
|
|
* Creates a packet data serializer sub-class if needed to allow the fixed read of a NbtTagCompound because of a
|
|
* null check in the MapChunk packet constructor.
|
|
*/
|
|
public static boolean tryInitTrickDataSerializer() {
|
|
if (TRICK_TRIED) {
|
|
return TRICKED_DATA_SERIALIZER_BASE != null;
|
|
}
|
|
|
|
synchronized (TRICK_INIT_LOCK) {
|
|
if (TRICK_TRIED) {
|
|
return TRICKED_DATA_SERIALIZER_BASE != null;
|
|
}
|
|
|
|
try {
|
|
// create an empty instance of a nbt tag compound / text compound that we can re-use when needed
|
|
Object textCompound = WrappedChatComponent.fromText("").getHandle();
|
|
Object compound = Accessors.getConstructorAccessor(MinecraftReflection.getNBTCompoundClass()).invoke();
|
|
// base builder which intercepts a few methods
|
|
DynamicType.Builder<?> baseBuilder = ByteBuddyFactory.getInstance()
|
|
.createSubclass(MinecraftReflection.getPacketDataSerializerClass())
|
|
.name(MinecraftMethods.class.getPackage().getName() + ".ProtocolLibTricksNmsDataSerializerBase")
|
|
.method(ElementMatchers.returns(MinecraftReflection.getNBTCompoundClass())
|
|
.and(ElementMatchers.takesArguments(MinecraftReflection.getNBTReadLimiterClass())))
|
|
.intercept(FixedValue.value(compound))
|
|
.method(ElementMatchers.returns(MinecraftReflection.getIChatBaseComponentClass()))
|
|
.intercept(FixedValue.value(textCompound))
|
|
.method(ElementMatchers.returns(PublicKey.class).and(ElementMatchers.takesNoArguments()))
|
|
.intercept(FixedValue.nullValue());
|
|
Class<?> serializerBase = baseBuilder.make()
|
|
.load(ByteBuddyFactory.getInstance().getClassLoader(), Default.INJECTION)
|
|
.getLoaded();
|
|
TRICKED_DATA_SERIALIZER_BASE = Accessors.getConstructorAccessor(serializerBase, ByteBuf.class);
|
|
|
|
// extended builder which intercepts the read string method as well
|
|
Class<?> withStringIntercept = baseBuilder
|
|
.name(MinecraftMethods.class.getPackage().getName() + ".ProtocolLibTricksNmsDataSerializerJson")
|
|
.method(ElementMatchers.returns(String.class).and(ElementMatchers.takesArguments(int.class)))
|
|
.intercept(FixedValue.value("{}"))
|
|
.make()
|
|
.load(ByteBuddyFactory.getInstance().getClassLoader(), Default.INJECTION)
|
|
.getLoaded();
|
|
TRICKED_DATA_SERIALIZER_JSON = Accessors.getConstructorAccessor(withStringIntercept, ByteBuf.class);
|
|
|
|
// worked
|
|
return true;
|
|
} catch (Exception ignored) {
|
|
} finally {
|
|
TRICK_TRIED = true;
|
|
}
|
|
|
|
// didn't work
|
|
return false;
|
|
}
|
|
}
|
|
}
|