CactiChameleon9/PrismLauncher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move legacy support classes to another jar

Browse Source 
Signed-off-by: TheKodeToad <TheKodeToad@proton.me>
This commit is contained in:
TheKodeToad
2023-01-06 09:21:09 +00:00
parent cb32711077
commit 17317ea308
23 changed files with 150 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
libraries/launcher/legacy/net/minecraft/Launcher.java Normal file
View File

@ -0,0 +1,225 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 icelimetea <fr3shtea@outlook.com>
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
* Copyright (C) 2022 solonovamax <solonovamax@12oclockpoint.com>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.minecraft;
import java.applet.Applet;
import java.applet.AppletStub;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
/**
* WARNING: This class is reflectively accessed by legacy Forge versions.
* <p>
* Changing field and method declarations without further testing is not
* recommended.
*/
public final class Launcher extends Applet implements AppletStub {
private static final long serialVersionUID = 1L;
private final Map<String, String> params = new HashMap<>();
private Applet wrappedApplet;
private final URL documentBase;
private boolean active = false;
public Launcher(Applet applet) {
this(applet, null);
}
public Launcher(Applet applet, URL documentBase) {
setLayout(new BorderLayout());
add(applet, "Center");
wrappedApplet = applet;
try {
if (documentBase == null) {
if (applet.getClass().getPackage().getName().startsWith("com.mojang.")) {
// Special case only for Classic versions
documentBase = new URL("http://www.minecraft.net:80/game/");
} else {
documentBase = new URL("http://www.minecraft.net/game/");
}
}
} catch (MalformedURLException e) {
throw new AssertionError(e);
}
this.documentBase = documentBase;
}
public void replace(Applet applet) {
wrappedApplet = applet;
applet.setStub(this);
applet.setSize(getWidth(), getHeight());
setLayout(new BorderLayout());
add(applet, "Center");
applet.init();
active = true;
applet.start();
validate();
}
@Override
public boolean isActive() {
return active;
}
@Override
public URL getDocumentBase() {
return documentBase;
}
@Override
public URL getCodeBase() {
try {
return new URL("http://www.minecraft.net/game/");
} catch (MalformedURLException e) {
throw new AssertionError(e);
}
}
@Override
public String getParameter(String key) {
String param = params.get(key);
if (param != null)
return param;
try {
return super.getParameter(key);
} catch (Throwable ignored) {
}
return null;
}
@Override
public void resize(int width, int height) {
wrappedApplet.resize(width, height);
}
@Override
public void resize(Dimension size) {
wrappedApplet.resize(size);
}
@Override
public void init() {
if (wrappedApplet != null)
wrappedApplet.init();
}
@Override
public void start() {
wrappedApplet.start();
active = true;
}
@Override
public void stop() {
wrappedApplet.stop();
active = false;
}
@Override
public void destroy() {
wrappedApplet.destroy();
}
@Override
public void appletResize(int width, int height) {
wrappedApplet.resize(width, height);
}
@Override
public void setVisible(boolean visible) {
super.setVisible(visible);
wrappedApplet.setVisible(visible);
}
@Override
public void paint(Graphics graphics) {
}
@Override
public void update(Graphics graphics) {
}
public void setParameter(String key, String value) {
params.put(key, value);
}
public void setParameter(String key, boolean value) {
setParameter(key, value ? "true" : "false");
}
}

190
libraries/launcher/legacy/org/prismlauncher/legacy/LegacyFrame.java Normal file
View File

@ -0,0 +1,190 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 icelimetea <fr3shtea@outlook.com>
* Copyright (C) 2022 flow <flowlnlnln@gmail.com>
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.prismlauncher.legacy;
import java.applet.Applet;
import java.awt.Dimension;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import org.prismlauncher.utils.logging.Log;
import net.minecraft.Launcher;
final class LegacyFrame extends JFrame {
private static final long serialVersionUID = 1L;
private final Launcher launcher;
public LegacyFrame(String title, Applet applet) {
super(title);
launcher = new Launcher(applet);
applet.setStub(launcher);
try {
setIconImage(ImageIO.read(new File("icon.png")));
} catch (IOException e) {
Log.error("Failed to read window icon", e);
}
addWindowListener(new ForceExitHandler());
}
public void start(String user, String session, int width, int height, boolean maximize, String serverAddress,
String serverPort, boolean demo) {
// Implements support for launching in to multiplayer on classic servers using a
// mpticket file generated by an external program and stored in the instance's
// root folder.
Path instanceFolder = Paths.get("..");
Path mpticket = instanceFolder.resolve("mpticket");
Path mpticketCorrupt = instanceFolder.resolve("mpticket.corrupt");
if (Files.exists(mpticket)) {
try {
List<String> lines = Files.readAllLines(mpticket, StandardCharsets.UTF_8);
if (lines.size() < 3) {
Files.move(mpticket, mpticketCorrupt, StandardCopyOption.REPLACE_EXISTING);
Log.warning("mpticket file is corrupted");
} else {
// Assumes parameters are valid and in the correct order
launcher.setParameter("server", lines.get(0));
launcher.setParameter("port", lines.get(1));
launcher.setParameter("mppass", lines.get(2));
}
} catch (IOException e) {
Log.error("Failed to read mpticket file", e);
}
}
if (serverAddress != null) {
launcher.setParameter("server", serverAddress);
launcher.setParameter("port", serverPort);
}
launcher.setParameter("username", user);
launcher.setParameter("sessionid", session);
launcher.setParameter("stand-alone", true); // Show the quit button. TODO: why won't this work?
launcher.setParameter("haspaid", true); // Some old versions need this for world saves to work.
launcher.setParameter("demo", demo);
launcher.setParameter("fullscreen", false);
add(launcher);
launcher.setPreferredSize(new Dimension(width, height));
pack();
setLocationRelativeTo(null);
setResizable(true);
if (maximize)
setExtendedState(MAXIMIZED_BOTH);
validate();
launcher.init();
launcher.start();
setVisible(true);
}
private final class ForceExitHandler extends WindowAdapter {
@Override
public void windowClosing(WindowEvent event) {
// FIXME better solution
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(30000L);
} catch (InterruptedException e) {
Log.error("Thread interrupted", e);
}
Log.warning("Forcing exit");
System.exit(0);
}
}).start();
if (launcher != null) {
launcher.stop();
launcher.destroy();
}
// old minecraft versions can hang without this >_<
System.exit(0);
}
}
}

161
libraries/launcher/legacy/org/prismlauncher/legacy/LegacyLauncher.java Normal file
View File

@ -0,0 +1,161 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 icelimetea <fr3shtea@outlook.com>
* Copyright (C) 2022 flow <flowlnlnln@gmail.com>
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
* Copyright (C) 2022 solonovamax <solonovamax@12oclockpoint.com>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.prismlauncher.legacy;
import java.applet.Applet;
import java.io.File;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Collections;
import java.util.List;
import org.prismlauncher.launcher.impl.AbstractLauncher;
import org.prismlauncher.utils.Parameters;
import org.prismlauncher.utils.ReflectionUtils;
import org.prismlauncher.utils.logging.Log;
/**
* Used to launch old versions that support applets.
*/
final class LegacyLauncher extends AbstractLauncher {
private final String user, session;
private final String title;
private final String appletClass;
private final boolean useApplet;
private final String gameDir;
public LegacyLauncher(Parameters params) {
super(params);
user = params.getString("userName");
session = params.getString("sessionId");
title = params.getString("windowTitle", "Minecraft");
appletClass = params.getString("appletClass", "net.minecraft.client.MinecraftApplet");
List<String> traits = params.getList("traits", Collections.<String>emptyList());
useApplet = !traits.contains("noapplet");
gameDir = System.getProperty("user.dir");
}
@Override
public void launch() throws Throwable {
Class<?> main = ClassLoader.getSystemClassLoader().loadClass(mainClassName);
Field gameDirField = findMinecraftGameDirField(main);
if (gameDirField != null) {
gameDirField.setAccessible(true);
gameDirField.set(null, new File(gameDir));
}
if (useApplet) {
System.setProperty("minecraft.applet.TargetDirectory", gameDir);
try {
LegacyFrame window = new LegacyFrame(title, createAppletClass(appletClass));
window.start(user, session, width, height, maximize, serverAddress, serverPort,
gameArgs.contains("--demo"));
return;
} catch (Throwable e) {
Log.error("Running applet wrapper failed with exception; falling back to main class", e);
}
}
// find and invoke the main method, this time without size parameters
// in all versions that support applets, these are ignored
MethodHandle method = ReflectionUtils.findMainMethod(main);
method.invokeExact(gameArgs.toArray(new String[0]));
}
private static Applet createAppletClass(String clazz) throws Throwable {
Class<?> appletClass = ClassLoader.getSystemClassLoader().loadClass(clazz);
MethodHandle appletConstructor = MethodHandles.lookup().findConstructor(appletClass, MethodType.methodType(void.class));
return (Applet) appletConstructor.invoke();
}
private static Field findMinecraftGameDirField(Class<?> clazz) {
Log.debug("Resolving minecraft game directory field");
// search for private static File
for (Field field : clazz.getDeclaredFields()) {
if (field.getType() != File.class) {
continue;
}
int fieldModifiers = field.getModifiers();
if (!Modifier.isStatic(fieldModifiers))
continue;
if (!Modifier.isPrivate(fieldModifiers))
continue;
if (Modifier.isFinal(fieldModifiers))
continue;
return field;
}
return null;
}
}

17
libraries/launcher/legacy/org/prismlauncher/legacy/LegacyProxy.java Normal file
View File

@ -0,0 +1,17 @@
package org.prismlauncher.legacy;
import org.prismlauncher.launcher.Launcher;
import org.prismlauncher.legacy.fix.online.OnlineFixes;
import org.prismlauncher.utils.Parameters;
public final class LegacyProxy {
public static Launcher createLauncher(Parameters params) {
return new LegacyLauncher(params);
}
public static void applyOnlineFixes(Parameters parameters) {
OnlineFixes.apply(parameters);
}
}

65
libraries/launcher/legacy/org/prismlauncher/legacy/fix/online/Handler.java Normal file
View File

@ -0,0 +1,65 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.fix.online;
import java.io.IOException;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import org.prismlauncher.legacy.utils.url.UrlUtils;
final class Handler extends URLStreamHandler {
@Override
protected URLConnection openConnection(URL address) throws IOException {
return openConnection(address, null);
}
@Override
protected URLConnection openConnection(URL address, Proxy proxy) throws IOException {
URLConnection result;
// try skin fix
result = SkinFix.openConnection(address, proxy);
if (result != null)
return result;
return UrlUtils.openConnection(address, proxy);
}
}

81
libraries/launcher/legacy/org/prismlauncher/legacy/fix/online/OnlineFixes.java Normal file
View File

@ -0,0 +1,81 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.fix.online;
import java.net.URL;
import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import org.prismlauncher.legacy.utils.Base64;
import org.prismlauncher.legacy.utils.url.UrlUtils;
import org.prismlauncher.utils.Parameters;
import org.prismlauncher.utils.logging.Log;
/**
* Fixes skins by redirecting to other URLs.
*
* @see {@link Handler}
* @see {@link UrlUtils}
*/
public final class OnlineFixes implements URLStreamHandlerFactory {
public static void apply(Parameters params) {
if (!"true".equals(params.getString("onlineFixes", null)))
return;
if (!UrlUtils.isSupported() || !Base64.isSupported()) {
Log.warning("Cannot access the necessary Java internals for skin fix");
Log.warning("Turning off legacy skin fix in Settings > Miscellaneous will silence the warnings");
return;
}
try {
URL.setURLStreamHandlerFactory(new OnlineFixes());
} catch (Error e) {
Log.warning("Cannot apply skin fix: URLStreamHandlerFactory is already set");
Log.warning("Turning off legacy skin fix in Settings > Miscellaneous will silence the warnings");
}
}
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
if ("http".equals(protocol))
return new Handler();
return null;
}
}

123
libraries/launcher/legacy/org/prismlauncher/legacy/fix/online/SkinFix.java Normal file
View File

@ -0,0 +1,123 @@
package org.prismlauncher.legacy.fix.online;
import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import javax.imageio.ImageIO;
import org.prismlauncher.legacy.utils.api.*;
import org.prismlauncher.legacy.utils.url.*;
final class SkinFix {
static URLConnection openConnection(URL address, Proxy proxy) throws IOException {
String skinOwner = findSkinOwner(address);
if (skinOwner != null)
// we need to correct the skin
return getSkinConnection(skinOwner, proxy);
String capeOwner = findCapeOwner(address);
if (capeOwner != null) {
// since we do not need to process the image, open a direct connection bypassing Handler
Texture texture = MojangApi.getTexture(MojangApi.getUuid(capeOwner), "CAPE");
if (texture == null)
return null;
return UrlUtils.openConnection(texture.getUrl(), proxy);
}
return null;
}
private static URLConnection getSkinConnection(String owner, Proxy proxy) throws IOException {
Texture texture = MojangApi.getTexture(MojangApi.getUuid(owner), "SKIN");
if (texture == null)
return null;
URLConnection connection = UrlUtils.openConnection(texture.getUrl(), proxy);
try (InputStream in = connection.getInputStream()) {
// thank you craftycodie!
// this is heavily based on
// https://github.com/Mojang/LegacyLauncher/pull/33/files#diff-b61023785a9260651ca0a223573ea9acb5be5eec478bff626dafb7abe13ffebaR99
BufferedImage image = ImageIO.read(in);
Graphics2D graphics = image.createGraphics();
graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
BufferedImage subimage;
if (image.getHeight() > 32) {
// flatten second layers
subimage = image.getSubimage(0, 32, 56, 16);
graphics.drawImage(subimage, 0, 16, null);
}
if (texture.isSlim()) {
// convert slim to wide
subimage = image.getSubimage(45, 16, 9, 16);
graphics.drawImage(subimage, 46, 16, null);
subimage = image.getSubimage(49, 16, 2, 4);
graphics.drawImage(subimage, 50, 16, null);
subimage = image.getSubimage(53, 20, 2, 12);
graphics.drawImage(subimage, 54, 20, null);
}
graphics.dispose();
// crop the image
ByteArrayOutputStream out = new ByteArrayOutputStream();
image = image.getSubimage(0, 0, 64, 32);
ImageIO.write(image, "png", out);
return new CustomUrlConnection(out.toByteArray());
}
}
private static String findSkinOwner(URL address) {
switch (address.getHost()) {
case "www.minecraft.net":
return stripIfPrefixed(address.getPath(), "/skin/");
case "s3.amazonaws.com":
case "skins.minecraft.net":
return stripIfPrefixed(address.getPath(), "/MinecraftSkins/");
}
return null;
}
private static String findCapeOwner(URL address) {
switch (address.getHost()) {
case "www.minecraft.net":
return stripIfPrefixed(address.getQuery(), "user=");
case "s3.amazonaws.com":
case "skins.minecraft.net":
return stripIfPrefixed(address.getPath(), "/MinecraftCloaks/");
}
return null;
}
private static String stripIfPrefixed(String string, String prefix) {
if (string != null && string.startsWith(prefix)) {
string = string.substring(prefix.length());
if (string.endsWith(".png"))
string = string.substring(0, string.lastIndexOf('.'));
return string;
}
return null;
}
}

94
libraries/launcher/legacy/org/prismlauncher/legacy/utils/Base64.java Normal file
View File

@ -0,0 +1,94 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.nio.charset.StandardCharsets;
import org.prismlauncher.utils.logging.Log;
/**
* Uses Base64 with Java 8 or later, otherwise DatatypeConverter. In the latter
* case, reflection is used to allow using newer compilers.
*/
public final class Base64 {
private static boolean supported = true;
private static MethodHandle legacy;
static {
try {
Class.forName("java.util.Base64");
} catch (ClassNotFoundException e) {
try {
Class<?> datatypeConverter = Class.forName("javax.xml.bind.DatatypeConverter");
legacy = MethodHandles.lookup().findStatic(datatypeConverter, "parseBase64Binary",
MethodType.methodType(byte[].class, String.class));
} catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException e1) {
Log.error("Base64 not supported", e1);
supported = false;
}
}
}
/**
* Determines whether base64 is supported.
*
* @return <code>true</code> if base64 can be parsed
*/
public static boolean isSupported() {
return supported;
}
public static byte[] decode(String input) {
if (!isSupported())
throw new UnsupportedOperationException();
if (legacy == null)
return java.util.Base64.getDecoder().decode(input.getBytes(StandardCharsets.UTF_8));
try {
return (byte[]) legacy.invokeExact(input);
} catch (Error | RuntimeException e) {
throw e;
} catch (Throwable e) {
throw new Error(e);
}
}
}

48
libraries/launcher/legacy/org/prismlauncher/legacy/utils/JsonParseException.java Normal file
View File

@ -0,0 +1,48 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils;
import java.io.IOException;
public class JsonParseException extends IOException {
private static final long serialVersionUID = 1L;
public JsonParseException(String message) {
super(message);
}
}

410
libraries/launcher/legacy/org/prismlauncher/legacy/utils/JsonParser.java Normal file
View File

@ -0,0 +1,410 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Single-file JSON parser to allow for usage in versions without GSON.
*/
public final class JsonParser {
private final Reader in;
private char[] buffer;
private int pos, length;
public static Object parse(String in) throws JsonParseException, IOException {
return parse(new StringReader(in));
}
public static Object parse(InputStream in) throws JsonParseException, IOException {
return parse(new InputStreamReader(in, StandardCharsets.UTF_8));
}
public static Object parse(Reader in) throws JsonParseException, IOException {
return new JsonParser(in).readSingleValue();
}
private JsonParser(Reader in) throws IOException {
this.in = in;
pos = length = 0;
read();
}
private int character() {
if (length == -1)
return -1;
return buffer[pos];
}
private int read() throws IOException {
if (length == -1)
return -1;
if (buffer == null || pos++ == length - 1) {
pos = 0;
buffer = new char[8192];
length = in.read(buffer);
}
return character();
}
private void assertCharacter(char character) throws JsonParseException {
if (character() != character)
throw new JsonParseException("Expected '" + character + "' but got "
+ (character() != -1 ? ("'" + (char) character() + "'") : "EOF"));
}
private void assertNoEOF(String expected) throws JsonParseException {
if (character() == -1)
throw new JsonParseException("Expected " + expected + " but got EOF");
}
private void skipWhitespace() throws IOException {
while (isWhitespace())
read();
}
private boolean isWhitespace() {
return character() == ' ' || character() == '\n' || character() == '\r' || character() == '\t';
}
private Object readSingleValue() throws IOException {
skipWhitespace();
Object result = readValue();
if (!(result instanceof Double))
read();
skipWhitespace();
if (character() != -1)
throw new JsonParseException("Found trailing non-whitespace characters");
return result;
}
private Object readValue() throws IOException {
assertNoEOF("a value");
int character = character();
switch (character) {
case '{':
return readObject();
case '[':
return readArray();
case '"':
return readString();
case 't':
case 'f':
// probably boolean
Boolean bool = readBoolean();
if (bool != null)
return bool;
break;
case 'n':
// probably null
if (readNull())
return null;
break;
}
if (character == '-' || isDigit())
// probably a number
return readNumber();
throw new JsonParseException("Expected a JSON value but got '" + (char) character + "'");
}
private Map<String, Object> readObject() throws IOException {
assertCharacter('{');
Map<String, Object> obj = new HashMap<>();
boolean comma = false;
read();
skipWhitespace();
while (character() != '}') {
if (comma) {
assertCharacter(',');
read();
skipWhitespace();
}
String key = readString();
read();
skipWhitespace();
assertCharacter(':');
read();
skipWhitespace();
Object value = readValue();
obj.put(key, value);
if (!(value instanceof Double))
read();
skipWhitespace();
comma = true;
}
return obj;
}
private List<Object> readArray() throws IOException {
assertCharacter('[');
List<Object> array = new ArrayList<>();
boolean comma = false;
read();
skipWhitespace();
while (character() != ']') {
if (comma) {
assertCharacter(',');
read();
skipWhitespace();
}
Object value = readValue();
array.add(value);
if (!(value instanceof Double))
read();
skipWhitespace();
comma = true;
}
return array;
}
private String readString() throws IOException {
assertCharacter('"');
StringBuilder result = new StringBuilder();
while (read() != '"') {
int character = character();
if (character >= '\u0000' && character <= '\u001F')
throw new JsonParseException("Found unescaped control character within string");
switch (character) {
case -1:
throw new JsonParseException("Expected '\"' but got EOF");
case 0x7F:
if (read() == '"') {
return result.toString();
}
continue;
case '\\':
int seq = read();
switch (seq) {
case -1:
throw new JsonParseException("Expected an escape sequence but got EOF");
case '\\':
break;
case '/':
case '\"':
character = seq;
break;
case 'b':
character = '\b';
break;
case 'f':
character = '\f';
break;
case 'n':
character = '\n';
break;
case 'r':
character = '\r';
break;
case 't':
character = '\t';
break;
case 'u':
// char array to allow allocation in advance.
char[] digits = new char[4];
for (int index = 0; index < digits.length; index++) {
character = read();
if (index == 0 && character() == '-') {
throw new JsonParseException("Hex sequence may not be negative");
} else if (character() == -1) {
throw new JsonParseException("Expected a hex sequence but got EOF");
}
digits[index] = (char) character;
}
String digitsString = new String(digits);
try {
character = Integer.parseInt(digitsString, 16);
} catch (NumberFormatException e) {
throw new JsonParseException("Could not parse hex sequence \"" + digitsString + "\"");
}
break;
default:
throw new JsonParseException("Invalid escape sequence: \\" + (char) seq);
}
break;
}
result.append((char) character);
}
return result.toString();
}
private boolean isDigit() {
return character() >= '0' && character() <= '9';
}
private Double readNumber() throws IOException {
StringBuilder result = new StringBuilder();
if (character() == '-') {
result.append((char) character());
read();
}
if (character() == '0') {
result.append((char) character());
read();
if (isDigit())
throw new JsonParseException("Found superfluous leading zero");
} else if (!isDigit())
throw new JsonParseException("Expected digits");
while (character() != -1 && isDigit()) {
result.append((char) character());
read();
}
if (character() == '.') {
result.append('.');
read();
assertNoEOF("digits");
if (!isDigit())
throw new JsonParseException("Expected digits after decimal point");
while (character() != -1 && isDigit()) {
result.append((char) character());
read();
}
}
if (character() == 'e' || character() == 'E') {
result.append('E');
read();
assertNoEOF("digits");
if (character() == '+' || character() == '-') {
result.append((char) character());
read();
}
if (!(character() == '+' || character() == '-' || isDigit()))
throw new JsonParseException("Expected exponent digits");
while (character() != -1 && isDigit()) {
result.append((char) character());
read();
}
}
String resultStr = result.toString();
try {
return Double.parseDouble(resultStr);
} catch (NumberFormatException e) {
throw new JsonParseException("Failed to parse number '" + resultStr + "'");
}
}
private Boolean readBoolean() throws IOException {
if (character() == 't') {
if (read() == 'r' && read() == 'u' && read() == 'e') {
return true;
}
} else if (character() == 'f') {
if (read() == 'a' && read() == 'l' && read() == 's' && read() == 'e') {
return false;
}
}
return null;
}
private boolean readNull() throws IOException {
return character() == 'n' && read() == 'u' && read() == 'l' && read() == 'l';
}
}

100
libraries/launcher/legacy/org/prismlauncher/legacy/utils/api/MojangApi.java Normal file
View File

@ -0,0 +1,100 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils.api;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Map;
import org.prismlauncher.legacy.utils.*;
/**
* Basic access to Mojang's Minecraft API.
*/
@SuppressWarnings("unchecked")
public final class MojangApi {
public static String getUuid(String username) throws IOException {
try (InputStream in = new URL("https://api.mojang.com/users/profiles/minecraft/" + username).openStream()) {
Map<String, Object> map = (Map<String, Object>) JsonParser.parse(in);
return (String) map.get("id");
}
}
public static Texture getTexture(String player, String name) throws IOException {
Map<String, Object> map = getTextures(player);
if (map != null) {
map = (Map<String, Object>) map.get(name);
if (map == null)
return null;
URL url = new URL((String) map.get("url"));
boolean slim = false;
if (name.equals("SKIN")) {
map = (Map<String, Object>) map.get("metadata");
if (map != null && "slim".equals(map.get("model")))
slim = true;
}
return new Texture(url, slim);
}
return null;
}
public static Map<String, Object> getTextures(String player) throws IOException {
try (InputStream profileIn = new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + player)
.openStream()) {
Map<String, Object> profile = (Map<String, Object>) JsonParser.parse(profileIn);
for (Map<String, Object> property : (Iterable<Map<String, Object>>) profile.get("properties")) {
if (property.get("name").equals("textures")) {
Map<String, Object> result = (Map<String, Object>) JsonParser
.parse(new String(Base64.decode((String) property.get("value"))));
result = (Map<String, Object>) result.get("textures");
return result;
}
}
return null;
}
}
}

61
libraries/launcher/legacy/org/prismlauncher/legacy/utils/api/Texture.java Normal file
View File

@ -0,0 +1,61 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils.api;
import java.net.URL;
/**
* Represents a texture from the Mojang API.
*/
public final class Texture {
private final URL url;
private final boolean slim;
public Texture(URL url, boolean slim) {
this.url = url;
this.slim = slim;
}
public URL getUrl() {
return url;
}
public boolean isSlim() {
return slim;
}
}

79
libraries/launcher/legacy/org/prismlauncher/legacy/utils/url/CustomUrlConnection.java Normal file
View File

@ -0,0 +1,79 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils.url;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
public class CustomUrlConnection extends HttpURLConnection {
private InputStream in;
public CustomUrlConnection(byte[] data) {
this(new ByteArrayInputStream(data));
}
public CustomUrlConnection(InputStream in) {
super(null);
this.in = in;
}
@Override
public void connect() throws IOException {
responseCode = 200;
}
@Override
public void disconnect() {
try {
in.close();
} catch (IOException e) {
}
}
@Override
public InputStream getInputStream() throws IOException {
return in;
}
@Override
public boolean usingProxy() {
return false;
}
}

110
libraries/launcher/legacy/org/prismlauncher/legacy/utils/url/UrlUtils.java Normal file
View File

@ -0,0 +1,110 @@
// SPDX-License-Identifier: GPL-3.0-only
/*
* Prism Launcher - Minecraft Launcher
* Copyright (C) 2022 TheKodeToad <TheKodeToad@proton.me>
*
* 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, version 3.
*
* 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.
*
* Linking this library statically or dynamically with other modules is
* making a combined work based on this library. Thus, the terms and
* conditions of the GNU General Public License cover the whole
* combination.
*
* As a special exception, the copyright holders of this library give
* you permission to link this library with independent modules to
* produce an executable, regardless of the license terms of these
* independent modules, and to copy and distribute the resulting
* executable under terms of your choice, provided that you also meet,
* for each linked independent module, the terms and conditions of the
* license of that module. An independent module is a module which is
* not derived from or based on this library. If you modify this
* library, you may extend this exception to your version of the
* library, but you are not obliged to do so. If you do not wish to do
* so, delete this exception statement from your version.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.prismlauncher.legacy.utils.url;
import java.io.IOException;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import org.prismlauncher.utils.logging.Log;
/**
* A utility class for URLs which uses reflection to access constructors for
* internal classes.
*/
public final class UrlUtils {
private static URLStreamHandler http;
private static MethodHandle openConnection;
static {
try {
// we first obtain the stock URLStreamHandler for http as we overwrite it later
Method getURLStreamHandler = URL.class.getDeclaredMethod("getURLStreamHandler", String.class);
getURLStreamHandler.setAccessible(true);
http = (URLStreamHandler) getURLStreamHandler.invoke(null, "http");
// we next find the openConnection method
Method openConnectionReflect = URLStreamHandler.class.getDeclaredMethod("openConnection", URL.class,
Proxy.class);
openConnectionReflect.setAccessible(true);
openConnection = MethodHandles.lookup().unreflect(openConnectionReflect);
} catch (Throwable e) {
Log.error("URL reflection failed - some features may not work", e);
}
}
/**
* Determines whether all the features of this class are available.
*
* @return <code>true</code> if all features can be used
*/
public static boolean isSupported() {
return http != null && openConnection != null;
}
public static URLConnection openConnection(URL url, Proxy proxy) throws IOException {
if (http == null)
throw new UnsupportedOperationException();
if (url.getProtocol().equals("http"))
return openConnection(http, url, proxy);
// fall back to Java's default method
// at this point, this should not cause a StackOverflowError unless we've missed
// a protocol out from the if statements
return url.openConnection();
}
public static URLConnection openConnection(URLStreamHandler handler, URL url, Proxy proxy) throws IOException {
if (openConnection == null)
throw new UnsupportedOperationException();
try {
return (URLConnection) openConnection.invokeExact(handler, url, proxy);
} catch (IOException | Error | RuntimeException e) {
throw e; // rethrow if possible
} catch (Throwable e) {
throw new AssertionError(e); // oh dear! this isn't meant to happen
}
}
}