Compare commits

..
3 Commits
14 changed files with 352 additions and 356 deletions

No files matched your search

-5
View File
@@ -3,8 +3,3 @@
plugins { plugins {
id 'com.gtnewhorizons.gtnhconvention' id 'com.gtnewhorizons.gtnhconvention'
} }
minecraft {
//extraRunJvmArguments.add("-Dccc.dev.runtimePublic=true")
//extraRunJvmArguments.add("-Dccc.dev.deobfuscate=true")
}
+1 -9
View File
@@ -90,9 +90,7 @@ usesMixinDebug = false
# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise. # Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
mixinPlugin = mixinPlugin =
# Specify the package that contains all of your Mixins. The package must exist or # Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
# the build will fail. If you have a package property defined in your mixins.<modid>.json,
# it must match with this or the build will fail.
mixinsPackage = mixinsPackage =
# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin! # Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
@@ -168,12 +166,6 @@ curseForgeRelations =
# projects. New projects should not use this parameter. # projects. New projects should not use this parameter.
# customArchiveBaseName = # customArchiveBaseName =
# Optional parameter to customize the default working directory used by the runClient* tasks. Relative to the project directory.
# runClientWorkingDirectory = run/client
# Optional parameter to customize the default working directory used by the runServer* tasks. Relative to the project directory.
# runServerWorkingDirectory = run/server
# Optional parameter to have the build automatically fail if an illegal version is used. # Optional parameter to have the build automatically fail if an illegal version is used.
# This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'. # This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
# The check is ONLY performed if the version is a git tag. # The check is ONLY performed if the version is a git tag.
+1 -1
View File
@@ -17,7 +17,7 @@ pluginManagement {
} }
plugins { plugins {
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.48' id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.41'
} }
@@ -5,19 +5,32 @@ import java.lang.reflect.Field;
import com.google.common.collect.ImmutableBiMap; import com.google.common.collect.ImmutableBiMap;
import codechicken.lib.asm.ObfMapping;
import cpw.mods.fml.common.asm.transformers.AccessTransformer; import cpw.mods.fml.common.asm.transformers.AccessTransformer;
import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper; import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
// This AccessTransformer will make all minecraft classes public at runtime in MCP just as they are in modloader.
// You should ONLY use this when you are testing with a mod that relies on runtime publicity and doesn't include
// access transformers. Such mods are doing the wrong thing and should be fixed.
public class CodeChickenAccessTransformer extends AccessTransformer { public class CodeChickenAccessTransformer extends AccessTransformer {
private static final Field f_classNameBiMap; private static boolean makeAllPublic;
@SuppressWarnings("FieldMayBeFinal") private static Field f_classNameBiMap;
private static Object emptyMap = ImmutableBiMap.of(); private static Object emptyMap = ImmutableBiMap.of();
static { public CodeChickenAccessTransformer() throws IOException {
super();
loadPublicConfig();
}
private void loadPublicConfig() {
if (ObfMapping.obfuscated) return;
makeAllPublic = CodeChickenCoreModContainer.config.getTag("dev.runtimePublic").setComment(
"Enabling this setting will make all minecraft classes public at runtime in MCP just as they are in modloader."
+ "\nYou should ONLY use this when you are testing with a mod that relies on runtime publicity and doesn't include access transformers."
+ "\nSuch mods are doing the wrong thing and should be fixed.")
.getBooleanValue(false);
if (!makeAllPublic) return;
try { try {
f_classNameBiMap = FMLDeobfuscatingRemapper.class.getDeclaredField("classNameBiMap"); f_classNameBiMap = FMLDeobfuscatingRemapper.class.getDeclaredField("classNameBiMap");
f_classNameBiMap.setAccessible(true); f_classNameBiMap.setAccessible(true);
@@ -26,18 +39,16 @@ public class CodeChickenAccessTransformer extends AccessTransformer {
} }
} }
public CodeChickenAccessTransformer() throws IOException {}
@Override @Override
public byte[] transform(String name, String transformedName, byte[] bytes) { public byte[] transform(String name, String transformedName, byte[] bytes) {
boolean setPublic = name.startsWith("net.minecraft."); boolean setPublic = makeAllPublic && name.startsWith("net.minecraft.");
if (setPublic) setClassMap(name); if (setPublic) setClassMap(name);
bytes = super.transform(name, transformedName, bytes); bytes = super.transform(name, transformedName, bytes);
if (setPublic) restoreClassMap(); if (setPublic) restoreClassMap();
return bytes; return bytes;
} }
private static void restoreClassMap() { private void restoreClassMap() {
try { try {
f_classNameBiMap.set(FMLDeobfuscatingRemapper.INSTANCE, emptyMap); f_classNameBiMap.set(FMLDeobfuscatingRemapper.INSTANCE, emptyMap);
} catch (Exception e) { } catch (Exception e) {
@@ -45,7 +56,7 @@ public class CodeChickenAccessTransformer extends AccessTransformer {
} }
} }
private static void setClassMap(String name) { private void setClassMap(String name) {
try { try {
f_classNameBiMap.set(FMLDeobfuscatingRemapper.INSTANCE, ImmutableBiMap.of(name.replace('.', '/'), "")); f_classNameBiMap.set(FMLDeobfuscatingRemapper.INSTANCE, ImmutableBiMap.of(name.replace('.', '/'), ""));
} catch (Exception e) { } catch (Exception e) {
@@ -1,5 +1,6 @@
package codechicken.core.asm; package codechicken.core.asm;
import java.io.File;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
@@ -12,6 +13,7 @@ import codechicken.core.ClientUtils;
import codechicken.core.featurehack.LiquidTextures; import codechicken.core.featurehack.LiquidTextures;
import codechicken.core.internal.CCCEventHandler; import codechicken.core.internal.CCCEventHandler;
import codechicken.core.launch.CodeChickenCorePlugin; import codechicken.core.launch.CodeChickenCorePlugin;
import codechicken.lib.config.ConfigFile;
import cpw.mods.fml.common.DummyModContainer; import cpw.mods.fml.common.DummyModContainer;
import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.LoadController; import cpw.mods.fml.common.LoadController;
@@ -24,6 +26,14 @@ import cpw.mods.fml.common.versioning.VersionRange;
public class CodeChickenCoreModContainer extends DummyModContainer { public class CodeChickenCoreModContainer extends DummyModContainer {
public static ConfigFile config;
public static void loadConfig() {
if (config == null)
config = new ConfigFile(new File(CodeChickenCorePlugin.minecraftDir, "config/CodeChickenCore.cfg"))
.setComment("CodeChickenCore configuration file.");
}
public CodeChickenCoreModContainer() { public CodeChickenCoreModContainer() {
super(getModMetadata()); super(getModMetadata());
} }
@@ -7,50 +7,35 @@ import java.util.HashSet;
import java.util.LinkedList; import java.util.LinkedList;
import net.minecraft.launchwrapper.IClassTransformer; import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch; import net.minecraft.launchwrapper.LaunchClassLoader;
import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.MethodNode;
import codechicken.lib.asm.ASMHelper; import codechicken.lib.asm.ASMHelper;
import codechicken.lib.asm.ClassHeirachyManager;
import codechicken.lib.asm.ObfMapping; import codechicken.lib.asm.ObfMapping;
import cpw.mods.fml.relauncher.FMLRelaunchLog;
public class DefaultImplementationTransformer implements IClassTransformer { public class DefaultImplementationTransformer implements IClassTransformer {
private static final HashMap<String, InterfaceImpl> impls = new HashMap<>(); private static LaunchClassLoader cl = (LaunchClassLoader) ClassHeirachyManager.class.getClassLoader();
public static void registerDefaultImpl(String iname, String cname) { private static ClassNode getClassNode(String name) {
if (impls.isEmpty()) { try {
String name = DefaultImplementationTransformer.class.getName(); return ASMHelper.createClassNode(cl.getClassBytes(name.replace('/', '.')));
FMLRelaunchLog.finer("Registering transformer %s", name); } catch (IOException e) {
Launch.classLoader.registerTransformer(name); throw new RuntimeException(e);
} }
impls.put(iname.replace('.', '/'), new InterfaceImpl(iname, cname));
}
@Override
public byte[] transform(String name, String transformedName, byte[] bytes) {
if (transformedName.startsWith("net.minecraft") || impls.isEmpty()) return bytes;
ClassNode cnode = ASMHelper.createClassNode(bytes);
boolean changed = false;
for (String iname : cnode.interfaces) {
InterfaceImpl impl = impls.get(iname);
if (impl != null) changed |= impl.patch(cnode);
}
return changed ? ASMHelper.createBytes(cnode, 0) : bytes;
} }
static class InterfaceImpl { static class InterfaceImpl {
public final String iname; public final String iname;
public ArrayList<MethodNode> impls = new ArrayList<>(); public ArrayList<MethodNode> impls = new ArrayList<MethodNode>();
public InterfaceImpl(String iname, String cname) { public InterfaceImpl(String iname, String cname) {
this.iname = iname; this.iname = iname;
HashSet<String> names = new HashSet<>(); HashSet<String> names = new HashSet<String>();
ClassNode inode = getClassNode(iname); ClassNode inode = getClassNode(iname);
for (MethodNode method : inode.methods) names.add(method.name + method.desc); for (MethodNode method : inode.methods) names.add(method.name + method.desc);
@@ -62,7 +47,7 @@ public class DefaultImplementationTransformer implements IClassTransformer {
} }
public boolean patch(ClassNode cnode) { public boolean patch(ClassNode cnode) {
LinkedList<String> names = new LinkedList<>(); LinkedList<String> names = new LinkedList<String>();
for (MethodNode method : cnode.methods) { for (MethodNode method : cnode.methods) {
ObfMapping m = new ObfMapping(cnode.name, method.name, method.desc).toRuntime(); ObfMapping m = new ObfMapping(cnode.name, method.name, method.desc).toRuntime();
names.add(m.s_name + m.s_desc); names.add(m.s_name + m.s_desc);
@@ -84,13 +69,25 @@ public class DefaultImplementationTransformer implements IClassTransformer {
} }
return changed; return changed;
} }
}
private static ClassNode getClassNode(String name) { private static HashMap<String, InterfaceImpl> impls = new HashMap<String, InterfaceImpl>();
try {
return ASMHelper.createClassNode(Launch.classLoader.getClassBytes(name.replace('/', '.'))); public static void registerDefaultImpl(String iname, String cname) {
} catch (IOException e) { impls.put(iname.replace('.', '/'), new InterfaceImpl(iname, cname));
throw new RuntimeException(e); }
}
@Override
public byte[] transform(String name, String transformedName, byte[] bytes) {
if (transformedName.startsWith("net.minecraft") || impls.isEmpty()) return bytes;
ClassNode cnode = ASMHelper.createClassNode(bytes);
boolean changed = false;
for (String iname : cnode.interfaces) {
InterfaceImpl impl = impls.get(iname);
if (impl != null) changed |= impl.patch(cnode);
} }
return changed ? ASMHelper.createBytes(cnode, 0) : bytes;
} }
} }
@@ -1,5 +1,7 @@
package codechicken.core.asm; package codechicken.core.asm;
import static codechicken.core.launch.CodeChickenCorePlugin.logger;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
@@ -9,9 +11,7 @@ import java.lang.reflect.Method;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Map; import java.util.Map;
import java.util.Stack; import java.util.Stack;
import java.util.jar.Attributes;
import java.util.jar.JarFile; import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry; import java.util.zip.ZipEntry;
import net.minecraft.launchwrapper.IClassTransformer; import net.minecraft.launchwrapper.IClassTransformer;
@@ -21,18 +21,14 @@ import net.minecraft.launchwrapper.LaunchClassLoader;
import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Opcodes; import org.objectweb.asm.Opcodes;
import codechicken.core.launch.CodeChickenCorePlugin;
import cpw.mods.fml.relauncher.FMLRelaunchLog;
public class DelegatedTransformer implements IClassTransformer { public class DelegatedTransformer implements IClassTransformer {
private static final ArrayList<IClassTransformer> delegatedTransformers; private static ArrayList<IClassTransformer> delegatedTransformers;
private static final Method m_defineClass; private static Method m_defineClass;
private static final Field f_cachedClasses; private static Field f_cachedClasses;
private static IClassTransformer[] transformers;
static { public DelegatedTransformer() {
delegatedTransformers = new ArrayList<>(); delegatedTransformers = new ArrayList<IClassTransformer>();
try { try {
m_defineClass = ClassLoader.class m_defineClass = ClassLoader.class
.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE); .getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
@@ -45,75 +41,14 @@ public class DelegatedTransformer implements IClassTransformer {
} }
@Override @Override
public byte[] transform(String name, String transformedName, byte[] basicClass) { public byte[] transform(String name, String tname, byte[] bytes) {
if (basicClass == null) return null; if (bytes == null) return null;
for (IClassTransformer t : transformers) { for (IClassTransformer trans : delegatedTransformers) bytes = trans.transform(name, tname, bytes);
basicClass = t.transform(name, transformedName, basicClass); return bytes;
}
return basicClass;
}
public static void load() {
scanModsForDelegatedTransformers();
final int size = delegatedTransformers.size();
if (size == 0) {
CodeChickenCorePlugin.logger
.debug("No delegated transformer found, skipping registration of main DelegatedTransformer.");
return;
}
CodeChickenCorePlugin.logger
.debug("Found " + size + " delegated transformers, registering main DelegatedTransformer.");
transformers = delegatedTransformers.toArray(new IClassTransformer[0]);
String name = DelegatedTransformer.class.getName();
FMLRelaunchLog.finer("Registering transformer %s", name);
Launch.classLoader.registerTransformer(name);
}
private static void scanModsForDelegatedTransformers() {
File modsDir = new File(CodeChickenCorePlugin.minecraftDir, "mods");
if (modsDir.exists()) {
final File[] files = modsDir.listFiles();
if (files != null) {
for (File file : files) {
scanMod(file);
}
}
}
File versionModsDir = new File(
CodeChickenCorePlugin.minecraftDir,
"mods/" + CodeChickenCorePlugin.currentMcVersion);
if (versionModsDir.exists()) {
final File[] files = versionModsDir.listFiles();
if (files != null) {
for (File file : files) {
scanMod(file);
}
}
}
}
private static void scanMod(File file) {
if (!file.getName().endsWith(".jar") && !file.getName().endsWith(".zip")) return;
try {
try (JarFile jar = new JarFile(file)) {
Manifest manifest = jar.getManifest();
if (manifest == null) return;
Attributes attr = manifest.getMainAttributes();
if (attr == null) return;
String transformer = attr.getValue("CCTransformer");
if (transformer != null) {
addTransformer(transformer, jar, file);
}
}
} catch (Exception e) {
CodeChickenCorePlugin.logger.error("CodeChickenCore: Failed to read jar file: " + file.getName(), e);
}
} }
public static void addTransformer(String transformer, JarFile jar, File jarFile) { public static void addTransformer(String transformer, JarFile jar, File jarFile) {
CodeChickenCorePlugin.logger.debug("Adding CCTransformer: " + transformer); logger.debug("Adding CCTransformer: " + transformer);
try { try {
byte[] bytes; byte[] bytes;
bytes = Launch.classLoader.getClassBytes(transformer); bytes = Launch.classLoader.getClassBytes(transformer);
@@ -172,7 +107,7 @@ public class DelegatedTransformer implements IClassTransformer {
byte[] depbytes = readFully(jar.getInputStream(entry)); byte[] depbytes = readFully(jar.getInputStream(entry));
defineDependancies(depbytes, jar, jarFile, depStack); defineDependancies(depbytes, jar, jarFile, depStack);
CodeChickenCorePlugin.logger.debug("Defining dependancy: " + dependancy); logger.debug("Defining dependancy: " + dependancy);
defineClass(dependancy.replace('/', '.'), depbytes); defineClass(dependancy.replace('/', '.'), depbytes);
} }
@@ -193,6 +128,7 @@ public class DelegatedTransformer implements IClassTransformer {
while ((r = stream.read()) != -1) { while ((r = stream.read()) != -1) {
bos.write(r); bos.write(r);
} }
return bos.toByteArray(); return bos.toByteArray();
} }
} }
@@ -24,6 +24,7 @@ import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap; import com.google.common.collect.Multimap;
import codechicken.lib.asm.ASMHelper; import codechicken.lib.asm.ASMHelper;
import codechicken.lib.asm.ASMInit;
import codechicken.lib.asm.CC_ClassWriter; import codechicken.lib.asm.CC_ClassWriter;
import codechicken.lib.asm.ObfMapping; import codechicken.lib.asm.ObfMapping;
import codechicken.obfuscator.IHeirachyEvaluator; import codechicken.obfuscator.IHeirachyEvaluator;
@@ -34,11 +35,15 @@ import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
public class MCPDeobfuscationTransformer implements IClassTransformer, Opcodes, IHeirachyEvaluator { public class MCPDeobfuscationTransformer implements IClassTransformer, Opcodes, IHeirachyEvaluator {
static {
ASMInit.init();
}
public static class LoadPlugin implements IFMLLoadingPlugin { public static class LoadPlugin implements IFMLLoadingPlugin {
@Override @Override
public String[] getASMTransformerClass() { public String[] getASMTransformerClass() {
return null; return new String[0];
} }
@Override @Override
@@ -113,20 +118,26 @@ public class MCPDeobfuscationTransformer implements IClassTransformer, Opcodes,
} }
public static void load() { public static void load() {
run = new ObfuscationRun( CodeChickenCoreModContainer.loadConfig();
false,
ObfMapping.MCPRemapper.getConfFiles(),
ObfuscationRun.fillDefaults(new HashMap<String, String>()));
run.obf.setHeirachyEvaluator(instance);
run.setQuiet().parseMappings();
Collections.addAll(excludedPackages, run.config.get("excludedPackages").split(";"));
if (ObfMapping.obfuscated) { if (CodeChickenCoreModContainer.config.getTag("dev.deobfuscate")
ObfMapping.loadMCPRemapper(); .setComment("set to true to completely deobfuscate mcp names")
run.setSeargeConstants(); .getBooleanValue(!ObfMapping.obfuscated)) {
getTransformers().add(instance); run = new ObfuscationRun(
} else { false,
getTransformers().add(0, instance); // insert transformer as first. ObfMapping.MCPRemapper.getConfFiles(),
ObfuscationRun.fillDefaults(new HashMap<String, String>()));
run.obf.setHeirachyEvaluator(instance);
run.setQuiet().parseMappings();
Collections.addAll(excludedPackages, run.config.get("excludedPackages").split(";"));
if (ObfMapping.obfuscated) {
ObfMapping.loadMCPRemapper();
run.setSeargeConstants();
getTransformers().add(instance);
} else {
getTransformers().add(0, instance); // insert transformer as first.
}
} }
} }
@@ -5,15 +5,14 @@ import static codechicken.lib.asm.InsnComparator.findOnce;
import java.util.Map; import java.util.Map;
import net.minecraft.launchwrapper.IClassTransformer; import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch;
import org.objectweb.asm.Opcodes; import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.JumpInsnNode; import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode; import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.MethodNode;
import codechicken.core.launch.CodeChickenCorePlugin;
import codechicken.lib.asm.ASMBlock; import codechicken.lib.asm.ASMBlock;
import codechicken.lib.asm.ASMInit;
import codechicken.lib.asm.ASMReader; import codechicken.lib.asm.ASMReader;
import codechicken.lib.asm.ModularASMTransformer; import codechicken.lib.asm.ModularASMTransformer;
import codechicken.lib.asm.ModularASMTransformer.MethodReplacer; import codechicken.lib.asm.ModularASMTransformer.MethodReplacer;
@@ -21,29 +20,20 @@ import codechicken.lib.asm.ModularASMTransformer.MethodTransformer;
import codechicken.lib.asm.ModularASMTransformer.MethodWriter; import codechicken.lib.asm.ModularASMTransformer.MethodWriter;
import codechicken.lib.asm.ObfMapping; import codechicken.lib.asm.ObfMapping;
import codechicken.lib.config.ConfigTag; import codechicken.lib.config.ConfigTag;
import cpw.mods.fml.relauncher.FMLRelaunchLog;
public class TweakTransformer implements IClassTransformer, Opcodes { public class TweakTransformer implements IClassTransformer, Opcodes {
private static final ModularASMTransformer transformer = new ModularASMTransformer(); static {
private static final Map<String, ASMBlock> blocks = ASMReader ASMInit.init();
.loadResource("/assets/codechickencore/asm/tweaks.asm"); }
private static ModularASMTransformer transformer = new ModularASMTransformer();
private static Map<String, ASMBlock> blocks = ASMReader.loadResource("/assets/codechickencore/asm/tweaks.asm");
public static ConfigTag tweaks; public static ConfigTag tweaks;
public static void load() { public static void load() {
loadTransformersFromConfig(); CodeChickenCoreModContainer.loadConfig();
if (transformer.isEmpty()) { tweaks = CodeChickenCoreModContainer.config.getTag("tweaks")
CodeChickenCorePlugin.logger
.debug("No tweaks parsed from config, skipping registration of TweakTransformer.");
return;
}
String name = TweakTransformer.class.getName();
FMLRelaunchLog.finer("Registering transformer %s", name);
Launch.classLoader.registerTransformer(name);
}
private static void loadTransformersFromConfig() {
tweaks = CodeChickenCorePlugin.config.getTag("tweaks")
.setComment("Various tweaks that can be applied to game mechanics.").useBraces(); .setComment("Various tweaks that can be applied to game mechanics.").useBraces();
tweaks.removeTag("persistantLava"); tweaks.removeTag("persistantLava");
@@ -113,7 +103,7 @@ public class TweakTransformer implements IClassTransformer, Opcodes {
} }
@Override @Override
public final byte[] transform(String name, String tname, byte[] bytes) { public byte[] transform(String name, String tname, byte[] bytes) {
return transformer.transform(name, bytes); return transformer.transform(name, bytes);
} }
} }
@@ -9,6 +9,9 @@ import java.text.CharacterIterator;
import java.text.StringCharacterIterator; import java.text.StringCharacterIterator;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import javax.swing.JEditorPane; import javax.swing.JEditorPane;
import javax.swing.JOptionPane; import javax.swing.JOptionPane;
@@ -18,87 +21,48 @@ import javax.swing.event.HyperlinkListener;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import codechicken.core.asm.CodeChickenCoreModContainer;
import codechicken.core.asm.DelegatedTransformer; import codechicken.core.asm.DelegatedTransformer;
import codechicken.core.asm.MCPDeobfuscationTransformer; import codechicken.core.asm.MCPDeobfuscationTransformer;
import codechicken.core.asm.Tags; import codechicken.core.asm.Tags;
import codechicken.core.asm.TweakTransformer; import codechicken.core.asm.TweakTransformer;
import codechicken.lib.config.ConfigFile;
import codechicken.lib.config.ConfigTag; import codechicken.lib.config.ConfigTag;
import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.versioning.DefaultArtifactVersion; import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
import cpw.mods.fml.common.versioning.VersionParser; import cpw.mods.fml.common.versioning.VersionParser;
import cpw.mods.fml.relauncher.CoreModManager; import cpw.mods.fml.relauncher.CoreModManager;
import cpw.mods.fml.relauncher.FMLInjectionData; import cpw.mods.fml.relauncher.FMLInjectionData;
import cpw.mods.fml.relauncher.IFMLCallHook;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin; import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin.MCVersion;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin.TransformerExclusions;
@IFMLLoadingPlugin.MCVersion("1.7.10") @TransformerExclusions(value = { "codechicken.core.asm", "codechicken.obfuscator" })
@IFMLLoadingPlugin.TransformerExclusions({ "codechicken.core.asm", "codechicken.obfuscator", "codechicken.lib.asm", @MCVersion("1.7.10")
"codechicken.lib.config" }) public class CodeChickenCorePlugin implements IFMLLoadingPlugin, IFMLCallHook {
public class CodeChickenCorePlugin implements IFMLLoadingPlugin {
public static final String mcVersion = "[1.7.10]"; public static final String mcVersion = "[1.7.10]";
@Deprecated @Deprecated
public static final String version = Tags.VERSION; public static final String version = Tags.VERSION;
public static ConfigFile config;
public static File minecraftDir; public static File minecraftDir;
public static String currentMcVersion; public static String currentMcVersion;
public static Logger logger = LogManager.getLogger("CodeChickenCore"); public static Logger logger = LogManager.getLogger("CodeChickenCore");
public CodeChickenCorePlugin() { public CodeChickenCorePlugin() {
if (minecraftDir != null) return; if (minecraftDir != null) return; // get called twice, once for IFMLCallHook
minecraftDir = (File) FMLInjectionData.data()[6]; minecraftDir = (File) FMLInjectionData.data()[6];
currentMcVersion = (String) FMLInjectionData.data()[4]; currentMcVersion = (String) FMLInjectionData.data()[4];
config = new ConfigFile(new File(minecraftDir, "config/CodeChickenCore.cfg"))
.setComment("CodeChickenCore configuration file.");
if (Boolean.getBoolean("ccc.dev.deobfuscate")) {
injectDeobfPlugin();
}
}
@Override injectDeobfPlugin();
public String[] getASMTransformerClass() {
versionCheck(mcVersion, "CodeChickenCore");
return new String[] { "codechicken.lib.asm.ClassHeirachyManager", "codechicken.lib.asm.RedirectorTransformer" };
}
@Override
public String getAccessTransformerClass() {
if (Boolean.getBoolean("ccc.dev.runtimePublic")) {
return "codechicken.core.asm.CodeChickenAccessTransformer";
} else {
return null;
}
}
@Override
public String getModContainerClass() {
return "codechicken.core.asm.CodeChickenCoreModContainer";
}
@Override
public String getSetupClass() {
return null;
}
@Override
public void injectData(Map<String, Object> data) {
ConfigTag checkRAM = CodeChickenCorePlugin.config.getTag("checks")
.setComment("Configuration options for checking various requirements for a modpack.").useBraces();
if (checkRAM.getTag("checkRAM")
.setComment("If set to true, check RAM available for Minecraft before continuing to load")
.getBooleanValue(false)) {
systemCheck(checkRAM);
}
TweakTransformer.load();
DelegatedTransformer.load();
} }
private void injectDeobfPlugin() { private void injectDeobfPlugin() {
try { try {
Class<?> wrapperClass = Class.forName("cpw.mods.fml.relauncher.CoreModManager$FMLPluginWrapper"); Class<?> wrapperClass = Class.forName("cpw.mods.fml.relauncher.CoreModManager$FMLPluginWrapper");
Constructor<?> wrapperConstructor = wrapperClass Constructor wrapperConstructor = wrapperClass
.getConstructor(String.class, IFMLLoadingPlugin.class, File.class, Integer.TYPE, String[].class); .getConstructor(String.class, IFMLLoadingPlugin.class, File.class, Integer.TYPE, String[].class);
Field f_loadPlugins = CoreModManager.class.getDeclaredField("loadPlugins"); Field f_loadPlugins = CoreModManager.class.getDeclaredField("loadPlugins");
wrapperConstructor.setAccessible(true); wrapperConstructor.setAccessible(true);
@@ -112,7 +76,7 @@ public class CodeChickenCorePlugin implements IFMLLoadingPlugin {
0, 0,
new String[0])); new String[0]));
} catch (Exception e) { } catch (Exception e) {
logger.error("Failed to inject FMLPluginWrapper for MCPDeobfuscation Transformer", e); logger.error("Failed to inject MCPDeobfuscation Transformer", e);
} }
} }
@@ -222,4 +186,74 @@ public class CodeChickenCorePlugin implements IFMLLoadingPlugin {
FMLCommonHandler.instance().exitJava(-98, true); FMLCommonHandler.instance().exitJava(-98, true);
} }
} }
@Override
public String[] getASMTransformerClass() {
versionCheck(mcVersion, "CodeChickenCore");
return new String[] { "codechicken.lib.asm.ClassHeirachyManager", "codechicken.core.asm.TweakTransformer",
"codechicken.core.asm.DelegatedTransformer", "codechicken.core.asm.DefaultImplementationTransformer",
"codechicken.lib.asm.RedirectorTransformer" };
}
@Override
public String getAccessTransformerClass() {
return "codechicken.core.asm.CodeChickenAccessTransformer";
}
@Override
public String getModContainerClass() {
return "codechicken.core.asm.CodeChickenCoreModContainer";
}
@Override
public String getSetupClass() {
return getClass().getName();
}
@Override
public void injectData(Map<String, Object> data) {}
@Override
public Void call() {
CodeChickenCoreModContainer.loadConfig();
ConfigTag checkRAM;
checkRAM = CodeChickenCoreModContainer.config.getTag("checks")
.setComment("Configuration options for checking various requirements for a modpack.").useBraces();
if (checkRAM.getTag("checkRAM")
.setComment("If set to true, check RAM available for Minecraft before continuing to load")
.getBooleanValue(false))
systemCheck(checkRAM);
TweakTransformer.load();
scanCodeChickenMods();
return null;
}
private void scanCodeChickenMods() {
File modsDir = new File(minecraftDir, "mods");
for (File file : modsDir.listFiles()) scanMod(file);
File versionModsDir = new File(minecraftDir, "mods/" + currentMcVersion);
if (versionModsDir.exists()) for (File file : versionModsDir.listFiles()) scanMod(file);
}
private void scanMod(File file) {
if (!file.getName().endsWith(".jar") && !file.getName().endsWith(".zip")) return;
try {
JarFile jar = new JarFile(file);
try {
Manifest manifest = jar.getManifest();
if (manifest == null) return;
Attributes attr = manifest.getMainAttributes();
if (attr == null) return;
String transformer = attr.getValue("CCTransformer");
if (transformer != null) DelegatedTransformer.addTransformer(transformer, jar, file);
} finally {
jar.close();
}
} catch (Exception e) {
logger.error("CodeChickenCore: Failed to read jar file: " + file.getName(), e);
}
}
} }
@@ -0,0 +1,44 @@
package codechicken.core.launch;
import java.util.Map;
import cpw.mods.fml.relauncher.IFMLCallHook;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
import cpw.mods.fml.relauncher.IFMLLoadingPlugin.MCVersion;
/**
* This was used to download dependencies during runtime and inject them into the classloader. It is now hollowed out
* but kept in the mod so that if another mod copied-pasted this class into their mod, there is a chance this empty
* class will be loaded instead and it will do nothing.
*/
@MCVersion("1.7.10")
public class DepLoader implements IFMLLoadingPlugin, IFMLCallHook {
@Override
public String[] getASMTransformerClass() {
return null;
}
@Override
public String getModContainerClass() {
return null;
}
@Override
public String getSetupClass() {
return null;
}
@Override
public void injectData(Map<String, Object> data) {}
@Override
public String getAccessTransformerClass() {
return null;
}
@Override
public Void call() {
return null;
}
}
@@ -1,12 +1,13 @@
package codechicken.lib.asm; package codechicken.lib.asm;
import java.util.Map; import java.util.ArrayList;
import java.util.concurrent.ConcurrentHashMap; import java.util.HashMap;
import java.util.HashSet;
import net.minecraft.launchwrapper.IClassTransformer; import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch; import net.minecraft.launchwrapper.Launch;
import net.minecraft.launchwrapper.LaunchClassLoader;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.ClassNode;
import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper; import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
@@ -17,60 +18,47 @@ import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
*/ */
public class ClassHeirachyManager implements IClassTransformer { public class ClassHeirachyManager implements IClassTransformer {
private static final Map<String, ClassInfo> superclasses = new ConcurrentHashMap<>(1000);
static { static {
superclasses.put("java.lang.Object", ClassInfo.OBJECT); ASMInit.init();
} }
@Override public static class SuperCache {
public byte[] transform(String name, String transformedName, byte[] bytes) {
if (bytes == null) return null; String superclass;
if (!superclasses.containsKey(transformedName)) { public HashSet<String> parents = new HashSet<String>();
declareASM(transformedName, bytes); private boolean flattened;
public void add(String parent) {
parents.add(parent);
} }
return bytes;
}
private static ClassInfo declareASM(String name, byte[] bytes) { public void flatten() {
final ClassNode node = ASMHelper.createClassNode(bytes, ClassReader.SKIP_CODE); if (flattened) return;
final ClassInfo classInfo = new ClassInfo(node);
superclasses.put(name, classInfo);
return classInfo;
}
private static ClassInfo declareReflection(String name) throws ClassNotFoundException { for (String s : new ArrayList<String>(parents)) {
final Class<?> aclass = Class.forName(name); SuperCache c = declareClass(s);
final ClassInfo classInfo = new ClassInfo(aclass); if (c != null) {
superclasses.put(name, classInfo); c.flatten();
return classInfo; parents.addAll(c.parents);
} }
private static ClassInfo declareClass(String name) {
try {
byte[] bytes = Launch.classLoader.getClassBytes(unKey(name));
if (bytes != null) {
return declareASM(name, bytes);
} }
} catch (Exception ignored) {} flattened = true;
try { }
return declareReflection(name);
} catch (ClassNotFoundException ignored) {}
return null;
} }
private static String toKey(String name) { public static HashMap<String, SuperCache> superclasses = new HashMap<String, SuperCache>();
if (ObfMapping.obfuscated) { private static LaunchClassLoader cl = Launch.classLoader;
return FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.', '/')).replace('/', '.');
} public static String toKey(String name) {
return name.replace('/', '.'); if (ObfMapping.obfuscated)
name = FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.', '/')).replace('/', '.');
return name;
} }
private static String unKey(String name) { public static String unKey(String name) {
if (ObfMapping.obfuscated) { if (ObfMapping.obfuscated)
return FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/', '.'); name = FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/', '.');
} return name;
return name.replace('/', '.');
} }
/** /**
@@ -84,90 +72,83 @@ public class ClassHeirachyManager implements IClassTransformer {
if (name.equals(superclass)) return true; if (name.equals(superclass)) return true;
ClassInfo classInfo = superclasses.get(name); SuperCache cache = declareClass(name);
if (classInfo == null) classInfo = declareClass(name); if (cache == null) // just can't handle this
if (classInfo == null) return false; return false;
return classInfo.hasSuper(superclass); cache.flatten();
return cache.parents.contains(superclass);
}
private static SuperCache declareClass(String name) {
name = toKey(name);
SuperCache cache = superclasses.get(name);
if (cache != null) return cache;
try {
byte[] bytes = cl.getClassBytes(unKey(name));
if (bytes != null) cache = declareASM(bytes);
} catch (Exception e) {}
if (cache != null) return cache;
try {
cache = declareReflection(name);
} catch (ClassNotFoundException e) {}
return cache;
}
private static SuperCache declareReflection(String name) throws ClassNotFoundException {
Class<?> aclass = Class.forName(name);
SuperCache cache = getOrCreateCache(name);
if (aclass.isInterface()) cache.superclass = "java.lang.Object";
else if (name.equals("java.lang.Object")) return cache;
else cache.superclass = toKey(aclass.getSuperclass().getName());
cache.add(cache.superclass);
for (Class<?> iclass : aclass.getInterfaces()) cache.add(toKey(iclass.getName()));
return cache;
}
private static SuperCache declareASM(byte[] bytes) {
ClassNode node = ASMHelper.createClassNode(bytes);
String name = toKey(node.name);
SuperCache cache = getOrCreateCache(name);
cache.superclass = toKey(node.superName.replace('/', '.'));
cache.add(cache.superclass);
for (String iclass : node.interfaces) cache.add(toKey(iclass.replace('/', '.')));
return cache;
}
@Override
public byte[] transform(String name, String tname, byte[] bytes) {
if (bytes == null) return null;
if (!superclasses.containsKey(tname)) declareASM(bytes);
return bytes;
}
public static SuperCache getOrCreateCache(String name) {
SuperCache cache = superclasses.get(name);
if (cache == null) superclasses.put(name, cache = new SuperCache());
return cache;
} }
public static String getSuperClass(String name, boolean runtime) { public static String getSuperClass(String name, boolean runtime) {
name = toKey(name); name = toKey(name);
SuperCache cache = declareClass(name);
if (cache == null) return "java.lang.Object";
ClassInfo classInfo = superclasses.get(name); cache.flatten();
if (classInfo == null) classInfo = declareClass(name); String s = cache.superclass;
if (classInfo == null || classInfo.superclass == null) return "java.lang.Object"; if (!runtime) s = FMLDeobfuscatingRemapper.INSTANCE.unmap(s);
final String s = classInfo.superclass;
if (!runtime) {
return FMLDeobfuscatingRemapper.INSTANCE.unmap(s);
}
return s; return s;
} }
private static class ClassInfo {
public static final ClassInfo OBJECT = new ClassInfo();
public final String superclass;
public final String[] interfaces;
public ClassInfo parent;
private ClassInfo() {
this.superclass = null;
this.interfaces = null;
}
public ClassInfo(ClassNode node) {
if ("java/lang/Object".equals(node.superName)) {
superclass = "java.lang.Object";
parent = OBJECT;
} else {
superclass = toKey(node.superName);
}
if (node.interfaces.isEmpty()) {
interfaces = null;
} else {
interfaces = new String[node.interfaces.size()];
for (int i = 0; i < node.interfaces.size(); i++) {
interfaces[i] = toKey(node.interfaces.get(i));
}
}
}
public ClassInfo(Class<?> aclass) {
if (aclass.isInterface()) {
this.superclass = "java.lang.Object";
this.parent = OBJECT;
} else {
final Class<?> superclass = aclass.getSuperclass();
if (superclass == null || "java.lang.Object".equals(superclass.getName())) {
this.superclass = "java.lang.Object";
this.parent = OBJECT;
} else {
this.superclass = toKey(superclass.getName());
}
}
final Class<?>[] interfaces = aclass.getInterfaces();
if (interfaces.length == 0) {
this.interfaces = null;
} else {
this.interfaces = new String[interfaces.length];
for (int i = 0; i < interfaces.length; i++) {
this.interfaces[i] = toKey(interfaces[i].getName());
}
}
}
public boolean hasSuper(String superclass) {
if (this.superclass == null) return false;
if (this.superclass.equals(superclass)) return true;
ClassInfo parentInfo = this.parent;
if (parentInfo == null) parentInfo = superclasses.get(this.superclass);
if (parentInfo == null) parentInfo = declareClass(this.superclass);
if (parentInfo == null) return false;
this.parent = parentInfo;
return parentInfo.hasSuper(superclass);
}
}
} }
@@ -275,22 +275,17 @@ public class ModularASMTransformer {
} }
} }
public HashMap<String, ClassNodeTransformerList> transformers = new HashMap<>(); public HashMap<String, ClassNodeTransformerList> transformers = new HashMap<String, ClassNodeTransformerList>();
public void add(ClassNodeTransformer t) { public void add(ClassNodeTransformer t) {
ClassNodeTransformerList list = transformers.get(t.className()); ClassNodeTransformerList list = transformers.get(t.className());
if (list == null) { if (list == null) transformers.put(t.className(), list = new ClassNodeTransformerList());
transformers.put(t.className(), list = new ClassNodeTransformerList());
}
list.add(t); list.add(t);
} }
public boolean isEmpty() {
return transformers.isEmpty();
}
public byte[] transform(String name, byte[] bytes) { public byte[] transform(String name, byte[] bytes) {
if (bytes == null) return null; if (bytes == null) return null;
ClassNodeTransformerList list = transformers.get(name); ClassNodeTransformerList list = transformers.get(name);
return list == null ? bytes : list.transform(bytes); return list == null ? bytes : list.transform(bytes);
} }
@@ -351,9 +351,9 @@ public final class PacketCustom implements MCDataInput, MCDataOutput {
public PacketCustom writeItemStack(ItemStack stack, boolean large) { public PacketCustom writeItemStack(ItemStack stack, boolean large) {
if (stack == null) { if (stack == null) {
writeShort(-1); writeInt(-1);
} else { } else {
writeShort(Item.getIdFromItem(stack.getItem())); writeInt(Item.getIdFromItem(stack.getItem()));
if (large) writeInt(stack.stackSize); if (large) writeInt(stack.stackSize);
else writeByte(stack.stackSize); else writeByte(stack.stackSize);
writeShort(stack.getItemDamage()); writeShort(stack.getItemDamage());
@@ -448,7 +448,7 @@ public final class PacketCustom implements MCDataInput, MCDataOutput {
public ItemStack readItemStack(boolean large) { public ItemStack readItemStack(boolean large) {
ItemStack item = null; ItemStack item = null;
short itemID = readShort(); int itemID = readInt();
if (itemID >= 0) { if (itemID >= 0) {
int stackSize = large ? readInt() : readByte(); int stackSize = large ? readInt() : readByte();