first commit

source/decompiled/de/maxhenkel/voicechat/voice/server/ClientConnection.java

@@ -0,0 +1,42 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.voice.common.NetworkMessage;
+import de.maxhenkel.voicechat.voice.server.Server;
+import java.net.SocketAddress;
+import java.util.UUID;
+
+public class ClientConnection {
+    private UUID playerUUID;
+    private SocketAddress address;
+    private long lastKeepAliveResponse;
+
+    public ClientConnection(UUID playerUUID, SocketAddress address) {
+        this.playerUUID = playerUUID;
+        this.address = address;
+        this.lastKeepAliveResponse = System.currentTimeMillis();
+    }
+
+    public UUID getPlayerUUID() {
+        return this.playerUUID;
+    }
+
+    public SocketAddress getAddress() {
+        return this.address;
+    }
+
+    public long getLastKeepAliveResponse() {
+        return this.lastKeepAliveResponse;
+    }
+
+    public void setLastKeepAliveResponse(long lastKeepAliveResponse) {
+        this.lastKeepAliveResponse = lastKeepAliveResponse;
+    }
+
+    public void send(Server server, NetworkMessage message) throws Exception {
+        server.getSocket().send(message.writeServer(server, this), this.address);
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/Group.java

@@ -0,0 +1,88 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.api.Group;
+import de.maxhenkel.voicechat.voice.common.ClientGroup;
+import java.util.UUID;
+import javax.annotation.Nullable;
+
+public class Group {
+    private UUID id;
+    private String name;
+    @Nullable
+    private String password;
+    private boolean persistent;
+    private boolean hidden;
+    private Group.Type type;
+
+    public Group(UUID id, String name, @Nullable String password, boolean persistent, boolean hidden, Group.Type type) {
+        this.id = id;
+        this.name = name;
+        this.password = password;
+        this.persistent = persistent;
+        this.hidden = hidden;
+        this.type = type;
+    }
+
+    public Group(UUID id, String name, @Nullable String password, boolean persistent) {
+        this(id, name, password, persistent, false, Group.Type.NORMAL);
+    }
+
+    public Group(UUID id, String name, @Nullable String password) {
+        this(id, name, password, false);
+    }
+
+    public Group(UUID id, String name) {
+        this(id, name, null);
+    }
+
+    public Group() {
+    }
+
+    public UUID getId() {
+        return this.id;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    @Nullable
+    public String getPassword() {
+        return this.password;
+    }
+
+    public boolean isPersistent() {
+        return this.persistent;
+    }
+
+    public boolean isHidden() {
+        return this.hidden;
+    }
+
+    public Group.Type getType() {
+        return this.type;
+    }
+
+    public boolean isOpen() {
+        return this.type == Group.Type.OPEN;
+    }
+
+    public boolean isNormal() {
+        return this.type == Group.Type.NORMAL;
+    }
+
+    public boolean isIsolated() {
+        return this.type == Group.Type.ISOLATED;
+    }
+
+    public ClientGroup toClientGroup() {
+        return new ClientGroup(this.id, this.name, this.password != null, this.persistent, this.hidden, this.type);
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/PingManager.java

@@ -0,0 +1,100 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.voice.common.PingPacket;
+import de.maxhenkel.voicechat.voice.server.ClientConnection;
+import de.maxhenkel.voicechat.voice.server.Server;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+public class PingManager {
+    private final Map<UUID, Ping> listeners;
+    private final Server server;
+
+    public PingManager(Server server) {
+        this.server = server;
+        this.listeners = new ConcurrentHashMap<UUID, Ping>();
+    }
+
+    public void onPongPacket(PingPacket packet) {
+        Voicechat.LOGGER.info("Received pong {}", packet.getId());
+        Ping ping = this.listeners.remove(packet.getId());
+        if (ping == null) {
+            return;
+        }
+        ping.listener.onPong(ping.attempt, System.currentTimeMillis() - packet.getTimestamp());
+    }
+
+    public void checkTimeouts() {
+        if (this.listeners.isEmpty()) {
+            return;
+        }
+        List timedOut = this.listeners.entrySet().stream().filter(uuidPingEntry -> ((Ping)uuidPingEntry.getValue()).isTimedOut()).collect(Collectors.toList());
+        for (Map.Entry pingEntry : timedOut) {
+            Ping ping = (Ping)pingEntry.getValue();
+            if (ping.attempt >= ping.maxAttempts) {
+                this.listeners.remove(pingEntry.getKey());
+                ping.listener.onTimeout(ping.attempt);
+                continue;
+            }
+            ping.listener.onFailedAttempt(ping.attempt);
+            try {
+                ping.send();
+            }
+            catch (Exception e) {
+                ping.listener.onTimeout(ping.attempt);
+                Voicechat.LOGGER.warn("Failed to send ping {} after attempt {}", ping.id, ping.attempt);
+            }
+        }
+    }
+
+    public void sendPing(ClientConnection connection, long timeout, int attempts, PingListener listener) throws Exception {
+        Ping ping = new Ping(connection, listener, timeout, attempts);
+        this.listeners.put(ping.id, ping);
+        ping.send();
+    }
+
+    private class Ping {
+        private final UUID id = UUID.randomUUID();
+        private final ClientConnection connection;
+        private final PingListener listener;
+        private long timestamp;
+        private final long timeout;
+        private final int maxAttempts;
+        private int attempt;
+
+        public Ping(ClientConnection connection, PingListener listener, long timeout, int maxAttempts) {
+            this.connection = connection;
+            this.listener = listener;
+            this.timeout = timeout;
+            this.maxAttempts = maxAttempts;
+            this.attempt = 0;
+        }
+
+        public boolean isTimedOut() {
+            return System.currentTimeMillis() - this.timestamp >= this.timeout;
+        }
+
+        public void send() throws Exception {
+            this.timestamp = System.currentTimeMillis();
+            ++this.attempt;
+            PingManager.this.server.sendPacketRaw(new PingPacket(this.id, this.timestamp), this.connection);
+            Voicechat.LOGGER.info("Sent ping {} attempt {}", this.id, this.attempt);
+        }
+    }
+
+    public static interface PingListener {
+        public void onPong(int var1, long var2);
+
+        public void onFailedAttempt(int var1);
+
+        public void onTimeout(int var1);
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/PlayerStateManager.java

@@ -0,0 +1,155 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.Bukkit
+ *  org.bukkit.entity.Player
+ *  org.bukkit.event.Listener
+ *  org.bukkit.event.player.PlayerJoinEvent
+ *  org.bukkit.event.player.PlayerQuitEvent
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.compatibility.PlayerHideEvent;
+import de.maxhenkel.voicechat.compatibility.PlayerShowEvent;
+import de.maxhenkel.voicechat.net.NetManager;
+import de.maxhenkel.voicechat.net.PlayerStatePacket;
+import de.maxhenkel.voicechat.net.PlayerStatesPacket;
+import de.maxhenkel.voicechat.net.RemovePlayerStatePacket;
+import de.maxhenkel.voicechat.net.UpdateStatePacket;
+import de.maxhenkel.voicechat.plugins.PluginManager;
+import de.maxhenkel.voicechat.voice.common.PlayerState;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import javax.annotation.Nullable;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class PlayerStateManager
+implements Listener {
+    private final ConcurrentHashMap<UUID, PlayerState> states = new ConcurrentHashMap();
+
+    public void onUpdateStatePacket(Player player, UpdateStatePacket packet) {
+        PlayerState state = this.states.get(player.getUniqueId());
+        if (state == null) {
+            state = PlayerStateManager.defaultDisconnectedState(player);
+        }
+        state.setDisabled(packet.isDisabled());
+        this.states.put(player.getUniqueId(), state);
+        this.broadcastState(player, state);
+        Voicechat.LOGGER.debug("Got state of {}: {}", player.getName(), state);
+    }
+
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        this.states.remove(event.getPlayer().getUniqueId());
+        this.broadcastRemoveState(event.getPlayer());
+        Voicechat.LOGGER.debug("Removing state of {}", event.getPlayer().getName());
+    }
+
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        PlayerState state = PlayerStateManager.defaultDisconnectedState(event.getPlayer());
+        this.states.put(event.getPlayer().getUniqueId(), state);
+        this.broadcastState(event.getPlayer(), state);
+        Voicechat.LOGGER.debug("Setting default state of {}: {}", event.getPlayer().getName(), state);
+    }
+
+    public void onPlayerHide(PlayerHideEvent event) {
+        RemovePlayerStatePacket packet = new RemovePlayerStatePacket(event.getHiddenPlayer().getUniqueId());
+        NetManager.sendToClient(event.getObserver(), packet);
+        Voicechat.LOGGER.debug("Removing state of {} for {}", event.getHiddenPlayer().getName(), event.getObserver().getName());
+    }
+
+    public void onPlayerShow(PlayerShowEvent event) {
+        PlayerState state = this.states.get(event.getShownPlayer().getUniqueId());
+        if (state == null) {
+            state = PlayerStateManager.defaultDisconnectedState(event.getShownPlayer());
+        }
+        PlayerStatePacket packet = new PlayerStatePacket(state);
+        NetManager.sendToClient(event.getObserver(), packet);
+        Voicechat.LOGGER.debug("Sending state of {} to {}", event.getShownPlayer().getName(), event.getObserver().getName());
+    }
+
+    public void broadcastState(@Nullable Player stateOwner, PlayerState state) {
+        PlayerStatePacket packet = new PlayerStatePacket(state);
+        for (Player receiver : Voicechat.INSTANCE.getServer().getOnlinePlayers()) {
+            if (stateOwner != null && !Voicechat.compatibility.canSee(receiver, stateOwner)) continue;
+            NetManager.sendToClient(receiver, packet);
+        }
+        PluginManager.instance().onPlayerStateChanged(state);
+    }
+
+    public void broadcastRemoveState(Player stateOwner) {
+        RemovePlayerStatePacket packet = new RemovePlayerStatePacket(stateOwner.getUniqueId());
+        for (Player receiver : Voicechat.INSTANCE.getServer().getOnlinePlayers()) {
+            NetManager.sendToClient(receiver, packet);
+        }
+        PluginManager.instance().onPlayerStateChanged(PlayerStateManager.defaultDisconnectedState(stateOwner));
+    }
+
+    public void onPlayerCompatibilityCheckSucceeded(Player player) {
+        ArrayList<PlayerState> stateList = new ArrayList<PlayerState>(this.states.size());
+        for (PlayerState state : this.states.values()) {
+            Player otherPlayer = Voicechat.INSTANCE.getServer().getPlayer(state.getUuid());
+            if (otherPlayer == null || !Voicechat.compatibility.canSee(player, otherPlayer)) continue;
+            stateList.add(state);
+        }
+        PlayerStatesPacket packet = new PlayerStatesPacket(stateList);
+        NetManager.sendToClient(player, packet);
+        Voicechat.LOGGER.debug("Sending initial states to {}", player.getName());
+    }
+
+    public void onPlayerVoicechatDisconnect(UUID uuid) {
+        PlayerState state = this.states.get(uuid);
+        if (state == null) {
+            return;
+        }
+        state.setDisconnected(true);
+        Player player = Bukkit.getPlayer((UUID)uuid);
+        this.broadcastState(player, state);
+        Voicechat.LOGGER.debug("Set state of {} to disconnected: {}", uuid, state);
+    }
+
+    public void onPlayerVoicechatConnect(Player player) {
+        PlayerState state = this.states.get(player.getUniqueId());
+        if (state == null) {
+            state = PlayerStateManager.defaultDisconnectedState(player);
+        }
+        state.setDisconnected(false);
+        this.states.put(player.getUniqueId(), state);
+        this.broadcastState(player, state);
+        Voicechat.LOGGER.debug("Set state of {} to connected: {}", player.getName(), state);
+    }
+
+    @Nullable
+    public PlayerState getState(UUID playerUUID) {
+        return this.states.get(playerUUID);
+    }
+
+    public static PlayerState defaultDisconnectedState(Player player) {
+        return new PlayerState(player.getUniqueId(), player.getName(), false, true);
+    }
+
+    public void setGroup(Player player, @Nullable UUID group) {
+        PlayerState state = this.states.get(player.getUniqueId());
+        if (state == null) {
+            state = PlayerStateManager.defaultDisconnectedState(player);
+            Voicechat.LOGGER.debug("Defaulting to default state for {}: {}", player.getName(), state);
+        }
+        state.setGroup(group);
+        this.states.put(player.getUniqueId(), state);
+        this.broadcastState(player, state);
+        Voicechat.LOGGER.debug("Setting group of {}: {}", player.getName(), state);
+    }
+
+    public Collection<PlayerState> getStates() {
+        return this.states.values();
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/Server.java

@@ -0,0 +1,502 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.Bukkit
+ *  org.bukkit.GameMode
+ *  org.bukkit.Server
+ *  org.bukkit.entity.Entity
+ *  org.bukkit.entity.Player
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.api.RawUdpPacket;
+import de.maxhenkel.voicechat.api.VoicechatSocket;
+import de.maxhenkel.voicechat.debug.CooldownTimer;
+import de.maxhenkel.voicechat.debug.VoicechatUncaughtExceptionHandler;
+import de.maxhenkel.voicechat.net.NetManager;
+import de.maxhenkel.voicechat.permission.PermissionManager;
+import de.maxhenkel.voicechat.plugins.PluginManager;
+import de.maxhenkel.voicechat.voice.common.AuthenticateAckPacket;
+import de.maxhenkel.voicechat.voice.common.AuthenticatePacket;
+import de.maxhenkel.voicechat.voice.common.ConnectionCheckAckPacket;
+import de.maxhenkel.voicechat.voice.common.ConnectionCheckPacket;
+import de.maxhenkel.voicechat.voice.common.GroupSoundPacket;
+import de.maxhenkel.voicechat.voice.common.KeepAlivePacket;
+import de.maxhenkel.voicechat.voice.common.LocationSoundPacket;
+import de.maxhenkel.voicechat.voice.common.MicPacket;
+import de.maxhenkel.voicechat.voice.common.NetworkMessage;
+import de.maxhenkel.voicechat.voice.common.Packet;
+import de.maxhenkel.voicechat.voice.common.PingPacket;
+import de.maxhenkel.voicechat.voice.common.PlayerSoundPacket;
+import de.maxhenkel.voicechat.voice.common.PlayerState;
+import de.maxhenkel.voicechat.voice.common.Secret;
+import de.maxhenkel.voicechat.voice.common.SoundPacket;
+import de.maxhenkel.voicechat.voice.common.Utils;
+import de.maxhenkel.voicechat.voice.server.ClientConnection;
+import de.maxhenkel.voicechat.voice.server.Group;
+import de.maxhenkel.voicechat.voice.server.PingManager;
+import de.maxhenkel.voicechat.voice.server.PlayerStateManager;
+import de.maxhenkel.voicechat.voice.server.ServerCategoryManager;
+import de.maxhenkel.voicechat.voice.server.ServerGroupManager;
+import de.maxhenkel.voicechat.voice.server.ServerPlayerManager;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.nio.channels.AsynchronousCloseException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+public class Server
+extends Thread {
+    private final Map<UUID, ClientConnection> connections;
+    private final Map<UUID, ClientConnection> unCheckedConnections;
+    private final Map<UUID, Secret> secrets;
+    private final int port;
+    private final org.bukkit.Server server;
+    private final VoicechatSocket socket;
+    private final ProcessThread processThread;
+    private final BlockingQueue<RawUdpPacket> packetQueue;
+    private final PingManager pingManager;
+    private final PlayerStateManager playerStateManager;
+    private final ServerGroupManager groupManager;
+    private final ServerCategoryManager categoryManager;
+
+    public Server() {
+        int configPort = Voicechat.SERVER_CONFIG.voiceChatPort.get();
+        if (configPort < 0) {
+            Voicechat.LOGGER.info("Using the Minecraft servers port as voice chat port", new Object[0]);
+            this.port = Bukkit.getPort();
+        } else {
+            this.port = configPort;
+        }
+        this.server = Bukkit.getServer();
+        this.socket = PluginManager.instance().getSocketImplementation();
+        this.connections = new ConcurrentHashMap<UUID, ClientConnection>();
+        this.unCheckedConnections = new ConcurrentHashMap<UUID, ClientConnection>();
+        this.secrets = new ConcurrentHashMap<UUID, Secret>();
+        this.packetQueue = new LinkedBlockingQueue<RawUdpPacket>();
+        this.pingManager = new PingManager(this);
+        this.playerStateManager = new PlayerStateManager();
+        this.groupManager = new ServerGroupManager();
+        this.categoryManager = new ServerCategoryManager();
+        this.setDaemon(true);
+        this.setName("VoiceChatServerThread");
+        this.setUncaughtExceptionHandler(new VoicechatUncaughtExceptionHandler());
+        this.processThread = new ProcessThread();
+        this.processThread.start();
+    }
+
+    @Override
+    public void run() {
+        try {
+            String bindAddress = this.getBindAddress();
+            try {
+                InetAddress.getByName(bindAddress);
+            }
+            catch (UnknownHostException e) {
+                Voicechat.LOGGER.error("Failed to parse bind IP address '{}'", bindAddress, e);
+                Voicechat.LOGGER.info("Binding to wildcard IP address", new Object[0]);
+                bindAddress = "";
+            }
+            this.socket.open(this.port, bindAddress);
+            if (bindAddress.isEmpty()) {
+                Voicechat.LOGGER.info("Voice chat server started at port {}", this.socket.getLocalPort());
+            } else {
+                Voicechat.LOGGER.info("Voice chat server started at {}:{}", bindAddress, this.socket.getLocalPort());
+            }
+            while (!this.socket.isClosed()) {
+                try {
+                    this.packetQueue.add(this.socket.read());
+                }
+                catch (Exception e) {
+                    if (e instanceof SocketException && e.getCause() instanceof AsynchronousCloseException || !Voicechat.debugMode()) continue;
+                    Voicechat.LOGGER.error("Failed to read from socket", e);
+                }
+            }
+        }
+        catch (Exception e) {
+            Voicechat.LOGGER.error("Voice chat server error", e);
+        }
+    }
+
+    private String getBindAddress() {
+        String bindAddress;
+        block8: {
+            bindAddress = Voicechat.SERVER_CONFIG.voiceChatBindAddress.get();
+            if (bindAddress.trim().equals("*")) {
+                bindAddress = "";
+            } else if (bindAddress.trim().isEmpty()) {
+                try {
+                    bindAddress = Bukkit.getIp();
+                    if (bindAddress.trim().isEmpty()) break block8;
+                    try {
+                        InetAddress address = InetAddress.getByName(bindAddress);
+                        if (address.isLoopbackAddress()) {
+                            bindAddress = "";
+                            break block8;
+                        }
+                        Voicechat.LOGGER.info("Using server-ip as bind address: {}", bindAddress);
+                    }
+                    catch (Exception e) {
+                        Voicechat.LOGGER.warn("Invalid server-ip", e);
+                        bindAddress = "";
+                    }
+                }
+                catch (Throwable t) {
+                    Voicechat.LOGGER.warn("Failed to get server-ip from server.properties - binding to wildcard address", t);
+                }
+            }
+        }
+        return bindAddress;
+    }
+
+    public Secret getSecret(UUID playerUUID) {
+        if (this.hasSecret(playerUUID)) {
+            return this.secrets.get(playerUUID);
+        }
+        Secret secret = Secret.generateNewRandomSecret();
+        this.secrets.put(playerUUID, secret);
+        return secret;
+    }
+
+    @Nullable
+    public Secret generateNewSecret(UUID playerUUID) {
+        if (this.hasSecret(playerUUID)) {
+            return null;
+        }
+        return this.getSecret(playerUUID);
+    }
+
+    public boolean hasSecret(UUID playerUUID) {
+        return this.secrets.containsKey(playerUUID);
+    }
+
+    public void disconnectClient(UUID playerUUID) {
+        this.connections.remove(playerUUID);
+        this.unCheckedConnections.remove(playerUUID);
+        this.secrets.remove(playerUUID);
+        PluginManager.instance().onPlayerDisconnected(playerUUID);
+    }
+
+    public void close() {
+        this.socket.close();
+        this.processThread.close();
+        PluginManager.instance().onServerStopped();
+    }
+
+    public boolean isClosed() {
+        return !this.processThread.running;
+    }
+
+    public void onMicPacket(UUID playerUuid, MicPacket packet) {
+        Player player = this.server.getPlayer(playerUuid);
+        if (player == null) {
+            return;
+        }
+        if (!player.hasPermission(PermissionManager.SPEAK_PERMISSION)) {
+            CooldownTimer.run("no-speak-" + playerUuid, () -> NetManager.sendStatusMessage(player, "message.voicechat.no_speak_permission", new String[0]));
+            return;
+        }
+        PlayerState state = this.playerStateManager.getState(player.getUniqueId());
+        if (state == null) {
+            return;
+        }
+        if (!PluginManager.instance().onMicPacket(player, state, packet)) {
+            this.processMicPacket(player, state, packet);
+        }
+    }
+
+    private void processMicPacket(Player player, PlayerState state, MicPacket packet) {
+        if (state.hasGroup()) {
+            Group group = this.groupManager.getGroup(state.getGroup());
+            this.processGroupPacket(state, player, packet);
+            if (group == null || group.isOpen()) {
+                this.processProximityPacket(state, player, packet);
+            }
+            return;
+        }
+        this.processProximityPacket(state, player, packet);
+    }
+
+    private void processGroupPacket(PlayerState senderState, Player sender, MicPacket packet) {
+        UUID groupId = senderState.getGroup();
+        if (groupId == null) {
+            return;
+        }
+        GroupSoundPacket groupSoundPacket = new GroupSoundPacket(senderState.getUuid(), senderState.getUuid(), packet.getData(), packet.getSequenceNumber(), null);
+        for (PlayerState state : this.playerStateManager.getStates()) {
+            Player p;
+            if (!groupId.equals(state.getGroup()) || senderState.getUuid().equals(state.getUuid()) || (p = this.server.getPlayer(state.getUuid())) == null) continue;
+            ClientConnection connection = this.getConnection(state.getUuid());
+            this.sendSoundPacket(sender, senderState, p, state, connection, groupSoundPacket, "group");
+        }
+    }
+
+    private void processProximityPacket(PlayerState senderState, Player sender, MicPacket packet) {
+        UUID groupId = senderState.getGroup();
+        float distance = packet.isWhispering() ? Voicechat.SERVER_CONFIG.whisperDistance.get().floatValue() : Utils.getDefaultDistance();
+        distance = PluginManager.instance().getDistance(sender, senderState, packet, distance);
+        SoundPacket soundPacket = null;
+        String source = null;
+        if (sender.getGameMode().equals((Object)GameMode.SPECTATOR)) {
+            Player spectatingPlayer;
+            Entity camera;
+            if (Voicechat.SERVER_CONFIG.spectatorPlayerPossession.get().booleanValue() && (camera = sender.getSpectatorTarget()) instanceof Player && (spectatingPlayer = (Player)camera) != sender) {
+                PlayerState receiverState = this.playerStateManager.getState(spectatingPlayer.getUniqueId());
+                if (receiverState == null) {
+                    return;
+                }
+                GroupSoundPacket groupSoundPacket = new GroupSoundPacket(senderState.getUuid(), senderState.getUuid(), packet.getData(), packet.getSequenceNumber(), null);
+                ClientConnection connection = this.getConnection(receiverState.getUuid());
+                this.sendSoundPacket(sender, senderState, spectatingPlayer, receiverState, connection, groupSoundPacket, "spectator");
+                return;
+            }
+            if (Voicechat.SERVER_CONFIG.spectatorInteraction.get().booleanValue()) {
+                soundPacket = new LocationSoundPacket(sender.getUniqueId(), sender.getUniqueId(), sender.getLocation(), packet.getData(), packet.getSequenceNumber(), distance, null);
+                source = "spectator";
+            }
+        }
+        if (soundPacket == null) {
+            soundPacket = new PlayerSoundPacket(sender.getUniqueId(), sender.getUniqueId(), packet.getData(), packet.getSequenceNumber(), packet.isWhispering(), distance, null);
+            source = "proximity";
+        }
+        this.broadcast(ServerPlayerManager.getPlayersInRange(sender.getWorld(), sender.getLocation(), this.getBroadcastRange(distance), p -> !p.getUniqueId().equals(sender.getUniqueId())), soundPacket, sender, senderState, groupId, source);
+    }
+
+    public void sendSoundPacket(@Nullable Player sender, @Nullable PlayerState senderState, Player receiver, PlayerState receiverState, @Nullable ClientConnection connection, SoundPacket<?> soundPacket, String source) {
+        PluginManager.instance().onListenerAudio(receiver.getUniqueId(), soundPacket);
+        if (connection == null) {
+            return;
+        }
+        if (receiverState.isDisabled() || receiverState.isDisconnected()) {
+            return;
+        }
+        if (PluginManager.instance().onSoundPacket(sender, senderState, receiver, receiverState, soundPacket, source)) {
+            return;
+        }
+        if (!receiver.hasPermission(PermissionManager.LISTEN_PERMISSION)) {
+            CooldownTimer.run(String.format("no-listen-%s", receiver.getUniqueId()), 30000L, () -> NetManager.sendStatusMessage(receiver, "message.voicechat.no_listen_permission", new String[0]));
+            return;
+        }
+        this.sendPacket(soundPacket, connection);
+    }
+
+    public double getBroadcastRange(float minRange) {
+        double broadcastRange = Voicechat.SERVER_CONFIG.broadcastRange.get();
+        if (broadcastRange < 0.0) {
+            broadcastRange = Voicechat.SERVER_CONFIG.voiceChatDistance.get() + 1.0;
+        }
+        return Math.max(broadcastRange, (double)minRange);
+    }
+
+    public void broadcast(Collection<Player> players, SoundPacket<?> packet, @Nullable Player sender, @Nullable PlayerState senderState, @Nullable UUID groupId, String source) {
+        for (Player player : players) {
+            PlayerState state = this.playerStateManager.getState(player.getUniqueId());
+            if (state == null || state.hasGroup() && state.getGroup().equals(groupId)) continue;
+            Group receiverGroup = null;
+            if (state.hasGroup()) {
+                receiverGroup = this.groupManager.getGroup(state.getGroup());
+            }
+            if (receiverGroup != null && receiverGroup.isIsolated()) continue;
+            ClientConnection connection = this.getConnection(state.getUuid());
+            this.sendSoundPacket(sender, senderState, player, state, connection, packet, source);
+        }
+    }
+
+    private void sendKeepAlives() {
+        long timestamp = System.currentTimeMillis();
+        this.connections.values().removeIf(connection -> {
+            if (timestamp - connection.getLastKeepAliveResponse() >= (long)Voicechat.SERVER_CONFIG.keepAlive.get().intValue() * 10L) {
+                this.secrets.remove(connection.getPlayerUUID());
+                Voicechat.LOGGER.info("Player {} timed out", connection.getPlayerUUID());
+                Player player = this.server.getPlayer(connection.getPlayerUUID());
+                if (player != null) {
+                    Voicechat.LOGGER.info("Reconnecting player {}", player.getName());
+                    Voicechat.SERVER.initializePlayerConnection(player);
+                } else {
+                    Voicechat.LOGGER.error("Reconnecting player {} failed (Could not find player)", connection.getPlayerUUID());
+                }
+                this.playerStateManager.onPlayerVoicechatDisconnect(connection.getPlayerUUID());
+                PluginManager.instance().onPlayerDisconnected(connection.getPlayerUUID());
+                return true;
+            }
+            return false;
+        });
+        for (ClientConnection connection2 : this.connections.values()) {
+            this.sendPacket(new KeepAlivePacket(), connection2);
+        }
+    }
+
+    @Nullable
+    public ClientConnection getSender(NetworkMessage message) {
+        return this.connections.values().stream().filter(connection -> connection.getAddress().equals(message.getAddress())).findAny().orElse(null);
+    }
+
+    @Nullable
+    public ClientConnection getUnconnectedSender(NetworkMessage message) {
+        return this.unCheckedConnections.values().stream().filter(connection -> connection.getAddress().equals(message.getAddress())).findAny().orElse(null);
+    }
+
+    public Map<UUID, ClientConnection> getConnections() {
+        return this.connections;
+    }
+
+    @Nullable
+    public ClientConnection getConnection(UUID playerID) {
+        return this.connections.get(playerID);
+    }
+
+    public VoicechatSocket getSocket() {
+        return this.socket;
+    }
+
+    public int getPort() {
+        return this.socket.getLocalPort();
+    }
+
+    public boolean sendPacket(Packet<?> packet, ClientConnection connection) {
+        try {
+            this.sendPacketRaw(packet, connection);
+            return true;
+        }
+        catch (Exception e) {
+            Voicechat.LOGGER.error("Failed to send voice chat packet to {}", connection.getPlayerUUID());
+            return false;
+        }
+    }
+
+    public void sendPacketRaw(Packet<?> packet, ClientConnection connection) throws Exception {
+        connection.send(this, new NetworkMessage(packet));
+    }
+
+    public PingManager getPingManager() {
+        return this.pingManager;
+    }
+
+    public PlayerStateManager getPlayerStateManager() {
+        return this.playerStateManager;
+    }
+
+    public ServerGroupManager getGroupManager() {
+        return this.groupManager;
+    }
+
+    public ServerCategoryManager getCategoryManager() {
+        return this.categoryManager;
+    }
+
+    private class ProcessThread
+    extends Thread {
+        private boolean running = true;
+        private long lastKeepAlive = 0L;
+
+        public ProcessThread() {
+            this.setDaemon(true);
+            this.setName("VoiceChatPacketProcessingThread");
+            this.setUncaughtExceptionHandler(new VoicechatUncaughtExceptionHandler());
+        }
+
+        @Override
+        public void run() {
+            while (this.running) {
+                try {
+                    NetworkMessage message;
+                    RawUdpPacket rawPacket;
+                    Server.this.pingManager.checkTimeouts();
+                    long keepAliveTime = System.currentTimeMillis();
+                    if (keepAliveTime - this.lastKeepAlive > (long)Voicechat.SERVER_CONFIG.keepAlive.get().intValue()) {
+                        Server.this.sendKeepAlives();
+                        this.lastKeepAlive = keepAliveTime;
+                    }
+                    if ((rawPacket = (RawUdpPacket)Server.this.packetQueue.poll(10L, TimeUnit.MILLISECONDS)) == null) continue;
+                    try {
+                        message = NetworkMessage.readPacketServer(rawPacket, Server.this);
+                    }
+                    catch (Exception e) {
+                        CooldownTimer.run("failed_reading_packet", () -> Voicechat.LOGGER.warn("Failed to read packet from {}", rawPacket.getSocketAddress()));
+                        continue;
+                    }
+                    if (message == null) continue;
+                    if (System.currentTimeMillis() - message.getTimestamp() > message.getTTL()) {
+                        CooldownTimer.run("ttl", () -> {
+                            Voicechat.LOGGER.error("Dropping voice chat packets! Your Server might be overloaded!", new Object[0]);
+                            Voicechat.LOGGER.error("Packet queue has {} packets", Server.this.packetQueue.size());
+                        });
+                        continue;
+                    }
+                    if (message.getPacket() instanceof AuthenticatePacket) {
+                        AuthenticatePacket packet = (AuthenticatePacket)message.getPacket();
+                        Secret secret = (Secret)Server.this.secrets.get(packet.getPlayerUUID());
+                        if (secret != null && secret.equals(packet.getSecret())) {
+                            ClientConnection connection = (ClientConnection)Server.this.unCheckedConnections.get(packet.getPlayerUUID());
+                            if (connection == null) {
+                                connection = (ClientConnection)Server.this.connections.get(packet.getPlayerUUID());
+                            }
+                            if (connection == null) {
+                                connection = new ClientConnection(packet.getPlayerUUID(), message.getAddress());
+                                Server.this.unCheckedConnections.put(packet.getPlayerUUID(), connection);
+                                Voicechat.LOGGER.info("Successfully authenticated player {}", packet.getPlayerUUID());
+                            }
+                            Server.this.sendPacket(new AuthenticateAckPacket(), connection);
+                        }
+                    }
+                    if (message.getPacket() instanceof ConnectionCheckPacket) {
+                        ClientConnection connection = Server.this.getUnconnectedSender(message);
+                        if (connection == null) {
+                            connection = Server.this.getSender(message);
+                            if (connection == null) continue;
+                            Server.this.sendPacket(new ConnectionCheckAckPacket(), connection);
+                            continue;
+                        }
+                        connection.setLastKeepAliveResponse(System.currentTimeMillis());
+                        Server.this.connections.put(connection.getPlayerUUID(), connection);
+                        Server.this.unCheckedConnections.remove(connection.getPlayerUUID());
+                        Voicechat.LOGGER.info("Successfully validated connection of player {}", connection.getPlayerUUID());
+                        Player player = Server.this.server.getPlayer(connection.getPlayerUUID());
+                        if (player != null) {
+                            Server.this.playerStateManager.onPlayerVoicechatConnect(player);
+                            PluginManager.instance().onPlayerConnected(player);
+                            Voicechat.LOGGER.info("Player {} ({}) successfully connected to voice chat", player.getName(), connection.getPlayerUUID());
+                        }
+                        Server.this.sendPacket(new ConnectionCheckAckPacket(), connection);
+                        continue;
+                    }
+                    ClientConnection conn = Server.this.getSender(message);
+                    if (conn == null) continue;
+                    if (message.getPacket() instanceof MicPacket) {
+                        Server.this.onMicPacket(conn.getPlayerUUID(), (MicPacket)message.getPacket());
+                        continue;
+                    }
+                    if (message.getPacket() instanceof PingPacket) {
+                        PingPacket packet = (PingPacket)message.getPacket();
+                        Server.this.pingManager.onPongPacket(packet);
+                        continue;
+                    }
+                    if (!(message.getPacket() instanceof KeepAlivePacket)) continue;
+                    conn.setLastKeepAliveResponse(System.currentTimeMillis());
+                }
+                catch (Exception e) {
+                    Voicechat.LOGGER.error("Voice chat server error", e);
+                }
+            }
+        }
+
+        public void close() {
+            this.running = false;
+        }
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/ServerCategoryManager.java

@@ -0,0 +1,54 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.entity.Player
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.net.AddCategoryPacket;
+import de.maxhenkel.voicechat.net.NetManager;
+import de.maxhenkel.voicechat.net.RemoveCategoryPacket;
+import de.maxhenkel.voicechat.plugins.CategoryManager;
+import de.maxhenkel.voicechat.plugins.impl.VolumeCategoryImpl;
+import javax.annotation.Nullable;
+import org.bukkit.entity.Player;
+
+public class ServerCategoryManager
+extends CategoryManager {
+    public void onPlayerCompatibilityCheckSucceeded(Player player) {
+        Voicechat.LOGGER.debug("Synchronizing {} volume categories with {}", this.categories.size(), player.getName());
+        for (VolumeCategoryImpl category : this.getCategories()) {
+            NetManager.sendToClient(player, new AddCategoryPacket(category));
+        }
+    }
+
+    @Override
+    public void addCategory(VolumeCategoryImpl category) {
+        super.addCategory(category);
+        Voicechat.LOGGER.debug("Synchronizing volume category {} with all players", category.getId());
+        this.broadcastAddCategory(category);
+    }
+
+    @Override
+    @Nullable
+    public VolumeCategoryImpl removeCategory(String categoryId) {
+        VolumeCategoryImpl volumeCategory = super.removeCategory(categoryId);
+        Voicechat.LOGGER.debug("Removing volume category {} for all players", categoryId);
+        this.broadcastRemoveCategory(categoryId);
+        return volumeCategory;
+    }
+
+    private void broadcastAddCategory(VolumeCategoryImpl category) {
+        AddCategoryPacket packet = new AddCategoryPacket(category);
+        Voicechat.INSTANCE.getServer().getOnlinePlayers().forEach(p -> NetManager.sendToClient(p, packet));
+    }
+
+    private void broadcastRemoveCategory(String categoryId) {
+        RemoveCategoryPacket packet = new RemoveCategoryPacket(categoryId);
+        Voicechat.INSTANCE.getServer().getOnlinePlayers().forEach(p -> NetManager.sendToClient(p, packet));
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/ServerGroupManager.java

@@ -0,0 +1,185 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.entity.Player
+ *  org.bukkit.event.player.PlayerQuitEvent
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.net.AddGroupPacket;
+import de.maxhenkel.voicechat.net.CreateGroupPacket;
+import de.maxhenkel.voicechat.net.JoinGroupPacket;
+import de.maxhenkel.voicechat.net.JoinedGroupPacket;
+import de.maxhenkel.voicechat.net.LeaveGroupPacket;
+import de.maxhenkel.voicechat.net.NetManager;
+import de.maxhenkel.voicechat.net.RemoveGroupPacket;
+import de.maxhenkel.voicechat.permission.PermissionManager;
+import de.maxhenkel.voicechat.plugins.PluginManager;
+import de.maxhenkel.voicechat.voice.common.PlayerState;
+import de.maxhenkel.voicechat.voice.server.Group;
+import de.maxhenkel.voicechat.voice.server.PlayerStateManager;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class ServerGroupManager {
+    private final Map<UUID, Group> groups = new ConcurrentHashMap<UUID, Group>();
+
+    public void onJoinGroupPacket(Player player, JoinGroupPacket packet) {
+        if (!Voicechat.SERVER_CONFIG.groupsEnabled.get().booleanValue()) {
+            return;
+        }
+        if (!player.hasPermission(PermissionManager.GROUPS_PERMISSION)) {
+            NetManager.sendStatusMessage(player, "message.voicechat.no_group_permission", new String[0]);
+            return;
+        }
+        this.joinGroup(this.groups.get(packet.getGroup()), player, packet.getPassword());
+    }
+
+    public void onCreateGroupPacket(Player player, CreateGroupPacket packet) {
+        if (!Voicechat.SERVER_CONFIG.groupsEnabled.get().booleanValue()) {
+            return;
+        }
+        if (!player.hasPermission(PermissionManager.GROUPS_PERMISSION)) {
+            NetManager.sendStatusMessage(player, "message.voicechat.no_group_permission", new String[0]);
+            return;
+        }
+        if (!Voicechat.GROUP_REGEX.matcher(packet.getName()).matches()) {
+            Voicechat.LOGGER.warn("Player {} tried to create a group with an invalid name", player.getDisplayName());
+            return;
+        }
+        if (packet.getPassword() != null && !Voicechat.GROUP_REGEX.matcher(packet.getPassword()).matches()) {
+            Voicechat.LOGGER.warn("Player {} tried to create a group with an invalid password", player.getDisplayName());
+            return;
+        }
+        Group group = new Group(UUID.randomUUID(), packet.getName(), packet.getPassword(), false, false, packet.getType());
+        this.addGroup(group, player);
+    }
+
+    public void onLeaveGroupPacket(Player player, LeaveGroupPacket packet) {
+        this.leaveGroup(player);
+    }
+
+    public void onPlayerCompatibilityCheckSucceeded(Player player) {
+        Voicechat.LOGGER.debug("Synchronizing {} groups with {}", this.groups.size(), player.getDisplayName());
+        for (Group group : this.groups.values()) {
+            NetManager.sendToClient(player, new AddGroupPacket(group.toClientGroup()));
+        }
+    }
+
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        this.cleanupGroups();
+    }
+
+    private PlayerStateManager getStates() {
+        return Voicechat.SERVER.getServer().getPlayerStateManager();
+    }
+
+    public void addGroup(Group group, @Nullable Player player) {
+        if (PluginManager.instance().onCreateGroup(player, group)) {
+            return;
+        }
+        this.groups.put(group.getId(), group);
+        this.broadcastAddGroup(group);
+        if (player == null) {
+            return;
+        }
+        PlayerStateManager manager = this.getStates();
+        manager.setGroup(player, group.getId());
+        NetManager.sendToClient(player, new JoinedGroupPacket(group.getId(), false));
+    }
+
+    public void joinGroup(@Nullable Group group, Player player, String password) {
+        if (group != null && group.getPassword() != null && !group.getPassword().equals(password)) {
+            NetManager.sendToClient(player, new JoinedGroupPacket(null, true));
+            return;
+        }
+        if (PluginManager.instance().onJoinGroup(player, group)) {
+            return;
+        }
+        if (group == null) {
+            NetManager.sendToClient(player, new JoinedGroupPacket(null, false));
+            return;
+        }
+        PlayerStateManager manager = this.getStates();
+        manager.setGroup(player, group.getId());
+        NetManager.sendToClient(player, new JoinedGroupPacket(group.getId(), false));
+    }
+
+    public void leaveGroup(Player player) {
+        if (PluginManager.instance().onLeaveGroup(player)) {
+            return;
+        }
+        PlayerStateManager manager = this.getStates();
+        manager.setGroup(player, null);
+        NetManager.sendToClient(player, new JoinedGroupPacket(null, false));
+        this.cleanupGroups();
+    }
+
+    public void cleanupGroups() {
+        PlayerStateManager manager = this.getStates();
+        List usedGroups = manager.getStates().stream().filter(PlayerState::hasGroup).map(PlayerState::getGroup).distinct().collect(Collectors.toList());
+        List groupsToRemove = this.groups.entrySet().stream().filter(entry -> !((Group)entry.getValue()).isPersistent()).map(Map.Entry::getKey).filter(uuid -> !usedGroups.contains(uuid)).collect(Collectors.toList());
+        for (UUID uuid2 : groupsToRemove) {
+            this.removeGroup(uuid2);
+        }
+    }
+
+    public boolean removeGroup(UUID groupId) {
+        Group group = this.groups.get(groupId);
+        if (group == null) {
+            return false;
+        }
+        PlayerStateManager manager = this.getStates();
+        if (manager.getStates().stream().anyMatch(state -> state.hasGroup() && state.getGroup().equals(groupId))) {
+            return false;
+        }
+        if (PluginManager.instance().onRemoveGroup(group)) {
+            return false;
+        }
+        this.groups.remove(groupId);
+        this.broadcastRemoveGroup(groupId);
+        return true;
+    }
+
+    @Nullable
+    public Group getGroup(UUID groupID) {
+        return this.groups.get(groupID);
+    }
+
+    private void broadcastAddGroup(Group group) {
+        AddGroupPacket packet = new AddGroupPacket(group.toClientGroup());
+        Voicechat.INSTANCE.getServer().getOnlinePlayers().forEach(p -> NetManager.sendToClient(p, packet));
+    }
+
+    private void broadcastRemoveGroup(UUID group) {
+        RemoveGroupPacket packet = new RemoveGroupPacket(group);
+        Voicechat.INSTANCE.getServer().getOnlinePlayers().forEach(p -> NetManager.sendToClient(p, packet));
+    }
+
+    @Nullable
+    public Group getPlayerGroup(Player player) {
+        PlayerState state = this.getStates().getState(player.getUniqueId());
+        if (state == null) {
+            return null;
+        }
+        UUID groupId = state.getGroup();
+        if (groupId == null) {
+            return null;
+        }
+        return this.getGroup(groupId);
+    }
+
+    public Map<UUID, Group> getGroups() {
+        return this.groups;
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/ServerPlayerManager.java

@@ -0,0 +1,107 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.Bukkit
+ *  org.bukkit.Location
+ *  org.bukkit.World
+ *  org.bukkit.entity.Player
+ *  org.bukkit.event.EventHandler
+ *  org.bukkit.event.Listener
+ *  org.bukkit.event.player.PlayerJoinEvent
+ *  org.bukkit.event.player.PlayerQuitEvent
+ *  org.bukkit.plugin.Plugin
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+import javax.annotation.Nullable;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.Plugin;
+
+public class ServerPlayerManager
+implements Listener {
+    private static final long REFRESH_INTERVAL_TICKS = 600L;
+    public static final ServerPlayerManager INSTANCE = new ServerPlayerManager();
+    private volatile Set<Player> players = Collections.emptySet();
+
+    public static void init(Plugin plugin) {
+        if (!Voicechat.SERVER_CONFIG.threadedServerSupport.get().booleanValue()) {
+            return;
+        }
+        Bukkit.getPluginManager().registerEvents((Listener)INSTANCE, plugin);
+        Voicechat.compatibility.scheduleSyncRepeatingTask(INSTANCE::refresh, 0L, 600L);
+    }
+
+    private ServerPlayerManager() {
+    }
+
+    private synchronized void refresh() {
+        this.players = new HashSet<Player>(Bukkit.getOnlinePlayers());
+    }
+
+    @EventHandler
+    public synchronized void onPlayerJoin(PlayerJoinEvent event) {
+        HashSet<Player> newPlayers = new HashSet<Player>(this.players);
+        newPlayers.add(event.getPlayer());
+        this.players = newPlayers;
+    }
+
+    @EventHandler
+    public synchronized void onPlayerQuit(PlayerQuitEvent event) {
+        HashSet<Player> newPlayers = new HashSet<Player>(this.players);
+        newPlayers.remove(event.getPlayer());
+        this.players = newPlayers;
+    }
+
+    public static Collection<Player> getPlayersInRange(World level, Location pos, double range, @Nullable Predicate<Player> filter) {
+        return INSTANCE.getPlayersInRangeInternal(level, pos, range, filter);
+    }
+
+    private Collection<Player> getPlayersInRangeInternal(World world, Location pos, double range, @Nullable Predicate<Player> filter) {
+        if (!Voicechat.SERVER_CONFIG.threadedServerSupport.get().booleanValue()) {
+            return ServerPlayerManager.getPlayersInRangeDirect(world, pos, range, filter);
+        }
+        ArrayList<Player> nearbyPlayers = new ArrayList<Player>();
+        for (Player player : this.players) {
+            if (!world.equals((Object)player.getWorld()) || !ServerPlayerManager.isInRange(player.getLocation(), pos, range) || filter != null && !filter.test(player)) continue;
+            nearbyPlayers.add(player);
+        }
+        return nearbyPlayers;
+    }
+
+    private static Collection<Player> getPlayersInRangeDirect(World world, Location pos, double range, @Nullable Predicate<Player> filter) {
+        ArrayList<Player> nearbyPlayers = new ArrayList<Player>();
+        List worldPlayers = world.getPlayers();
+        for (int i = 0; i < worldPlayers.size(); ++i) {
+            Player player = (Player)worldPlayers.get(i);
+            if (!ServerPlayerManager.isInRange(player.getLocation(), pos, range) || filter != null && !filter.test(player)) continue;
+            nearbyPlayers.add(player);
+        }
+        return nearbyPlayers;
+    }
+
+    public static boolean isInRange(Location pos1, Location pos2, double range) {
+        return ServerPlayerManager.square(pos1.getX() - pos2.getX()) + ServerPlayerManager.square(pos1.getY() - pos2.getY()) + ServerPlayerManager.square(pos1.getZ() - pos2.getZ()) <= ServerPlayerManager.square(range);
+    }
+
+    private static double square(double value) {
+        return value * value;
+    }
+}
+

source/decompiled/de/maxhenkel/voicechat/voice/server/ServerVoiceEvents.java

@@ -0,0 +1,167 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.bukkit.Bukkit
+ *  org.bukkit.entity.Player
+ *  org.bukkit.event.EventHandler
+ *  org.bukkit.event.Listener
+ *  org.bukkit.event.player.PlayerJoinEvent
+ *  org.bukkit.event.player.PlayerQuitEvent
+ */
+package de.maxhenkel.voicechat.voice.server;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.compatibility.PlayerHideEvent;
+import de.maxhenkel.voicechat.compatibility.PlayerShowEvent;
+import de.maxhenkel.voicechat.net.NetManager;
+import de.maxhenkel.voicechat.net.PacketRateLimiter;
+import de.maxhenkel.voicechat.net.RequestSecretPacket;
+import de.maxhenkel.voicechat.net.SecretPacket;
+import de.maxhenkel.voicechat.plugins.PluginManager;
+import de.maxhenkel.voicechat.voice.common.Secret;
+import de.maxhenkel.voicechat.voice.server.Server;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class ServerVoiceEvents
+implements Listener {
+    private static final int LEGACY_COMPATIBILITY_VERSION = 18;
+    private static final int CURRENT_COMPATIBILITY_VERSION = 20;
+    private final Map<UUID, Integer> clientCompatibilities = new ConcurrentHashMap<UUID, Integer>();
+    private final PacketRateLimiter rateLimiter;
+    private Server server;
+
+    public ServerVoiceEvents() {
+        this.rateLimiter = new PacketRateLimiter(Voicechat.SERVER_CONFIG.tcpRateLimit.get());
+    }
+
+    public void init() {
+        if (this.server != null) {
+            return;
+        }
+        if (!Bukkit.getOnlineMode()) {
+            Voicechat.LOGGER.warn("Running in offline mode - Voice chat encryption is not secure!", new Object[0]);
+        }
+        Voicechat.compatibility.registerPlayerHideEvent(this::onPlayerHide);
+        Voicechat.compatibility.registerPlayerShowEvent(this::onPlayerShow);
+        this.server = new Server();
+        this.server.start();
+        PluginManager.instance().onServerStarted();
+    }
+
+    public void onRequestSecretPacket(Player player, RequestSecretPacket requestSecretPacket) {
+        UUID uUID;
+        int n = requestSecretPacket.getCompatibilityVersion();
+        Voicechat.LOGGER.info("Received secret request of {} ({})", player.getName(), n);
+        try {
+            uUID = player.getUniqueId();
+        }
+        catch (UnsupportedOperationException unsupportedOperationException) {
+            player.kickPlayer("Tried to authenticate voice chat while still connecting");
+            Voicechat.LOGGER.warn("{} tried to authenticate voice chat while still connecting", player.getName());
+            return;
+        }
+        this.clientCompatibilities.put(uUID, n);
+        if (!ServerVoiceEvents.isSupportedCompatibilityVersion(n)) {
+            Voicechat.LOGGER.warn("Connected client {} has incompatible voice chat version (server={}, client={})", player.getName(), Voicechat.COMPATIBILITY_VERSION, n);
+            ServerVoiceEvents.sendIncompatibleMessage(player, n);
+            return;
+        }
+        this.initializePlayerConnection(player);
+    }
+
+    private static boolean isSupportedCompatibilityVersion(int n) {
+        return n == 18 || n == 20;
+    }
+
+    public boolean isCompatible(Player player) {
+        return this.isCompatible(player.getUniqueId());
+    }
+
+    public boolean isCompatible(UUID uUID) {
+        return ServerVoiceEvents.isSupportedCompatibilityVersion(this.clientCompatibilities.getOrDefault(uUID, -1));
+    }
+
+    public static void sendIncompatibleMessage(Player player, int n) {
+        if (n <= 6) {
+            player.sendMessage(String.format(Voicechat.TRANSLATIONS.voicechatNotCompatibleMessage.get(), "2.6.x", "Simple Voice Chat"));
+        } else {
+            Voicechat.compatibility.sendIncompatibleMessage(player, "2.6.x", "Simple Voice Chat");
+        }
+    }
+
+    public void initializePlayerConnection(Player player) {
+        if (this.server == null) {
+            return;
+        }
+        UUID uUID = player.getUniqueId();
+        this.server.getPlayerStateManager().onPlayerCompatibilityCheckSucceeded(player);
+        this.server.getCategoryManager().onPlayerCompatibilityCheckSucceeded(player);
+        this.server.getGroupManager().onPlayerCompatibilityCheckSucceeded(player);
+        Secret secret = this.server.generateNewSecret(uUID);
+        if (secret == null) {
+            Voicechat.LOGGER.warn("Player already requested secret - ignoring", new Object[0]);
+            return;
+        }
+        secret.setLegacyProtocol(this.clientCompatibilities.getOrDefault(uUID, -1) == 18);
+        String string = PluginManager.instance().getVoiceHost(player, Voicechat.SERVER_CONFIG.voiceHost.get());
+        NetManager.sendToClient(player, new SecretPacket(player, secret, this.server.getPort(), Voicechat.SERVER_CONFIG, string));
+        Voicechat.LOGGER.info("Sent secret to {}", player.getName());
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent playerJoinEvent) {
+        this.server.getPlayerStateManager().onPlayerJoin(playerJoinEvent);
+        if (!Voicechat.SERVER_CONFIG.forceVoiceChat.get().booleanValue()) {
+            return;
+        }
+        Player player = playerJoinEvent.getPlayer();
+        Voicechat.compatibility.runTaskLater(() -> {
+            if (!player.isOnline()) {
+                return;
+            }
+            if (!this.isCompatible(player)) {
+                player.kickPlayer(String.format(Voicechat.TRANSLATIONS.forceVoicechatKickMessage.get(), "Simple Voice Chat", Voicechat.INSTANCE.getDescription().getVersion()));
+            }
+        }, (long)Voicechat.SERVER_CONFIG.loginTimeout.get().intValue() / 50L);
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent playerQuitEvent) {
+        this.server.getPlayerStateManager().onPlayerQuit(playerQuitEvent);
+        this.server.getGroupManager().onPlayerQuit(playerQuitEvent);
+        UUID uUID = playerQuitEvent.getPlayer().getUniqueId();
+        this.clientCompatibilities.remove(uUID);
+        this.rateLimiter.onPlayerLoggedOut(playerQuitEvent.getPlayer());
+        if (this.server == null) {
+            return;
+        }
+        this.server.disconnectClient(uUID);
+        Voicechat.LOGGER.info("Disconnecting client {}", playerQuitEvent.getPlayer().getName());
+    }
+
+    public void onPlayerHide(PlayerHideEvent playerHideEvent) {
+        this.server.getPlayerStateManager().onPlayerHide(playerHideEvent);
+    }
+
+    public void onPlayerShow(PlayerShowEvent playerShowEvent) {
+        this.server.getPlayerStateManager().onPlayerShow(playerShowEvent);
+    }
+
+    public PacketRateLimiter getRateLimiter() {
+        return this.rateLimiter;
+    }
+
+    public Server getServer() {
+        return this.server;
+    }
+}
+