ChannelFilter.java

package com.osroyale.net;
 
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
import com.osroyale.Config;
import com.osroyale.game.world.entity.mob.player.IPBannedPlayers;
import com.osroyale.net.codec.login.LoginResponse;
import com.osroyale.net.codec.login.LoginResponsePacket;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
 
import java.net.InetSocketAddress;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;

@Sharable
 
public class ChannelFilter extends ChannelInboundHandlerAdapter {

    private final Multiset<Connection> connections = ConcurrentHashMultiset.create();
 
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Connection connection = getConenction(ctx);
        connection.setCanConnect(true);
    }
 
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        Connection connection = getConenction(ctx);
 
        /* Make sure this channel is not going to get flooded. */
        if (!connection.canConnect()) {
            return;
        }
 
        /*
         * If this local then, do nothing and proceed to next handler in the
         * pipeline.
         */
        if (connection.getHost().equalsIgnoreCase("127.0.0.1")) {
            return;
        }
 
        /* Add the host */
        connection.addConnection();
 
        /* Evaluate the host */
        if (connection.getConnections() > Config.CONNECTION_LIMIT) {
            disconnect(ctx, LoginResponse.LOGIN_LIMIT_EXCEEDED);
            return;
        }
 
        if (IPBannedPlayers.ipBans.contains(connection.getHost())) {
            disconnect(ctx, LoginResponse.ACCOUNT_DISABLED);
            return;
        }
 
        connections.add(connection);
        connection.setCanConnect(false);
 
        /*
         * Nothing went wrong, so register the channel and forward the randomevent to
         * next handler in the pipeline.
         */
        ctx.fireChannelRegistered();
    }
 
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        Connection connection = getConenction(ctx);
 
        /*
         * If this is local, do nothing and proceed to next handler in the
         * pipeline.
         */
        if (connection.getHost().equalsIgnoreCase("127.0.0.1")) {
            return;
        }
 
        connection.removeConnection();
 
        /* Remove the host from the connection list */
        if (connection.getConnections() == 0) {
            connections.remove(connection);
        }
 
        /*
         * The connection is unregistered so forward the randomevent to the next
         * handler in the pipeline.
         */
        ctx.fireChannelUnregistered();
    }

    private void disconnect(ChannelHandlerContext ctx, LoginResponse response) {
        LoginResponsePacket message = new LoginResponsePacket(response);
        ByteBuf initialMessage = ctx.alloc().buffer(8).writeLong(0);
 
        ctx.write(initialMessage, ctx.voidPromise());
        ctx.writeAndFlush(message).addListener(ChannelFutureListener.CLOSE);
    }

    private Connection getConenction(ChannelHandlerContext ctx) {
        String host = ((InetSocketAddress) ctx.channel().remoteAddress()).getAddress().getHostAddress();
        return connections.stream().filter(conn -> conn.getHost().equalsIgnoreCase(host)).findFirst().orElse(new Connection(host));
    }

    private static class Connection {

        private final AtomicBoolean canConnect = new AtomicBoolean(true);

        private final String host;

        private int connections;

        public Connection(String host) {
            this.host = host;
        }

        public String getHost() {
            return host;
        }

        public int getConnections() {
            return connections;
        }

        public boolean canConnect() {
            return canConnect.get();
        }

        public void addConnection() {
            connections++;
        }

        public void removeConnection() {
            connections--;
        }
 
        public void setCanConnect(boolean val) {
            canConnect.compareAndSet(!val, val);
        }
 
        @Override
        public int hashCode() {
            return Objects.hash(host);
        }
 
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Connection) {
                Connection other = (Connection) obj;
                return host.equalsIgnoreCase(other.getHost());
            }
            return obj == this;
        }
 
        @Override
        public String toString() {
            return String.format("Connection[host=%s, connections=%s, elapsed=%s]", host, connections, canConnect);
        }
 
    }
 
}