cachedResponses = new HashMap<>(0);
-
- /**
- * Transforms a string (raw input) into a format that can be sent to the player
- * @param message he message to transform
- * @return the transformed message
- */
- protected abstract T transformMessage(String message);
-
- /**
- * If the message has no arguments: {
- String LINK_ACCOUNT_COMMAND = "linkaccount";
- String UNLINK_ACCOUNT_COMMAND = "unlinkaccount";
-
- /**
- * Send the specified player a message
- *
- * @param player the player to send the message to
- * @param message the command message
- * @param args the arguments
- */
- void sendMessage(P player, CommandMessage message, Object... args);
-
- /**
- * Same as {@link ICommandUtil#sendMessage(Object, CommandMessage, Object...)} except it kicks the player.
- *
- * @param player the player to send the message to
- * @param message the command message
- * @param args the arguments
- */
- void kickPlayer(P player, CommandMessage message, Object... args);
-}
diff --git a/common/src/main/java/org/geysermc/floodgate/util/MessageFormatter.java b/common/src/main/java/org/geysermc/floodgate/util/MessageFormatter.java
new file mode 100644
index 00000000..d84e12c6
--- /dev/null
+++ b/common/src/main/java/org/geysermc/floodgate/util/MessageFormatter.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.util;
+
+public final class MessageFormatter {
+ private static final String DELIM_STR = "{}";
+ private static final int DELIM_LENGTH = DELIM_STR.length();
+
+ public static String format(String message, Object... arguments) {
+ // simple variant of slf4j's parameters.
+ if (arguments == null || arguments.length == 0) return message;
+
+ String[] args = new String[arguments.length];
+ for (int i = 0; i < arguments.length; i++) {
+ args[i] = arguments[i].toString();
+ }
+
+ int previousIndex = -1;
+ int currentIndex;
+ StringBuilder stringBuilder = new StringBuilder(
+ message.length() + getArgsContentLength(args)
+ );
+
+ for (String argument : args) {
+ currentIndex = message.indexOf(DELIM_STR, previousIndex);
+ if (currentIndex == -1) {
+ // no parameter places left in message,
+ // we'll ignore the remaining parameters and return the message
+ if (previousIndex == -1) return message;
+ else {
+ stringBuilder.append(message.substring(previousIndex));
+ return stringBuilder.toString();
+ }
+ }
+
+ if (previousIndex == -1) stringBuilder.append(message, 0, currentIndex);
+ else stringBuilder.append(message, previousIndex, currentIndex);
+ stringBuilder.append(argument);
+
+ // we finished this argument, so we're past the current delimiter
+ previousIndex = currentIndex + DELIM_LENGTH;
+ }
+
+ if (previousIndex != message.length())
+ stringBuilder.append(message, previousIndex, message.length());
+ return stringBuilder.toString();
+ }
+
+ public static int getArgsContentLength(String... args) {
+ int length = 0;
+ for (String arg : args)
+ length += arg.length();
+ return length;
+ }
+}
diff --git a/common/src/main/java/org/geysermc/floodgate/util/ReflectionUtil.java b/common/src/main/java/org/geysermc/floodgate/util/ReflectionUtil.java
index 4f13270f..66aef2e8 100644
--- a/common/src/main/java/org/geysermc/floodgate/util/ReflectionUtil.java
+++ b/common/src/main/java/org/geysermc/floodgate/util/ReflectionUtil.java
@@ -1,28 +1,55 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
package org.geysermc.floodgate.util;
-import lombok.Getter;
import lombok.Setter;
import java.lang.reflect.*;
-public class ReflectionUtil {
+public final class ReflectionUtil {
/**
* Prefix without dot{@link #getValue(Object, Field) getValue}(instance,
+ * {@link #getField(Class, String) getField}(instance.getClass(), fieldName))
+ */
public static Object getValue(Object instance, String fieldName) {
return getValue(instance, getField(instance.getClass(), fieldName));
}
@SuppressWarnings("unchecked")
- public static T getCastedValue(Object instance, Field field, Class returnType) {
+ public static T getCastedValue(Object instance, Field field) {
return (T) getValue(instance, field);
}
- @SuppressWarnings("unchecked")
- public static T getCastedValue(Object instance, String fieldName, Class returnType) {
- return (T) getValue(instance, getField(instance.getClass(), fieldName));
+ /**
+ * This method is equal to running:{@link #getCastedValue(Object, Field) getCastedValue}(instance,
+ * {@link #getField(Class, String) getField}(instance.getClass(), fieldName))
+ */
+ public static T getCastedValue(Object instance, String fieldName) {
+ return getCastedValue(instance, getField(instance.getClass(), fieldName));
}
public static boolean setValue(Object instance, String fieldName, Object value) {
@@ -86,8 +133,8 @@ public class ReflectionUtil {
makeAccessible(field);
try {
field.set(instance, value);
- } catch (IllegalAccessException e) {
- e.printStackTrace();
+ } catch (IllegalAccessException exception) {
+ exception.printStackTrace();
}
}
@@ -95,69 +142,110 @@ public class ReflectionUtil {
try {
makeAccessible(field);
- Field modifiersField = null;
int modifiers = field.getModifiers();
if (Modifier.isFinal(modifiers)) {
- try {
- modifiersField = Field.class.getDeclaredField("modifiers");
- } catch (NoSuchFieldException e) {
- // Java 12 compatibility, thanks to https://github.com/powermock/powermock/pull/1010
- Method getDeclaredFields0 = Class.class.getDeclaredMethod("getDeclaredFields0", boolean.class);
- makeAccessible(getDeclaredFields0);
- Field[] fields = (Field[]) getDeclaredFields0.invoke(Field.class, false);
- for (Field classField : fields) {
- if ("modifiers".equals(classField.getName())) {
- modifiersField = classField;
- break;
- }
- }
- }
- assert modifiersField != null;
+ Field modifiersField = getModifiersField();
makeAccessible(modifiersField);
modifiersField.setInt(field, modifiers & ~Modifier.FINAL);
}
setValue(instance, field, value);
return true;
- } catch (Exception e) {
- e.printStackTrace();
+ } catch (Exception exception) {
+ exception.printStackTrace();
return false;
}
}
- public static Method getMethod(Class clazz, String method, Class... args) {
+ public static Field getModifiersField(){
+ if (modifiersField != null) return modifiersField;
+
try {
- return clazz.getMethod(method, args);
- } catch (NoSuchMethodException e) {
- e.printStackTrace();
+ modifiersField = Field.class.getDeclaredField("modifiers");
+ } catch (NoSuchFieldException exception) {
+ // Java 12 compatibility, thanks to https://github.com/powermock/powermock/pull/1010
+ try {
+ Method getDeclaredFields0 = Class.class.getDeclaredMethod(
+ "getDeclaredFields0", boolean.class
+ );
+ makeAccessible(getDeclaredFields0);
+
+ Field[] fields = (Field[]) getDeclaredFields0.invoke(Field.class, false);
+ for (Field field : fields) {
+ if ("modifiers".equals(field.getName())) {
+ modifiersField = field;
+ break;
+ }
+ }
+ } catch (Exception exception1) {
+ exception1.printStackTrace();
+ return null;
+ }
+ }
+ return modifiersField;
+ }
+
+ public static Method getMethod(Class clazz, String method,
+ boolean isPublic, Class... args) {
+ try {
+ return isPublic ? clazz.getMethod(method, args) : clazz.getDeclaredMethod(method, args);
+ } catch (NoSuchMethodException exception) {
+ // method is not found, so we return null
return null;
}
}
- public static Object invoke(Object instance, Method method) {
+ public static Method getMethod(Class clazz, String methodName, Class... args) {
+ Method method = getMethod(clazz, methodName, false, args);
+ if (method != null) {
+ return method;
+ }
+ return getMethod(clazz, methodName, true, args);
+ }
+
+ public static Method getMethod(Object instance, String method, Class... args) {
+ return getMethod(instance.getClass(), method, args);
+ }
+
+ public static Object invoke(Object instance, Method method, Object... args) {
+ makeAccessible(method);
try {
- return method.invoke(instance);
- } catch (IllegalAccessException | InvocationTargetException e) {
- e.printStackTrace();
+ return method.invoke(instance, args);
+ } catch (IllegalAccessException | InvocationTargetException exception) {
+ exception.printStackTrace();
return null;
}
}
+ public static Object invoke(Object instance, String method) {
+ return invoke(instance, getMethod(instance.getClass(), method));
+ }
+
@SuppressWarnings("unchecked")
- public static T invokeCasted(Object instance, Method method, Class cast) {
- return (T) invoke(instance, method);
+ public static T castedInvoke(Object instance, Method method, Object... args) {
+ try {
+ return (T) invoke(instance, method, args);
+ } catch (NullPointerException exception) {
+ return null;
+ }
+ }
+
+ public static T castedInvoke(Object instance, String method) {
+ return castedInvoke(instance, getMethod(instance.getClass(), method));
}
public static Object invokeStatic(Class clazz, String method) {
try {
- return getMethod(clazz, method).invoke(null);
- } catch (IllegalAccessException | InvocationTargetException e) {
- e.printStackTrace();
+ return invoke(null, getMethod(clazz, method));
+ } catch (NullPointerException exception) {
+ exception.printStackTrace();
return null;
}
}
public static T makeAccessible(T accessibleObject) {
- if (!accessibleObject.isAccessible()) accessibleObject.setAccessible(true);
+ if (!accessibleObject.isAccessible()) {
+ accessibleObject.setAccessible(true);
+ }
return accessibleObject;
}
}
diff --git a/common/src/main/resources/config.yml b/common/src/main/resources/config.yml
index 255ef4f3..9cb41687 100644
--- a/common/src/main/resources/config.yml
+++ b/common/src/main/resources/config.yml
@@ -17,16 +17,13 @@ disconnect:
invalid-key: Please connect through the official Geyser
# The disconnect message Geyser users should get when connecting
# to the server with the correct key but not with the correct data format
- invalid-arguments-length: Expected {0} arguments, got {1}. Is Geyser up-to-date?
+ invalid-arguments-length: Expected {} arguments, got {}. Is Geyser up-to-date?
# Configuration for player linking
player-link:
# Whether to enable the linking system. Turning this off will prevent
# players from using the linking feature even if they are already linked.
enable: false
- # The type of storage system you want to use
- # Currently implemented: SQLite
- type: sqlite
# Whether to allow the use of /linkaccount and /unlinkaccount
# You can also use allow specific people to use the commands using the
# permissions floodgate.linkaccount and floodgate.unlinkaccount.
@@ -34,3 +31,13 @@ player-link:
allow-linking: true
# The amount of time until a link code expires in seconds
link-code-timeout: 300
+ # The database type you want to use.
+ # The option is only used when auto-download is enabled or when
+ # there are more then one database implementations found in the config directory
+ type: sqlite
+ # Automatically download the database type you want to use
+ # This doesn't include updating automatically (I don't expect the database implementations to be updated frequently)
+ auto-download: true
+
+# Do not change this
+config-version: 1
diff --git a/bungee/src/main/resources/config.yml b/common/src/main/resources/proxy-config.yml
similarity index 73%
rename from bungee/src/main/resources/config.yml
rename to common/src/main/resources/proxy-config.yml
index d127d524..87d797af 100644
--- a/bungee/src/main/resources/config.yml
+++ b/common/src/main/resources/proxy-config.yml
@@ -11,7 +11,8 @@ username-prefix: "*"
# Should spaces be replaced with '_' in bedrock usernames?
replace-spaces: true
-# Should Bungeecord send the bedrock player data to the servers it is connecting to?
+# todo impl args like {proxy}
+# Should {proxy} send the bedrock player data to the servers it is connecting to?
# This requires Floodgate to be installed on the servers.
# You'll get kicked if you don't use the plugin. The default value is false because of it
send-floodgate-data: false
@@ -22,16 +23,13 @@ disconnect:
invalid-key: Please connect through the official Geyser
# The disconnect message Geyser users should get when connecting
# to the server with the correct key but not with the correct data format
- invalid-arguments-length: Expected {0} arguments, got {1}. Is Geyser up-to-date?
+ invalid-arguments-length: Expected {} arguments, got {}. Is Geyser up-to-date?
# Configuration for player linking
player-link:
# Whether to enable the linking system. Turning this off will prevent
# players from using the linking feature even if they are already linked.
enable: false
- # The type of storage system you want to use
- # Currently implemented: SQLite
- type: sqlite
# Whether to allow the use of /linkaccount and /unlinkaccount
# You can also use allow specific people to use the commands using the
# permissions floodgate.linkaccount and floodgate.unlinkaccount.
@@ -39,4 +37,14 @@ player-link:
allow-linking: true
# The amount of time until a link code expires in seconds
link-code-timeout: 300
-
+ # The database type you want to use.
+ # The option is only used when auto-download is enabled or when
+ # there are more then one database implementations found in the config directory
+ type: sqlite
+ # Automatically download the database type you want to use
+ # This doesn't include updating automatically
+ # (because the database implementations won't be updated frequently)
+ auto-download: true
+
+# Do not change this
+config-version: 1
diff --git a/database/pom.xml b/database/pom.xml
new file mode 100644
index 00000000..c1858179
--- /dev/null
+++ b/database/pom.xml
@@ -0,0 +1,52 @@
+
+
+
+
+
+ parent
+ org.geysermc.floodgate
+ 1.0-SNAPSHOT
+
+ 4.0.0
+
+ org.geysermc.floodgate.database
+ parent
+ pom
+ 1.0-SNAPSHOT
+
+ database
+
+
+ sqlite
+
+
+
+ floodgate-${project.name}-database
+
+
\ No newline at end of file
diff --git a/database/sqlite/pom.xml b/database/sqlite/pom.xml
new file mode 100644
index 00000000..216badf5
--- /dev/null
+++ b/database/sqlite/pom.xml
@@ -0,0 +1,88 @@
+
+
+
+
+
+ parent
+ org.geysermc.floodgate.database
+ 1.0-SNAPSHOT
+
+ 4.0.0
+
+ sqlite
+
+
+
+ org.xerial
+ sqlite-jdbc
+ 3.30.1
+ compile
+
+
+ org.geysermc.floodgate
+ common
+ 1.0-SNAPSHOT
+ provided
+
+
+ org.projectlombok
+ lombok
+ 1.18.12
+ provided
+
+
+
+
+
+
+ src/main/resources/
+ true
+
+
+
+
+ org.apache.maven.plugins
+ maven-shade-plugin
+ 3.2.1
+
+
+ package
+
+ shade
+
+
+
+
+ ${outputName}
+ true
+
+
+
+
+
\ No newline at end of file
diff --git a/database/sqlite/src/main/java/org/geysermc/floodgate/database/SqliteDatabase.java b/database/sqlite/src/main/java/org/geysermc/floodgate/database/SqliteDatabase.java
new file mode 100644
index 00000000..58fef691
--- /dev/null
+++ b/database/sqlite/src/main/java/org/geysermc/floodgate/database/SqliteDatabase.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.database;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import org.geysermc.floodgate.link.CommonPlayerLink;
+import org.geysermc.floodgate.util.LinkedPlayer;
+
+import java.nio.file.Path;
+import java.sql.*;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+public class SqliteDatabase extends CommonPlayerLink {
+ private Connection connection;
+ @Inject @Named("dataDirectory")
+ private Path dataDirectory;
+
+ @Override
+ public void load() {
+ Path databasePath = dataDirectory.resolve("linked-players.db");
+ try {
+ Class.forName("org.sqlite.JDBC");
+ connection = DriverManager.getConnection("jdbc:sqlite:" + databasePath.toString());
+ Statement statement = connection.createStatement();
+ statement.setQueryTimeout(30); // set timeout to 30 sec.
+ statement.executeUpdate("create table if not exists LinkedPlayers (bedrockId string, javaUniqueId string, javaUsername string)");
+ } catch (ClassNotFoundException ignored) {
+ getLogger().error("The required class to load the SQLite database wasn't found");
+ } catch (SQLException exception) {
+ getLogger().error("Error while loading database", exception);
+ }
+ }
+
+ @Override
+ public void stop() {
+ super.stop();
+ try {
+ connection.close();
+ } catch (SQLException exception) {
+ getLogger().error("Error while closing database connection", exception);
+ }
+ }
+
+ @Override
+ public CompletableFuture getLinkedPlayer(UUID bedrockId) {
+ return CompletableFuture.supplyAsync(() -> {
+ try {
+ PreparedStatement query = connection.prepareStatement("select * from LinkedPlayers where bedrockId = ?");
+ query.setString(1, bedrockId.toString());
+ ResultSet result = query.executeQuery();
+ if (!result.next()) return null;
+
+ String javaUsername = result.getString("javaUsername");
+ UUID javaUniqueId = UUID.fromString(result.getString("javaUniqueId"));
+ return new LinkedPlayer(javaUsername, javaUniqueId, bedrockId);
+ } catch (SQLException | NullPointerException exception) {
+ getLogger().error("Error while getting LinkedPlayer", exception);
+ throw new CompletionException("Error while getting LinkedPlayer", exception);
+ }
+ }, getExecutorService());
+ }
+
+ @Override
+ public CompletableFuture isLinkedPlayer(UUID bedrockId) {
+ return CompletableFuture.supplyAsync(() -> {
+ try {
+ PreparedStatement query = connection.prepareStatement("select javaUniqueId from LinkedPlayers where bedrockId = ? or javaUniqueId = ?");
+ query.setString(1, bedrockId.toString());
+ query.setString(2, bedrockId.toString());
+ ResultSet result = query.executeQuery();
+ return result.next();
+ } catch (SQLException | NullPointerException exception) {
+ getLogger().error("Error while checking if player is a LinkedPlayer", exception);
+ throw new CompletionException(
+ "Error while checking if player is a LinkedPlayer", exception
+ );
+ }
+ }, getExecutorService());
+ }
+
+ @Override
+ public CompletableFuture linkPlayer(UUID bedrockId, UUID javaId, String username) {
+ return CompletableFuture.runAsync(() -> {
+ try {
+ PreparedStatement query = connection.prepareStatement("insert into LinkedPlayers values(?, ?, ?)");
+ query.setString(1, bedrockId.toString());
+ query.setString(2, javaId.toString());
+ query.setString(3, username);
+ query.executeUpdate();
+ } catch (SQLException | NullPointerException exception) {
+ getLogger().error("Error while linking player", exception);
+ throw new CompletionException("Error while linking player", exception);
+ }
+ }, getExecutorService());
+ }
+
+ @Override
+ public CompletableFuture unlinkPlayer(UUID javaId) {
+ return CompletableFuture.runAsync(() -> {
+ try {
+ PreparedStatement query = connection.prepareStatement("delete from LinkedPlayers where javaUniqueId = ? or bedrockId = ?");
+ query.setString(1, javaId.toString());
+ query.setString(2, javaId.toString());
+ query.executeUpdate();
+ } catch (SQLException | NullPointerException exception) {
+ getLogger().error("Error while unlinking player", exception);
+ throw new CompletionException("Error while unlinking player", exception);
+ }
+ }, getExecutorService());
+ }
+}
diff --git a/database/sqlite/src/main/resources/config.json b/database/sqlite/src/main/resources/config.json
new file mode 100644
index 00000000..8d17bcbc
--- /dev/null
+++ b/database/sqlite/src/main/resources/config.json
@@ -0,0 +1,3 @@
+{
+ "mainClass": "org.geysermc.floodgate.database.SqliteDatabase"
+}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 5671356d..2264049f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,19 +4,21 @@
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.0.0
- org.geysermc
- floodgate-parent
+ org.geysermc.floodgate
+ parent
1.0-SNAPSHOT
- bungee
+ api
common
- bukkit
+ spigot
+ bungee
velocity
+ database
pom
floodgate
Allows Bedrock players to join Java edition servers while keeping online mode
- https://github.com/GeyserMC/Floodgate/
+ https://github.com/GeyserMC/Floodgate
1.0-SNAPSHOT
@@ -24,7 +26,7 @@
1.15-SNAPSHOT
1.1.0-SNAPSHOT
- ${project.name}
+ floodgate-${project.name}
UTF-8
UTF-8
1.8
diff --git a/bukkit/pom.xml b/spigot/pom.xml
similarity index 89%
rename from bukkit/pom.xml
rename to spigot/pom.xml
index cb63fe58..d708d39c 100644
--- a/bukkit/pom.xml
+++ b/spigot/pom.xml
@@ -3,13 +3,13 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- org.geysermc
- floodgate-parent
+ org.geysermc.floodgate
+ parent
1.0-SNAPSHOT
4.0.0
- floodgate-bukkit
+ spigot
@@ -38,10 +38,9 @@
provided
- org.geysermc
- floodgate-common
+ org.geysermc.floodgate
+ common
${project.version}
- compile
diff --git a/spigot/src/main/java/org/geysermc/floodgate/SpigotPlatform.java b/spigot/src/main/java/org/geysermc/floodgate/SpigotPlatform.java
new file mode 100644
index 00000000..d1f2c9f5
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/SpigotPlatform.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate;
+
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import com.google.inject.name.Named;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.api.FloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.config.loader.ConfigLoader;
+import org.geysermc.floodgate.link.PlayerLinkLoader;
+
+import java.nio.file.Path;
+
+public final class SpigotPlatform extends FloodgatePlatform {
+ @Inject private JavaPlugin plugin;
+
+ @Inject
+ public SpigotPlatform(@Named("dataDirectory") Path dataDirectory, FloodgateApi api,
+ ConfigLoader configLoader, PlayerLinkLoader playerLinkLoader,
+ HandshakeHandler handshakeHandler, FloodgateLogger logger,
+ Injector injector) {
+ super(dataDirectory, api, configLoader, playerLinkLoader,
+ handshakeHandler, logger, injector);
+ }
+
+ @Override
+ public boolean enable(Module... postCreateModules) {
+ boolean success = super.enable(postCreateModules);
+ if (!success) {
+ Bukkit.getPluginManager().disablePlugin(plugin);
+ }
+ return success;
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/SpigotPlugin.java b/spigot/src/main/java/org/geysermc/floodgate/SpigotPlugin.java
new file mode 100644
index 00000000..2df7cbd4
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/SpigotPlugin.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.module.*;
+import org.geysermc.floodgate.util.ReflectionUtil;
+
+public final class SpigotPlugin extends JavaPlugin {
+ private SpigotPlatform platform;
+
+ @Override
+ public void onLoad() {
+ String minecraftVersion = getServer().getClass().getPackage().getName().split("\\.")[3];
+ ReflectionUtil.setPrefix("net.minecraft.server." + minecraftVersion);
+
+ long ctm = System.currentTimeMillis();
+ Injector injector = Guice.createInjector(
+ new CommonModule(getDataFolder().toPath()),
+ new SpigotPlatformModule(this)
+ );
+
+ long endCtm = System.currentTimeMillis();
+ getLogger().info("Took " + (endCtm - ctm) + "ms to boot Floodgate");
+
+ platform = injector.getInstance(SpigotPlatform.class);
+ }
+
+ @Override
+ public void onEnable() {
+ platform.enable(new CommandModule(), new SpigotListenerModule(), new SpigotAddonModule());
+ }
+
+ @Override
+ public void onDisable() {
+ platform.disable();
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataAddon.java b/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataAddon.java
new file mode 100644
index 00000000..fc23cba8
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataAddon.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.addon.data;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import io.netty.channel.Channel;
+import org.geysermc.floodgate.HandshakeHandler;
+import org.geysermc.floodgate.api.inject.InjectorAddon;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.config.FloodgateConfig;
+
+public final class SpigotDataAddon implements InjectorAddon {
+ @Inject private HandshakeHandler handshakeHandler;
+ @Inject private FloodgateConfig config;
+ @Inject private FloodgateLogger logger;
+
+ @Inject @Named("packetHandler")
+ private String packetHandlerName;
+
+ @Override
+ public void onInject(Channel channel, boolean proxyToServer) {
+ channel.pipeline().addBefore(
+ packetHandlerName, "floodgate_data_handler",
+ new SpigotDataHandler(handshakeHandler, config, logger)
+ );
+ }
+
+ @Override
+ public void onLoginDone(Channel channel) {
+ onRemoveInject(channel);
+ }
+
+ @Override
+ public void onRemoveInject(Channel channel) {
+ channel.pipeline().remove("floodgate_data_handler");
+ }
+
+ @Override
+ public boolean shouldInject() {
+ return true;
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataHandler.java b/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataHandler.java
new file mode 100644
index 00000000..af1b1e90
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/addon/data/SpigotDataHandler.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.addon.data;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.HandshakeHandler;
+import org.geysermc.floodgate.HandshakeHandler.HandshakeResult;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+import org.geysermc.floodgate.config.FloodgateConfig;
+import org.geysermc.floodgate.util.BedrockData;
+import org.geysermc.floodgate.util.ReflectionUtil;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.UUID;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.geysermc.floodgate.util.ReflectionUtil.*;
+
+@RequiredArgsConstructor
+public final class SpigotDataHandler extends SimpleChannelInboundHandler {
+ private static final Field SOCKET_ADDRESS;
+ private static final Class HANDSHAKE_PACKET;
+ private static final Field HANDSHAKE_HOST;
+
+ private static final Class GAME_PROFILE;
+ private static final Constructor GAME_PROFILE_CONSTRUCTOR;
+ private static final Field LOGIN_PROFILE;
+
+ private static final Class LOGIN_START_PACKET;
+ private static final Class LOGIN_LISTENER;
+ private static final Method INIT_UUID;
+
+ private static final Class LOGIN_HANDLER;
+ private static final Constructor LOGIN_HANDLER_CONSTRUCTOR;
+ private static final Method FIRE_LOGIN_EVENTS;
+
+ private static final Field PACKET_LISTENER;
+ private static final Field PROTOCOL_STATE;
+ private static final Object READY_TO_ACCEPT_PROTOCOL_STATE;
+
+ /* per player stuff */
+ private final HandshakeHandler handshakeHandler;
+ private final FloodgateConfig config;
+ private final FloodgateLogger logger;
+
+ private Object networkManager;
+ private FloodgatePlayer fPlayer;
+ private boolean bungee;
+
+ private boolean done;
+
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, Object packet) throws Exception {
+ // we're done but we're not yet removed from the connection
+ if (done) {
+ ctx.fireChannelRead(packet);
+ return;
+ }
+
+ boolean isHandshake = HANDSHAKE_PACKET.isInstance(packet);
+ boolean isLogin = LOGIN_START_PACKET.isInstance(packet);
+
+ try {
+ if (isHandshake) {
+ networkManager = ctx.channel().pipeline().get("packet_handler");
+
+ String handshakeValue = getCastedValue(packet, HANDSHAKE_HOST);
+ HandshakeResult result = handshakeHandler.handle(handshakeValue);
+ switch (result.getResultType()) {
+ case SUCCESS:
+ break;
+ case INVALID_DATA_LENGTH:
+ int dataLength = result.getBedrockData().getDataLength();
+ logger.info(config.getMessages().getInvalidArgumentsLength(),
+ BedrockData.EXPECTED_LENGTH, dataLength);
+ ctx.close();
+ return;
+ default: // only continue when SUCCESS
+ return;
+ }
+
+ fPlayer = result.getFloodgatePlayer();
+ BedrockData bedrockData = result.getBedrockData();
+ String[] data = result.getHandshakeData();
+
+ if (bungee = (data.length == 6 || data.length == 7)) {
+ setValue(packet, HANDSHAKE_HOST, data[0] + '\0' +
+ bedrockData.getIp() + '\0' + fPlayer.getCorrectUniqueId() +
+ (data.length == 7 ? '\0' + data[6] : "")
+ );
+ } else {
+ // Use a spoofedUUID for initUUID (just like Bungeecord)
+ setValue(networkManager, "spoofedUUID", fPlayer.getCorrectUniqueId());
+ // Use the player his IP for stuff instead of Geyser his IP
+ SocketAddress newAddress = new InetSocketAddress(
+ bedrockData.getIp(),
+ ((InetSocketAddress) ctx.channel().remoteAddress()).getPort()
+ );
+
+ setValue(networkManager, SOCKET_ADDRESS, newAddress);
+ }
+ } else if (isLogin) {
+ if (!bungee) {
+ // we have to fake the offline player cycle
+ Object loginListener = PACKET_LISTENER.get(networkManager);
+
+ // Set the player his GameProfile
+ Object gameProfile = GAME_PROFILE_CONSTRUCTOR.newInstance(
+ fPlayer.getCorrectUniqueId(), fPlayer.getCorrectUsername()
+ );
+ setValue(loginListener, LOGIN_PROFILE, gameProfile);
+
+ // Just like on Spigot:
+
+ // LoginListener#initUUID
+ // new LoginHandler().fireEvents();
+ // LoginListener#protocolState = READY_TO_ACCEPT
+
+ // and the tick of LoginListener will do the rest
+
+ INIT_UUID.invoke(loginListener);
+ FIRE_LOGIN_EVENTS.invoke(LOGIN_HANDLER_CONSTRUCTOR.newInstance(loginListener));
+ setValue(loginListener, PROTOCOL_STATE, READY_TO_ACCEPT_PROTOCOL_STATE);
+ }
+ }
+ } finally {
+ // don't let the packet through if the packet is the login packet
+ // because we want to skip the login cycle
+ if (!isLogin) ctx.fireChannelRead(packet);
+
+ if (isHandshake && bungee || isLogin && !bungee || fPlayer == null) {
+ // we're done, we'll just wait for the loginSuccessCall
+ done = true;
+ }
+ }
+ }
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+ super.exceptionCaught(ctx, cause);
+ cause.printStackTrace();
+ }
+
+ static {
+ Class networkManager = getPrefixedClass("NetworkManager");
+ checkNotNull(networkManager, "NetworkManager class cannot be null");
+
+ SOCKET_ADDRESS = getFieldOfType(networkManager, SocketAddress.class, false);
+ checkNotNull(SOCKET_ADDRESS, "SocketAddress field cannot be null");
+
+ HANDSHAKE_PACKET = getPrefixedClass("PacketHandshakingInSetProtocol");
+ checkNotNull(HANDSHAKE_PACKET, "PacketHandshakingInSetProtocol cannot be null");
+ HANDSHAKE_HOST = getFieldOfType(HANDSHAKE_PACKET, String.class, true);
+ checkNotNull(HANDSHAKE_HOST, "Host field from handshake packet cannot be null");
+
+ LOGIN_START_PACKET = getPrefixedClass("PacketLoginInStart");
+ checkNotNull(LOGIN_START_PACKET, "PacketLoginInStart cannot be null");
+
+ GAME_PROFILE = ReflectionUtil.getClass("com.mojang.authlib.GameProfile");
+ checkNotNull(GAME_PROFILE, "GameProfile class cannot be null");
+
+ Constructor gameProfileConstructor = null;
+ try {
+ gameProfileConstructor = GAME_PROFILE.getConstructor(UUID.class, String.class);
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ }
+ GAME_PROFILE_CONSTRUCTOR = gameProfileConstructor;
+ checkNotNull(GAME_PROFILE_CONSTRUCTOR, "GameProfileConstructor cannot be null");
+
+ LOGIN_LISTENER = getPrefixedClass("LoginListener");
+ checkNotNull(LOGIN_LISTENER, "LoginListener cannot be null");
+ LOGIN_PROFILE = getFieldOfType(LOGIN_LISTENER, GAME_PROFILE, true);
+ checkNotNull(LOGIN_PROFILE, "Profile from LoginListener cannot be null");
+ INIT_UUID = getMethod(LOGIN_LISTENER, "initUUID");
+ checkNotNull(INIT_UUID, "initUUID from LoginListener cannot be null");
+
+ Field protocolStateField = null;
+ for (Field field : LOGIN_LISTENER.getDeclaredFields()) {
+ if (field.getType().isEnum()) {
+ protocolStateField = field;
+ }
+ }
+ PROTOCOL_STATE = protocolStateField;
+ checkNotNull(PROTOCOL_STATE, "Protocol state field from LoginListener cannot be null");
+
+ Enum[] protocolStates = (Enum[]) PROTOCOL_STATE.getType().getEnumConstants();
+ Object readyToAcceptState = null;
+ for (Enum protocolState : protocolStates) {
+ if (protocolState.name().equals("READY_TO_ACCEPT")) {
+ readyToAcceptState = protocolState;
+ }
+ }
+ READY_TO_ACCEPT_PROTOCOL_STATE = readyToAcceptState;
+ checkNotNull(READY_TO_ACCEPT_PROTOCOL_STATE,
+ "Ready to accept state from Protocol state cannot be null");
+
+ Class packetListenerClass = getPrefixedClass("PacketListener");
+ PACKET_LISTENER = getFieldOfType(networkManager, packetListenerClass, true);
+ checkNotNull(PACKET_LISTENER, "PacketListener cannot be null");
+
+ LOGIN_HANDLER = getPrefixedClass("LoginListener$LoginHandler");
+ checkNotNull(LOGIN_HANDLER, "LoginHandler cannot be null");
+
+ Constructor loginHandlerConstructor = null;
+ try {
+ loginHandlerConstructor = makeAccessible(LOGIN_HANDLER.getDeclaredConstructor(LOGIN_LISTENER));
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ }
+ LOGIN_HANDLER_CONSTRUCTOR = loginHandlerConstructor;
+ checkNotNull(LOGIN_HANDLER_CONSTRUCTOR, "LoginHandler constructor cannot be null");
+
+ FIRE_LOGIN_EVENTS = getMethod(LOGIN_HANDLER, "fireEvents");
+ checkNotNull(FIRE_LOGIN_EVENTS, "fireEvents from LoginHandler cannot be null");
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/command/SpigotCommandRegistration.java b/spigot/src/main/java/org/geysermc/floodgate/command/SpigotCommandRegistration.java
new file mode 100644
index 00000000..58ef9426
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/command/SpigotCommandRegistration.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.command;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.platform.command.Command;
+import org.geysermc.floodgate.platform.command.CommandRegistration;
+
+import java.util.UUID;
+
+@RequiredArgsConstructor
+public final class SpigotCommandRegistration implements CommandRegistration {
+ private final JavaPlugin plugin;
+ private final FloodgateLogger logger;
+
+ @Override
+ public void register(Command command) {
+ try {
+ plugin.getCommand(command.getName())
+ .setExecutor(new SpigotCommandWrapper(command));
+ } catch (ClassCastException e) {
+ logger.error("Failed to cast plugin object to JavaPlugin", e);
+ }
+ }
+
+ @RequiredArgsConstructor
+ protected static class SpigotCommandWrapper implements CommandExecutor {
+ private final Command command;
+
+ @Override
+ public boolean onCommand(CommandSender source, org.bukkit.command.Command cmd, String label, String[] args) {
+ if (!(source instanceof Player)) {
+ if (command.isRequirePlayer()) {
+ source.sendMessage(CommonCommandMessage.NOT_A_PLAYER.getMessage());
+ return true;
+ }
+ command.execute(source, args);
+ return true;
+ }
+
+ UUID uuid = ((Player) source).getUniqueId();
+ String username = source.getName();
+ command.execute(source, uuid, username, args);
+ return true;
+ }
+ }
+}
diff --git a/bukkit/src/main/java/org/geysermc/floodgate/injector/CustomList.java b/spigot/src/main/java/org/geysermc/floodgate/inject/spigot/CustomList.java
similarity index 70%
rename from bukkit/src/main/java/org/geysermc/floodgate/injector/CustomList.java
rename to spigot/src/main/java/org/geysermc/floodgate/inject/spigot/CustomList.java
index a3a21b47..68ae5544 100644
--- a/bukkit/src/main/java/org/geysermc/floodgate/injector/CustomList.java
+++ b/spigot/src/main/java/org/geysermc/floodgate/inject/spigot/CustomList.java
@@ -1,4 +1,30 @@
-package org.geysermc.floodgate.injector;
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.inject.spigot;
import lombok.AllArgsConstructor;
import lombok.Getter;
@@ -9,6 +35,7 @@ import java.util.List;
import java.util.ListIterator;
@AllArgsConstructor
+@SuppressWarnings({"unchecked", "rawtypes"})
public abstract class CustomList implements List {
@Getter private final List originalList;
diff --git a/spigot/src/main/java/org/geysermc/floodgate/inject/spigot/SpigotInjector.java b/spigot/src/main/java/org/geysermc/floodgate/inject/spigot/SpigotInjector.java
new file mode 100644
index 00000000..02647263
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/inject/spigot/SpigotInjector.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.inject.spigot;
+
+import io.netty.channel.*;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.inject.CommonPlatformInjector;
+import org.geysermc.floodgate.util.ReflectionUtil;
+
+import java.lang.reflect.*;
+import java.util.*;
+
+@RequiredArgsConstructor
+public final class SpigotInjector extends CommonPlatformInjector {
+ private Object serverConnection;
+ private final Set injectedClients = new HashSet<>();
+
+ @Getter private boolean injected = false;
+ private String injectedFieldName;
+
+ @Override
+ @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
+ public boolean inject() throws Exception {
+ if (isInjected()) {
+ return true;
+ }
+
+ if (getServerConnection() != null) {
+ for (Field f : serverConnection.getClass().getDeclaredFields()) {
+ if (f.getType() == List.class) {
+ f.setAccessible(true);
+
+ ParameterizedType parameterType = ((ParameterizedType) f.getGenericType());
+ Type listType = parameterType.getActualTypeArguments()[0];
+
+ // the list we search has ChannelFuture as type
+ if (listType != ChannelFuture.class) {
+ continue;
+ }
+
+ injectedFieldName = f.getName();
+ List newList = new CustomList((List) f.get(serverConnection)) {
+ @Override
+ public void onAdd(Object o) {
+ try {
+ injectClient((ChannelFuture) o);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ };
+
+ // inject existing
+ synchronized (newList) {
+ for (Object o : newList) {
+ try {
+ injectClient((ChannelFuture) o);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ f.set(serverConnection, newList);
+ injected = true;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public void injectClient(ChannelFuture future) {
+ future.channel().pipeline().addFirst("floodgate-init", new ChannelInboundHandlerAdapter() {
+ @Override
+ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+ super.channelRead(ctx, msg);
+
+ Channel channel = (Channel) msg;
+ channel.pipeline().addLast(new ChannelInitializer() {
+ @Override
+ protected void initChannel(Channel channel) {
+ injectAddonsCall(channel, false);
+ injectedClients.add(channel);
+ }
+ });
+ }
+ });
+ }
+
+ @Override
+ public boolean removeInjection() throws Exception {
+ if (!isInjected()) {
+ return true;
+ }
+
+ // remove injection from clients
+ for (Channel channel : injectedClients) {
+ removeAddonsCall(channel);
+ }
+ injectedClients.clear();
+
+ // and change the list back to the original
+ Object serverConnection = getServerConnection();
+ if (serverConnection != null) {
+ Field field = ReflectionUtil.getField(serverConnection.getClass(), injectedFieldName);
+ List list = (List) ReflectionUtil.getValue(serverConnection, field);
+ if (list instanceof CustomList) {
+ CustomList customList = (CustomList) list;
+ ReflectionUtil.setValue(serverConnection, field, customList.getOriginalList());
+ customList.clear();
+ customList.addAll(list);
+ }
+ }
+
+ injectedFieldName = null;
+ injected = false;
+ return true;
+ }
+
+ public Object getServerConnection() throws IllegalAccessException, InvocationTargetException {
+ if (serverConnection != null) return serverConnection;
+ Class minecraftServer = ReflectionUtil.getPrefixedClass("MinecraftServer");
+ assert minecraftServer != null;
+
+ Object minecraftServerInstance = ReflectionUtil.invokeStatic(minecraftServer, "getServer");
+ for (Method m : minecraftServer.getDeclaredMethods()) {
+ if (m.getReturnType().getSimpleName().equals("ServerConnection")) {
+ if (m.getParameterTypes().length == 0) {
+ serverConnection = m.invoke(minecraftServerInstance);
+ }
+ }
+ }
+
+ return serverConnection;
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListener.java b/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListener.java
new file mode 100644
index 00000000..6d1b1256
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListener.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.listener;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.geysermc.floodgate.FloodgatePlayerImpl;
+import org.geysermc.floodgate.api.SimpleFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+
+import java.util.UUID;
+
+@RequiredArgsConstructor
+public final class SpigotListener implements Listener {
+ private final SimpleFloodgateApi api;
+ private final FloodgateLogger logger;
+
+ @EventHandler(priority = EventPriority.MONITOR)
+ public void onAsyncPreLogin(AsyncPlayerPreLoginEvent event) {
+ if (event.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+ api.removePlayer(event.getUniqueId(), true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR)
+ public void onPlayerLogin(PlayerLoginEvent event) {
+ UUID uniqueId = event.getPlayer().getUniqueId();
+ if (event.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+ api.removePlayer(uniqueId);
+ return;
+ }
+
+ // if there was another player with the same uuid online,
+ // he would've been disconnected by now
+ FloodgatePlayer player = api.getPlayer(uniqueId);
+ if (player != null) {
+ player.as(FloodgatePlayerImpl.class).setLogin(false);
+ logger.info("Floodgate player who is logged in as {} {} joined",
+ player.getCorrectUsername(), player.getCorrectUniqueId());
+ }
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR)
+ public void onPlayerQuit(PlayerQuitEvent event) {
+ Player player = event.getPlayer();
+ if (api.removePlayer(player.getUniqueId()) != null) {
+ logger.info(
+ "Floodgate player who was logged in as {} {} disconnected",
+ player.getName(), player.getUniqueId()
+ );
+ }
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListenerRegistration.java b/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListenerRegistration.java
new file mode 100644
index 00000000..719f9c35
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/listener/SpigotListenerRegistration.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.listener;
+
+import com.google.inject.Inject;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.platform.listener.ListenerRegistration;
+
+@RequiredArgsConstructor(onConstructor = @__(@Inject))
+public final class SpigotListenerRegistration implements ListenerRegistration {
+ private final JavaPlugin plugin;
+
+ @Override
+ public void register(Listener listener) {
+ Bukkit.getServer().getPluginManager().registerEvents(listener, plugin);
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/module/SpigotAddonModule.java b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotAddonModule.java
new file mode 100644
index 00000000..22547c47
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotAddonModule.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Singleton;
+import com.google.inject.multibindings.ProvidesIntoSet;
+import org.geysermc.floodgate.addon.AddonManagerAddon;
+import org.geysermc.floodgate.addon.data.SpigotDataAddon;
+import org.geysermc.floodgate.api.inject.InjectorAddon;
+import org.geysermc.floodgate.addon.DebugAddon;
+import org.geysermc.floodgate.register.AddonRegister;
+
+public final class SpigotAddonModule extends AbstractModule {
+ @Override
+ protected void configure() {
+ bind(AddonRegister.class).asEagerSingleton();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon managerAddon() {
+ return new AddonManagerAddon();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon dataAddon() {
+ return new SpigotDataAddon();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon debugAddon() {
+ return new DebugAddon();
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/module/SpigotListenerModule.java b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotListenerModule.java
new file mode 100644
index 00000000..7cd0b095
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotListenerModule.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Singleton;
+import com.google.inject.TypeLiteral;
+import com.google.inject.multibindings.ProvidesIntoSet;
+import org.bukkit.event.Listener;
+import org.geysermc.floodgate.api.SimpleFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.listener.SpigotListener;
+import org.geysermc.floodgate.register.ListenerRegister;
+
+public final class SpigotListenerModule extends AbstractModule {
+ @Override
+ protected void configure() {
+ bind(new TypeLiteral>() {}).asEagerSingleton();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public Listener spigotListener(SimpleFloodgateApi api, FloodgateLogger logger) {
+ return new SpigotListener(api, logger);
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/module/SpigotPlatformModule.java b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotPlatformModule.java
new file mode 100644
index 00000000..60218087
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/module/SpigotPlatformModule.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.SpigotPlugin;
+import org.geysermc.floodgate.api.SimpleFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.command.SpigotCommandRegistration;
+import org.geysermc.floodgate.config.FloodgateConfig;
+import org.geysermc.floodgate.inject.CommonPlatformInjector;
+import org.geysermc.floodgate.inject.spigot.SpigotInjector;
+import org.geysermc.floodgate.listener.SpigotListenerRegistration;
+import org.geysermc.floodgate.logger.JavaDefaultFloodgateLogger;
+import org.geysermc.floodgate.platform.command.CommandRegistration;
+import org.geysermc.floodgate.platform.listener.ListenerRegistration;
+import org.geysermc.floodgate.platform.command.util.CommandUtil;
+import org.geysermc.floodgate.util.SpigotCommandUtil;
+
+@RequiredArgsConstructor
+public final class SpigotPlatformModule extends AbstractModule {
+ private final SpigotPlugin plugin;
+
+ @Provides
+ @Singleton
+ public JavaPlugin javaPlugin() {
+ return plugin;
+ }
+
+ @Provides
+ @Singleton
+ @Named("configClass")
+ public Class floodgateConfigClass() {
+ return FloodgateConfig.class;
+ }
+
+ @Provides
+ @Singleton
+ public SimpleFloodgateApi floodgateApi() {
+ return new SimpleFloodgateApi();
+ }
+
+ @Provides
+ @Singleton
+ public FloodgateLogger floodgateLogger() {
+ return new JavaDefaultFloodgateLogger(plugin.getLogger());
+ }
+
+ /*
+ Commands / Listeners
+ */
+
+ @Provides
+ @Singleton
+ public CommandRegistration commandRegistration(FloodgateLogger logger) {
+ return new SpigotCommandRegistration(plugin, logger);
+ }
+
+ @Provides
+ @Singleton
+ public CommandUtil commandUtil(FloodgateLogger logger) {
+ return new SpigotCommandUtil(plugin, logger);
+ }
+
+ @Provides
+ @Singleton
+ public ListenerRegistration listenerRegistration() {
+ return new SpigotListenerRegistration(plugin);
+ }
+
+ /*
+ DebugAddon / PlatformInjector
+ */
+
+ @Provides
+ @Singleton
+ public CommonPlatformInjector platformInjector() {
+ return new SpigotInjector();
+ }
+
+ @Provides
+ @Named("packetEncoder")
+ public String packetEncoder() {
+ return "encoder";
+ }
+
+ @Provides
+ @Named("packetDecoder")
+ public String packetDecoder() {
+ return "decoder";
+ }
+
+ @Provides
+ @Named("packetHandler")
+ public String packetHandler() {
+ return "packet_handler";
+ }
+
+ @Provides
+ @Named("implementationName")
+ public String implementationName() {
+ return "Spigot";
+ }
+}
diff --git a/spigot/src/main/java/org/geysermc/floodgate/util/SpigotCommandUtil.java b/spigot/src/main/java/org/geysermc/floodgate/util/SpigotCommandUtil.java
new file mode 100644
index 00000000..f8833805
--- /dev/null
+++ b/spigot/src/main/java/org/geysermc/floodgate/util/SpigotCommandUtil.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.util;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.platform.command.CommandMessage;
+import org.geysermc.floodgate.platform.command.util.CommandResponseCache;
+import org.geysermc.floodgate.platform.command.util.CommandUtil;
+
+@RequiredArgsConstructor
+public final class SpigotCommandUtil extends CommandResponseCache implements CommandUtil {
+ private final JavaPlugin plugin;
+ private final FloodgateLogger logger;
+
+ @Override
+ public void sendMessage(Object player, CommandMessage message, Object... args) {
+ cast(player).sendMessage(format(message, args));
+ }
+
+ @Override
+ public void kickPlayer(Object player, CommandMessage message, Object... args) {
+ // Have to run this in the main thread so we don't get a `Asynchronous player kick!` error
+ Bukkit.getScheduler().runTask(plugin,
+ () -> cast(player).kickPlayer(format(message, args)));
+ }
+
+ @Override
+ protected String transformMessage(String message) {
+ // unlike others, Bukkit doesn't have to transform a message into another class.
+ return message;
+ }
+
+ protected Player cast(Object instance) {
+ try {
+ return (Player) instance;
+ } catch (ClassCastException exception) {
+ logger.error("Failed to cast {} to Player", instance.getClass().getName());
+ throw exception;
+ }
+ }
+}
diff --git a/spigot/src/main/resources/plugin.yml b/spigot/src/main/resources/plugin.yml
new file mode 100644
index 00000000..36dc6876
--- /dev/null
+++ b/spigot/src/main/resources/plugin.yml
@@ -0,0 +1,10 @@
+name: ${outputName}
+description: ${project.description}
+version: ${project.version}
+author: ${project.organization.name}
+website: ${project.url}
+main: org.geysermc.floodgate.SpigotPlugin
+api-version: 1.13
+commands: #todo maybe add the commands directly to the commandmap?
+ linkaccount:
+ unlinkaccount:
\ No newline at end of file
diff --git a/velocity/pom.xml b/velocity/pom.xml
index 4a7eefb4..a18569b5 100644
--- a/velocity/pom.xml
+++ b/velocity/pom.xml
@@ -3,14 +3,14 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- org.geysermc
- floodgate-parent
+ parent
+ org.geysermc.floodgate
1.0-SNAPSHOT
4.0.0
${parent.url}
- floodgate-velocity
+ velocity
@@ -36,12 +36,6 @@
${velocity-version}
provided
-
- org.javassist
- javassist
- 3.26.0-GA
- compile
-
io.netty
netty-all
@@ -49,8 +43,8 @@
provided
- org.geysermc
- floodgate-common
+ org.geysermc.floodgate
+ common
${project.version}
compile
diff --git a/velocity/src/main/java/org/geysermc/floodgate/FloodgateAPI.java b/velocity/src/main/java/org/geysermc/floodgate/FloodgateAPI.java
deleted file mode 100644
index bb7cca9a..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/FloodgateAPI.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package org.geysermc.floodgate;
-
-import com.velocitypowered.api.proxy.Player;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-public class FloodgateAPI extends AbstractFloodgateAPI {
- private static Map encryptedData = new HashMap<>();
-
- static void addEncryptedData(UUID uuid, String encryptedData) {
- FloodgateAPI.encryptedData.put(uuid, encryptedData); // just override it I guess
- }
-
- static void removeEncryptedData(UUID uuid) {
- encryptedData.remove(uuid);
- }
-
- public static String getEncryptedData(UUID uuid) {
- return encryptedData.get(uuid);
- }
-
- /**
- * See {@link AbstractFloodgateAPI#getPlayer(UUID)}
- */
- public static FloodgatePlayer getPlayer(Player player) {
- return getPlayer(player.getUniqueId());
- }
-
- /**
- * See {@link AbstractFloodgateAPI#isBedrockPlayer(UUID)}
- */
- public static boolean isBedrockPlayer(Player player) {
- return isBedrockPlayer(player.getUniqueId());
- }
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/VelocityFloodgateConfig.java b/velocity/src/main/java/org/geysermc/floodgate/VelocityFloodgateConfig.java
deleted file mode 100644
index 3e49c0de..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/VelocityFloodgateConfig.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.geysermc.floodgate;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.Getter;
-
-public class VelocityFloodgateConfig extends FloodgateConfig {
- @JsonProperty(value = "send-floodgate-data")
- @Getter
- private boolean sendFloodgateData;
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/VelocityPlugin.java b/velocity/src/main/java/org/geysermc/floodgate/VelocityPlugin.java
index be2ecebd..a9475f0e 100644
--- a/velocity/src/main/java/org/geysermc/floodgate/VelocityPlugin.java
+++ b/velocity/src/main/java/org/geysermc/floodgate/VelocityPlugin.java
@@ -1,233 +1,64 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
package org.geysermc.floodgate;
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
import com.google.inject.Inject;
-import com.velocitypowered.api.event.PostOrder;
+import com.google.inject.Injector;
import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.event.connection.ConnectionHandshakeEvent;
-import com.velocitypowered.api.event.connection.DisconnectEvent;
-import com.velocitypowered.api.event.connection.PreLoginEvent;
-import com.velocitypowered.api.event.connection.PreLoginEvent.PreLoginComponentResult;
-import com.velocitypowered.api.event.player.GameProfileRequestEvent;
import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
-import com.velocitypowered.api.proxy.InboundConnection;
-import com.velocitypowered.api.proxy.Player;
-import com.velocitypowered.api.proxy.ProxyServer;
-import com.velocitypowered.api.util.GameProfile;
-import io.netty.channel.Channel;
-import io.netty.util.AttributeKey;
-import lombok.Getter;
-import net.kyori.text.TextComponent;
-import org.geysermc.floodgate.HandshakeHandler.HandshakeResult;
-import org.geysermc.floodgate.command.LinkAccountCommand;
-import org.geysermc.floodgate.command.UnlinkAccountCommand;
-import org.geysermc.floodgate.injector.VelocityInjector;
-import org.geysermc.floodgate.util.CommandUtil;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import org.geysermc.floodgate.module.*;
import org.geysermc.floodgate.util.ReflectionUtil;
+import org.slf4j.Logger;
-import java.io.File;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import java.nio.file.Path;
-import static org.geysermc.floodgate.util.ReflectionUtil.*;
-
-public class VelocityPlugin {
- @Getter private VelocityFloodgateConfig config;
- @Getter private PlayerLink playerLink;
- private HandshakeHandler handshakeHandler;
-
- private Set workingSet;
- private Cache playerCache;
- private Cache playersToKick;
-
- private final ProxyServer server;
- private final Logger logger;
- private boolean injectSucceed;
+public final class VelocityPlugin {
+ private final FloodgatePlatform platform;
@Inject
- public VelocityPlugin(ProxyServer server, Logger logger) {
- this.server = server;
- // we're too late if we would do this in the init event
- injectSucceed = false;
- try {
- injectSucceed = VelocityInjector.inject(this);
- } catch (Exception e) {
- e.printStackTrace();
- }
- this.logger = logger;
- if (!injectSucceed) return;
+ public VelocityPlugin(@DataDirectory Path dataDirectory, Injector guice, Logger logger) {
+ ReflectionUtil.setPrefix("com.velocitypowered.proxy");
- this.workingSet = new HashSet<>();
- this.playersToKick = CacheBuilder.newBuilder()
- .maximumSize(3000)
- .expireAfterWrite(50, TimeUnit.SECONDS)
- .build();
- this.playerCache = CacheBuilder.newBuilder()
- .maximumSize(500)
- .expireAfterAccess(50, TimeUnit.SECONDS)
- .build();
+ long ctm = System.currentTimeMillis();
+ Injector injector = guice.createChildInjector(
+ new CommonModule(dataDirectory),
+ new VelocityPlatformModule()
+ );
+
+ long endCtm = System.currentTimeMillis();
+ logger.info("Took " + (endCtm - ctm) + "ms to boot Floodgate");
+
+ platform = injector.getInstance(FloodgatePlatform.class);
}
@Subscribe
public void onProxyInitialization(ProxyInitializeEvent event) {
- if (injectSucceed) {
- logger.info("Floodgate injection process succeeded!");
- } else {
- logger.severe("Failed to inject! Floodgate won't do anything.");
- return;
- }
-
- File dataFolder = new File("plugins/floodgate/");
- if (!dataFolder.exists()) {
- dataFolder.mkdir();
- }
-
- config = FloodgateConfig.load(logger, dataFolder.toPath().resolve("config.yml"), VelocityFloodgateConfig.class);
- playerLink = PlayerLink.initialize(logger, dataFolder.toPath(), config);
- handshakeHandler = new HandshakeHandler(config.getPrivateKey(), true, config.getUsernamePrefix(), config.isReplaceSpaces());
-
- CommandUtil commandUtil = new CommandUtil();
- server.getCommandManager().register(CommandUtil.LINK_ACCOUNT_COMMAND, new LinkAccountCommand(playerLink, commandUtil));
- server.getCommandManager().register(CommandUtil.UNLINK_ACCOUNT_COMMAND, new UnlinkAccountCommand(playerLink, commandUtil));
- }
-
- @Subscribe(order = PostOrder.EARLY)
- public void onConnectionHandshake(ConnectionHandshakeEvent event) {
- if (!injectSucceed) return;
- workingSet.add(event.getConnection());
-
- try {
- Object cachedHandshake = ReflectionUtil.getValue(event.getConnection(), handshakeField);
- String handshakeData = ReflectionUtil.getCastedValue(cachedHandshake, handshakeAddressField, String.class);
-
- HandshakeResult result = handshakeHandler.handle(handshakeData);
- switch (result.getResultType()) {
- case SUCCESS:
- break;
- case EXCEPTION:
- playersToKick.put(event.getConnection(), config.getMessages().getInvalidKey());
- return;
- case INVALID_DATA_LENGTH:
- playersToKick.put(event.getConnection(), config.getMessages().getInvalidArgumentsLength());
- return;
- default:
- return;
- }
-
- FloodgatePlayer player = result.getFloodgatePlayer();
- FloodgateAPI.addEncryptedData(player.getCorrectUniqueId(), result.getHandshakeData()[2] + '\0' + result.getHandshakeData()[3]);
- playerCache.put(event.getConnection(), player);
- logger.info("Added " + player.getCorrectUsername() + " " + player.getCorrectUniqueId());
- } catch (Exception e) {
- e.printStackTrace();
- } finally {
- workingSet.remove(event.getConnection());
- }
- }
-
- @Subscribe(order = PostOrder.EARLY)
- public void onPreLogin(PreLoginEvent event) {
- if (!injectSucceed) return;
-
- if (workingSet.contains(event.getConnection())) {
- int count = 70;
- // 70 * 70 / 1000 = 4.9 seconds to get removed from working cache
- while (count-- != 0 && workingSet.contains(event.getConnection())) {
- // should be 'just fine' because the event system is multithreaded
- try {
- Thread.sleep(70);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- if (workingSet.contains(event.getConnection())) {
- String message = "Took more then 4.9 seconds (after PreLoginEvent) to finish Handshake data for "+event.getUsername();
- logger.warning(message);
- event.setResult(PreLoginComponentResult.denied(TextComponent.of(message)));
- return;
- }
- }
-
- FloodgatePlayer player = playerCache.getIfPresent(event.getConnection());
- if (player != null) {
- System.out.println(event.getUsername());
- event.setResult(PreLoginComponentResult.forceOfflineMode());
-
- // we can't rely on Velocity when it comes to kicking the old players, so with this system we only
- // have to check if the connection (which is already closed at that time) has a FloodgatePlayer as attribute
- try {
- Object mcConnection = initialMinecraftConnectionField.get(event.getConnection());
- Channel channel = (Channel) channelField.get(mcConnection);
- channel.attr(playerAttribute).set(player);
- return;
- } catch (Exception e) {
- logger.log(Level.SEVERE, "Failed to add FloodgatePlayer to player", e);
- playersToKick.put(event.getConnection(), "Failed to add FloodgatePlayer to player");
- }
- }
-
- String message = playersToKick.getIfPresent(event.getConnection());
- if (message != null) {
- playersToKick.invalidate(event.getConnection());
- event.setResult(PreLoginComponentResult.denied(TextComponent.of(message)));
- }
- }
-
- @Subscribe(order = PostOrder.EARLY)
- public void onGameProfileRequest(GameProfileRequestEvent event) {
- if (!injectSucceed) return;
-
- FloodgatePlayer player = playerCache.getIfPresent(event.getConnection());
- if (player != null) {
- playerCache.invalidate(event.getConnection());
- event.setGameProfile(new GameProfile(player.getCorrectUniqueId(), player.getCorrectUsername(), new ArrayList<>()));
- }
- }
-
- @Subscribe(order = PostOrder.LAST)
- public void onDisconnect(DisconnectEvent event) {
- Player player = event.getPlayer();
-
- try {
- Object minecraftConnection = minecraftConnectionField.get(player);
- Channel channel = (Channel) channelField.get(minecraftConnection);
- FloodgatePlayer fPlayer = channel.attr(playerAttribute).get();
- if (fPlayer != null) {
- FloodgateAPI.removePlayer(fPlayer);
- FloodgateAPI.removeEncryptedData(event.getPlayer().getUniqueId());
- logger.info("Removed Bedrock player who was logged in as " + player.getUsername() + " " + player.getUniqueId());
- }
- } catch (Exception e) {
- logger.log(Level.SEVERE, "Failed to remove the player", e);
- }
- }
-
- private Field handshakeField;
- private Field handshakeAddressField;
-
- private final AttributeKey playerAttribute = AttributeKey.newInstance("floodgate-player");
- private Field initialMinecraftConnectionField;
- private Field minecraftConnectionField;
- private Field channelField;
-
- public void initReflection() {
- ReflectionUtil.setPrefix("com.velocitypowered.proxy");
- Class IIC = getPrefixedClass("connection.client.InitialInboundConnection");
- Class HandshakePacket = getPrefixedClass("protocol.packet.Handshake");
-
- handshakeField = getField(IIC, "handshake");
- handshakeAddressField = getField(HandshakePacket, "serverAddress");
-
- Class minecraftConnection = getPrefixedClass("connection.MinecraftConnection");
- initialMinecraftConnectionField = getFieldOfType(IIC, minecraftConnection, true);
- Class connectedPlayer = getPrefixedClass("connection.client.ConnectedPlayer");
- minecraftConnectionField = getFieldOfType(connectedPlayer, minecraftConnection, true);
- channelField = getFieldOfType(minecraftConnection, Channel.class, true);
+ platform.enable(new CommandModule(), new VelocityListenerModule(),
+ new VelocityAddonModule());
}
}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityDataAddon.java b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityDataAddon.java
new file mode 100644
index 00000000..91a17bb8
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityDataAddon.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.addon.data;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import io.netty.channel.Channel;
+import io.netty.channel.EventLoop;
+import io.netty.util.AttributeKey;
+import org.geysermc.floodgate.HandshakeHandler;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.inject.InjectorAddon;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+import org.geysermc.floodgate.config.ProxyFloodgateConfig;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class VelocityDataAddon implements InjectorAddon {
+ @Inject private HandshakeHandler handshakeHandler;
+ @Inject private ProxyFloodgateConfig config;
+ @Inject private ProxyFloodgateApi api;
+ @Inject private FloodgateLogger logger;
+
+ @Inject
+ @Named("packetHandler")
+ private String packetHandler;
+
+ @Inject
+ @Named("packetEncoder")
+ private String packetEncoder;
+
+ @Inject
+ @Named("playerAttribute")
+ private AttributeKey playerAttribute;
+
+ @Inject
+ @Named("kickMessageAttribute")
+ private AttributeKey kickMessageAttribute;
+
+ private final Map playerMap = new HashMap<>();
+
+ @Override
+ public void onInject(Channel channel, boolean proxyToServer) {
+ if (proxyToServer) {
+ channel.pipeline().addAfter(
+ packetEncoder, "floodgate_data_handler",
+ new VelocityServerDataHandler(config, api, playerMap)
+ );
+ } else {
+ // The handler is already added so we should add our handler before it
+ channel.pipeline().addBefore(
+ packetHandler, "floodgate_data_handler",
+ new VelocityProxyDataHandler(
+ config, api, handshakeHandler, playerAttribute,
+ kickMessageAttribute, playerMap, logger
+ )
+ );
+ }
+ }
+
+ @Override
+ public void onLoginDone(Channel channel) {
+ onRemoveInject(channel);
+ }
+
+ @Override
+ public void onRemoveInject(Channel channel) {
+ channel.pipeline().remove("floodgate_data_handler");
+ }
+
+ @Override
+ public boolean shouldInject() {
+ return true;
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityProxyDataHandler.java b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityProxyDataHandler.java
new file mode 100644
index 00000000..b0eda845
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityProxyDataHandler.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.addon.data;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.EventLoop;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.util.AttributeKey;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.HandshakeHandler;
+import org.geysermc.floodgate.HandshakeHandler.HandshakeResult;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+import org.geysermc.floodgate.config.ProxyFloodgateConfig;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.geysermc.floodgate.util.ReflectionUtil.*;
+
+@RequiredArgsConstructor
+public final class VelocityProxyDataHandler extends SimpleChannelInboundHandler {
+ private static final Field HANDSHAKE;
+ private static final Class HANDSHAKE_PACKET;
+ private static final Field HANDSHAKE_SERVER_ADDRESS;
+
+ private final ProxyFloodgateConfig config;
+ private final ProxyFloodgateApi api;
+ private final HandshakeHandler handshakeHandler;
+
+ private final AttributeKey playerAttribute;
+ private final AttributeKey kickMessageAttribute;
+ private final Map playerMap;
+
+ private final FloodgateLogger logger;
+
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
+ // we're only interested in the Handshake packet
+ if (!HANDSHAKE_PACKET.isInstance(msg)) {
+ ctx.fireChannelRead(msg);
+ return;
+ }
+
+ handleClientToProxy(ctx, msg);
+ ctx.fireChannelRead(msg);
+ }
+
+ private void handleClientToProxy(ChannelHandlerContext ctx, Object packet) {
+ String address = getCastedValue(packet, HANDSHAKE_SERVER_ADDRESS);
+
+ HandshakeResult result = handshakeHandler.handle(address);
+ switch (result.getResultType()) {
+ case SUCCESS:
+ break;
+ case EXCEPTION:
+ ctx.channel().attr(kickMessageAttribute).set(config.getMessages().getInvalidKey());
+ case INVALID_DATA_LENGTH:
+ ctx.channel().attr(kickMessageAttribute)
+ .set(config.getMessages().getInvalidArgumentsLength());
+ return;
+ default:
+ return;
+ }
+
+ FloodgatePlayer player = result.getFloodgatePlayer();
+
+ // we can't rely on Velocity when it comes to kicking the old players, so with this
+ // system we only have to check if the connection (which is already closed at that time)
+ // has the FloodgatePlayer attribute
+ ctx.channel().attr(playerAttribute).set(player);
+ playerMap.put(ctx.channel().eventLoop(), player);
+
+ api.addEncryptedData(player.getCorrectUniqueId(),
+ result.getHandshakeData()[2] + '\0' + result.getHandshakeData()[3]);
+ logger.info("Floodgate player who is logged in as {} {} joined",
+ player.getCorrectUsername(), player.getCorrectUniqueId());
+ }
+
+ static {
+ Class initialInboundConnection =
+ getPrefixedClass("connection.client.InitialInboundConnection");
+ checkNotNull(initialInboundConnection, "InitialInboundConnection class cannot be null");
+
+ HANDSHAKE = getField(initialInboundConnection, "handshake");
+ checkNotNull(HANDSHAKE, "Handshake field cannot be null");
+
+ HANDSHAKE_PACKET = getPrefixedClass("protocol.packet.Handshake");
+ checkNotNull(HANDSHAKE_PACKET, "Handshake packet class cannot be null");
+
+ HANDSHAKE_SERVER_ADDRESS = getField(HANDSHAKE_PACKET, "serverAddress");
+ checkNotNull(HANDSHAKE_SERVER_ADDRESS, "Address field of the Handshake packet cannot be null");
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityServerDataHandler.java b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityServerDataHandler.java
new file mode 100644
index 00000000..37a534e6
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/addon/data/VelocityServerDataHandler.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.addon.data;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.EventLoop;
+import io.netty.handler.codec.MessageToMessageEncoder;
+import io.netty.util.ReferenceCountUtil;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+import org.geysermc.floodgate.config.ProxyFloodgateConfig;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.geysermc.floodgate.util.BedrockData.FLOODGATE_IDENTIFIER;
+import static org.geysermc.floodgate.util.ReflectionUtil.*;
+
+@RequiredArgsConstructor
+public class VelocityServerDataHandler extends MessageToMessageEncoder {
+ private static final Class HANDSHAKE_PACKET;
+ private static final Field HANDSHAKE_SERVER_ADDRESS;
+
+ private final ProxyFloodgateConfig config;
+ private final ProxyFloodgateApi api;
+
+ private final Map playerMap;
+
+ @Override
+ protected void encode(ChannelHandlerContext ctx, Object packet, List out) {
+ ReferenceCountUtil.retain(packet);
+ if (!HANDSHAKE_PACKET.isInstance(packet) || !config.isSendFloodgateData()) {
+ System.out.println(HANDSHAKE_PACKET.isInstance(packet)+" "+config.isSendFloodgateData());
+ out.add(packet);
+ return;
+ }
+
+ String address = getCastedValue(packet, HANDSHAKE_SERVER_ADDRESS);
+
+ // works because the EventLoop is shared between the Player and the ServerConnection
+ // todo check if it actually works (by using multiple accounts and log if the map
+ // overrides older ones)
+ FloodgatePlayer player = playerMap.get(ctx.channel().eventLoop());
+
+ // player is not a Floodgate player
+ if (player == null) {
+ System.out.println("Not Floodgate player");
+ out.add(packet);
+ return;
+ }
+
+ String encryptedData = api.getEncryptedData(player.getCorrectUniqueId());
+ checkArgument(encryptedData != null, "Encrypted data cannot be null");
+
+ // use the same system that we use on bungee, our data goes before all the other data
+ String[] split = address.split("\0");
+ String remaining = address.substring(split[0].length());
+
+ setValue(packet, HANDSHAKE_SERVER_ADDRESS,
+ split[0] + '\0' + FLOODGATE_IDENTIFIER + '\0' + encryptedData + remaining);
+ System.out.println("done");
+ out.add(packet);
+ }
+
+ static {
+ HANDSHAKE_PACKET = getPrefixedClass("protocol.packet.Handshake");
+ checkNotNull(HANDSHAKE_PACKET, "Handshake packet class cannot be null");
+
+ HANDSHAKE_SERVER_ADDRESS = getField(HANDSHAKE_PACKET, "serverAddress");
+ checkNotNull(HANDSHAKE_SERVER_ADDRESS, "Address field of the Handshake packet cannot be null");
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/command/LinkAccountCommand.java b/velocity/src/main/java/org/geysermc/floodgate/command/LinkAccountCommand.java
deleted file mode 100644
index 9bcc9220..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/command/LinkAccountCommand.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.geysermc.floodgate.command;
-
-import com.velocitypowered.api.command.Command;
-import com.velocitypowered.api.command.CommandSource;
-import com.velocitypowered.api.proxy.Player;
-import org.geysermc.floodgate.AbstractLinkAccountCommand;
-import org.geysermc.floodgate.PlayerLink;
-import org.geysermc.floodgate.util.CommandUtil;
-import org.geysermc.floodgate.util.CommonMessage;
-
-import java.util.UUID;
-
-public class LinkAccountCommand extends AbstractLinkAccountCommand implements Command {
- public LinkAccountCommand(PlayerLink link, CommandUtil commandUtil) {
- super(link, commandUtil);
- }
-
- @Override
- public void execute(CommandSource sender, String[] args) {
- if (!(sender instanceof Player)) {
- sender.sendMessage(getCommandUtil().getOrAddCachedMessage(CommonMessage.NOT_A_PLAYER));
- return;
- }
- UUID uuid = ((Player) sender).getUniqueId();
- String username = ((Player) sender).getUsername();
- execute((Player) sender, uuid, username, args);
- }
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/command/UnlinkAccountCommand.java b/velocity/src/main/java/org/geysermc/floodgate/command/UnlinkAccountCommand.java
deleted file mode 100644
index 899ebb73..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/command/UnlinkAccountCommand.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package org.geysermc.floodgate.command;
-
-import com.velocitypowered.api.command.Command;
-import com.velocitypowered.api.command.CommandSource;
-import com.velocitypowered.api.proxy.Player;
-import org.geysermc.floodgate.AbstractUnlinkAccountCommand;
-import org.geysermc.floodgate.PlayerLink;
-import org.geysermc.floodgate.util.CommandUtil;
-import org.geysermc.floodgate.util.CommonMessage;
-
-import java.util.UUID;
-
-public class UnlinkAccountCommand extends AbstractUnlinkAccountCommand implements Command {
- public UnlinkAccountCommand(PlayerLink link, CommandUtil commandUtil) {
- super(link, commandUtil);
- }
-
- @Override
- public void execute(CommandSource sender, String[] args) {
- if (!(sender instanceof Player)) {
- sender.sendMessage(getCommandUtil().getOrAddCachedMessage(CommonMessage.NOT_A_PLAYER));
- return;
- }
- UUID uuid = ((Player) sender).getUniqueId();
- execute((Player) sender, uuid);
- }
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/command/VelocityCommandRegistration.java b/velocity/src/main/java/org/geysermc/floodgate/command/VelocityCommandRegistration.java
new file mode 100644
index 00000000..03430167
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/command/VelocityCommandRegistration.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.command;
+
+import com.velocitypowered.api.command.CommandManager;
+import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.api.proxy.Player;
+import lombok.RequiredArgsConstructor;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.geysermc.floodgate.platform.command.Command;
+import org.geysermc.floodgate.platform.command.CommandRegistration;
+import org.geysermc.floodgate.util.VelocityCommandUtil;
+
+import java.util.UUID;
+
+@RequiredArgsConstructor
+public final class VelocityCommandRegistration implements CommandRegistration {
+ private final CommandManager commandManager;
+ private final VelocityCommandUtil commandUtil;
+
+ @Override
+ public void register(Command command) {
+ commandManager.register(command.getName(),
+ new VelocityCommandWrapper(commandUtil, command));
+ }
+
+ @RequiredArgsConstructor
+ protected static final class VelocityCommandWrapper
+ implements com.velocitypowered.api.command.Command {
+ private final VelocityCommandUtil commandUtil;
+ private final Command command;
+
+ @Override
+ public void execute(CommandSource source, @NonNull String[] args) {
+ if (!(source instanceof Player)) {
+ if (command.isRequirePlayer()) {
+ commandUtil.sendMessage(source, CommonCommandMessage.NOT_A_PLAYER);
+ return;
+ }
+ command.execute(source, args);
+ return;
+ }
+
+ Player player = (Player) source;
+ UUID uuid = player.getUniqueId();
+ String username = player.getUsername();
+ command.execute(source, uuid, username, args);
+ }
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/inject/velocity/VelocityInjector.java b/velocity/src/main/java/org/geysermc/floodgate/inject/velocity/VelocityInjector.java
new file mode 100644
index 00000000..968057f2
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/inject/velocity/VelocityInjector.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.inject.velocity;
+
+import com.velocitypowered.api.proxy.ProxyServer;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.inject.CommonPlatformInjector;
+
+import javax.naming.OperationNotSupportedException;
+import java.lang.reflect.Method;
+
+import static org.geysermc.floodgate.util.ReflectionUtil.*;
+
+@RequiredArgsConstructor
+public final class VelocityInjector extends CommonPlatformInjector {
+ private final ProxyServer server;
+ @Getter private boolean injected = false;
+
+ @SuppressWarnings("rawtypes")
+ public boolean inject() {
+ if (isInjected()) return true;
+
+ Object connectionManager = getValue(server, "cm");
+
+ // Client <-> Proxy
+
+ Object serverInitializerHolder = getValue(connectionManager, "serverChannelInitializer");
+ ChannelInitializer serverInitializer = castedInvoke(serverInitializerHolder, "get");
+
+ Method serverSetter = getMethod(serverInitializerHolder, "set", ChannelInitializer.class);
+ invoke(serverInitializerHolder, serverSetter,
+ new VelocityChannelInitializer(this, serverInitializer, false));
+
+ // Proxy <-> Server
+
+ Object backendInitializerHolder = getValue(connectionManager,"backendChannelInitializer");
+ ChannelInitializer backendInitializer = castedInvoke(backendInitializerHolder, "get");
+
+ Method backendSetter = getMethod(backendInitializerHolder, "set", ChannelInitializer.class);
+ invoke(backendInitializerHolder, backendSetter,
+ new VelocityChannelInitializer(this, backendInitializer, true));
+ return injected = true;
+ }
+
+ @Override
+ public boolean removeInjection() throws Exception {
+ //todo implement injection removal support
+ throw new OperationNotSupportedException(
+ "Floodgate cannot remove the Velocity injection at the moment");
+ }
+
+ @RequiredArgsConstructor
+ @SuppressWarnings("rawtypes")
+ private static final class VelocityChannelInitializer extends ChannelInitializer {
+ private static Method initChannel;
+
+ private final VelocityInjector injector;
+ private final ChannelInitializer original;
+ private final boolean proxyToServer;
+
+ @Override
+ protected void initChannel(Channel channel) {
+ invoke(original, initChannel, channel);
+
+ injector.injectAddonsCall(channel, proxyToServer);
+ injector.addInjectedClient(channel);
+ }
+
+ static {
+ initChannel = getMethod(ChannelInitializer.class, "initChannel", Channel.class);
+ }
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/injector/VelocityInjector.java b/velocity/src/main/java/org/geysermc/floodgate/injector/VelocityInjector.java
deleted file mode 100644
index d46f5a02..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/injector/VelocityInjector.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package org.geysermc.floodgate.injector;
-
-import com.velocitypowered.api.proxy.Player;
-import javassist.ClassPool;
-import javassist.CtClass;
-import javassist.CtField;
-import javassist.Modifier;
-import javassist.bytecode.Descriptor;
-import lombok.Getter;
-import org.geysermc.floodgate.FloodgateAPI;
-import org.geysermc.floodgate.VelocityPlugin;
-import org.geysermc.floodgate.util.ReflectionUtil;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.function.BiConsumer;
-
-import static org.geysermc.floodgate.util.BedrockData.FLOODGATE_IDENTIFIER;
-
-public class VelocityInjector {
- @Getter private static boolean injected = false;
-
- public static boolean inject(VelocityPlugin plugin) throws Exception {
- if (isInjected()) return true;
- // Tnx Velocity for making it difficult x)
- // But I made my way in >:)
- // Please note that doing this is not recommended
-
- // This method will edit the source code of MinecraftConnection to allow us to edit any outgoing packet.
-
- ClassPool classPool = ClassPool.getDefault();
- CtClass ctClass = classPool.get("com.velocitypowered.proxy.connection.MinecraftConnection");
- ctClass.defrost();
-
- // create dataConsumer field
- CtClass biConsumerClass = classPool.get("java.util.function.BiConsumer");
- CtField dataConsumer = new CtField(biConsumerClass, "dataConsumer", ctClass);
- dataConsumer.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
- ctClass.addField(dataConsumer);
-
- // override write and delayedWrite in MinecraftConnection
- String voidObjectDescriptor = Descriptor.ofMethod(CtClass.voidType, new CtClass[] { classPool.get("java.lang.Object") });
- String codeToInsert =
- "if (msg != null && dataConsumer != null && msg instanceof com.velocitypowered.proxy.protocol.MinecraftPacket) {\n" +
- " dataConsumer.accept(this, (com.velocitypowered.proxy.protocol.MinecraftPacket)msg);\n" +
- "}\n";
-
- ctClass.getMethod("write", voidObjectDescriptor).insertAt(1, codeToInsert);
- ctClass.getMethod("delayedWrite", voidObjectDescriptor).insertAt(1, codeToInsert);
-
- Class clazz = ctClass.toClass();
-
- // The most important part is done,
- // So now we call initReflection to let us use getPrefixedClass
- plugin.initReflection();
-
- // handshake handle stuff
- Class handshakePacket = ReflectionUtil.getPrefixedClass("protocol.packet.Handshake");
- Field serverAddress = ReflectionUtil.getField(handshakePacket, "serverAddress");
-
- Field sessionHandlerField = ReflectionUtil.getField(clazz, "sessionHandler");
- Class loginHandler = ReflectionUtil.getPrefixedClass("connection.backend.LoginSessionHandler");
-
- Field serverConnField = ReflectionUtil.getField(loginHandler, "serverConn");
-
- Class serverConnection = ReflectionUtil.getPrefixedClass("connection.backend.VelocityServerConnection");
- Method playerGetMethod = ReflectionUtil.getMethod(serverConnection, "getPlayer");
- assert playerGetMethod != null;
-
- // create and set our custom made Consumer
-
- BiConsumer biConsumer = (minecraftConnection, packet) -> {
- // This consumer is only called when the server is sending data (outgoing).
- // So when we get a handshake packet it'll be Velocity trying to connect to a server.
- // And that is exactly what we need, to edit the outgoing handshake packet to include Floodgate data
- if (plugin.getConfig().isSendFloodgateData()) {
- try {
- if (handshakePacket.isInstance(packet)) {
- String address = ReflectionUtil.getCastedValue(packet, serverAddress, String.class);
-
- Object sessionHandler = ReflectionUtil.getValue(minecraftConnection, sessionHandlerField);
- if (loginHandler.isInstance(sessionHandler)) {
- Object serverConn = ReflectionUtil.getValue(sessionHandler, serverConnField);
- Player connectedPlayer = ReflectionUtil.invokeCasted(serverConn, playerGetMethod, Player.class);
-
- String encryptedData = FloodgateAPI.getEncryptedData(connectedPlayer.getUniqueId());
- if (encryptedData == null) return; // we know enough, this is not a Floodgate player
-
- String[] splitted = address.split("\0");
- String remaining = address.substring(splitted[0].length());
- ReflectionUtil.setValue(packet, serverAddress, splitted[0] + '\0' + FLOODGATE_IDENTIFIER + '\0' + encryptedData + remaining);
- // keep the same system as we have on Bungeecord. Our data is before the Bungee data
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- };
-
- Class minecraftConnection = ReflectionUtil.getPrefixedClass("connection.MinecraftConnection");
- ReflectionUtil.setValue(null, ReflectionUtil.getField(minecraftConnection, "dataConsumer"), biConsumer);
- return true;
- }
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListener.java b/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListener.java
new file mode 100644
index 00000000..7d0e51b5
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListener.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.listener;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.velocitypowered.api.event.PostOrder;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.connection.DisconnectEvent;
+import com.velocitypowered.api.event.connection.PreLoginEvent;
+import com.velocitypowered.api.event.player.GameProfileRequestEvent;
+import com.velocitypowered.api.proxy.InboundConnection;
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.util.GameProfile;
+import io.netty.channel.Channel;
+import io.netty.util.AttributeKey;
+import net.kyori.adventure.text.TextComponent;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+import static org.geysermc.floodgate.util.ReflectionUtil.*;
+
+public final class VelocityListener {
+ private static final Field INITIAL_MINECRAFT_CONNECTION;
+ private static final Field MINECRAFT_CONNECTION;
+ private static final Field CHANNEL;
+
+ private final ProxyFloodgateApi api;
+ private final AttributeKey playerAttribute;
+ private final AttributeKey kickMessageAttribute;
+ private final FloodgateLogger logger;
+
+ private final Cache playerCache;
+
+ public VelocityListener(ProxyFloodgateApi api,
+ AttributeKey playerAttribute,
+ AttributeKey kickMessageAttribute,
+ FloodgateLogger logger) {
+ this.api = api;
+ this.playerAttribute = playerAttribute;
+ this.kickMessageAttribute = kickMessageAttribute;
+ this.logger = logger;
+
+ this.playerCache = CacheBuilder.newBuilder()
+ .maximumSize(500)
+ .expireAfterAccess(20, TimeUnit.SECONDS)
+ .build();
+ }
+
+ @Subscribe(order = PostOrder.EARLY)
+ public void onPreLogin(PreLoginEvent event) {
+ FloodgatePlayer player = null;
+ String kickMessage;
+ try {
+ Object mcConnection = getValue(event.getConnection(), INITIAL_MINECRAFT_CONNECTION);
+ Channel channel = getCastedValue(mcConnection, CHANNEL);
+
+ player = channel.attr(playerAttribute).get();
+ if (player != null) {
+ event.setResult(PreLoginEvent.PreLoginComponentResult.forceOfflineMode());
+ }
+
+ kickMessage = channel.attr(kickMessageAttribute).get();
+ } catch (Exception exception) {
+ logger.error("Failed get the FloodgatePlayer from the player's channel", exception);
+ kickMessage = "Failed to get the FloodgatePlayer from the players's Channel";
+ }
+
+ if (kickMessage != null) {
+ event.setResult(PreLoginEvent.PreLoginComponentResult.denied(TextComponent.of(kickMessage)));
+ return;
+ }
+
+ if (player != null) {
+ playerCache.put(event.getConnection(), player);
+ }
+ }
+
+ @Subscribe(order = PostOrder.EARLY)
+ public void onGameProfileRequest(GameProfileRequestEvent event) {
+ FloodgatePlayer player = playerCache.getIfPresent(event.getConnection());
+ if (player != null) {
+ playerCache.invalidate(event.getConnection());
+ event.setGameProfile(new GameProfile(
+ player.getCorrectUniqueId(), player.getCorrectUsername(), new ArrayList<>()));
+ }
+ }
+
+ @Subscribe(order = PostOrder.LAST)
+ public void onDisconnect(DisconnectEvent event) {
+ Player player = event.getPlayer();
+ try {
+ Object minecraftConnection = getValue(player, MINECRAFT_CONNECTION);
+ Channel channel = getCastedValue(minecraftConnection, CHANNEL);
+ FloodgatePlayer fPlayer = channel.attr(playerAttribute).get();
+
+ if (fPlayer != null && api.removePlayer(fPlayer)) {
+ api.removeEncryptedData(event.getPlayer().getUniqueId());
+ logger.info("Removed Bedrock player who was logged in as {} {} ",
+ player.getUsername(), player.getUniqueId());
+ }
+ } catch (Exception exception) {
+ logger.error("Failed to remove the player", exception);
+ }
+ }
+
+ static {
+ Class initialConnection = getPrefixedClass("connection.client.InitialInboundConnection");
+
+ Class minecraftConnection = getPrefixedClass("connection.MinecraftConnection");
+ INITIAL_MINECRAFT_CONNECTION = getFieldOfType(initialConnection, minecraftConnection, true);
+ Class connectedPlayer = getPrefixedClass("connection.client.ConnectedPlayer");
+ MINECRAFT_CONNECTION = getFieldOfType(connectedPlayer, minecraftConnection, true);
+ CHANNEL = getFieldOfType(minecraftConnection, Channel.class, true);
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListenerRegistration.java b/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListenerRegistration.java
new file mode 100644
index 00000000..a3ed8401
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/listener/VelocityListenerRegistration.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.listener;
+
+import com.velocitypowered.api.event.EventManager;
+import lombok.RequiredArgsConstructor;
+import org.geysermc.floodgate.VelocityPlugin;
+import org.geysermc.floodgate.platform.listener.ListenerRegistration;
+
+@RequiredArgsConstructor
+public final class VelocityListenerRegistration implements ListenerRegistration {
+ private final EventManager eventManager;
+ private final VelocityPlugin plugin;
+
+ @Override
+ public void register(Object listener) {
+ eventManager.register(plugin, listener);
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/logger/Slf4jLogger.java b/velocity/src/main/java/org/geysermc/floodgate/logger/Slf4jLogger.java
new file mode 100644
index 00000000..99aaf6dc
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/logger/Slf4jLogger.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.logger;
+
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.geysermc.floodgate.util.MessageFormatter.format;
+
+@AllArgsConstructor
+@NoArgsConstructor
+public final class Slf4jLogger implements FloodgateLogger {
+ private Logger logger = LoggerFactory.getLogger(LOGGER_NAME);
+
+ @Override
+ public void error(String message, Object... args) {
+ logger.error(message, args);
+ }
+
+ @Override
+ public void error(String message, Throwable throwable, Object... args) {
+ logger.error(format(message, args), throwable);
+ }
+
+ @Override
+ public void warn(String message, Object... args) {
+ logger.warn(message, args);
+ }
+
+ @Override
+ public void info(String message, Object... args) {
+ logger.info(message, args);
+ }
+
+ @Override
+ public void debug(String message, Object... args) {
+ logger.debug(message, args);
+ }
+
+ @Override
+ public void trace(String message, Object... args) {
+ logger.trace(message, args);
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/module/VelocityAddonModule.java b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityAddonModule.java
new file mode 100644
index 00000000..366ead08
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityAddonModule.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Singleton;
+import com.google.inject.multibindings.ProvidesIntoSet;
+import org.geysermc.floodgate.addon.AddonManagerAddon;
+import org.geysermc.floodgate.addon.DebugAddon;
+import org.geysermc.floodgate.addon.data.VelocityDataAddon;
+import org.geysermc.floodgate.api.inject.InjectorAddon;
+import org.geysermc.floodgate.register.AddonRegister;
+
+public final class VelocityAddonModule extends AbstractModule {
+ @Override
+ protected void configure() {
+ bind(AddonRegister.class).asEagerSingleton();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon managerAddon() {
+ return new AddonManagerAddon();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon dataAddon() {
+ return new VelocityDataAddon();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public InjectorAddon debugAddon() {
+ return new DebugAddon();
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/module/VelocityListenerModule.java b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityListenerModule.java
new file mode 100644
index 00000000..6d3ca869
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityListenerModule.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.*;
+import com.google.inject.multibindings.ProvidesIntoSet;
+import com.google.inject.name.Named;
+import io.netty.util.AttributeKey;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.api.player.FloodgatePlayer;
+import org.geysermc.floodgate.listener.VelocityListener;
+import org.geysermc.floodgate.register.ListenerRegister;
+
+public final class VelocityListenerModule extends AbstractModule {
+ @Override
+ protected void configure() {
+ bind(new TypeLiteral>() {}).asEagerSingleton();
+ }
+
+ @Singleton
+ @ProvidesIntoSet
+ public Object velocityListener(ProxyFloodgateApi api, FloodgateLogger logger,
+ @Named("playerAttribute") AttributeKey playerAttr,
+ @Named("kickMessageAttribute") AttributeKey kickMessageAttr) {
+ return new VelocityListener(api, playerAttr, kickMessageAttr, logger);
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/module/VelocityPlatformModule.java b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityPlatformModule.java
new file mode 100644
index 00000000..264a17b8
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/module/VelocityPlatformModule.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.module;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import com.google.inject.name.Named;
+import com.velocitypowered.api.command.CommandManager;
+import com.velocitypowered.api.event.EventManager;
+import com.velocitypowered.api.proxy.ProxyServer;
+import io.netty.util.AttributeKey;
+import org.geysermc.floodgate.VelocityPlugin;
+import org.geysermc.floodgate.api.ProxyFloodgateApi;
+import org.geysermc.floodgate.api.SimpleFloodgateApi;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.command.VelocityCommandRegistration;
+import org.geysermc.floodgate.config.FloodgateConfig;
+import org.geysermc.floodgate.config.ProxyFloodgateConfig;
+import org.geysermc.floodgate.inject.CommonPlatformInjector;
+import org.geysermc.floodgate.inject.velocity.VelocityInjector;
+import org.geysermc.floodgate.listener.VelocityListenerRegistration;
+import org.geysermc.floodgate.logger.Slf4jLogger;
+import org.geysermc.floodgate.platform.command.CommandRegistration;
+import org.geysermc.floodgate.platform.command.util.CommandUtil;
+import org.geysermc.floodgate.platform.listener.ListenerRegistration;
+import org.geysermc.floodgate.util.VelocityCommandUtil;
+import org.slf4j.Logger;
+
+public final class VelocityPlatformModule extends AbstractModule {
+ @Override
+ protected void configure() {
+ bind(SimpleFloodgateApi.class).to(ProxyFloodgateApi.class);
+ bind(CommandUtil.class).to(VelocityCommandUtil.class);
+ }
+
+ @Provides
+ @Singleton
+ @Named("configClass")
+ public Class floodgateConfigClass() {
+ return ProxyFloodgateConfig.class;
+ }
+
+ @Provides
+ @Singleton
+ public ProxyFloodgateApi proxyFloodgateApi() {
+ return new ProxyFloodgateApi();
+ }
+
+ @Provides
+ @Singleton
+ public FloodgateLogger floodgateLogger(Logger logger) {
+ return new Slf4jLogger(logger);
+ }
+
+ /*
+ Commands / Listeners
+ */
+
+ @Provides
+ @Singleton
+ public CommandRegistration commandRegistration(CommandManager commandManager,
+ VelocityCommandUtil commandUtil) {
+ return new VelocityCommandRegistration(commandManager, commandUtil);
+ }
+
+ @Provides
+ @Singleton
+ public VelocityCommandUtil commandUtil(FloodgateLogger logger) {
+ return new VelocityCommandUtil(logger);
+ }
+
+ @Provides
+ @Singleton
+ public ListenerRegistration listenerRegistration(EventManager eventManager,
+ VelocityPlugin plugin) {
+ return new VelocityListenerRegistration(eventManager, plugin);
+ }
+
+ /*
+ DebugAddon / PlatformInjector
+ */
+
+ @Provides
+ @Singleton
+ public CommonPlatformInjector platformInjector(ProxyServer server) {
+ return new VelocityInjector(server);
+ }
+
+ @Provides
+ @Named("packetEncoder")
+ public String packetEncoder() {
+ return "minecraft-encoder";
+ }
+
+ @Provides
+ @Named("packetDecoder")
+ public String packetDecoder() {
+ return "minecraft-decoder";
+ }
+
+ @Provides
+ @Named("packetHandler")
+ public String packetHandler() {
+ return "handler";
+ }
+
+ @Provides
+ @Named("implementationName")
+ public String implementationName() {
+ return "Velocity";
+ }
+
+ @Provides
+ @Singleton
+ @Named("kickMessageAttribute")
+ public AttributeKey kickMessageAttribute() {
+ return AttributeKey.newInstance("floodgate-kick-message");
+ }
+}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/util/CommandUtil.java b/velocity/src/main/java/org/geysermc/floodgate/util/CommandUtil.java
deleted file mode 100644
index 93fbabf4..00000000
--- a/velocity/src/main/java/org/geysermc/floodgate/util/CommandUtil.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.geysermc.floodgate.util;
-
-import com.velocitypowered.api.proxy.Player;
-import net.kyori.text.TextComponent;
-import net.kyori.text.serializer.legacy.LegacyComponentSerializer;
-import org.geysermc.floodgate.command.CommandMessage;
-
-public class CommandUtil extends AbstractCommandResponseCache implements ICommandUtil {
- @Override
- public void sendMessage(Player player, CommandMessage message, Object... args) {
- player.sendMessage(getOrAddCachedMessage(message, args));
- }
-
- @Override
- public void kickPlayer(Player player, CommandMessage message, Object... args) {
- player.disconnect(getOrAddCachedMessage(message, args));
- }
-
- @Override
- protected TextComponent transformMessage(String message) {
- return LegacyComponentSerializer.legacy().deserialize(message);
- }
-}
diff --git a/velocity/src/main/java/org/geysermc/floodgate/util/VelocityCommandUtil.java b/velocity/src/main/java/org/geysermc/floodgate/util/VelocityCommandUtil.java
new file mode 100644
index 00000000..b396a91a
--- /dev/null
+++ b/velocity/src/main/java/org/geysermc/floodgate/util/VelocityCommandUtil.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2019-2020 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Floodgate
+ *
+ */
+
+package org.geysermc.floodgate.util;
+
+import com.velocitypowered.api.proxy.Player;
+import lombok.RequiredArgsConstructor;
+import net.kyori.text.TextComponent;
+import net.kyori.text.serializer.legacy.LegacyComponentSerializer;
+import org.geysermc.floodgate.api.logger.FloodgateLogger;
+import org.geysermc.floodgate.platform.command.CommandMessage;
+import org.geysermc.floodgate.platform.command.util.CommandResponseCache;
+import org.geysermc.floodgate.platform.command.util.CommandUtil;
+
+@RequiredArgsConstructor
+public final class VelocityCommandUtil extends CommandResponseCache implements CommandUtil {
+ private final FloodgateLogger logger;
+
+ @Override
+ public void sendMessage(Object player, CommandMessage message, Object... args) {
+ cast(player).sendMessage(getOrAddCachedMessage(message, args));
+ }
+
+ @Override
+ public void kickPlayer(Object player, CommandMessage message, Object... args) {
+ cast(player).disconnect(getOrAddCachedMessage(message, args));
+ }
+
+ @Override
+ protected TextComponent transformMessage(String message) {
+ return LegacyComponentSerializer.legacy().deserialize(message);
+ }
+
+ protected Player cast(Object instance) {
+ try {
+ return (Player) instance;
+ } catch (ClassCastException exception) {
+ logger.error("Failed to cast {} to Player", instance.getClass().getName());
+ throw exception;
+ }
+ }
+}
diff --git a/velocity/src/main/resources/config.yml b/velocity/src/main/resources/config.yml
deleted file mode 100644
index f0485db9..00000000
--- a/velocity/src/main/resources/config.yml
+++ /dev/null
@@ -1,41 +0,0 @@
-# In Floodgate bedrock player data is send encrypted
-# The following value should point to the key Floodgate generated.
-# The public key should be used for the Geyser(s) and the private key for the Floodgate(s)
-key-file-name: key.pem
-
-# Floodgate prepends a prefix to bedrock usernames to avoid conflicts
-# However, certain conflicts can cause issues with some plugins so this prefix is configurable using the property below
-# It is recommended to use a prefix that does not contain alphanumerical to avoid the possibility of duplicate usernames.
-username-prefix: "*"
-
-# Should spaces be replaced with '_' in bedrock usernames?
-replace-spaces: true
-
-# Should Velocity send the bedrock player data to the servers it is connecting to?
-# This requires Floodgate to be installed on the servers.
-# You'll get kicked if you don't use the plugin. The default value is false because of it
-send-floodgate-data: false
-
-disconnect:
- # The disconnect message Geyser users should get when connecting
- # to the server with an invalid key
- invalid-key: Please connect through the official Geyser
- # The disconnect message Geyser users should get when connecting
- # to the server with the correct key but not with the correct data format
- invalid-arguments-length: Expected {0} arguments, got {1}. Is Geyser up-to-date?
-
-# Configuration for player linking
-player-link:
- # Whether to enable the linking system. Turning this off will prevent
- # players from using the linking feature even if they are already linked.
- enable: false
- # The type of storage system you want to use
- # Currently implemented: SQLite
- type: sqlite
- # Whether to allow the use of /linkaccount and /unlinkaccount
- # You can also use allow specific people to use the commands using the
- # permissions floodgate.linkaccount and floodgate.unlinkaccount.
- # This is only for linking, already connected people will stay connected
- allow-linking: true
- # The amount of time until a link code expires in seconds
- link-code-timeout: 300
\ No newline at end of file
diff --git a/velocity/src/main/resources/velocity-plugin.json b/velocity/src/main/resources/velocity-plugin.json
index 6bdc8e29..872b82e7 100644
--- a/velocity/src/main/resources/velocity-plugin.json
+++ b/velocity/src/main/resources/velocity-plugin.json
@@ -1 +1 @@
-{"id": "floodgate", "name": "${project.artifactId}", "version": "${project.version}", "description": "${project.description}", "url": "${project.url}", "authors": ["${project.organization.name}"], "main": "org.geysermc.floodgate.VelocityPlugin"}
\ No newline at end of file
+{"id": "${project.parent.name}", "name": "${outputName}", "version": "${project.version}", "description": "${project.description}", "url": "${project.url}", "authors": ["${project.organization.name}"], "main": "org.geysermc.floodgate.VelocityPlugin"}
\ No newline at end of file