/*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.instancemanager;
import gnu.trove.map.hash.TIntObjectHashMap;
import gnu.trove.procedure.TObjectProcedure;
import java.util.Map;
import javolution.util.FastMap;
import com.l2jserver.Config;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.network.L2GameClient;
public class AntiFeedManager
{
public static final int GAME_ID = 0;
public static final int OLYMPIAD_ID = 1;
public static final int TVT_ID = 2;
public static final int L2EVENT_ID = 3;
private final Map<Integer,Long> _lastDeathTimes;
private final TIntObjectHashMap<Map<Integer, Connections>> _eventIPs;
public static final AntiFeedManager getInstance()
{
return SingletonHolder._instance;
}
private AntiFeedManager()
{
_lastDeathTimes = new FastMap<Integer,Long>().shared();
_eventIPs = new TIntObjectHashMap<Map<Integer, Connections>>();
}
/**
* Set time of the last player's death to current
* @param objectId Player's objectId
*/
public final void setLastDeathTime(int objectId)
{
_lastDeathTimes.put(objectId, System.currentTimeMillis());
}
/**
* Check if current kill should be counted as non-feeded.
* @param attacker Attacker character
* @param target Target character
* @return True if kill is non-feeded.
*/
public final boolean check(L2Character attacker, L2Character target)
{
if (!Config.L2JMOD_ANTIFEED_ENABLE)
return true;
if (target == null)
return false;
final L2PcInstance targetPlayer = target.getActingPlayer();
if (targetPlayer == null)
return false;
if (Config.L2JMOD_ANTIFEED_INTERVAL > 0
&& _lastDeathTimes.containsKey(targetPlayer.getObjectId()))
return (System.currentTimeMillis() - _lastDeathTimes.get(targetPlayer.getObjectId())) > Config.L2JMOD_ANTIFEED_INTERVAL;
if (Config.L2JMOD_ANTIFEED_DUALBOX && attacker != null)
{
final L2PcInstance attackerPlayer = attacker.getActingPlayer();
if (attackerPlayer == null)
return false;
final L2GameClient targetClient = targetPlayer.getClient();
final L2GameClient attackerClient = attackerPlayer.getClient();
if (targetClient == null
|| attackerClient == null
|| targetClient.isDetached()
|| attackerClient.isDetached())
// unable to check ip address
return !Config.L2JMOD_ANTIFEED_DISCONNECTED_AS_DUALBOX;
return !targetClient.getConnectionAddress().equals(attackerClient.getConnectionAddress());
}
return true;
}
/**
* Clears all timestamps
*/
public final void clear()
{
_lastDeathTimes.clear();
}
/**
* Register new event for dualbox check.
* Should be called only once.
* @param eventId
*/
public final void registerEvent(int eventId)
{
if (!_eventIPs.containsKey(eventId))
_eventIPs.put(eventId, new FastMap<Integer, Connections>());
}
/**
*
* @param eventId
* @param player
* @param max
* @return If number of all simultaneous connections from player's IP address lower than max
* then increment connection count and return true.<br>
* False if number of all simultaneous connections from player's IP address higher than max.
*/
public final boolean tryAddPlayer(int eventId, L2PcInstance player, int max)
{
return tryAddClient(eventId, player.getClient(), max);
}
/**
*
* @param eventId
* @param client
* @param max
* @return If number of all simultaneous connections from player's IP address lower than max then increment connection count and return true.<br>
* False if number of all simultaneous connections from player's IP address higher than max.
*/
public final boolean tryAddClient(int eventId, L2GameClient client, int max)
{
if (client == null)
return false; // unable to determine IP address
final Map<Integer, Connections> event = _eventIPs.get(eventId);
if (event == null)
return false; // no such event registered
final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
int limit = Config.L2JMOD_DUALBOX_CHECK_WHITELIST.get(addrHash);
limit = limit < 0 ? Integer.MAX_VALUE : limit + max;
Connections conns;
synchronized (event)
{
conns = event.get(addrHash);
if (conns == null)
{
conns = new Connections();
event.put(addrHash, conns);
}
}
return conns.testAndIncrement(limit);
}
/**
* Decreasing number of active connection from player's IP address
* @param eventId
* @param player
* @return true if success and false if any problem detected.
*/
public final boolean removePlayer(int eventId, L2PcInstance player)
{
final L2GameClient client = player.getClient();
if (client == null)
return false; // unable to determine IP address
final Map<Integer, Connections> event = _eventIPs.get(eventId);
if (event == null)
return false; // no such event registered
final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
Connections conns = event.get(addrHash);
if (conns == null)
return false; // address not registered
synchronized (event)
{
if (conns.testAndDecrement())
event.remove(addrHash);
}
return true;
}
/**
* Remove player connection IP address from all registered events lists.
* @param client
*/
public final void onDisconnect(L2GameClient client)
{
if (client == null)
return;
final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
_eventIPs.forEachValue(new DisconnectProcedure(addrHash));
}
/**
* Clear all entries for this eventId.
* @param eventId
*/
public final void clear(int eventId)
{
final Map<Integer, Connections> event = _eventIPs.get(eventId);
if (event != null)
event.clear();
}
/**
* @param player
* @param max
* @return maximum number of allowed connections (whitelist + max)
*/
public final int getLimit(L2PcInstance player, int max)
{
return getLimit(player.getClient(), max);
}
/**
* @param client
* @param max
* @return maximum number of allowed connections (whitelist + max)
*/
public final int getLimit(L2GameClient client, int max)
{
if (client == null)
return max;
final Integer addrHash = Integer.valueOf(client.getConnectionAddress().hashCode());
final int limit = Config.L2JMOD_DUALBOX_CHECK_WHITELIST.get(addrHash);
return limit < 0 ? 0 : limit + max;
}
private static final class Connections
{
private int _num = 0;
/**
* and false if maximum number is reached.
* @param max
* @return true if successfully incremented number of connections
*/
public final synchronized boolean testAndIncrement(int max)
{
if (_num < max)
{
_num++;
return true;
}
return false;
}
/**
* @return true if all connections are removed
*/
public final synchronized boolean testAndDecrement()
{
if (_num > 0)
_num--;
return _num == 0;
}
}
private static final class DisconnectProcedure implements TObjectProcedure<Map<Integer, Connections>>
{
private final Integer _addrHash;
public DisconnectProcedure(Integer addrHash)
{
_addrHash = addrHash;
}
@Override
public final boolean execute(Map<Integer, Connections> event)
{
final Connections conns = event.get(_addrHash);
if (conns != null)
{
synchronized (event)
{
if (conns.testAndDecrement())
event.remove(_addrHash);
}
}
return true;
}
}
@SuppressWarnings("synthetic-access")
private static class SingletonHolder
{
protected static final AntiFeedManager _instance = new AntiFeedManager();
}
}