package atavism.server.plugins;
import atavism.msgsys.ResponseMessage;
import atavism.msgsys.GenericMessage;
import java.util.LinkedHashMap;
import atavism.server.objects.Road;
import atavism.server.objects.FogRegionConfig;
import atavism.server.math.Quaternion;
import atavism.server.util.SecureTokenSpec;
import atavism.server.util.AnimationCommand;
import atavism.server.events.NotifyPlayAnimationEvent;
import atavism.server.events.DetachEvent;
import atavism.server.objects.Color;
import atavism.server.events.AmbientLightEvent;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import atavism.server.util.ObjectLockManager;
import atavism.server.objects.OceanData;
import atavism.server.objects.Template;
import atavism.server.engine.Database;
import atavism.server.events.NotifyFreeObjectEvent;
import atavism.server.events.FreeTerrainDecalEvent;
import atavism.server.objects.SoundData;
import atavism.server.objects.ObjectType;
import atavism.server.events.NewTerrainDecalEvent;
import atavism.server.objects.TerrainDecalData;
import atavism.server.events.NewLightEvent;
import atavism.server.objects.Light;
import atavism.server.objects.LightData;
import atavism.server.objects.ObjectTypes;
import atavism.server.messages.PerceptionMessage;
import atavism.server.events.ExtensionMessageEvent;
import atavism.server.events.SceneLoadedEvent;
import atavism.server.events.LogoutEvent;
import atavism.agis.events.AbilityStatusMessage;
import atavism.agis.events.AbilityStatusEvent;
import atavism.server.events.ActivateItemEvent;
import atavism.server.events.AutoAttackEvent;
import atavism.server.events.CommandEvent;
import atavism.server.events.ComEvent;
import atavism.server.events.DirLocOrientEvent;
import atavism.msgsys.RPCTimeoutException;
import atavism.server.messages.LogoutMessage;
import atavism.agis.events.ConcludeQuest;
import atavism.agis.events.QuestResponse;
import atavism.agis.plugins.QuestClient;
import atavism.agis.events.RequestQuestInfo;
import atavism.server.events.LoadingStateEvent;
import atavism.server.events.AttachEvent;
import atavism.server.objects.DisplayContext;
import atavism.server.events.ModelInfoEvent;
import atavism.server.events.WorldFileEvent;
import atavism.msgsys.ResponseCallback;
import atavism.server.messages.LoginMessage;
import atavism.server.objects.World;
import atavism.server.math.AOVector;
import atavism.server.objects.InstanceRestorePoint;
import atavism.server.engine.BasicWorldNode;
import atavism.agis.database.AccountDatabase;
import atavism.server.math.Point;
import atavism.server.engine.Namespace;
import atavism.server.util.SecureToken;
import atavism.msgsys.SubjectMessage;
import atavism.msgsys.FilterUpdate;
import atavism.msgsys.NoRecipientsException;
import atavism.msgsys.TargetMessage;
import atavism.server.util.SecureTokenManager;
import atavism.server.events.AuthorizedLoginResponseEvent;
import java.util.Collections;
import java.util.Iterator;
import atavism.server.events.AuthorizedLoginEvent;
import atavism.server.util.DebugUtils;
import atavism.server.network.AOByteBuffer;
import java.net.URLConnection;
import java.util.concurrent.TimeUnit;
import atavism.server.util.EncryptionHelper;
import atavism.agis.util.HelperFunctions;
import atavism.server.util.Base64;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.i
utputStreamWriter;
import java.net.URLEncoder;
import java.net.URL;
import java.util.Random;
import java.net.UnknownHostException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import atavism.server.network.rdp.RDPServer;
import atavism.management.Management;
import atavism.msgsys.MessageTrigger;
import atavism.server.messages.PerceptionTrigger;
import java.util.Collection;
import atavism.agis.plugins.AnimationClient;
import atavism.agis.plugins.CombatClient;
import atavism.server.messages.PropertyMessage;
import atavism.msgsys.IFilter;
import atavism.msgsys.MessageTypeFilter;
import atavism.server.network.PacketAggregator;
import java.util.ArrayList;
import atavism.server.engine.Hook;
import java.util.LinkedList;
import java.io.Serializable;
import atavism.agis.plugins.SocialClient;
import atavism.server.util.Log;
import atavism.agis.database.ContentDatabase;
import atavism.server.util.ServerVersion;
import java.io.IOException;
import atavism.server.util.AORuntimeException;
import atavism.server.engine.Engine;
import java.util.HashSet;
import atavism.server.util.SQCallback;
import atavism.server.util.LockFactory;
import atavism.server.objects.ProxyExtensionHook;
import java.util.Set;
import atavism.server.network.ClientTCPMessageIO;
import atavism.server.objects.InstanceEntryCallback;
import atavism.server.objects.ProxyLoginCallback;
import java.util.List;
import atavism.server.util.TimeHistogram;
import atavism.server.engine.OID;
import java.util.concurrent.ConcurrentHashMap;
import atavism.server.objects.PlayerManager;
import atavism.server.util.Logger;
import atavism.server.network.rdp.RDPServerSocket;
import atavism.server.messages.PerceptionFilter;
import atavism.msgsys.MessageType;
import java.util.HashMap;
import atavism.server.util.AOMeter;
import atavism.server.engine.Event;
import atavism.server.util.SQThreadPool;
import atavism.msgsys.Message;
import atavism.server.util.SquareQueue;
import atavism.server.objects.Player;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import atavism.server.util.CountLogger;
import atavism.server.network.ClientConnection;
import atavism.msgsys.MessageCallback;
import atavism.server.engine.EnginePlugin;
public class ProxyPlugin extends EnginePlugin implements atavism.msgsys.MessageCallback, ClientConnection.AcceptCallback, ClientConnection.MessageCallback
{
public static final int PERCEPTION_GAIN_THRESHOLD = 20;
Thread periodicGC;
CountLogger countLogger;
CountLogger.Counter countMsgPerception;
CountLogger.Counter countMsgPerceptionGain;
CountLogger.Counter countMsgPerceptionLost;
CountLogger.Counter countMsgUpdateWNodeIn;
CountLogger.Counter countMsgUpdateWNodeOut;
CountLogger.Counter countMsgPropertyIn;
CountLogger.Counter countMsgPropertyOut;
CountLogger.Counter countMsgTargetedProperty;
CountLogger.Counter countMsgWNodeCorrectIn;
CountLogger.Counter countMsgWNodeCorrectOut;
CountLogger.Counter countMsgMobPathIn;
CountLogger.Counter countMsgMobPathOut;
protected Lock commandMapLock;
Map<String, RegisteredCommand> commandMap;
CommandAccessCheck defaultCommandAccess;
private static final Player loginSerializer;
SquareQueue<Player, Message> messageQQ;
SQThreadPool messageThreadPool;
SquareQueue<Player, Event> eventQQ;
SQThreadPool eventThreadPool;
AOMeter clientMsgMeter;
public boolean defaultAllowClientToClientMessage;
protected HashMap<String, MessageType> extensionMessageRegistry;
protected PerceptionFilter perceptionFilter;
protected long perceptionSubId;
protected PerceptionFilter responderFilter;
protected long responderSubId;
protected RDPServerSocket serverSocket;
protected int clientPort;
protected static final Logger log;
PlayerMessageCallback playerMessageCallback;
protected PlayerManager playerManager;
protected ConcurrentHashMap<OID, String> playersOnlineList;
protected ConcurrentHashMap<OID, String> playersOnlineOnProxy;
protected TimeHistogram proxyQueueHistogram;
protected TimeHistogram proxyCallbackHistogram;
protected List<MessageType> extraPlayerMessageTypes;
private ProxyLoginCallback proxyLoginCallback;
private InstanceEntryCallback instanceEntryCallback;
private int instanceEntryCount;
private int chatSentCount;
private int privateChatSentCount;
public static final MessageType MSG_TYPE_VOICE_PARMS;
public static final MessageType MSG_TYPE_PLAYER_PATH_REQ;
public static final MessageType MSG_TYPE_UPDATE_PLAYER_IGNORE_LIST;
public static final MessageType MSG_TYPE_GET_MATCHING_PLAYERS;
public static final MessageType MSG_TYPE_PLAYER_IGNORE_LIST;
public static final MessageType MSG_TYPE_PLAYER_IGNORE_LIST_REQ;
public static final MessageType MSG_TYPE_RELAY_UPDATE_PLAYER_IGNORE_LIST;
public static final MessageType MSG_TYPE_GET_PLAYER_LOGIN_STATUS;
public static final MessageType MSG_TYPE_LOGOUT_PLAYER;
public static final MessageType MSG_TYPE_ADD_STATIC_PERCEPTION;
public static final MessageType MSG_TYPE_REMOVE_STATIC_PERCEPTION;
public static final MessageType MSG_TYPE_LOGIN_SPAWNED;
public static final MessageType MSG_TYPE_ACCOUNT_LOGIN;
protected static String voiceServerHost;
protected static Integer voiceServerPort;
public String serverCapabilitiesSentToClient;
public static int DiffTimeToSkipDirLocOrientMessage;
static int serverSocketReceiveBufferSize;
public static int MaxConcurrentUsers;
public static int idleTimeout;
public static int silenceTimeout;
public static int silenceLoadingTimeout;
public static int maxMessagesBeforeConnectionReset;
public static int maxByteCountBeforeConnectionReset;
public String capacityError;
public String tokenError;
private ClientTCPMessageIO clientTCPMessageIO;
Set<OID> adminSet;
HashMap<OID, ClientConnection> clientConnections;
Set<String> filteredProps;
Set<String> playerSpecificProps;
Set<String> cachedPlayerSpecificFilterProps;
String serverVersion;
protected Map<String, List<ProxyExtensionHook>> extensionHooks;
private int connectionLimit;
boolean devMode;
public ProxyPlugin() {
this.countLogger = new CountLogger("ProxyMsg", 5000, 2);
this.commandMapLock = LockFactory.makeLock("CommandMapLock");
this.commandMap = new HashMap<String, RegisteredCommand>();
this.defaultCommandAccess = new DefaultCommandAccess();
this.messageQQ = new SquareQueue<Player, Message>("Message");
this.messageThreadPool = new SQThreadPool(this.messageQQ, new MessageCallback(this));
this.eventQQ = new SquareQueue<Player, Event>("Event");
this.eventThreadPool = new SQThreadPool(this.eventQQ, new EventCallback());
this.clientMsgMeter = new AOMeter("ClientEventProcessorMeter");
this.defaultAllowClientToClientMessage = false;
this.extensionMessageRegistry = new HashMap<String, MessageType>();
this.serverSocket = null;
this.playerMessageCallback = new PlayerMessageCallback();
this.playerManager = new PlayerManager();
this.playersOnlineList = new ConcurrentHashMap<OID, String>();
this.playersOnlineOnProxy = new ConcurrentHashMap<OID, String>();
this.proxyQueueHistogram = null;
this.proxyCallbackHistogram = null;
this.extraPlayerMessageTypes = null;
this.proxyLoginCallback = new DefaultProxyLoginCallback();
this.instanceEntryCallback = new DefaultInstanceEntryCallback();
this.instanceEntryCount = 0;
this.chatSentCount = 0;
this.privateChatSentCount = 0;
this.serverCapabilitiesSentToClient = "DirLocOrient";
this.capacityError = "Login Failed: Servers at capacity, please try again later.";
this.tokenError = "Login Failed: Secure token invalid.";
this.clientTCPMessageIO = null;
this.adminSet = new HashSet<OID>();
this.clientConnections = new HashMap<OID, ClientConnection>();
this.filteredProps = null;
this.playerSpecificProps = null;
this.cachedPlayerSpecificFilterProps = null;
this.serverVersion = null;
this.extensionHooks = new HashMap<String, List<ProxyExtensionHook>>();
this.connectionLimit = 0;
this.devMode = true;
this.setPluginType("Proxy");
String proxyPluginName;
try {
proxyPluginName = Engine.getAgent().getDomainClient().allocName("PLUGIN", this.getPluginType() + "#");
}
catch (IOException e) {
throw new AORuntimeException("Could not allocate proxy plugin name", e);
}
this.setName(proxyPluginName);
this.serverVersion = "2019.1.2 " + ServerVersion.getBuildNumber();
this.setMessageHandler(null);
this.countMsgPerception = this.countLogger.addCounter("ao.PERCEPTION_INFO");
this.countMsgPerceptionGain = this.countLogger.addCounter("Perception.gain");
this.countMsgPerceptionLost = this.countLogger.addCounter("Perception.lost");
this.countMsgUpdateWNodeIn = this.countLogger.addCounter("ao.UPDATEWNODE.in");
this.countMsgUpdateWNodeOut = this.countLogger.addCounter("ao.UPDATEWNODE.out");
this.countMsgPropertyIn = this.countLogger.addCounter("ao.PROPERTY.in");
this.countMsgPropertyOut = this.countLogger.addCounter("ao.PROPERTY.out");
this.countMsgTargetedProperty = this.countLogger.addCounter("ao.TARGETED_PROPERTY");
this.countMsgWNodeCorrectIn = this.countLogger.addCounter("ao.WNODECORRECT.in");
this.countMsgWNodeCorrectOut = this.countLogger.addCounter("ao.WNODECORRECT.out");
this.countMsgMobPathIn = this.countLogger.addCounter("ao.MOB_PATH.in");
this.countMsgMobPathOut = this.countLogger.addCounter("ao.MOB_PATH.out");
final ContentDatabase ctDB = new ContentDatabase(false);
final String _silenceTimeout = ctDB.loadGameSetting("PLAYER_SILENCE_TIMEOUT");
if (_silenceTimeout != null) {
ProxyPlugin.silenceTimeout = Integer.parseInt(_silenceTimeout);
}
this.addProxyExtensionHook("ao.heartbeat", new PlayerHeartbeat());
new Thread(new PlayerTimeout(), "PlayerTimeout").start();
}
public static boolean isOnBlockList(final OID subject, final OID target) {
Log.error("SocialClient.isOnBlockList: subject:" + subject + " target:" + target);
final WorldManagerClient.ExtensionMessage message = new WorldManagerClient.ExtensionMessage(SocialClient.MSG_TYPE_IS_ON_BLOCK_LIST, "ao.IS_ON_BLOCK_LIST", subject);
message.setProperty("targetOid", target);
return Engine.getAgent().sendRPCReturnBoolean(message);
}
public boolean isDevMode() {
return this.devMode;
}
public void setDevMode(final boolean mode) {
this.devMode = mode;
}
public List<MessageType> getExtraPlayerMessageTypes() {
return this.extraPlayerMessageTypes;
}
public void setExtraPlayerMessageTypes(final List<MessageType> extraPlayerMessageTypes) {
this.extraPlayerMessageTypes = extraPlayerMessageTypes;
}
public void addExtraPlayerMessageType(final MessageType messageType) {
if (this.extraPlayerMessageTypes == null) {
this.extraPlayerMessageTypes = new LinkedList<MessageType>();
}
this.extraPlayerMessageTypes.add(messageType);
}
public void addExtraPlayerExtensionMessageType(final MessageType messageType) {
this.addExtraPlayerMessageType(messageType);
this.getHookManager().addHook(messageType, new ExtensionHook());
}
public void addProxyExtensionHook(final String subType, final ProxyExtensionHook hook) {
synchronized (this.extensionHooks) {
List<ProxyExtensionHook> hookList = this.extensionHooks.get(subType);
if (hookList == null) {
hookList = new ArrayList<ProxyExtensionHook>();
this.extensionHooks.put(subType, hookList);
}
hookList.add(hook);
}
}
public Map<String, List<ProxyExtensionHook>> getProxyExtensionHooks(final String subType) {
return this.extensionHooks;
}
public void onActivate() {
try {
PacketAggregator.initializeAggregation(Engine.getProperties());
final String logProxyHistograms = Engine.properties.getProperty("atavism.log_proxy_histograms");
if (logProxyHistograms != null && logProxyHistograms.equals("true")) {
int interval = 5000;
final String intervalString = Engine.properties.getProperty("atavism.log_proxy_histograms_interval");
if (intervalString != null) {
final int newInterval = Integer.parseInt(intervalString);
if (newInterval > 0) {
interval = newInterval;
}
}
this.proxyQueueHistogram = new TimeHistogram("TimeInQ", interval);
this.proxyCallbackHistogram = new TimeHistogram("TimeInCallback", interval);
this.countLogger.start();
}
this.filteredProps = new HashSet<String>();
this.playerSpecificProps = new HashSet<String>();
this.cachedPlayerSpecificFilterProps = new HashSet<String>();
this.addFilteredProperty("inv.bag");
this.addFilteredProperty(":loc");
this.addFilteredProperty("masterOid");
this.addFilteredProperty("agisobj.basedc");
this.addFilteredProperty("aoobj.dc");
this.addFilteredProperty("aoobj.followsterrainflag");
this.addFilteredProperty("aoobj.perceiver");
this.addFilteredProperty("aoobj.scale");
this.addFilteredProperty("aoobj.mobflag");
this.addFilteredProperty("aoobj.structflag");
this.addFilteredProperty("aoobj.userflag");
this.addFilteredProperty("aoobj.itemflag");
this.addFilteredProperty("aoobj.lightflag");
this.addFilteredProperty("namespace");
this.addFilteredProperty("regenEffectMap");
this.addFilteredProperty(WorldManagerClient.MOB_PATH_PROPERTY);
this.addFilteredProperty(WorldManagerClient.TEMPL_SOUND_DATA_LIST);
this.addFilteredProperty(WorldManagerClient.TEMPL_TERRAIN_DECAL_DATA);
this.addFilteredProperty("instanceStack");
this.addFilteredProperty("currentInstanceName");
this.addFilteredProperty("ignored_oids");
this.registerHooks();
final PluginMessageCallback pluginMessageCallback = new PluginMessageCallback();
final MessageTypeFilter filter = new MessageTypeFilter();
filter.addType(WorldManagerClient.MSG_TYPE_SYS_CHAT);
Engine.getAgent().createSubscription(filter, pluginMessageCallback);
this.perceptionFilter = new PerceptionFilter();
final LinkedList<MessageType> types = new LinkedList<MessageType>();
types.add(WorldManagerClient.MSG_TYPE_PERCEPTION_INFO);
types.add(WorldManagerClient.MSG_TYPE_ANIMATION);
types.add(WorldManagerClient.MSG_TYPE_DISPLAY_CONTEXT);
types.add(WorldManagerClient.MSG_TYPE_DETACH);
types.add(PropertyMessage.MSG_TYPE_PROPERTY);
types.add(WorldManagerClient.MSG_TYPE_COM);
types.add(SocialClient.MSG_TYPE_BLOCK_LIST);
types.add(CombatClient.MSG_TYPE_DAMAGE);
types.add(WorldManagerClient.MSG_TYPE_UPDATEWNODE);
types.add(WorldManagerClient.MSG_TYPE_MOB_PATH);
types.add(WorldManagerClient.MSG_TYPE_WNODECORRECT);
types.add(WorldManagerClient.MSG_TYPE_ORIENT);
types.add(WorldManagerClient.MSG_TYPE_SOUND);
types.add(AnimationClient.MSG_TYPE_INVOKE_EFFECT);
types.add(WorldManagerClient.MSG_TYPE_EXTENSION);
types.add(WorldManagerClient.MSG_TYPE_P2P_EXTENSION);
types.add(InventoryClient.MSG_TYPE_INV_UPDATE);
types.add(CombatClient.MSG_TYPE_ABILITY_STATUS);
types.add(CombatClient.MSG_TYPE_ABILITY_UPDATE);
types.add(WorldManagerClient.MSG_TYPE_FOG);
types.add(WorldManagerClient.MSG_TYPE_ROAD);
types.add(WorldManagerClient.MSG_TYPE_NEW_DIRLIGHT);
types.add(WorldManagerClient.MSG_TYPE_SET_AMBIENT);
types.add(WorldManagerClient.MSG_TYPE_TARGETED_PROPERTY);
types.add(WorldManagerClient.MSG_TYPE_FREE_OBJECT);
types.add(ProxyPlugin.MSG_TYPE_VOICE_PARMS);
types.add(ProxyPlugin.MSG_TYPE_UPDATE_PLAYER_IGNORE_LIST);
types.add(ProxyPlugin.MSG_TYPE_GET_MATCHING_PLAYERS);
types.add(ProxyPlugin.MSG_TYPE_ADD_STATIC_PERCEPTION);
types.add(ProxyPlugin.MSG_TYPE_REMOVE_STATIC_PERCEPTION);
if (this.extraPlayerMessageTypes != null) {
types.addAll(this.extraPlayerMessageTypes);
}
this.perceptionFilter.setTypes(types);
this.perceptionFilter.setMatchAllSubjects(true);
final PerceptionTrigger perceptionTrigger = new PerceptionTrigger();
this.perceptionSubId = Engine.getAgent().createSubscription(this.perceptionFilter, this.playerMessageCallback, 0, perceptionTrigger);
this.responderFilter = new PerceptionFilter();
types.clear();
types.add(InstanceClient.MSG_TYPE_INSTANCE_ENTRY_REQ);
types.add(ProxyPlugin.MSG_TYPE_PLAYER_IGNORE_LIST_REQ);
types.add(ProxyPlugin.MSG_TYPE_GET_PLAYER_LOGIN_STATUS);
types.add(ProxyPlugin.MSG_TYPE_LOGOUT_PLAYER);
this.responderFilter.setTypes(types);
this.responderSubId = Engine.getAgent().createSubscription(this.responderFilter, this.playerMessageCallback, 8);
types.clear();
types.add(Management.MSG_TYPE_GET_PLUGIN_STATUS);
Engine.getAgent().createSubscription(new MessageTypeFilter(types), pluginMessageCallback, 8);
final MessageTypeFilter filter2 = new MessageTypeFilter();
filter2.addType(ProxyPlugin.MSG_TYPE_ACCOUNT_LOGIN);
Engine.getAgent().createSubscription(filter2, this);
this.serverSocket = new RDPServerSocket();
final String log_rdp_counters = Engine.getProperty("atavism.log_rdp_counters");
if (log_rdp_counters == null || log_rdp_counters.equals("false")) {
RDPServer.setCounterLogging(false);
}
RDPServer.startRDPServer();
this.serverSocket.registerAcceptCallback(this);
this.initializeVoiceServerInformation();
this.registerExtensionSubtype("voice_parms", ProxyPlugin.MSG_TYPE_VOICE_PARMS);
this.registerExtensionSubtype("player_path_req", ProxyPlugin.MSG_TYPE_PLAYER_PATH_REQ);
this.registerExtensionSubtype("player_path_req", ProxyPlugin.MSG_TYPE_PLAYER_PATH_REQ);
this.registerExtensionSubtype("ao.UPDATE_PLAYER_IGNORE_LIST", ProxyPlugin.MSG_TYPE_UPDATE_PLAYER_IGNORE_LIST);
this.registerExtensionSubtype("ao.GET_MATCHING_PLAYERS", ProxyPlugin.MSG_TYPE_GET_MATCHING_PLAYERS);
this.registerExtensionSubtype("ao.PLAYER_IGNORE_LIST_REQ", ProxyPlugin.MSG_TYPE_PLAYER_IGNORE_LIST_REQ);
Log.debug("ProxyPlugin before bindAddress");
final InetSocketAddress bindAddress = this.getBindAddress();
Log.debug("ProxyPlugin after bindAddress " + bindAddress.getHostName() + " " + bindAddress.getAddress() + " " + bindAddress.getPort());
if (Log.loggingDebug) {
Log.debug("BIND: binding for client tcp and rdp packets on port " + bindAddress.getPort() + " with rdpsocket: " + this.serverSocket.toString());
}
Log.debug("ProxyPlugin before server socket");
this.serverSocket.bind(Integer.parseInt(Engine.getProperty("atavism.proxy.bindport")), ProxyPlugin.serverSocketReceiveBufferSize);
Log.debug("BIND: bound server socket");
this.clientTCPMessageIO = ClientTCPMessageIO.setup(bindAddress, this, this);
Log.debug("BIND: setup clientTCPMessage");
this.clientTCPMessageIO.start("ClientIO");
Log.debug("BIND: started clientTCPMessage");
final InetSocketAddress externalAddress = this.getExternalAddress(bindAddress);
Log.debug("BIND: got external Address " + externalAddress.getHostName() + " " + externalAddress.getAddress() + " " + externalAddress.getPort());
this.setPluginInfo("host=" + Engine.getProperty("atavism.proxy.externaladdress") + ",port=" + externalAddress.getPort());
Log.debug("Registering proxy plugin");
Engine.registerStatusReportingPlugin(this);
Log.debug("Proxy: activation done");
this.runCheck();
}
catch (Exception e) {
throw new AORuntimeException("activate failed", e);
}
}
private InetSocketAddress getBindAddress() throws IOException {
String propStr = Engine.getProperty("atavism.proxy.bindport");
Log.debug("Proxy: getBindAddress propStr=" + propStr);
int port;
if (propStr != null) {
port = Integer.parseInt(propStr.trim());
Log.debug("Proxy: getBindAddress port=" + port);
}
else {
port = Integer.parseInt(Engine.getProperty("atavism.proxyport").trim());
}
Log.debug("Proxy: getBindAddress port=" + port);
propStr = Engine.getProperty("atavism.proxy.bindaddress");
Log.debug("Proxy: getBindAddress propStr=" + propStr + " " + Character.digit(propStr.charAt(0), 16) + " " + Character.digit(propStr.charAt(1), 16) + " " + Character.digit(propStr.charAt(2), 16) + " c=");
int count = 0;
if (propStr.contains(".")) {
for (int i = 0; i < propStr.length(); ++i) {
if (propStr.charAt(i) == '.') {
++count;
}
}
}
InetAddress address = null;
InetAddress[] address2 = null;
if (count != 3 || Character.digit(propStr.charAt(0), 10) != -1) {}
if (propStr != null) {
try {
address = InetAddress.getByName(propStr.trim());
final InetAddress[] allByName;
address2 = (allByName = InetAddress.getAllByName(propStr.trim()));
for (final InetAddress ai : allByName) {
Log.debug("Proxy: getBindAddress address2=" + ai + " " + ai.getHostName() + " " + ai.getHostAddress());
}
Log.debug("Proxy: getBindAddress address=" + address + " " + address.getHostName() + " " + address.getHostAddress());
}
catch (UnknownHostException e) {
ProxyPlugin.log.error("getBindAddress " + e.getMessage() + " " + e.getLocalizedMessage());
}
}
Log.debug("Proxy: getBindAddress address=" + address + " " + address.getHostName() + " " + address.getAddress());
return new InetSocketAddress(address, port);
}
private InetSocketAddress getExternalAddress(final InetSocketAddress bindAddress) throws IOException {
String propStr = Engine.getProperty("atavism.proxy.externalport");
Log.debug("Proxy: getExternalAddress propStr=" + propStr);
int port;
if (propStr != null) {
port = Integer.parseInt(propStr.trim());
}
else {
port = bindAddress.getPort();
}
Log.debug("Proxy: getExternalAddress port=" + port);
propStr = Engine.getProperty("atavism.proxy.externaladdress");
Log.debug("Proxy: getExternalAddress propStr=" + propStr);
InetAddress address;
if (propStr != null) {
address = InetAddress.getByName(propStr.trim());
}
else {
address = bindAddress.getAddress();
Log.debug("Proxy: getExternalAddress else address=" + address);
if (address.isAnyLocalAddress()) {
address = InetAddress.getLocalHost();
Log.debug("Proxy: getExternalAddress get local host address=" + address + " " + address.getHostName() + " " + address.getHostAddress());
}
}
Log.debug("Proxy: getExternalAddress address=" + address + " " + address.getHostName() + " " + address.getAddress());
return new InetSocketAddress(address, port);
}
private String howla() {
final String characters = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijklmnoprstquwxyz123456789";
String k = "";
for (int i = 0; i < 14; ++i) {
final Random random = new Random();
k += characters.charAt(random.nextInt(characters.length() - 1));
}
return k;
}
private void runCheck() {
final String email = Engine.getProperty("atavism.licence.email");
final String licencekey = Engine.getProperty("atavism.licence.key");
int num = 0;
final String[] url = { "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
" };
while (num < url.length) {
boolean failed = false;
try {
String res = "";
final URL urlObj = new URL(url[num]);
final URLConnection lu = urlObj.openConnection();
final String resSor = this.howla();
final String data = "email=" + URLEncoder.encode(email, "UTF-8") + "&licence=" + URLEncoder.encode(licencekey, "UTF-8") + "&ver=" + URLEncoder.encode("2019.1.2", "UTF-8") + "&addr=" + URLEncoder.encode(Engine.getProperty("atavism.proxy.bindaddress"), "UTF-8") + "&sor=" + URLEncoder.encode(resSor, "UTF-8") + "&c=" + URLEncoder.encode("0", "UTF-8") + "&cp=" + this.playerManager.getPlayerCount();
lu.setDoOutput(true);
final OutputStreamWriter wr = new OutputStreamWriter(lu.getOutputStream());
wr.write(data);
wr.flush();
final BufferedReader rd = new BufferedReader(new InputStreamReader(lu.getInputStream()));
String line = "";
while ((line = rd.readLine()) != null) {
res += line;
}
wr.flush();
wr.close();
res = HelperFunctions.readEncodedString(Base64.decode(res));
final String[] output = res.split(":");
if (EncryptionHelper.passwordMD5Check(output[0], this.getTemp()) && resSor.equals(HelperFunctions.readEncodedString(Base64.decode(output[2])))) {
this.connectionLimit = Integer.parseInt(HelperFunctions.readEncodedString(Base64.decode(output[1])));
final recheck reCheck = new recheck(resSor);
Engine.getExecutor().scheduleAtFixedRate(reCheck, 300L, 300L, TimeUnit.SECONDS);
}
else {
System.out.println("\nLicense verification failed");
Log.error("License verification failed");
}
Log.debug("CONNECTOR: connections set to: " + this.connectionLimit);
}
catch (Exception e) {
Log.error("CONNECTOR: failed verifying with : " + e);
++num;
failed = true;
}
if (!failed) {
return;
}
}
System.out.println("\nLicense verification failed");
Log.error("License verification failed");
this.connectionLimit = 0;
}
public Map<String, String> getStatusMap() {
final Map<String, String> status = new HashMap<String, String>();
status.put("players", Integer.toString(this.playerManager.getPlayerCount()));
return status;
}
public void registerCommand(final String command, final CommandParser parser) {
this.commandMapLock.lock();
try {
this.commandMap.put(command, new RegisteredCommand(parser, this.defaultCommandAccess));
}
finally {
this.commandMapLock.unlock();
}
}
public void registerCommand(final String command, final CommandParser parser, final CommandAccessCheck access) {
this.commandMapLock.lock();
try {
this.commandMap.put(command, new RegisteredCommand(parser, access));
}
finally {
this.commandMapLock.unlock();
}
}
void registerHooks() {
ProxyPlugin.log.debug("registering hooks");
this.getHookManager().addHook(SocialClient.MSG_TYPE_BLOCK_LIST, new BlockListHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_DISPLAY_CONTEXT, new DisplayContextHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_DETACH, new DetachHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_ANIMATION, new AnimationHook());
this.getHookManager().addHook(AnimationClient.MSG_TYPE_INVOKE_EFFECT, new InvokeEffectHook());
this.getHookManager().addHook(PropertyMessage.MSG_TYPE_PROPERTY, new PropertyHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_EXTENSION, new ExtensionHook());
this.getHookManager().addHook(CombatClient.MSG_TYPE_ABILITY_STATUS, new AbilityStatusHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_TARGETED_PROPERTY, new TargetedPropertyHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_PERCEPTION_INFO, new PerceptionHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_COM, new ComHook());
this.getHookManager().addHook(CombatClient.MSG_TYPE_DAMAGE, new DamageHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_SYS_CHAT, new SysChatHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_UPDATEWNODE, new UpdateWNodeHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_MOB_PATH, new UpdateMobPathHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_WNODECORRECT, new WNodeCorrectHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_ORIENT, new OrientHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_SOUND, new SoundHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_FOG, new FogHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_ROAD, new RoadHook());
this.getHookManager().addHook(InventoryClient.MSG_TYPE_INV_UPDATE, new InvUpdateHook());
this.getHookManager().addHook(CombatClient.MSG_TYPE_ABILITY_UPDATE, new AbilityUpdateHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_NEW_DIRLIGHT, new NewDirLightHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_FREE_OBJECT, new FreeObjectHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_SET_AMBIENT, new SetAmbientHook());
this.getHookManager().addHook(WorldManagerClient.MSG_TYPE_P2P_EXTENSION, new P2PExtensionHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_VOICE_PARMS, new VoiceParmsHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_PLAYER_PATH_REQ, new PlayerPathReqHook());
this.getHookManager().addHook(InstanceClient.MSG_TYPE_INSTANCE_ENTRY_REQ, new InstanceEntryReqHook());
this.getHookManager().addHook(Management.MSG_TYPE_GET_PLUGIN_STATUS, new GetPluginStatusHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_UPDATE_PLAYER_IGNORE_LIST, new UpdatePlayerIgnoreListHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_GET_MATCHING_PLAYERS, new GetMatchingPlayersHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_PLAYER_IGNORE_LIST_REQ, new PlayerIgnoreListReqHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_GET_PLAYER_LOGIN_STATUS, new GetPlayerLoginStatusHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_LOGOUT_PLAYER, new LogoutPlayerHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_ADD_STATIC_PERCEPTION, new AddStaticPerceptionHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_REMOVE_STATIC_PERCEPTION, new RemoveStaticPerceptionHook());
this.getHookManager().addHook(ProxyPlugin.MSG_TYPE_ACCOUNT_LOGIN, new AccountLoginHook());
}
void callEngineOnMessage(final Message message, final int flags) {
super.handleMessage(message, flags);
}
protected void initializeVoiceServerInformation() {
ProxyPlugin.voiceServerHost = Engine.properties.getProperty("atavism.voiceserver");
final String s = Engine.properties.getProperty("atavism.voiceport");
if (s != null) {
ProxyPlugin.voiceServerPort = Integer.parseInt(s);
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("initializeVoiceServerInformation: voiceServerHost " + ProxyPlugin.voiceServerHost + ", voiceServerPort " + ProxyPlugin.voiceServerPort);
}
}
public void acceptConnection(final ClientConnection con) {
Log.info("ProxyPlugin: CONNECTION remote=" + con);
con.registerMessageCallback(this);
}
public void processPacket(final ClientConnection con, final AOByteBuffer buf) {
try {
if (Log.loggingNet) {
if (ClientConnection.getLogMessageContents()) {
Log.net("ProxyPlugin.processPacket: con " + con + ", length " + buf.limit() + ", packet " + DebugUtils.byteArrayToHexString(buf));
}
else {
Log.net("ProxyPlugin.processPacket: con " + con + ", buf " + buf);
}
}
final Event event = Engine.getEventServer().parseBytes(buf, con);
if (event == null) {
Log.error("Engine: could not parse packet data, remote=" + con);
return;
}
Player player = (Player)con.getAssociation();
if (player == null) {
player = ProxyPlugin.loginSerializer;
if (event instanceof AuthorizedLoginEvent) {
Log.info("ProxyPlugin: LOGIN_RECV remote=" + con + " playerOid=" + ((AuthorizedLoginEvent)event).getOid());
}
}
this.playerManager.processEvent(player, event, this.eventQQ);
}
catch (AORuntimeException e) {
Log.exception("ProxyPlugin.processPacket caught exception", e);
}
}
public Set<OID> getPlayerOids() {
final List<Player> players = new ArrayList<Player>(this.playerManager.getPlayerCount());
this.playerManager.getPlayers(players);
final Set<OID> result = new HashSet<OID>(players.size());
for (final Player player : players) {
result.add(player.getOid());
}
return result;
}
public List<String> getPlayerNames() {
final List<Player> players = new ArrayList<Player>(this.playerManager.getPlayerCount());
Log.debug("ProxyPlugin.getPlayerNames: count is " + this.playerManager.getPlayerCount());
this.playerManager.getPlayers(players);
final List<String> result = new ArrayList<String>(players.size());
for (final Player player : players) {
result.add(player.getName() + " " + player.getOid() + " " + this.getName());
}
Collections.sort(result);
return result;
}
public List<String> getAllPlayerNames() {
Log.debug("ProxyPlugin.getAllPlayerNames: count is " + this.playersOnlineList.size());
final List<String> result = new ArrayList<String>(this.playersOnlineList.size());
final HashMap<OID, String> plays = new HashMap<OID, String>();
plays.putAll(this.playersOnlineList);
for (final OID player : plays.keySet()) {
result.add(plays.get(player) + " " + player + " " + this.playersOnlineOnProxy.get(player));
}
Collections.sort(result);
return result;
}
public List<Player> getPlayers() {
final List<Player> players = new ArrayList<Player>(this.playerManager.getPlayerCount());
this.playerManager.getPlayers(players);
return players;
}
public Player getPlayer(final OID oid) {
return this.playerManager.getPlayer(oid);
}
public void addPlayerMessage(final Message message, final Player player) {
final long start = System.nanoTime();
message.setEnqueueTime();
this.messageQQ.insert(player, message);
final long microseconds = System.nanoTime() - start;
}
public void addFilteredProperty(final String filteredProperty) {
this.filteredProps.add(filteredProperty);
this.cachedPlayerSpecificFilterProps.add(filteredProperty);
}
public void addPlayerSpecificProperty(final String filteredProperty) {
this.playerSpecificProps.add(filteredProperty);
this.cachedPlayerSpecificFilterProps.add(filteredProperty);
}
protected void recreatePlayerSpecificCache() {
(this.cachedPlayerSpecificFilterProps = new HashSet<String>()).addAll(this.filteredProps);
this.cachedPlayerSpecificFilterProps.addAll(this.playerSpecificProps);
}
protected boolean processLogin(final ClientConnection con, final AuthorizedLoginEvent loginEvent) {
final OID playerOid = loginEvent.getOid();
final String version = loginEvent.getVersion();
final int nPlayers = this.playerManager.getPlayerCount();
String[] clientVersionCapabilities = null;
if (version != null && version.length() > 0) {
clientVersionCapabilities = version.split(",");
}
final LinkedList<String> clientCapabilities = new LinkedList<String>();
String clientVersion = "";
if (clientVersionCapabilities != null && clientVersionCapabilities.length > 0) {
clientVersion = clientVersionCapabilities[0];
for (int i = 1; i < clientVersionCapabilities.length; ++i) {
clientCapabilities.add(clientVersionCapabilities
.trim());
}
}
final int versionCompare = ServerVersion.compareVersionStrings(clientVersion, "2019.1.2");
if (versionCompare != 1 && versionCompare != 0) {
Log.warn("processLogin: unsupported version " + clientVersion + " from player: " + playerOid);
final AuthorizedLoginResponseEvent loginResponse = new AuthorizedLoginResponseEvent(playerOid, false, "Login Failed: Unsupported client version", this.serverVersion);
con.send(loginResponse.toBytes());
return false;
}
final SecureToken token = SecureTokenManager.getInstance().importToken(loginEvent.getWorldToken());
boolean validToken = true;
if (!token.getValid()) {
Log.debug("token is not valid");
validToken = false;
}
final OID characterOid = (OID)token.getProperty("character_oid");
Log.debug("PlayerOID: " + playerOid);
Log.debug("CharacterOID: " + characterOid);
if (!playerOid.equals(characterOid)) {
Log.debug("playerOid does not match character_oid");
validToken = false;
}
if (!token.getProperty("proxy_server").equals(Engine.getAgent().getName())) {
Log.debug("proxy_server does not match engine agent name");
validToken = false;
}
if (!validToken) {
Log.error("processLogin: invalid proxy token");
final Event loginResponse3 = new AuthorizedLoginResponseEvent(playerOid, false, this.tokenError, this.serverVersion);
con.send(loginResponse3.toBytes());
return false;
}
try {
final TargetMessage getPlayerLoginStatus = new TargetMessage(ProxyPlugin.MSG_TYPE_GET_PLAYER_LOGIN_STATUS, playerOid);
final PlayerLoginStatus loginStatus = (PlayerLoginStatus)Engine.getAgent().sendRPCReturnObject(getPlayerLoginStatus);
if (this.proxyLoginCallback.duplicateLogin(loginStatus, con)) {
if (loginStatus != null) {
Log.info("processLogin: LOGIN_DUPLICATE remote=" + con + " playerOid=" + playerOid + " name=" + loginStatus.name + " existingCon=" + loginStatus.clientCon + " existingProxy=" + loginStatus.proxyPluginName);
}
else {
Log.info("processLogin: LOGIN_DUPLICATE remote=" + con + " playerOid=" + playerOid + " loginStatus is null");
}
final AuthorizedLoginResponseEvent loginResponse4 = new AuthorizedLoginResponseEvent(playerOid, false, "Login Failed: Already connected", this.serverVersion);
con.send(loginResponse4.toBytes());
return false;
}
}
catch (NoRecipientsException e) {
ProxyPlugin.log.debug("processLogin: OK! player is not logged " + e);
}
Player player = new Player(playerOid, con);
player.setStatus(1);
if (!this.playerManager.addPlayer(player)) {
player = this.playerManager.getPlayer(playerOid);
Log.info("processLogin: LOGIN_DUPLICATE remote=" + con + " playerOid=" + playerOid + " existing=" + player.getConnection());
final AuthorizedLoginResponseEvent loginResponse5 = new AuthorizedLoginResponseEvent(playerOid, false, "Login Failed: Already connected", this.serverVersion);
con.send(loginResponse5.toBytes());
return false;
}
con.setAssociation(player);
player.setVersion(clientVersion);
player.setCapabilities(clientCapabilities);
String errorMessage = this.proxyLoginCallback.preLoad(player, con);
if (errorMessage != null) {
this.playerManager.removePlayer(playerOid);
final Event loginResponse6 = new AuthorizedLoginResponseEvent(playerOid, false, errorMessage, this.serverVersion);
con.send(loginResponse6.toBytes());
return false;
}
if (Log.loggingDebug) {
Log.debug("processLogin: loading object: " + playerOid + ", con=" + con);
}
if (!this.loadPlayerObject(player)) {
Log.error("processLogin: could not load object " + playerOid);
this.playerManager.removePlayer(playerOid);
final Event loginResponse6 = new AuthorizedLoginResponseEvent(playerOid, false, "Login Failed", this.serverVersion);
con.send(loginResponse6.toBytes());
return false;
}
if (Log.loggingDebug) {
Log.debug("processLogin: loaded player object: " + playerOid);
}
errorMessage = this.proxyLoginCallback.postLoad(player, con);
if (errorMessage != null) {
this.playerManager.removePlayer(playerOid);
final Event loginResponse6 = new AuthorizedLoginResponseEvent(playerOid, false, errorMessage, this.serverVersion);
con.send(loginResponse6.toBytes());
return false;
}
final AuthorizedLoginResponseEvent loginResponse4 = new AuthorizedLoginResponseEvent(playerOid, true, "Login Succeeded", this.serverVersion + ", " + this.serverCapabilitiesSentToClient);
con.send(loginResponse4.toBytes());
if (Log.loggingDebug) {
Log.debug("Login response sent for playerOid=" + playerOid + " the authorized login response message is : " + loginResponse4.getMessage());
}
this.playerManager.addStaticPerception(player, playerOid);
final boolean loginOK = this.processLoginHelper(con, player);
if (!loginOK) {
if (Log.loggingDebug) {
Log.debug("processLogin: loading object: " + playerOid + ", con=" + con + " login failed disconect player");
}
con.setAssociation(null);
if (this.perceptionFilter.removeTarget(playerOid)) {
final FilterUpdate filterUpdate = new FilterUpdate(1);
filterUpdate.removeFieldValue(1, playerOid);
Engine.getAgent().applyFilterUpdate(this.perceptionSubId, filterUpdate);
this.responderFilter.removeTarget(playerOid);
Engine.getAgent().applyFilterUpdate(this.responderSubId, filterUpdate);
}
this.playerManager.removeStaticPerception(player, playerOid);
this.playerManager.removePlayer(playerOid);
con.close();
}
else {
this.proxyLoginCallback.postSpawn(player, con);
this.playerManager.loginComplete(player, this.eventQQ);
final SubjectMessage loginSpawned = new SubjectMessage(ProxyPlugin.MSG_TYPE_LOGIN_SPAWNED);
loginSpawned.setSubject(playerOid);
Engine.getAgent().sendBroadcast(loginSpawned);
this.processPlayerIgnoreList(player);
final OID accountID = (OID)EnginePlugin.getObjectProperty(playerOid, WorldManagerClient.NAMESPACE, "accountId");
this.clientConnections.put(accountID, con);
}
ProxyPlugin.log.debug("processLogin: loginOK:" + loginOK + " end");
return loginOK;
}
protected boolean loadPlayerObject(final Player player) {
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject player " + player);
}
InstanceRestorePoint restorePoint = null;
LinkedList restoreStack = null;
boolean first = true;
final OID playerOid = player.getOid();
final List<Namespace> namespaces = new ArrayList<Namespace>();
final OID oidResult = ObjectManagerClient.loadSubObject(playerOid, namespaces);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject player " + player + " oidResult=" + oidResult);
}
if (oidResult == null) {
return false;
}
Point location = new Point();
OID instanceOid = Engine.getDatabase().getLocation(playerOid, WorldManagerClient.NAMESPACE, location);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject instanceOid " + instanceOid + " instanceEntryAllowed:" + this.instanceEntryAllowed(playerOid, instanceOid, location));
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject: trying to load player into instance: " + instanceOid);
}
final AccountDatabase aDB = new AccountDatabase(false);
final int guildID = aDB.GetGuildId(playerOid);
Label_0274: {
if (!Log.loggingDebug) {
break Label_0274;
}
ProxyPlugin.log.debug("loadPlayerObject: load player guildID: " + guildID);
try {
while (true) {
OID result = null;
if (this.instanceEntryAllowed(playerOid, instanceOid, location)) {
final InstanceClient.InstanceInfo instanceInfo = InstanceClient.getInstanceInfo(instanceOid, -262145);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject InstanceInfo " + instanceInfo + " " + instanceInfo.playerOid + " " + instanceInfo.templateID + " " + instanceInfo.groupOid + " " + instanceInfo.guildId + " start do ");
}
if (instanceInfo.oid != null && (instanceInfo.populationLimit < 1 || instanceInfo.playerPopulation < instanceInfo.populationLimit)) {
result = ObjectManagerClient.loadObject(playerOid);
if (Log.loggingDebug) {
Log.debug("loadPlayerObject: loading player into instance: " + instanceInfo.oid + " of ID: " + instanceInfo.templateID);
}
}
}
if (restoreStack != null && !restorePoint.getFallbackFlag()) {
EnginePlugin.setObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "instanceStack", restoreStack);
}
if (result != null) {
if (restorePoint != null) {
EnginePlugin.setObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "currentInstanceName", restorePoint.getInstanceID());
if (Log.loggingDebug) {
ProxyPlugin.log.debug("INSTANCE: setting current instance prop: " + restorePoint.getInstanceID());
}
}
break;
}
if (first) {
final Integer instanceID = (Integer)EnginePlugin.getObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "currentInstanceName");
if (Log.loggingDebug) {
ProxyPlugin.log.debug("Failed initial load, retrying with current instanceID=" + instanceID);
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug(" loadPlayerObject instanceID=" + instanceID + " playerOid=" + playerOid + " guildID=" + guildID);
}
if (instanceID > 0) {
instanceOid = this.instanceEntryCallback.selectInstance(player, instanceID, playerOid, guildID);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject instanceOid:" + instanceOid);
}
if (instanceOid != null) {
InstanceClient.InstanceInfo instanceInfo2 = InstanceClient.getInstanceInfo(instanceOid, -262145, false);
if (Log.loggingDebug) {
ProxyPlugin.log.debug(" loadPlayerObject InstanceInfo " + instanceInfo2 + " " + instanceInfo2.playerOid + " " + instanceInfo2.templateID + " " + instanceInfo2.groupOid + " " + instanceInfo2.guildId);
}
if (instanceInfo2.oid != null) {
if (instanceInfo2.populationLimit > 0 && instanceInfo2.playerPopulation >= instanceInfo2.populationLimit) {
if (Log.loggingDebug) {
Log.debug("POP: got population: " + instanceInfo2.playerPopulation + " and limit: " + instanceInfo2.populationLimit);
}
instanceOid = handleFullInstance(instanceInfo2.templateID, instanceInfo2);
instanceInfo2 = InstanceClient.getInstanceInfo(instanceOid, -262145);
ProxyPlugin.log.debug(" loadPlayerObject 2 InstanceInfo " + instanceInfo2 + " " + instanceInfo2.playerOid + " " + instanceInfo2.templateID + " " + instanceInfo2.groupOid + " " + instanceInfo2.guildId);
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("Failed initial load, retrying with instanceOid=" + instanceOid + " and instanceName: " + instanceInfo2.name);
}
final BasicWorldNode wnode = new BasicWorldNode();
wnode.setInstanceOid(instanceOid);
ObjectManagerClient.fixWorldNode(playerOid, wnode);
first = false;
continue;
}
}
}
}
if (restorePoint != null && restorePoint.getFallbackFlag()) {
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject instanceOid " + instanceOid + " restorePoint:" + restorePoint + " restorePoint.getFallbackFlag():" + restorePoint.getFallbackFlag() + " return false");
}
return false;
}
restoreStack = (LinkedList)EnginePlugin.getObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "instanceStack");
if (restoreStack == null || restoreStack.size() == 0) {
Log.error("Failed finding matching instance, and restore stack is null or empty?" + restoreStack + " return false");
return false;
}
final int size = restoreStack.size();
restorePoint = restoreStack.get(size - 1);
instanceOid = restorePoint.getInstanceOid();
if (restorePoint.getInstanceID() > 0) {
instanceOid = this.instanceEntryCallback.selectInstance(player, restorePoint.getInstanceID());
Log.debug("Failed finding matching instance, retrying with restore point instanceID=" + restorePoint.getInstanceID() + " result: " + instanceOid);
}
if (instanceOid != null) {
final BasicWorldNode wnode2 = new BasicWorldNode();
wnode2.setInstanceOid(instanceOid);
wnode2.setLoc(restorePoint.getLoc());
wnode2.setOrientation(restorePoint.getOrientation());
wnode2.setDir(new AOVector(0.0f, 0.0f, 0.0f));
final boolean rc = ObjectManagerClient.fixWorldNode(playerOid, wnode2);
if (!rc) {
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject instanceOid " + instanceOid + " rc:" + rc + " return false");
}
return false;
}
location = restorePoint.getLoc();
}
first = false;
if (restorePoint.getFallbackFlag()) {
continue;
}
restoreStack.remove(size - 1);
}
}
catch (Exception e) {
ProxyPlugin.log.error("loadPlayerObject instanceOid " + instanceOid + " Exception: " + e.getMessage() + " " + e.getLocalizedMessage());
}
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("loadPlayerObject instanceOid " + instanceOid + " END return true");
}
return true;
}
protected boolean processLoginHelper(final ClientConnection con, final Player player) {
final OID playerOid = player.getOid();
final WorldManagerClient.ObjectInfo objInfo = WorldManagerClient.getObjectInfo(playerOid);
if (objInfo == null) {
Log.error("processLogin: Could not get player ObjectInfo oid=" + playerOid);
return false;
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("processLoginHelper objInfo " + objInfo.instanceOid);
}
if (World.FollowsTerrainOverride != null) {
Log.debug("using follows terrain override");
objInfo.followsTerrain = World.FollowsTerrainOverride;
}
if (Log.loggingDebug) {
Log.debug("processLogin: got object info: " + objInfo);
}
player.setName(objInfo.name);
final InstanceClient.InstanceInfo instanceInfo = InstanceClient.getInstanceInfo(objInfo.instanceOid, -262145);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("InstanceInfo " + instanceInfo + " " + instanceInfo.playerOid + " " + instanceInfo.templateID + " " + instanceInfo.groupOid + " " + instanceInfo.guildId);
}
if (instanceInfo == null) {
Log.error("processLogin: unknown instanceOid=" + objInfo.instanceOid);
return false;
}
final LoginMessage loginMessage = new LoginMessage(playerOid, objInfo.name);
loginMessage.setInstanceOid(objInfo.instanceOid);
loginMessage.setProxy(this.getName());
final AsyncRPCCallback asyncRPCCallback = new AsyncRPCCallback(player, "processLogin: got LoginMessage response");
final int expectedResponses = Engine.getAgent().sendBroadcastRPC(loginMessage, asyncRPCCallback);
asyncRPCCallback.waitForResponses(expectedResponses);
Log.debug("processLogin: sending template (scene) name: " + instanceInfo.templateName);
final Event worldFileEvent = new WorldFileEvent(instanceInfo.templateName);
con.send(worldFileEvent.toBytes());
player.sceneLoading(true);
Log.debug("INFO: process login helper");
con.send(objInfo.toBuffer(playerOid));
final DisplayContext dc = WorldManagerClient.getDisplayContext(playerOid);
final ModelInfoEvent modelInfoEvent = new ModelInfoEvent(playerOid);
modelInfoEvent.setDisplayContext(dc);
if (Log.loggingDebug) {
Log.debug("processLogin: got dc: " + dc);
}
con.send(modelInfoEvent.toBytes());
final Map<String, DisplayContext> childMap = dc.getChildDCMap();
if (childMap != null && !childMap.isEmpty()) {
for (final String slot : childMap.keySet()) {
final DisplayContext attachDC = childMap.get(slot);
if (attachDC == null) {
throw new AORuntimeException("attach DC is null for obj: " + playerOid);
}
final OID attacheeOID = attachDC.getObjRef();
if (attacheeOID == null) {
throw new AORuntimeException("attachee oid is null for obj: " + playerOid);
}
if (Log.loggingDebug) {
Log.debug("processLogin: sending attach message to " + playerOid + " attaching to obj " + playerOid + ", object being attached=" + attacheeOID + " to slot " + slot + ", attachmentDC=" + attachDC);
}
final AttachEvent event = new AttachEvent(playerOid, attacheeOID, slot, attachDC);
con.send(event.toBytes());
}
Log.debug("processLogin: done with processing attachments");
}
if (this.perceptionFilter.addTarget(playerOid)) {
final FilterUpdate filterUpdate = new FilterUpdate(1);
filterUpdate.addFieldValue(1, playerOid);
Engine.getAgent().applyFilterUpdate(this.perceptionSubId, filterUpdate);
this.responderFilter.addTarget(playerOid);
Engine.getAgent().applyFilterUpdate(this.responderSubId, filterUpdate);
}
WorldManagerClient.updateObject(playerOid, playerOid);
final WorldManagerClient.TargetedExtensionMessage spawnBegin = new WorldManagerClient.TargetedExtensionMessage(playerOid, playerOid);
spawnBegin.setExtensionType("ao.SCENE_BEGIN");
spawnBegin.setProperty("action", "login");
spawnBegin.setProperty("name", instanceInfo.name);
spawnBegin.setProperty("templateName", instanceInfo.templateName);
final WorldManagerClient.TargetedExtensionMessage spawnEnd = new WorldManagerClient.TargetedExtensionMessage(playerOid, playerOid);
spawnEnd.setExtensionType("ao.SCENE_END");
spawnEnd.setProperty("action", "login");
spawnEnd.setProperty("name", instanceInfo.name);
spawnEnd.setProperty("templateName", instanceInfo.templateName);
final Integer perceptionCount = WorldManagerClient.spawn(playerOid, spawnBegin, spawnEnd);
if (perceptionCount < 0) {
Log.error("processLogin: spawn failed error=" + perceptionCount + " playerOid=" + playerOid);
return perceptionCount == -2 && false;
}
if (perceptionCount == 0 && player.supportsLoadingState()) {
player.setLoadingState(1);
con.send(new LoadingStateEvent(false).toBytes());
}
if (Log.loggingDebug) {
Log.debug("processLogin: During login, perceptionCount is " + perceptionCount);
Log.debug("processLogin: spawned player, master playerOid=" + playerOid);
}
if (Log.loggingDebug) {
Log.debug("processLogin: sending over instance information for player " + playerOid + ", instance=" + instanceInfo.name + ", instanceOid=" + instanceInfo.oid);
}
this.updateInstancePerception(player.getOid(), null, instanceInfo.oid, instanceInfo.name);
return true;
}
public ProxyLoginCallback getProxyLoginCallback() {
return this.proxyLoginCallback;
}
public void setProxyLoginCallback(final ProxyLoginCallback callback) {
this.proxyLoginCallback = callback;
}
private boolean instanceEntryAllowed(final OID playerOid, final OID instanceOid, final Point location) {
return instanceOid != null && this.instanceEntryCallback.instanceEntryAllowed(playerOid, instanceOid, location);
}
public InstanceEntryCallback getInstanceEntryCallback() {
return this.instanceEntryCallback;
}
public void setInstanceEntryCallback(final InstanceEntryCallback callback) {
this.instanceEntryCallback = callback;
}
public void processRequestQuestInfo(final ClientConnection con, final RequestQuestInfo event) {
final OID npcOid = event.getQuestNpcOid();
final Player player = this.verifyPlayer("processRequestQuestInfo", (Event)event, con);
if (Log.loggingDebug) {
Log.debug("processRequestQuestInfo: player=" + player + ", npc=" + npcOid);
}
QuestClient.requestQuestInfo(npcOid, player.getOid());
}
public void processQuestResponse(final ClientConnection con, final QuestResponse event) {
final Player player = this.verifyPlayer("processQuestResponse", (Event)event, con);
final boolean acceptStatus = event.getResponse();
final OID npcOid = event.getQuestNpcOid();
final OID questOid = event.getQuestId();
if (Log.loggingDebug) {
Log.debug("processQuestResponse: player=" + player + ", npcOid=" + npcOid + ", acceptStatus=" + acceptStatus);
}
final QuestClient.QuestResponseMessage msg = new QuestClient.QuestResponseMessage(npcOid, player.getOid(), questOid, acceptStatus);
Engine.getAgent().sendBroadcast((Message)msg);
}
public void processReqConcludeQuest(final ClientConnection con, final ConcludeQuest event) {
final Player player = this.verifyPlayer("processReqConcludeQuest", (Event)event, con);
final OID mobOid = event.getQuestNpcOid();
if (Log.loggingDebug) {
Log.debug("processReqConclude: player=" + player + ", mobOid=" + mobOid);
}
QuestClient.requestConclude(mobOid, player.getOid());
}
public void connectionReset(final ClientConnection con) {
final Player player = (Player)con.getAssociation();
if (player == null) {
Log.info("ProxyPlugin: DISCONNECT remote=" + con);
return;
}
Log.info("ProxyPlugin: DISCONNECT remote=" + con + " playerOid=" + player.getOid() + " name=" + player.getName());
if (this.playerManager.logout(player)) {
final long start = System.nanoTime();
final ConnectionResetMessage message = new ConnectionResetMessage(con, player);
message.setEnqueueTime(System.currentTimeMillis());
this.messageQQ.insert(player, message);
final long n = System.nanoTime() - start;
}
}
protected void processConnectionResetInternal(final ConnectionResetMessage message) {
final long startTime = System.currentTimeMillis();
final ClientConnection con = message.getConnection();
final Player player = message.getPlayer();
final OID playerOid = player.getOid();
Log.info("ProxyPlugin: LOGOUT_BEGIN remote=" + con + " playerOid=" + player.getOid() + " name=" + player.getName());
if (player.getStatus() != 3) {
ProxyPlugin.log.error("processConnectionReset: player status is " + Player.statusToString(player.getStatus()) + " should be " + Player.statusToString(3));
}
try {
if (!WorldManagerClient.despawn(playerOid)) {
ProxyPlugin.log.warn("processConnectionReset: despawn player failed for " + playerOid);
}
Log.debug("processConnectionResetInternal Removing perceptionFilter for palyer: " + playerOid);
if (this.perceptionFilter.removeTarget(playerOid)) {
final FilterUpdate filterUpdate = new FilterUpdate(1);
filterUpdate.removeFieldValue(1, playerOid);
Log.debug("processConnectionResetInternal Removing perceptionFilter applyFilterUpdate for palyer: " + playerOid);
Engine.getAgent().applyFilterUpdate(this.perceptionSubId, filterUpdate);
Log.debug("processConnectionResetInternal Removing responderFilter for palyer: " + playerOid);
this.responderFilter.removeTarget(playerOid);
Log.debug("processConnectionResetInternal Removing perceptionFilter applyFilterUpdate for palyer: " + playerOid);
Engine.getAgent().applyFilterUpdate(this.responderSubId, filterUpdate);
}
final LogoutMessage logoutMessage = new LogoutMessage(playerOid, player.getName());
Log.debug("processConnectionResetInternal: Send LogoutMessage for player: " + playerOid + " and wait for response");
final AsyncRPCCallback asyncRPCCallback = new AsyncRPCCallback(player, "processLogout: got LogoutMessage response");
final int expectedResponses = Engine.getAgent().sendBroadcastRPCBlocking(logoutMessage, asyncRPCCallback);
Log.debug("processConnectionResetInternal: Send LogoutMessage for player: " + playerOid + " and wait for response expectedResponses=" + expectedResponses);
final OID accountID = (OID)EnginePlugin.getObjectProperty(playerOid, WorldManagerClient.NAMESPACE, "accountId");
Log.debug("Removing connection from client connection map for account: " + accountID);
this.clientConnections.remove(accountID);
if (!ObjectManagerClient.unloadObject(playerOid)) {
ProxyPlugin.log.warn("processConnectionReset: unloadObject failed oid=" + playerOid);
}
}
catch (NoRecipientsException nre) {
ProxyPlugin.log.exception("ProxyPlugin.processConnectionResetInternal(): NoRecipientsException ", nre);
}
catch (RPCTimeoutException nre2) {
ProxyPlugin.log.exception("ProxyPlugin.processConnectionResetInternal(): RPCTimeoutException ", nre2);
}
catch (Exception nre3) {
ProxyPlugin.log.exception("ProxyPlugin.processConnectionResetInternal(): Exception ", nre3);
}
this.messageQQ.removeKey(player);
this.eventQQ.removeKey(player);
this.playerManager.removeStaticPerception(player, playerOid);
this.playerManager.removePlayer(playerOid);
Log.info("ProxyPlugin: LOGOUT_END remote=" + con + " playerOid=" + player.getOid() + " name=" + player.getName() + " in-queue=" + (startTime - message.getEnqueueTime()) + " processing=" + (System.currentTimeMillis() - startTime) + " nPlayers=" + this.playerManager.getPlayerCount());
synchronized (player) {
player.clearConnection();
player.notifyAll();
}
}
protected void processDirLocOrient(final ClientConnection con, final DirLocOrientEvent event) {
if (Log.loggingDebug) {
Log.debug("processDirLocOrient: got dir loc orient event: " + event);
}
final Player player = this.verifyPlayer("processDirLoc", event, con);
final BasicWorldNode wnode = new BasicWorldNode();
wnode.setDir(event.getDir());
wnode.setLoc(event.getLoc());
wnode.setOrientation(event.getQuaternion());
WorldManagerClient.updateWorldNode(player.getOid(), wnode);
}
protected void processCom(final ClientConnection con, final ComEvent event) {
final Player player = this.verifyPlayer("processCom", event, con);
Log.info("ProxyPlugin: CHAT_SENT player=" + player + " channel=" + event.getChannelId() + " msg=[" + event.getMessage() + "]");
final AccountDatabase aDB = new AccountDatabase(false);
ProxyPlugin.log.debug("processCom: CHAT_SENT");
if (aDB.isOnBlackList(player.getOid(), event.getObjectOid())) {
aDB.close();
return;
}
this.incrementChatCount();
WorldManagerClient.sendChatMsg(player.getOid(), player.getName(), event.getChannelId(), event.getMessage());
}
protected void processCommand(final ClientConnection con, final CommandEvent event) {
final Player player = this.verifyPlayer("processCommand", event, con);
final String cmd = event.getCommand().split(" ")[0];
if (Log.loggingDebug) {
ProxyPlugin.log.debug("processCommand: cmd=" + cmd + ", fullCmd=" + event.getCommand());
}
this.commandMapLock.lock();
RegisteredCommand command;
try {
command = this.commandMap.get(cmd);
}
finally {
this.commandMapLock.unlock();
}
if (command == null) {
Log.warn("processCommand: no parser for command: " + event.getCommand());
command = this.commandMap.get("/unknowncmd");
if (command != null) {
Engine.setCurrentPlugin(this);
command.parser.parse(event);
Engine.setCurrentPlugin(null);
}
return;
}
Engine.setCurrentPlugin(this);
if (command.access.allowed(event, this)) {
command.parser.parse(event);
}
else {
Log.warn("Player " + player + " not allowed to run command '" + event.getCommand() + "'");
}
Engine.setCurrentPlugin(null);
}
protected void processAutoAttack(final ClientConnection con, final AutoAttackEvent event) {
CombatClient.autoAttack(event.getAttackerOid(), event.getTargetOid(), event.getAttackStatus());
}
protected void processActivateItem(final ClientConnection con, final ActivateItemEvent event) {
InventoryClient.activateObject(event.getItemOid(), event.getObjectOid(), event.getTargetOid());
}
protected void processAbilityStatusEvent(final ClientConnection con, final AbilityStatusEvent event) {
final Player player = (Player)con.getAssociation();
final AbilityStatusMessage msg = new AbilityStatusMessage(CombatClient.MSG_TYPE_ABILITY_STATUS, player.getOid(), event.getPropertyMap());
Engine.getAgent().sendBroadcast((Message)msg);
}
protected void processLogout(final ClientConnection con, final LogoutEvent event) {
}
protected void processSceneLoaded(final ClientConnection con, final SceneLoadedEvent event) {
final Player player = (Player)con.getAssociation();
player.sceneLoading(false);
Log.debug("SCENE: sceneLoading set to false for player: " + player.getOid());
}
protected void processExtensionMessageEvent(final ClientConnection con, final ExtensionMessageEvent event) {
final String key = event.getPropertyMap().get("ext_msg_subtype");
final OID target = event.getTargetOid();
final Player player = (Player)con.getAssociation();
if (Log.loggingDebug) {
Log.debug("processExtensionMessageEvent: " + player + " subType=" + key + " target=" + target);
}
final List<ProxyExtensionHook> proxyHookList = this.extensionHooks.get(key);
if (proxyHookList != null) {
for (final ProxyExtensionHook hook : proxyHookList) {
hook.processExtensionEvent(event, player, this);
}
return;
}
if (target != null) {
final WorldManagerClient.TargetedExtensionMessage msg = new WorldManagerClient.TargetedExtensionMessage(WorldManagerClient.MSG_TYPE_EXTENSION, target, player.getOid(), event.getClientTargeted(), event.getPropertyMap());
if (event.getClientTargeted()) {
msg.setMsgType(WorldManagerClient.MSG_TYPE_P2P_EXTENSION);
if (this.allowClientToClientMessage(player, target, msg)) {
Engine.getAgent().sendBroadcast(msg);
}
}
else {
final MessageType msgType = this.getExtensionMessageType(key);
if (msgType == null) {
Log.error("processExtensionMessageEvent: key '" + key + "' has no corresponding MessageType");
return;
}
msg.setMsgType(msgType);
Engine.getAgent().sendBroadcast(msg);
}
}
else {
final MessageType msgType2 = this.getExtensionMessageType(key);
if (msgType2 == null) {
Log.error("processExtensionMessageEvent: key '" + key + "' has no corresponding MessageType");
return;
}
final WorldManagerClient.ExtensionMessage msg2 = new WorldManagerClient.ExtensionMessage(msgType2, player.getOid(), event.getPropertyMap());
Engine.getAgent().sendBroadcast(msg2);
}
}
public void registerExtensionSubtype(final String subtype, final MessageType type) {
this.extensionMessageRegistry.put(subtype, type);
}
public MessageType unregisterExtensionSubtype(final String subtype) {
return this.extensionMessageRegistry.remove(subtype);
}
public MessageType getExtensionMessageType(final String subtype) {
return this.extensionMessageRegistry.get(subtype);
}
public boolean allowClientToClientMessage(final Player sender, final OID targetOid, final WorldManagerClient.TargetedExtensionMessage message) {
return this.defaultAllowClientToClientMessage;
}
protected boolean specialCaseNewProcessing(final PerceptionMessage.ObjectNote objectNote, final Player player) {
final long start = System.currentTimeMillis();
final ClientConnection con = player.getConnection();
final OID objOid = objectNote.getSubject();
final ObjectType objType = objectNote.getObjectType();
if (objType == ObjectTypes.light) {
Log.debug("specialCaseNewProcessing: got a light object");
final LightData lightData = (LightData)EnginePlugin.getObjectProperty(objOid, Namespace.WORLD_MANAGER, Light.LightDataPropertyKey);
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: light data=" + lightData);
}
final NewLightEvent lightEvent = new NewLightEvent(player.getOid(), objOid, lightData);
con.send(lightEvent.toBytes());
return true;
}
if (objType.equals(WorldManagerClient.TEMPL_OBJECT_TYPE_TERRAIN_DECAL)) {
Log.debug("specialCaseNewProcessing: got a terrain decal object");
final TerrainDecalData decalData = (TerrainDecalData)EnginePlugin.getObjectProperty(objOid, Namespace.WORLD_MANAGER, WorldManagerClient.TEMPL_TERRAIN_DECAL_DATA);
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: terrain decal data=" + decalData);
}
final NewTerrainDecalEvent decalEvent = new NewTerrainDecalEvent(objOid, decalData);
con.send(decalEvent.toBytes());
return true;
}
if (objType.equals(WorldManagerClient.TEMPL_OBJECT_TYPE_POINT_SOUND)) {
Log.debug("specialCaseNewProcessing: got a point sound object");
final List<SoundData> soundData = (List<SoundData>)EnginePlugin.getObjectProperty(objOid, Namespace.WORLD_MANAGER, WorldManagerClient.TEMPL_SOUND_DATA_LIST);
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: sound data=" + soundData);
}
final WorldManagerClient.SoundMessage soundMsg = new WorldManagerClient.SoundMessage(objOid);
soundMsg.setSoundData(soundData);
con.send(soundMsg.toBuffer());
return true;
}
final WorldManagerClient.PerceptionInfo perceptionInfo = (WorldManagerClient.PerceptionInfo)objectNote.getObjectInfo();
if (perceptionInfo.objectInfo == null) {
return true;
}
final WorldManagerClient.MobPathMessage pathMsg = (WorldManagerClient.MobPathMessage)perceptionInfo.objectInfo.getProperty(WorldManagerClient.MOB_PATH_PROPERTY);
con.send(perceptionInfo.objectInfo.toBuffer(player.getOid()));
if (perceptionInfo.displayContext != null) {
final ModelInfoEvent modelInfoEvent = new ModelInfoEvent(objOid);
modelInfoEvent.setDisplayContext(perceptionInfo.displayContext);
con.send(modelInfoEvent.toBytes());
}
else if (Log.loggingDebug) {
Log.debug("No display context for " + objOid + " " + perceptionInfo.objectInfo);
}
if (pathMsg != null) {
if (pathMsg.pathExpired()) {
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: for mob " + objOid + ", last mob path expired " + pathMsg.toString());
}
}
else {
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: for mob " + objOid + ", sending last mob path " + pathMsg.toString());
}
final AOByteBuffer pathBuf = pathMsg.toBuffer();
con.send(pathBuf);
}
}
Map<String, DisplayContext> childMap = null;
if (perceptionInfo.displayContext != null) {
childMap = perceptionInfo.displayContext.getChildDCMap();
}
if (childMap != null && !childMap.isEmpty()) {
for (final String slot : childMap.keySet()) {
final DisplayContext attachDC = childMap.get(slot);
if (attachDC == null) {
throw new AORuntimeException("attach DC is null for obj: " + objOid);
}
final OID attacheeOID = attachDC.getObjRef();
if (attacheeOID == null) {
throw new AORuntimeException("attachee oid is null for obj: " + objOid);
}
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: sending attach message to " + player.getOid() + " attaching to obj " + objOid + ", object being attached=" + attacheeOID + " to slot " + slot + ", attachmentDC=" + attachDC);
}
final AttachEvent event = new AttachEvent(objOid, attacheeOID, slot, attachDC);
con.send(event.toBytes());
}
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: done with processing attachments");
}
}
final long finish = System.currentTimeMillis();
if (Log.loggingDebug) {
Log.debug("specialCaseNewProcessing: finished.\tplayerOid=" + player.getOid() + ", oid=" + objOid + " in " + (finish - start) + " ms");
}
return false;
}
protected boolean specialCaseFreeProcessing(final PerceptionMessage.ObjectNote objectNote, final Player player) {
if (player.getOid().equals(objectNote.getSubject())) {
Log.debug("ignoring free object message to self");
return true;
}
ClientConnection con = player.getConnection();
if (!con.isOpen()) {
con = null;
}
final OID objOid = objectNote.getSubject();
if (objectNote.getObjectType() == ObjectTypes.road) {
if (Log.loggingDebug) {
Log.debug("specialCaseFreeProcessing: playerOid=" + player.getOid() + ", roadSegmentOid=" + objOid);
}
this.handleFreeRoad(con, objOid);
return true;
}
if (objectNote.getObjectType().equals(WorldManagerClient.TEMPL_OBJECT_TYPE_TERRAIN_DECAL)) {
if (Log.loggingDebug) {
Log.debug("specialCaseFreeProcessing: playerOid=" + player.getOid() + ", decalOid=" + objOid);
}
final FreeTerrainDecalEvent decalEvent = new FreeTerrainDecalEvent(objOid);
if (con != null) {
con.send(decalEvent.toBytes());
}
return true;
}
if (Log.loggingDebug) {
Log.debug("specialCaseFreeProcessing: playerOid=" + player.getOid() + ", objOid=" + objOid);
}
final NotifyFreeObjectEvent freeEvent = new NotifyFreeObjectEvent(player.getOid(), objOid);
if (con != null) {
con.send(freeEvent.toBytes());
}
return false;
}
protected void handleFreeRoad(final ClientConnection con, final OID objOid) {
final WorldManagerClient.FreeRoadMessage freeRoadMsg = new WorldManagerClient.FreeRoadMessage(objOid);
final AOByteBuffer buf = freeRoadMsg.toBuffer();
if (con != null) {
con.send(buf);
}
}
public static void addStaticPerception(final OID playerOid, final OID oid) {
addStaticPerception(playerOid, oid, null, null, false);
}
public static void addStaticPerception(final OID oid, final OID oid2, final String name, final ObjectType type) {
addStaticPerception(oid, oid2, name, type, true);
}
private static void addStaticPerception(final OID playerOid, final OID oid, final String name, final ObjectType type, final boolean hasObjectInfo) {
final AddStaticPerceptionMessage message = new AddStaticPerceptionMessage(ProxyPlugin.MSG_TYPE_ADD_STATIC_PERCEPTION);
message.setTarget(playerOid);
message.setSubject(oid);
message.setName(name);
message.setType(type);
message.setHasObjectInfo(hasObjectInfo);
Engine.getAgent().sendBroadcast(message);
}
public static void removeStaticPerception(final OID playerOid, final OID oid) {
final TargetMessage message = new TargetMessage(ProxyPlugin.MSG_TYPE_REMOVE_STATIC_PERCEPTION);
message.setTarget(playerOid);
message.setSubject(oid);
Engine.getAgent().sendBroadcast(message);
}
protected void processPlayerIgnoreList(final Player player) {
if (player.getStatus() == 3) {
Log.error("ProxyPlugin.processPlayerIgnoreList: Aborting... player.getStatus() is STATUS_LOGOUT");
return;
}
this.sendPlayerIgnoreList(player);
}
protected void sendPlayerIgnoreList(final Player player) {
final String missing = " Missing ";
}
public void updateIgnoredOids(final Player player, final List<OID> nowIgnored, final List<OID> noLongerIgnored) {
}
public List<Object> matchingPlayers(final Player player, final String playerName, final Boolean exactMatch) {
final boolean match = exactMatch == null || exactMatch;
final List<Object> matchLists = Engine.getDatabase().getOidsAndNamesMatchingName(playerName, match);
final List<OID> oids = matchLists.get(0);
final List<String> names = matchLists.get(1);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("ProxyPlugin.matchingPlayers: For player " + player.getOid() + ", found " + ((oids == null) ? 0 : oids.size()) + " players: " + Database.makeOidCollectionString(oids) + " " + (match ? "exactly matching" : "starting with") + " name '" + playerName + "':" + Database.makeNameCollectionString(names));
}
return matchLists;
}
public static OID handleFullInstance(final int instanceTemplateID, InstanceClient.InstanceInfo instanceInfo) {
Log.debug("POP: instance full with template: " + instanceTemplateID);
int instanceNum = 1;
String instanceName = "";
OID instanceOid;
while (true) {
instanceName = instanceTemplateID + "_" + instanceNum;
instanceOid = InstanceClient.getInstanceOid(instanceName);
if (instanceOid != null) {
instanceInfo = InstanceClient.getInstanceInfo(instanceOid, -262145);
if (instanceInfo.populationLimit < 1) {
break;
}
if (instanceInfo.playerPopulation < instanceInfo.populationLimit) {
break;
}
}
else {
final Template overrideTemplate = new Template();
overrideTemplate.put(Namespace.INSTANCE, "name", instanceName);
instanceOid = InstanceClient.createInstance(instanceTemplateID, overrideTemplate);
if (instanceOid != null) {
break;
}
}
++instanceNum;
}
return instanceOid;
}
private void updateInstancePerception(final OID playerOid, final OID prevInstanceOid, final OID destInstanceOid, final String destInstanceName) {
if (prevInstanceOid != null) {
removeStaticPerception(playerOid, prevInstanceOid);
}
addStaticPerception(playerOid, destInstanceOid, destInstanceName, ObjectTypes.instance);
}
protected void pushInstanceRestorePoint(final Player player, final BasicWorldNode loc) {
final OID playerOid = player.getOid();
ProxyPlugin.log.debug("pushInstanceRestorePoint " + playerOid);
final InstanceRestorePoint restorePoint = new InstanceRestorePoint();
restorePoint.setInstanceOid(loc.getInstanceOid());
restorePoint.setLoc(loc.getLoc());
restorePoint.setOrientation(loc.getOrientation());
final InstanceClient.InstanceInfo instanceInfo = InstanceClient.getInstanceInfo(loc.getInstanceOid(), 8);
restorePoint.setInstanceID(instanceInfo.templateID);
LinkedList<Object> restoreStack = (LinkedList<Object>)EnginePlugin.getObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "instanceStack");
if (restoreStack == null) {
restoreStack = new LinkedList<Object>();
}
restoreStack.add(restorePoint);
EnginePlugin.setObjectProperty(playerOid, Namespace.OBJECT_MANAGER, "instanceStack", restoreStack);
}
protected void sendOceanData(final OceanData oceanData, final Player player) {
final WorldManagerClient.TargetedExtensionMessage oceanMsg = new ClientParameter.ClientParameterMessage(player.getOid());
oceanMsg.setProperty("Ocean.DisplayOcean", oceanData.displayOcean.toString());
if (oceanData.useParams != null) {
oceanMsg.setProperty("Ocean.UseParams", oceanData.useParams.toString());
}
if (oceanData.waveHeight != null) {
oceanMsg.setProperty("Ocean.WaveHeight", oceanData.waveHeight.toString());
}
if (oceanData.seaLevel != null) {
oceanMsg.setProperty("Ocean.SeaLevel", oceanData.seaLevel.toString());
}
if (oceanData.bumpScale != null) {
oceanMsg.setProperty("Ocean.BumpScale", oceanData.bumpScale.toString());
}
if (oceanData.bumpSpeedX != null) {
oceanMsg.setProperty("Ocean.BumpSpeedX", oceanData.bumpSpeedX.toString());
}
if (oceanData.bumpSpeedZ != null) {
oceanMsg.setProperty("Ocean.BumpSpeedZ", oceanData.bumpSpeedZ.toString());
}
if (oceanData.textureScaleX != null) {
oceanMsg.setProperty("Ocean.TextureScaleX", oceanData.textureScaleX.toString());
}
if (oceanData.textureScaleZ != null) {
oceanMsg.setProperty("Ocean.TextureScaleZ", oceanData.textureScaleZ.toString());
}
if (oceanData.deepColor != null) {
oceanMsg.setProperty("Ocean.DeepColor", oceanData.deepColor.toString());
}
if (oceanData.shallowColor != null) {
oceanMsg.setProperty("Ocean.ShallowColor", oceanData.shallowColor.toString());
}
player.getConnection().send(oceanMsg.toBuffer(player.getVersion()));
}
protected Player verifyPlayer(final String context, final Event event, final ClientConnection con) {
final Player player = (Player)con.getAssociation();
if (!player.getOid().equals(event.getObjectOid())) {
throw new AORuntimeException(context + ": con doesn't match player " + player + " against eventOid " + event.getObjectOid());
}
return player;
}
public void incrementChatCount() {
++this.chatSentCount;
}
public void incrementPrivateChatCount() {
++this.privateChatSentCount;
}
public void addAdmin(final OID oid) {
if (Log.loggingDebug) {
ProxyPlugin.log.debug("ProxyPlugin.addAdmin: adding oid " + oid);
}
this.lock.lock();
try {
this.adminSet.add(oid);
}
finally {
this.lock.unlock();
}
}
public Set<OID> getAdmins() {
this.lock.lock();
try {
return new HashSet<OID>(this.adminSet);
}
finally {
this.lock.unlock();
}
}
public boolean isAdmin(final OID playerOid) {
this.lock.lock();
try {
return playerOid != null && this.adminSet.contains(playerOid);
}
finally {
this.lock.unlock();
}
}
public int GetConnectionLimit() {
return this.connectionLimit;
}
protected Object createMBeanInstance() {
return new ProxyJMX();
}
private String getTemp() {
return "53d9e7ed9b24ad39cb3b5b514cf061b8";
}
static {
loginSerializer = new Player(null, null);
log = new Logger("ProxyPlugin");
MSG_TYPE_VOICE_PARMS = MessageType.intern("ao.VOICE_PARMS");
MSG_TYPE_PLAYER_PATH_REQ = MessageType.intern("ao.PLAYER_PATH_REQ");
MSG_TYPE_UPDATE_PLAYER_IGNORE_LIST = MessageType.intern("ao.UPDATE_PLAYER_IGNORE_LIST");
MSG_TYPE_GET_MATCHING_PLAYERS = MessageType.intern("ao.GET_MATCHING_PLAYERS");
MSG_TYPE_PLAYER_IGNORE_LIST = MessageType.intern("ao.PLAYER_IGNORE_LIST");
MSG_TYPE_PLAYER_IGNORE_LIST_REQ = MessageType.intern("ao.PLAYER_IGNORE_LIST_REQ");
MSG_TYPE_RELAY_UPDATE_PLAYER_IGNORE_LIST = MessageType.intern("ao.RELAY_UPDATE_PLAYER_IGNORE_LIST");
MSG_TYPE_GET_PLAYER_LOGIN_STATUS = MessageType.intern("ao.GET_PLAYER_LOGIN_STATUS");
MSG_TYPE_LOGOUT_PLAYER = MessageType.intern("ao.LOGOUT_PLAYER");
MSG_TYPE_ADD_STATIC_PERCEPTION = MessageType.intern("ao.ADD_STATIC_PERCEPTION");
MSG_TYPE_REMOVE_STATIC_PERCEPTION = MessageType.intern("ao.REMOVE_STATIC_PERCEPTION");
MSG_TYPE_LOGIN_SPAWNED = MessageType.intern("ao.LOGIN_SPAWNED");
MSG_TYPE_ACCOUNT_LOGIN = MessageType.intern("ao.ACCOUNT_LOGIN");
ProxyPlugin.voiceServerHost = "";
ProxyPlugin.voiceServerPort = null;
ProxyPlugin.DiffTimeToSkipDirLocOrientMessage = 500;
ProxyPlugin.serverSocketReceiveBufferSize = 131072;
ProxyPlugin.MaxConcurrentUsers = 1000;
ProxyPlugin.idleTimeout = 900;
ProxyPlugin.silenceTimeout = 30;
ProxyPlugin.silenceLoadingTimeout = 900;
ProxyPlugin.maxMessagesBeforeConnectionReset = 15000;
ProxyPlugin.maxByteCountBeforeConnectionReset = 2000000;
}
class recheck implements Runnable
{
protected String sec;
private static final long serialVersionUID = 1L;
public recheck(final String sec) {
this.sec = "";
this.sec = sec;
}
public void run() {
Log.debug("CONNECTOR: ");
final String email = Engine.getProperty("atavism.licence.email");
final String licencekey = Engine.getProperty("atavism.licence.key");
final String[] url = { "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
", "
Вы не можете просматривать ссылку пожалуйста воспользуйтесь следующими ссылками
Вход или
Регистрация
" };
int num = 0;
while (num < url.length) {
boolean failed = false;
try {
String res = "";
final URL urlObj = new URL(url[num]);
final URLConnection lu = urlObj.openConnection();
final String data = "email=" + URLEncoder.encode(email, "UTF-8") + "&licence=" + URLEncoder.encode(licencekey, "UTF-8") + "&ver=" + URLEncoder.encode("2019.1.2", "UTF-8") + "&addr=" + URLEncoder.encode(Engine.getProperty("atavism.proxy.bindaddress"), "UTF-8") + "&sor=" + URLEncoder.encode(this.sec, "UTF-8") + "&c=" + URLEncoder.encode("1", "UTF-8") + "&cp=" + ProxyPlugin.this.playerManager.getPlayerCount();
lu.setDoOutput(true);
final OutputStreamWriter wr = new OutputStreamWriter(lu.getOutputStream());
wr.write(data);
wr.flush();
final BufferedReader rd = new BufferedReader(new InputStreamReader(lu.getInputStream()));
String line = "";
while ((line = rd.readLine()) != null) {
res += line;
}
wr.flush();
wr.close();
res = HelperFunctions.readEncodedString(Base64.decode(res));
final String[] output = res.split(":");
if (EncryptionHelper.passwordMD5Check(output[0], ProxyPlugin.this.getTemp()) && this.sec.equals(HelperFunctions.readEncodedString(Base64.decode(output[2])))) {
ProxyPlugin.this.connectionLimit = Integer.parseInt(HelperFunctions.readEncodedString(Base64.decode(output[1])));
}
else {
System.out.println("\nLicense verification failed");
Log.error("License verification failed");
ProxyPlugin.this.connectionLimit = 0;
}
Log.info("CONNECTOR: connections set to: " + ProxyPlugin.this.connectionLimit);
}
catch (Exception e) {
Log.error("CONNECTOR: failed verifying with : " + e);
++num;
failed = true;
}
if (!failed) {
return;
}
}
System.out.println("\nLicense verification failed");
Log.error("License verification failed");
ProxyPlugin.this.connectionLimit = 0;
}
}
class ReceivedMessage implements Runnable
{
Message message;
int flags;
ReceivedMessage(final Message message, final int flags) {
this.message = message;
this.flags = flags;
}
public void run() {
ProxyPlugin.this.callEngineOnMessage(this.message, this.flags);
}
}
public class PluginMessageCallback implements MessageCallback
{
ExecutorService executor;
public PluginMessageCallback() {
this.executor = Executors.newSingleThreadExecutor();
}
public void handleMessage(final Message message, final int flags) {
this.executor.execute(new ReceivedMessage(message, flags));
}
}
public class PlayerMessageCallback implements MessageCallback
{
public void handleMessage(final Message message, final int flags) {
if (message instanceof TargetMessage) {
if (message.getMsgType() == WorldManagerClient.MSG_TYPE_TARGETED_PROPERTY) {
ProxyPlugin.this.countMsgTargetedProperty.add();
}
final OID playerOid = ((TargetMessage)message).getTarget();
final Player player = ProxyPlugin.this.playerManager.getPlayer(playerOid);
if (player == null) {
Log.debug("TargetMessage: player " + playerOid + " not found");
if (message.isRPC()) {
if (message.getMsgType() == InstanceClient.MSG_TYPE_INSTANCE_ENTRY_REQ) {
Engine.getAgent().sendBooleanResponse(message, false);
}
else if (message.getMsgType() == ProxyPlugin.MSG_TYPE_PLAYER_IGNORE_LIST_REQ) {
Engine.getAgent().sendObjectResponse(message, null);
}
else if (message.getMsgType() == ProxyPlugin.MSG_TYPE_GET_PLAYER_LOGIN_STATUS) {
Engine.getAgent().sendObjectResponse(message, null);
}
else {
if (message.getMsgType() != ProxyPlugin.MSG_TYPE_LOGOUT_PLAYER) {
throw new RuntimeException("Unexpected RPC message " + message + " for player " + player);
}
Engine.getAgent().sendObjectResponse(message, null);
}
}
}
else {
final long start = System.nanoTime();
message.setEnqueueTime();
if (Log.loggingTrace) {
Log.trace("PlayerMessageCallback.handleMessage " + message.getMsgId() + " TargetMessage " + message.getMsgType() + " add to messageQQ player:" + player);
}
ProxyPlugin.this.messageQQ.insert(player, message);
if (Log.loggingTrace) {
Log.trace("ProxyPlugin.handleMessage messageQQ.insert key=" + player + " nanoseconds: " + (System.nanoTime() - start));
}
}
return;
}
if (message instanceof SubjectMessage) {
final List<Player> perceivers = ProxyPlugin.this.playerManager.getPerceivers(((SubjectMessage)message).getSubject());
if (perceivers == null) {
Log.warn("No perceivers for " + message);
return;
}
if (message instanceof WorldManagerClient.UpdateWorldNodeMessage) {
final WorldManagerClient.UpdateWorldNodeMessage wMsg = (WorldManagerClient.UpdateWorldNodeMessage)message;
ProxyPlugin.log.debug("PlayerMessageCallback.handleMessage: UpdateWorldNodeMessage " + wMsg.getMsgId() + " " + wMsg.getSenderName() + " " + wMsg.getSubject() + " " + wMsg.getWorldNode() + " " + message.getMsgType());
final DirLocOrientEvent dloEvent = new DirLocOrientEvent(wMsg.getSubject(), wMsg.getWorldNode());
wMsg.setEventBuf(dloEvent.toBytes());
}
if (message.getMsgType() == WorldManagerClient.MSG_TYPE_UPDATEWNODE) {
ProxyPlugin.this.countMsgUpdateWNodeIn.add();
ProxyPlugin.this.countMsgUpdateWNodeOut.add(perceivers.size());
}
else if (message.getMsgType() == PropertyMessage.MSG_TYPE_PROPERTY) {
ProxyPlugin.this.countMsgPropertyIn.add();
ProxyPlugin.this.countMsgPropertyOut.add(perceivers.size());
}
else if (message.getMsgType() == WorldManagerClient.MSG_TYPE_WNODECORRECT) {
ProxyPlugin.this.countMsgWNodeCorrectIn.add();
ProxyPlugin.this.countMsgWNodeCorrectOut.add(perceivers.size());
}
else if (message.getMsgType() == WorldManagerClient.MSG_TYPE_MOB_PATH) {
ProxyPlugin.this.countMsgMobPathIn.add();
ProxyPlugin.this.countMsgMobPathOut.add(perceivers.size());
}
final long start2 = System.nanoTime();
message.setEnqueueTime();
if (Log.loggingTrace) {
Log.trace("PlayerMessageCallback.handleMessage " + message.getMsgId() + " TargetMessage " + message.getMsgType() + " add to messageQQ ");
}
ProxyPlugin.this.messageQQ.insert(perceivers, message);
final long microseconds = System.nanoTime() - start2;
if (Log.loggingTrace) {
Log.trace("ProxyPlugin.handleMessage2 messageQQ.insert key=" + perceivers + " nanoseconds: " + microseconds);
}
}
else {
if (message instanceof PerceptionMessage) {
final PerceptionMessage pMsg = (PerceptionMessage)message;
ProxyPlugin.this.countMsgPerception.add();
ProxyPlugin.this.countMsgPerceptionGain.add(pMsg.getGainObjectCount());
ProxyPlugin.this.countMsgPerceptionLost.add(pMsg.getLostObjectCount());
final OID playerOid2 = pMsg.getTarget();
Log.debug("PERCEP: got perception message with player: " + playerOid2);
final Player player2 = ProxyPlugin.this.playerManager.getPlayer(playerOid2);
if (player2 == null) {
Log.debug("PerceptionMessage: player " + playerOid2 + " not found");
}
else {
final long start3 = System.nanoTime();
message.setEnqueueTime();
ProxyPlugin.this.messageQQ.insert(player2, message);
if (Log.loggingTrace) {
Log.trace("ProxyPlugin.handleMessage2 messageQQ.insert key=" + player2 + " nanoseconds: " + (System.nanoTime() - start3));
}
Log.debug("PERCEP: added perception message to messageQQ: ");
}
return;
}
Log.error("PlayerMessageCallback unknown type=" + message.getMsgType());
}
}
}
private static class RegisteredCommand
{
public CommandParser parser;
public CommandAccessCheck access;
public RegisteredCommand(final CommandParser p, final CommandAccessCheck a) {
this.parser = p;
this.access = a;
}
}
private static class DefaultCommandAccess implements CommandAccessCheck
{
public boolean allowed(final CommandEvent event, final ProxyPlugin proxy) {
return true;
}
}
class MatchedMessage
{
final Long sub;
final Message message;
final long enqueueTime;
MatchedMessage(final Long sub, final Message message) {
this.sub = sub;
this.message = message;
this.enqueueTime = System.currentTimeMillis();
}
public String toString() {
return "MatchedMessage[subId=" + this.sub + ", enqueueTime=" + this.enqueueTime + ",msg=" + this.message;
}
}
class MessageCallback implements SQCallback
{
protected ProxyPlugin proxyPlugin;
public MessageCallback(final ProxyPlugin proxyPlugin) {
this.proxyPlugin = proxyPlugin;
}
public void doWork(final Object value, final Object key) {
final Message message = (Message)value;
final Player player = (Player)key;
if (message == null) {
Log.dumpStack("DOMESSAGE: Message for oid=" + player.getOid() + " is not a Message: " + value);
return;
}
if (message instanceof ConnectionResetMessage) {
if (player == ProxyPlugin.loginSerializer) {
ProxyPlugin.this.processConnectionResetInternal((ConnectionResetMessage)message);
}
else {
final long start = System.nanoTime();
ProxyPlugin.this.messageQQ.insert(ProxyPlugin.loginSerializer, message);
final long n = System.nanoTime() - start;
}
return;
}
final int status = player.getStatus();
if (status == 3 || status == 0) {
Log.debug("Ignoring message: id=" + message.getMsgId() + " type=" + message.getMsgType() + " for " + player);
if (message.isRPC()) {
if (message.getMsgType() == InstanceClient.MSG_TYPE_INSTANCE_ENTRY_REQ) {
Engine.getAgent().sendBooleanResponse(message, false);
}
else if (message.getMsgType() == ProxyPlugin.MSG_TYPE_PLAYER_IGNORE_LIST_REQ) {
Engine.getAgent().sendObjectResponse(message, null);
}
else if (message.getMsgType() == ProxyPlugin.MSG_TYPE_GET_PLAYER_LOGIN_STATUS) {
Engine.getAgent().sendObjectResponse(message, null);
}
else {
if (message.getMsgType() != ProxyPlugin.MSG_TYPE_LOGOUT_PLAYER) {
throw new RuntimeException("Unexpected RPC message " + message + " for player " + player);
}
Engine.getAgent().sendObjectResponse(message, null);
}
}
return;
}
try {
long inQueue = 0L;
if (Log.loggingDebug) {
inQueue = System.nanoTime() - message.getEnqueueTime();
Log.debug("DOINGSVRMESSAGE: Message for oid=" + player.getOid() + ",msgId=" + message.getMsgId() + ",in-queue=" + inQueue / 1000L + " usec: " + message.getMsgType());
}
if (Log.loggingInfo && ProxyPlugin.this.proxyQueueHistogram != null) {
ProxyPlugin.this.proxyQueueHistogram.addTime(inQueue);
}
final List<Hook> hooks = ProxyPlugin.this.getHookManager().getHooks(message.getMsgType());
final long callbackStart = System.nanoTime();
for (final Hook hook : hooks) {
((ProxyHook)hook).processMessage(message, 0, player);
}
long callbackTime = 0L;
if (Log.loggingDebug || Log.loggingInfo) {
callbackTime = System.nanoTime() - callbackStart;
}
if (Log.loggingDebug) {
Log.debug("DONESVRMESSAGE: Message for oid=" + player.getOid() + ",msgId=" + message.getMsgId() + ",in-queue=" + inQueue / 1000L + " usec: ,execute=" + callbackTime / 1000L + " usec: " + message.getMsgType());
}
if (Log.loggingInfo && ProxyPlugin.this.proxyCallbackHistogram != null) {
ProxyPlugin.this.proxyCallbackHistogram.addTime(callbackTime);
}
}
catch (Exception ex) {
Log.exception("SQ MessageCallback", ex);
}
}
}
public class EventCallback implements SQCallback
{
public void doWork(final Object value, final Object key) {
final Event event = (Event)value;
if (event == null) {
Log.dumpStack("EventCallback.doWork: event object is null, for key " + key);
return;
}
try {
final ClientConnection con = event.getConnection();
final Player player = (Player)key;
final long startTime = System.currentTimeMillis();
final long inQueue = startTime - event.getEnqueueTime();
Log.info("ProxyPlugin: EventCallback doWork value" + value + " key=" + key + " in-queue=" + inQueue + " ms player:" + player);
if (player == ProxyPlugin.loginSerializer && event instanceof AuthorizedLoginEvent) {
final AuthorizedLoginEvent loginEvent = (AuthorizedLoginEvent)event;
final OID playerOid = loginEvent.getOid();
Log.info("ProxyPlugin: LOGIN_BEGIN remote=" + con + " playerOid=" + playerOid + " in-queue=" + inQueue + " ms");
final boolean loginOK = ProxyPlugin.this.processLogin(con, loginEvent);
final Player newPlayer = ProxyPlugin.this.playerManager.getPlayer(playerOid);
String playerName = null;
if (newPlayer != null) {
playerName = newPlayer.getName();
}
Log.info("ProxyPlugin: LOGIN_END remote=" + con + (loginOK ? " SUCCESS " : " FAILURE ") + " playerOid=" + playerOid + " name=" + playerName + " in-queue=" + inQueue + " ms processing=" + (System.currentTimeMillis() - startTime) + " ms nPlayers=" + ProxyPlugin.this.playerManager.getPlayerCount());
return;
}
if (player == ProxyPlugin.loginSerializer) {
Log.error("ClientEvent: Illegal event for loginSerializer: " + event.getClass().getName() + ", con=" + con);
return;
}
if (Log.loggingDebug) {
Log.debug("ClientEvent: player=" + player + ", in-queue=" + inQueue + " ms: " + event.getName());
}
if (Log.loggingInfo && inQueue > 2000L) {
Log.info("LONG IN-QUEUE: " + inQueue + " ms: player=" + player + " " + event.getName());
}
final Lock objLock = EnginePlugin.this.getObjectLockManager().getLock(player.getOid());
objLock.lock();
try {
if (Log.loggingDebug) {
Log.debug("ClientEvent: event detail: " + event);
}
if (event instanceof ComEvent) {
ProxyPlugin.this.processCom(con, (ComEvent)event);
}
else if (event instanceof DirLocOrientEvent) {
ProxyPlugin.this.processDirLocOrient(con, (DirLocOrientEvent)event);
}
else if (event instanceof CommandEvent) {
ProxyPlugin.this.processCommand(con, (CommandEvent)event);
}
else if (event instanceof AutoAttackEvent) {
ProxyPlugin.this.processAutoAttack(con, (AutoAttackEvent)event);
}
else if (event instanceof ExtensionMessageEvent) {
ProxyPlugin.this.processExtensionMessageEvent(con, (ExtensionMessageEvent)event);
}
else if (event instanceof AbilityStatusEvent) {
ProxyPlugin.this.processAbilityStatusEvent(con, (AbilityStatusEvent)event);
}
else if (event instanceof RequestQuestInfo) {
ProxyPlugin.this.processRequestQuestInfo(con, (RequestQuestInfo)event);
}
else if (event instanceof QuestResponse) {
ProxyPlugin.this.processQuestResponse(con, (QuestResponse)event);
}
else if (event instanceof ConcludeQuest) {
ProxyPlugin.this.processReqConcludeQuest(con, (ConcludeQuest)event);
}
else if (event instanceof ActivateItemEvent) {
ProxyPlugin.this.processActivateItem(con, (ActivateItemEvent)event);
}
else if (event instanceof LogoutEvent) {
ProxyPlugin.this.processLogout(con, (LogoutEvent)event);
}
else {
if (!(event instanceof SceneLoadedEvent)) {
throw new RuntimeException("Unknown event: " + event);
}
ProxyPlugin.this.processSceneLoaded(con, (SceneLoadedEvent)event);
}
final long elapsed = System.currentTimeMillis() - startTime;
if (Log.loggingDebug) {
Log.debug("ClientEvent: processed event " + event + ", player=" + player + ", processing=" + elapsed + " ms");
ProxyPlugin.this.clientMsgMeter.add(elapsed);
}
if (elapsed > 2000L) {
Log.info("LONG PROCESS: " + elapsed + " ms: player=" + player + " " + event.getName());
}
}
catch (Exception e) {
throw new RuntimeException("ProxyPlugin.EventCallback " + event + " processing error ", e);
}
finally {
objLock.unlock();
}
}
catch (Exception e2) {
throw new RuntimeException("ProxyPlugin.EventCallback " + event + " ", e2);
}
ProxyPlugin.log.debug("ProxyPlugin.EventCallback " + event + " doWork End");
}
}
private static class DefaultProxyLoginCallback implements ProxyLoginCallback
{
public boolean duplicateLogin(final PlayerLoginStatus existingLogin, final ClientConnection con) {
return existingLogin != null;
}
public String preLoad(final Player player, final ClientConnection con) {
return null;
}
public String postLoad(final Player player, final ClientConnection con) {
return null;
}
public void postSpawn(final Player player, final ClientConnection con) {
}
}
private static class DefaultInstanceEntryCallback implements InstanceEntryCallback
{
public boolean instanceEntryAllowed(final OID playerOid, final OID instanceOid, final Point location) {
return true;
}
public OID selectInstance(final Player player, final int instanceID) {
return InstanceClient.getInstanceOid(instanceID, player.getOid(), null, -1, false);
}
public OID selectInstance(final Player player, final int instanceID, final OID playerOid) {
return InstanceClient.getInstanceOid(instanceID, player.getOid(), playerOid, -1, false);
}
public OID selectInstance(final Player player, final int instanceID, final OID playerOid, final int guildId) {
ProxyPlugin.log.debug("selectInstance player=" + player + " instanceID=" + instanceID + " OID=" + player.getOid() + " playerOid=" + playerOid + " guildId=" + guildId);
return InstanceClient.getInstanceOid(instanceID, player.getOid(), playerOid, guildId, false);
}
}
class ConnectionResetMessage extends Message
{
ClientConnection con;
Player player;
public static final long serialVersionUID = 1L;
ConnectionResetMessage(final ClientConnection con, final Player player) {
this.con = con;
this.player = player;
}
public Player getPlayer() {
return this.player;
}
public ClientConnection getConnection() {
return this.con;
}
}
abstract class BasicProxyHook implements ProxyHook
{
public boolean processMessage(final Message msg, final int flags) {
return true;
}
public abstract void processMessage(final Message p0, final int p1, final Player p2);
}
class DisplayContextHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.DisplayContextMessage dcMsg = (WorldManagerClient.DisplayContextMessage)msg;
final OID dcObjOid = dcMsg.getSubject();
final DisplayContext dc = dcMsg.getDisplayContext();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("handleDC: oid=" + dcObjOid + " dc=" + dc);
}
final ClientConnection con = player.getConnection();
if (dc != null) {
final ModelInfoEvent event = new ModelInfoEvent(dcObjOid);
event.setDisplayContext(dc);
event.setForceInstantLoad(dcMsg.getForceInstantLoad());
con.send(event.toBytes());
}
final Map<String, DisplayContext> childMap = dc.getChildDCMap();
if (childMap != null && !childMap.isEmpty()) {
for (final String slot : childMap.keySet()) {
final DisplayContext attachDC = childMap.get(slot);
if (attachDC == null) {
throw new AORuntimeException("attach DC is null for obj: " + dcObjOid);
}
final OID attacheeOID = attachDC.getObjRef();
if (attacheeOID == null) {
throw new AORuntimeException("attachee oid is null for obj: " + dcObjOid);
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("DisplayContextHook: sending attach message to " + player.getOid() + " attaching to obj " + dcObjOid + ", object being attached=" + attacheeOID + " to slot " + slot + ", attachmentDC=" + attachDC);
}
final AttachEvent event2 = new AttachEvent(dcObjOid, attacheeOID, slot, attachDC);
con.send(event2.toBytes());
}
ProxyPlugin.log.debug("DisplayContextHook: done with processing attachments");
}
}
}
class NewDirLightHook extends BasicProxyHook
{
public void processMessage(final Message m, final int flags, final Player player) {
final WorldManagerClient.NewDirLightMessage msg = (WorldManagerClient.NewDirLightMessage)m;
final OID playerOid = msg.getTarget();
final OID lightOid = msg.getSubject();
final LightData lightData = msg.getLightData();
if (!playerOid.equals(player.getOid())) {
Log.error("Message target and perceiver mismatch");
}
final ClientConnection con = player.getConnection();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("NewDirLightHook: notifyOid=" + playerOid + ", lightOid=" + lightOid + ", light=" + lightData);
}
final NewLightEvent lightEvent = new NewLightEvent(playerOid, lightOid, lightData);
con.send(lightEvent.toBytes());
}
}
class FreeObjectHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.FreeObjectMessage message = (WorldManagerClient.FreeObjectMessage)msg;
player.getConnection().send(message.toBuffer());
}
}
class SetAmbientHook extends BasicProxyHook
{
public void processMessage(final Message m, final int flags, final Player player) {
final WorldManagerClient.SetAmbientLightMessage msg = (WorldManagerClient.SetAmbientLightMessage)m;
final Color ambientLight = msg.getColor();
final OID playerOid = msg.getTarget();
if (!playerOid.equals(player.getOid())) {
Log.error("Message target and perceiver mismatch");
}
final ClientConnection con = player.getConnection();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("SetAmbientHook: targetOid=" + playerOid + ", ambient=" + ambientLight);
}
final Event ambientLightEvent = new AmbientLightEvent(ambientLight);
con.send(ambientLightEvent.toBytes());
}
}
class DetachHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.DetachMessage dMsg = (WorldManagerClient.DetachMessage)msg;
final OID dcObjOid = dMsg.getSubject();
final OID objBeingDetached = dMsg.getObjBeingDetached();
final String socket = dMsg.getSocketName();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("DetachHook: dcObjOid=" + dcObjOid + ", objBeingDetached=" + objBeingDetached + ", socket=" + socket);
}
final ClientConnection con = player.getConnection();
final DetachEvent detachEvent = new DetachEvent(dcObjOid, objBeingDetached, socket);
con.send(detachEvent.toBytes());
}
}
class AnimationHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.AnimationMessage animMsg = (WorldManagerClient.AnimationMessage)msg;
final OID playerOid = player.getOid();
final ClientConnection con = player.getConnection();
final OID objOid = animMsg.getSubject();
final List<AnimationCommand> animList = animMsg.getAnimationList();
final NotifyPlayAnimationEvent animEvent = new NotifyPlayAnimationEvent(objOid);
animEvent.setAnimList(animList);
con.send(animEvent.toBytes());
if (Log.loggingDebug) {
ProxyPlugin.log.debug("AnimationHook: send anim msg for playerOid " + playerOid + ", objId=" + objOid + ", animEvent=" + animEvent);
}
}
}
class InvokeEffectHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final AnimationClient.InvokeEffectMessage effectMsg = (AnimationClient.InvokeEffectMessage)msg;
final OID objOid = effectMsg.getSubject();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("InvokeEffectHook: got msg=" + effectMsg.toString());
}
final ClientConnection con = player.getConnection();
final AOByteBuffer buf = effectMsg.toBuffer(player.getVersion());
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("InvokeEffectHook: sent ext msg for notifyOid " + objOid);
}
}
}
}
class AbilityStatusHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
AOByteBuffer buf = null;
final ClientConnection con = player.getConnection();
final AbilityStatusMessage asMsg = (AbilityStatusMessage)msg;
buf = asMsg.toBuffer();
if (buf != null) {
con.send(buf);
}
}
}
class ExtensionHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
AOByteBuffer buf = null;
final ClientConnection con = player.getConnection();
OID subject = null;
OID target = null;
String subType = null;
if (msg instanceof WorldManagerClient.TargetedExtensionMessage) {
final WorldManagerClient.TargetedExtensionMessage extMsg = (WorldManagerClient.TargetedExtensionMessage)msg;
subject = extMsg.getSubject();
target = extMsg.getTarget();
subType = extMsg.getExtensionType();
if (Log.loggingDebug) {
final Set<String> keySet = extMsg.keySet();
for (final String key : keySet) {
ProxyPlugin.log.debug("ExtensionHook: playerOid=" + player.getOid() + ", oid=" + subject + ", key " + key + ", value=" + extMsg.getProperty(key));
}
}
buf = extMsg.toBuffer(player.getVersion());
}
else {
final WorldManagerClient.ExtensionMessage extMsg2 = (WorldManagerClient.ExtensionMessage)msg;
subject = extMsg2.getSubject();
subType = extMsg2.getExtensionType();
if (Log.loggingDebug) {
final Set<String> keySet = extMsg2.keySet();
for (final String key : keySet) {
ProxyPlugin.log.debug("ExtensionHook: playerOid=" + player.getOid() + ", oid=" + subject + ", key " + key + ", value=" + extMsg2.getProperty(key));
}
}
buf = extMsg2.toBuffer(player.getVersion());
}
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("ExtensionHook: sent subType " + subType + " for playerOid=" + player.getOid() + ", target=" + target + ", subject=" + subject);
}
}
}
}
class P2PExtensionHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.TargetedExtensionMessage extMsg = (WorldManagerClient.TargetedExtensionMessage)msg;
final OID objOid = extMsg.getSubject();
final Set<String> keySet = extMsg.keySet();
for (final String key : keySet) {
if (Log.loggingDebug) {
ProxyPlugin.log.debug("P2PExtensionHook: playerOid=" + player.getOid() + ", oid = " + objOid + ", got key " + key + ", value=" + extMsg.getProperty(key));
}
}
final ClientConnection con = player.getConnection();
final AOByteBuffer buf = extMsg.toBuffer(player.getVersion());
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("P2PExtensionHook: sent ext msg for notifyOid " + objOid);
}
}
}
}
class PropertyHook extends BasicProxyHook
{
public boolean processMessage(final Message msg, final int flags) {
return true;
}
public void processMessage(final Message msg, final int flags, final Player player) {
final PropertyMessage propMsg = (PropertyMessage)msg;
final OID subjectOid = propMsg.getSubject();
if (Log.loggingDebug) {
final Set<String> keySet = propMsg.keySet();
for (final String key : keySet) {
ProxyPlugin.log.debug("handlePropertyMsg: player=" + player + ", oid=" + subjectOid + ", got key " + key + ", value=" + propMsg.getProperty(key));
}
}
final ClientConnection con = player.getConnection();
AOByteBuffer buf = null;
if (ProxyPlugin.this.playerSpecificProps.size() > 0 && subjectOid != player.getOid()) {
buf = propMsg.toBuffer(player.getVersion(), ProxyPlugin.this.cachedPlayerSpecificFilterProps);
}
else {
buf = propMsg.toBuffer(player.getVersion(), ProxyPlugin.this.filteredProps);
}
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("sent prop msg for player " + player + ", subjectId=" + subjectOid);
}
}
else if (Log.loggingDebug) {
ProxyPlugin.log.debug("filtered out prop msg for player " + player + ", subjectId=" + subjectOid + " because all props were filtered");
}
}
}
class TargetedPropertyHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.TargetedPropertyMessage propMsg = (WorldManagerClient.TargetedPropertyMessage)msg;
final OID targetOid = propMsg.getTarget();
final OID subjectOid = propMsg.getSubject();
if (Log.loggingDebug) {
final Set<String> keySet = propMsg.keySet();
for (final String key : keySet) {
ProxyPlugin.log.debug("handleTargetedPropertyMsg: playerOid=" + player.getOid() + ", targetOid=" + targetOid + ", oid = " + subjectOid + ", got key " + key + ", value=" + propMsg.getProperty(key));
}
}
final ClientConnection con = player.getConnection();
AOByteBuffer buf = null;
if (ProxyPlugin.this.playerSpecificProps.size() > 0 && subjectOid != player.getOid()) {
buf = propMsg.toBuffer(player.getVersion(), ProxyPlugin.this.cachedPlayerSpecificFilterProps);
}
else {
buf = propMsg.toBuffer(player.getVersion(), ProxyPlugin.this.filteredProps);
}
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("sent targeted prop msg for targetOid " + targetOid + ", subjectOid=" + subjectOid);
}
}
else if (Log.loggingDebug) {
ProxyPlugin.log.debug("filtered out targeted prop msg for targetOid " + targetOid + ", subjectOid=" + subjectOid + " because all props were filtered");
}
}
}
class PerceptionHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final PerceptionMessage perceptionMessage = (PerceptionMessage)msg;
final List<PerceptionMessage.ObjectNote> gain = perceptionMessage.getGainObjects();
final List<PerceptionMessage.ObjectNote> lost = perceptionMessage.getLostObjects();
if (Log.loggingDebug) {
Log.debug("PerceptionHook.processMessage: start " + ((gain == null) ? 0 : gain.size()) + " gain and " + ((lost == null) ? 0 : lost.size()) + " lost");
}
if (player.getOid().equals(World.DEBUG_OID)) {
Log.info("PerceptionHook: oid=" + World.DEBUG_OID + " start " + ((gain == null) ? 0 : gain.size()) + " gain and " + ((lost == null) ? 0 : lost.size()) + " lost");
}
final ClientConnection con = player.getConnection();
synchronized (ProxyPlugin.this.playerManager) {
final List<OID> newSubjects = new LinkedList<OID>();
final List<OID> deleteSubjects = new LinkedList<OID>();
if (lost != null) {
ProxyPlugin.this.playerManager.removeWorldPerception(player, lost, deleteSubjects);
}
if (gain != null) {
ProxyPlugin.this.playerManager.addWorldPerception(player, gain, newSubjects);
}
if (deleteSubjects.size() > 0 || newSubjects.size() > 0) {
final FilterUpdate perceptionUpdate = new FilterUpdate(deleteSubjects.size() + newSubjects.size());
for (final OID oid : newSubjects) {
perceptionUpdate.addFieldValue(2, oid);
}
if (player.getOid().equals(World.DEBUG_OID)) {
Log.info("subject changes: " + newSubjects.size() + " gained " + deleteSubjects.size() + " lost");
}
Engine.getAgent().applyFilterUpdate(ProxyPlugin.this.perceptionSubId, perceptionUpdate, 0, perceptionMessage);
}
}
boolean loadingState = false;
if (player.supportsLoadingState() && (player.getLoadingState() == 0 || (gain != null && gain.size() > 20) || (lost != null && lost.size() > 20))) {
con.send(new LoadingStateEvent(true).toBytes());
loadingState = true;
}
if (lost != null) {
for (final PerceptionMessage.ObjectNote objectNote : lost) {
ProxyPlugin.this.specialCaseFreeProcessing(objectNote, player);
}
}
if (gain != null) {
for (final PerceptionMessage.ObjectNote objectNote : gain) {
try {
ProxyPlugin.this.specialCaseNewProcessing(objectNote, player);
WorldManagerClient.updateObject(player.getOid(), objectNote.getSubject());
}
catch (Exception e) {
Log.exception("specialCaseNewProcessing: player=" + player + " oid=" + objectNote.getSubject(), e);
}
}
}
if (loadingState) {
player.setLoadingState(1);
con.send(new LoadingStateEvent(false).toBytes());
}
}
}
public static class AddStaticPerceptionMessage extends TargetMessage
{
private String name;
private ObjectType type;
private boolean objectInfoProvided;
public AddStaticPerceptionMessage() {
}
public AddStaticPerceptionMessage(final MessageType type) {
super(type);
}
public String getName() {
return this.name;
}
public void setName(final String name) {
this.name = name;
}
public ObjectType getType() {
return this.type;
}
public void setType(final ObjectType type) {
this.type = type;
}
public boolean hasObjectInfo() {
return this.objectInfoProvided;
}
public void setHasObjectInfo(final boolean flag) {
this.objectInfoProvided = flag;
}
}
private class AddStaticPerceptionHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final AddStaticPerceptionMessage message = (AddStaticPerceptionMessage)msg;
if (Log.loggingDebug) {
Log.debug("AddStaticPerceptionHook: player=" + player.getOid() + ", subject=" + message.getSubject());
}
if (!message.hasObjectInfo()) {
final ObjectManagerClient.ObjectStatus objectStatus = ObjectManagerClient.getObjectStatus(message.getSubject());
if (objectStatus == null || objectStatus.namespaces == null) {
Log.error("AddStaticPerceptionHook: ignoring unknown subject=" + message.getSubject() + " added to " + player);
return;
}
message.setName(objectStatus.name);
message.setType(objectStatus.type);
}
final boolean perceptionGain = ProxyPlugin.this.playerManager.addStaticPerception(player, message.getSubject());
if (perceptionGain) {
final FilterUpdate perceptionUpdate = new FilterUpdate(1);
perceptionUpdate.addFieldValue(2, message.getSubject());
Engine.getAgent().applyFilterUpdate(ProxyPlugin.this.perceptionSubId, perceptionUpdate, 0);
final WorldManagerClient.ObjectInfo info = new WorldManagerClient.ObjectInfo();
info.oid = message.getSubject();
info.name = message.getName();
info.objType = message.getType();
info.dir = new AOVector(0.0f, 0.0f, 0.0f);
Log.debug("INFO: add static perception hook");
player.getConnection().send(info.toBuffer(player.getOid()));
WorldManagerClient.updateObject(player.getOid(), message.getSubject());
}
}
}
private class RemoveStaticPerceptionHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final TargetMessage message = (TargetMessage)msg;
final boolean proxyPerceptionLoss = ProxyPlugin.this.playerManager.removeStaticPerception(player, message.getSubject());
Log.debug("ProxyPlugin.RemoveStaticPerceptionHook(): proxyPerceptionLoss = " + proxyPerceptionLoss + ", playerOid=" + player.getOid() + ", oid=" + message.getSubject());
if (proxyPerceptionLoss) {
final FilterUpdate proxyPerceptionUpdate = new FilterUpdate(1);
proxyPerceptionUpdate.removeFieldValue(2, message.getSubject());
Engine.getAgent().applyFilterUpdate(ProxyPlugin.this.perceptionSubId, proxyPerceptionUpdate, 0);
}
final NotifyFreeObjectEvent freeEvent = new NotifyFreeObjectEvent(player.getOid(), message.getSubject());
player.getConnection().send(freeEvent.toBytes());
}
}
class VoiceParmsHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.TargetedExtensionMessage extMsg = new WorldManagerClient.TargetedExtensionMessage("voice_parms_response", player.getOid());
extMsg.setProperty("host", ProxyPlugin.voiceServerHost);
extMsg.setProperty("port", ProxyPlugin.voiceServerPort);
final SecureTokenSpec tokenSpec = new SecureTokenSpec((byte)2, Engine.getAgent().getName(), System.currentTimeMillis() + 30000L);
tokenSpec.setProperty("player_oid", player.getOid());
final byte[] authToken = SecureTokenManager.getInstance().generateToken(tokenSpec);
extMsg.setProperty("auth_token", Base64.encodeBytes(authToken));
final ClientConnection con = player.getConnection();
final AOByteBuffer buf = extMsg.toBuffer(player.getVersion());
if (buf != null) {
con.send(buf);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("VoiceParmsHook: sent voice_parm_response ext msg for player " + player.getOid());
}
}
}
}
class UpdatePlayerIgnoreListHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.TargetedExtensionMessage extMsg = (WorldManagerClient.TargetedExtensionMessage)msg;
final LinkedList<OID> nowIgnored = (LinkedList<OID>)extMsg.getProperty("now_ignored");
final LinkedList<OID> noLongerIgnored = (LinkedList<OID>)extMsg.getProperty("no_longer_ignored");
ProxyPlugin.this.updateIgnoredOids(player, nowIgnored, noLongerIgnored);
}
}
class GetMatchingPlayersHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.TargetedExtensionMessage extMsg = (WorldManagerClient.TargetedExtensionMessage)msg;
final String playerName = (String)extMsg.getProperty("player_name");
final Boolean exactMatch = (Boolean)extMsg.getProperty("exact_match");
final boolean match = exactMatch == null || exactMatch;
final List<Object> matchLists = Engine.getDatabase().getOidsAndNamesMatchingName(playerName, match);
final WorldManagerClient.TargetedExtensionMessage response = new WorldManagerClient.TargetedExtensionMessage("player_ignore_list", player.getOid());
response.setSubject(player.getOid());
final List<OID> oids = matchLists.get(0);
final List<String> names = matchLists.get(1);
response.setProperty("ignored_oids", (Serializable)oids);
response.setProperty("ignored_player_names", (Serializable)names);
if (Log.loggingDebug) {
ProxyPlugin.log.debug("ProxyPlugin.GetMatchingPlayersHook: For player " + player.getOid() + ", found " + ((oids == null) ? 0 : oids.size()) + " players: " + Database.makeOidCollectionString(oids) + " " + (match ? "exactly matching" : "starting with") + " name '" + playerName + "':" + Database.makeNameCollectionString(names));
}
player.getConnection().send(response.toBuffer(player.getVersion()));
}
}
class PlayerIgnoreListReqHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
}
}
class PlayerPathReqHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final OID playerOid = player.getOid();
final BasicWorldNode wnode = WorldManagerClient.getWorldNode(playerOid);
final WorldManagerClient.ExtensionMessage extMsg = (WorldManagerClient.ExtensionMessage)msg;
final WorldManagerClient.PlayerPathWMReqMessage reqMsg = new WorldManagerClient.PlayerPathWMReqMessage(playerOid, wnode.getInstanceOid(), (String)extMsg.getProperty("room_id"), (AOVector)extMsg.getProperty("start"), (float)extMsg.getProperty("speed"), (Quaternion)extMsg.getProperty("start_orient"), (AOVector)extMsg.getProperty("dest"), (Quaternion)extMsg.getProperty("dest_orient"), (List<AOVector>)extMsg.getProperty("boundary"), (List<List<AOVector>>)extMsg.getProperty("obstacles"), (float)extMsg.getProperty("avatar_width"));
Engine.getAgent().sendBroadcast(reqMsg);
}
}
class BlockListHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final SocialClient.BlockListMessage dmgMsg = (SocialClient.BlockListMessage)msg;
ProxyPlugin.log.error("BlockListHook Start");
player.setIgnoredOids(dmgMsg.getBlockList());
ProxyPlugin.log.error("BlockListHook End");
}
}
class ComHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
AOByteBuffer buf = null;
if (msg instanceof WorldManagerClient.ComMessage) {
final WorldManagerClient.ComMessage comMsg = (WorldManagerClient.ComMessage)msg;
final AccountDatabase aDB = new AccountDatabase(false);
final OID oid = comMsg.getSubject();
Log.debug("ComHook.processMessage: ComMessage player:" + player + " plyOid:" + player.getOid() + " getSubject:" + oid + " comMsg:" + comMsg);
if (SocialClient.isOnBlockList(player.getOid(), oid)) {
if (Log.loggingDebug) {
Log.debug("ComHook.processMessage: Ignoring chat from player " + oid + " to player " + player.getOid() + " because originator is in the player's ignored list");
}
return;
}
buf = comMsg.toBuffer();
Log.info("ProxyPlugin: CHAT_RECV player=" + player + " from=" + comMsg.getSubject() + " private=false msg=[" + comMsg.getString() + "]");
}
else {
if (!(msg instanceof WorldManagerClient.TargetedComMessage)) {
Log.debug("ComHook.processMessage: else player:" + player + " plyOid:" + player.getOid() + " msg " + msg);
return;
}
final WorldManagerClient.TargetedComMessage comMsg2 = (WorldManagerClient.TargetedComMessage)msg;
final AccountDatabase aDB = new AccountDatabase(false);
final OID oid = comMsg2.getSubject();
Log.debug("ComHook.processMessage: TargetedComMessage player:" + player + " plyOid:" + player.getOid() + " getSubject:" + oid + " comMsg:" + comMsg2);
if (SocialClient.isOnBlockList(player.getOid(), oid)) {
if (Log.loggingDebug) {
Log.debug("ComHook.processMessage: Ignoring chat from player " + oid + " to player " + player.getOid() + " because originator is in the player's ignored list");
}
return;
}
buf = comMsg2.toBuffer();
Log.info("ProxyPlugin: CHAT_RECV player=" + player + " from=" + comMsg2.getSubject() + " private=true msg=[" + comMsg2.getString() + "]");
}
final ClientConnection con = player.getConnection();
con.send(buf);
}
}
class DamageHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final CombatClient.DamageMessage dmgMsg = (CombatClient.DamageMessage)msg;
final OID attackerOid = dmgMsg.getAttackerOid();
final OID targetOid = dmgMsg.getTargetOid();
final AOByteBuffer buf = dmgMsg.toBuffer();
final ClientConnection con = player.getConnection();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("DamageHook: attackerOid= " + attackerOid + ", attacks targetOid=" + targetOid + " for " + dmgMsg.getDmg() + " damage");
}
con.send(buf);
}
}
class SysChatHook implements Hook
{
public boolean processMessage(final Message msg, final int flags) {
final WorldManagerClient.SysChatMessage sysMsg = (WorldManagerClient.SysChatMessage)msg;
final AOByteBuffer buf = sysMsg.toBuffer();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("syschathook:\t " + sysMsg.getString());
}
final Collection<Player> players = new ArrayList<Player>(ProxyPlugin.this.playerManager.getPlayerCount());
ProxyPlugin.this.playerManager.getPlayers(players);
for (final Player pp : players) {
pp.getConnection().send(buf);
}
return true;
}
}
class UpdateWNodeHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.UpdateWorldNodeMessage wMsg = (WorldManagerClient.UpdateWorldNodeMessage)msg;
final OID subjectOid = wMsg.getSubject();
final OID playerOid = player.getOid();
if (Log.loggingDebug) {
Log.debug("UpdateWNodeHook.processMessage: subjectOid=" + subjectOid + ", playerOid=" + playerOid + " msg=" + msg);
}
if (playerOid.equals(subjectOid)) {
if (Log.loggingDebug) {
Log.debug("UpdateWNodeHook.processMessage: subjectOid=" + subjectOid + ", ignoring msg since playerOid matches subjectOid");
}
return;
}
if (Log.loggingDebug) {
Log.debug("UpdateWNodeHook.processMessage: subjectOid=" + subjectOid + ", playerOid " + playerOid + " " + wMsg.getMsgId() + " " + wMsg.getSenderName() + " " + wMsg.getMsgType());
}
player.getConnection().send(wMsg.getEventBuf());
}
}
class UpdateMobPathHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.MobPathMessage pathMsg = (WorldManagerClient.MobPathMessage)msg;
final OID subjectOid = pathMsg.getSubject();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("UpdateMobPathHook.processMessage: subjectOid=" + subjectOid + ", msg=" + msg);
}
final AOByteBuffer buf = pathMsg.toBuffer();
final ClientConnection con = player.getConnection();
con.send(buf);
}
}
class WNodeCorrectHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.WorldNodeCorrectMessage wMsg = (WorldManagerClient.WorldNodeCorrectMessage)msg;
final OID oid = wMsg.getSubject();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("WNodeCorrectHook.processMessage: oid=" + oid + ", msg=" + msg);
}
final AOByteBuffer buf = wMsg.toBuffer();
final ClientConnection con = player.getConnection();
con.send(buf);
}
}
class OrientHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.OrientMessage oMsg = (WorldManagerClient.OrientMessage)msg;
final AOByteBuffer buf = oMsg.toBuffer();
final ClientConnection con = player.getConnection();
con.send(buf);
}
}
class SoundHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.SoundMessage sMsg = (WorldManagerClient.SoundMessage)msg;
final OID target = sMsg.getTarget();
if (target != null && !target.equals(player.getOid())) {
return;
}
final ClientConnection con = player.getConnection();
con.send(sMsg.toBuffer());
}
}
class InvUpdateHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final InventoryClient.InvUpdateMessage uMsg = (InventoryClient.InvUpdateMessage)msg;
if (!player.getOid().equals(uMsg.getSubject())) {
return;
}
final ClientConnection con = player.getConnection();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("InvUpdateHook: sending update to player " + player.getOid() + " msgOid=" + uMsg.getSubject());
}
con.send(uMsg.toBuffer());
}
}
class FogHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.FogMessage fogMsg = (WorldManagerClient.FogMessage)msg;
final FogRegionConfig fogConfig = fogMsg.getFogConfig();
final OID targetOid = fogMsg.getTarget();
final ClientConnection con = player.getConnection();
final WorldManagerClient.FogMessage fogMessage = new WorldManagerClient.FogMessage(null, fogConfig);
con.send(fogMessage.toBuffer());
if (Log.loggingDebug) {
ProxyPlugin.log.debug("FogHook: sending new fog to targetOid " + targetOid + fogConfig);
}
}
}
class RoadHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final WorldManagerClient.RoadMessage roadMsg = (WorldManagerClient.RoadMessage)msg;
final Set<Road> roads = roadMsg.getRoads();
if (Log.loggingDebug) {
ProxyPlugin.log.debug("RoadHook: got " + roads.size() + " roads");
}
final OID targetOid = roadMsg.getTarget();
final ClientConnection con = player.getConnection();
final List<AOByteBuffer> bufList = roadMsg.toBuffer();
for (final AOByteBuffer buf : bufList) {
con.send(buf);
}
if (Log.loggingDebug) {
ProxyPlugin.log.debug("RoadHook: sent new roads to targetOid " + targetOid);
}
}
}
class AbilityUpdateHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final CombatClient.AbilityUpdateMessage pMsg = (CombatClient.AbilityUpdateMessage)msg;
if (Log.loggingDebug) {
ProxyPlugin.log.debug("AbilityUpdateHook: got AbilityUpdate message: " + msg);
}
final ClientConnection con = player.getConnection();
con.send(pMsg.toBuffer());
}
}
class GetPluginStatusHook implements Hook
{
public boolean processMessage(final Message msg, final int flags) {
final LinkedHashMap<String, Serializable> status = new LinkedHashMap<String, Serializable>();
status.put("plugin", ProxyPlugin.this.getName());
status.put("user", ProxyPlugin.this.playerManager.getPlayerCount());
status.put("login", ProxyPlugin.this.playerManager.getLoginCount());
status.put("login_sec", ProxyPlugin.this.playerManager.getLoginSeconds());
status.put("instance_entry", ProxyPlugin.this.instanceEntryCount);
status.put("chat", ProxyPlugin.this.chatSentCount);
status.put("private_chat", ProxyPlugin.this.privateChatSentCount);
Engine.getAgent().sendObjectResponse(msg, status);
return true;
}
}
public static class PlayerLoginStatus
{
public OID oid;
public int status;
public String name;
public String clientCon;
public String proxyPluginName;
private static final long serialVersionUID = 1L;
public String toString() {
return "[PlayerLoginStatus: oid=" + this.oid + ", status=" + this.status + ", name=" + this.name + ", proxyPluginName=" + this.proxyPluginName + "]";
}
}
private class GetPlayerLoginStatusHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
Log.debug("GetPlayerLoginStatusHook: player=" + player);
final PlayerLoginStatus loginStatus = new PlayerLoginStatus();
loginStatus.oid = player.getOid();
loginStatus.status = player.getStatus();
loginStatus.name = player.getName();
loginStatus.clientCon = player.getConnection().toString();
loginStatus.proxyPluginName = ProxyPlugin.this.getName();
Log.debug("GetPlayerLoginStatusHook: response=" + loginStatus);
Engine.getAgent().sendObjectResponse(msg, loginStatus);
}
}
private class LogoutPlayerHook extends BasicProxyHook
{
public void processMessage(final Message message, final int flags, final Player player) {
new Thread(new LogoutPlayerRPCThread(message, player), "LogoutPlayer" + player.getOid()).start();
}
}
private class LogoutPlayerRPCThread implements Runnable
{
private Player player;
private Message message;
public LogoutPlayerRPCThread(final Message message, final Player player) {
this.player = player;
this.message = message;
}
public void run() {
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.run(): start");
try {
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.run(): try { logoutPlayer(); }");
this.logoutPlayer();
}
catch (Exception e) {
Log.exception("LogoutPlayer", e);
Engine.getAgent().sendObjectResponse(this.message, null);
}
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.run(): done");
}
public void logoutPlayer() {
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.logoutPlayer(): start");
final PlayerLoginStatus loginStatus = new PlayerLoginStatus();
loginStatus.oid = this.player.getOid();
loginStatus.status = this.player.getStatus();
loginStatus.name = this.player.getName();
loginStatus.clientCon = this.player.getConnection().toString();
loginStatus.proxyPluginName = ProxyPlugin.this.getName();
final WorldManagerClient.ComMessage comMessage = new WorldManagerClient.ComMessage(this.player.getOid(), "", 0, "Your player logged in from a different location.");
this.player.getConnection().sendInternal(comMessage.toBuffer());
try {
Thread.sleep(20L);
}
catch (InterruptedException ex) {}
this.player.getConnection().close();
synchronized (this.player) {
while (this.player.getConnection() != null) {
try {
this.player.wait();
}
catch (InterruptedException ex2) {}
}
}
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.logoutPlayer(): Engine.getAgent().sendObjectResponse() message=" + this.message + ", loginStatus=" + loginStatus);
Engine.getAgent().sendObjectResponse(this.message, loginStatus);
Log.debug("[CYC] ProxyPlugin.LogoutPlayerRPCThread.logoutPlayer(): done");
}
}
private class AccountLoginHook implements Hook
{
public boolean processMessage(final Message msg, final int flags) {
Log.debug("AccountLoginHook hit");
final GenericMessage tMsg = (GenericMessage)msg;
final OID accountId = (OID)tMsg.getProperty("accountId");
Log.debug("AccountLoginHook accountId=" + accountId + "; map=" + ProxyPlugin.this.clientConnections);
if (ProxyPlugin.this.clientConnections.containsKey(accountId)) {
Log.debug("Closing client connection");
ProxyPlugin.this.clientConnections.get(accountId).close();
ProxyPlugin.this.clientConnections.remove(accountId);
}
return true;
}
}
static class InstanceEntryState
{
int step;
InstanceClient.InstanceInfo instanceInfo;
LinkedList restoreStack;
BasicWorldNode previousLoc;
InstanceEntryState() {
this.step = 1;
}
}
class InstanceEntryReqHook extends BasicProxyHook
{
public void processMessage(final Message msg, final int flags, final Player player) {
final InstanceClient.InstanceEntryReqMessage entryMessage = (InstanceClient.InstanceEntryReqMessage)msg;
ProxyPlugin.log.debug("InstanceEntryReqHook ");
InstanceEntryState state = (InstanceEntryState)entryMessage.getProcessingState();
if (state == null) {
state = new InstanceEntryState();
entryMessage.setProcessingState(state);
}
if (state.step == 1) {
this.entryStep1(entryMessage, state, player);
}
else if (state.step == 2) {
this.entryStep2(entryMessage, state, player);
}
}
protected void entryStep1(final InstanceClient.InstanceEntryReqMessage entryMessage, final InstanceEntryState state, final Player player) {
ProxyPlugin.log.debug("entryStep1 ");
BasicWorldNode destination = entryMessage.getWorldNode();
final int entryFlags = entryMessage.getFlags();
String flagStr = "";
if ((entryFlags & 0x1) != 0x0) {
flagStr += "push,";
}
if ((entryFlags & 0x2) != 0x0) {
flagStr += "pop,";
}
Log.info("ProxyPlugin: INSTANCE_BEGIN player=" + player + " destination=" + destination + " flags=" + flagStr);
if ((entryFlags & 0x1) != 0x0 && (entryFlags & 0x2) != 0x0) {
Log.debug("InstanceEntryReqHook: push and pop flags cannot be combined oid=" + player.getOid());
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
if ((entryFlags & 0x1) != 0x0 && destination == null) {
Log.debug("InstanceEntryReqHook: push without destination oid=" + player.getOid());
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
if ((entryFlags & 0x2) != 0x0 && destination != null) {
Log.debug("InstanceEntryReqHook: pop with destination oid=" + player.getOid());
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
if (player.getStatus() != 2) {
Log.debug("InstanceEntryReqHook: invalid player status " + player);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
if ((entryFlags & 0x2) != 0x0) {
final LinkedList restoreStack = (LinkedList)EnginePlugin.getObjectProperty(player.getOid(), Namespace.OBJECT_MANAGER, "instanceStack");
if (restoreStack == null || restoreStack.size() == 0) {
Log.debug("InstanceEntryReqHook: player has no stack to pop " + player);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
state.restoreStack = restoreStack;
final InstanceRestorePoint restorePoint = restoreStack.get(restoreStack.size() - 1);
if (restoreStack.size() == 1) {
if (restorePoint.getFallbackFlag()) {
Log.warn("InstanceEntryReqHook: popping to fallback restore point " + player);
}
else {
Log.warn("InstanceEntryReqHook: popping last instance restore point " + player);
}
}
destination = new BasicWorldNode();
OID instanceOid = restorePoint.getInstanceOid();
if (restorePoint.getInstanceID() > 0) {
instanceOid = ProxyPlugin.this.instanceEntryCallback.selectInstance(player, restorePoint.getInstanceID());
}
if (instanceOid != null) {
destination.setInstanceOid(instanceOid);
destination.setLoc(restorePoint.getLoc());
destination.setOrientation(restorePoint.getOrientation());
destination.setDir(new AOVector(0.0f, 0.0f, 0.0f));
}
entryMessage.setWorldNode(destination);
}
if (!ProxyPlugin.this.instanceEntryAllowed(player.getOid(), destination.getInstanceOid(), destination.getLoc())) {
Log.info("ProxyPlugin: INSTANCE_REJECT player=" + player + " current=" + state.previousLoc + " destination=" + destination);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
state.instanceInfo = InstanceClient.getInstanceInfo(destination.getInstanceOid(), -262145);
if (state.instanceInfo.oid == null) {
Log.error("InstanceEntryReqHook: unknown instanceOid=" + destination.getInstanceOid());
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
Log.debug("POP: got population: " + state.instanceInfo.playerPopulation + " and limit: " + state.instanceInfo.populationLimit);
if (state.instanceInfo.populationLimit > 0 && state.instanceInfo.playerPopulation >= state.instanceInfo.populationLimit) {
final OID instanceOid2 = ProxyPlugin.handleFullInstance(state.instanceInfo.templateID, state.instanceInfo);
destination.setInstanceOid(instanceOid2);
state.instanceInfo = InstanceClient.getInstanceInfo(destination.getInstanceOid(), -262145);
}
if (Log.loggingDebug) {
Log.debug("InstanceEntryReqHook: instance terrain config: " + state.instanceInfo.terrainConfig);
}
final WorldManagerClient.TargetedExtensionMessage instanceBegin = new WorldManagerClient.TargetedExtensionMessage(player.getOid(), player.getOid());
instanceBegin.setExtensionType("ao.SCENE_BEGIN");
instanceBegin.setProperty("action", "instance");
instanceBegin.setProperty("name", state.instanceInfo.name);
instanceBegin.setProperty("templateName", state.instanceInfo.templateName);
boolean rc = WorldManagerClient.despawn(player.getOid(), instanceBegin, null);
if (!rc) {
Log.error("InstanceEntryReqHook: despawn failed " + player);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
state.previousLoc = WorldManagerClient.getWorldNode(player.getOid());
Log.info("ProxyPlugin: INSTANCE_STEP1 player=" + player + " current=" + state.previousLoc + " destination=" + destination + " destName=" + state.instanceInfo.name);
final ArrayList<Namespace> unloadWM = new ArrayList<Namespace>(1);
unloadWM.add(WorldManagerClient.NAMESPACE);
rc = ObjectManagerClient.unloadSubObject(player.getOid(), unloadWM);
if (!rc) {
Log.error("InstanceEntryReqHook: unload wm sub-object failed " + player);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
state.step = 2;
ProxyPlugin.this.messageQQ.insert(player, entryMessage);
}
protected void entryStep2(final InstanceClient.InstanceEntryReqMessage entryMessage, final InstanceEntryState state, final Player player) {
ProxyPlugin.log.debug(" entryStep1 ");
int entryFlags = entryMessage.getFlags();
final ClientConnection con = player.getConnection();
BasicWorldNode destination = entryMessage.getWorldNode();
final BasicWorldNode previousLoc = state.previousLoc;
BasicWorldNode restoreLoc = null;
if ((entryFlags & 0x1) != 0x0) {
restoreLoc = entryMessage.getRestoreNode();
if (restoreLoc == null) {
restoreLoc = previousLoc;
}
}
while (true) {
final boolean rc = ObjectManagerClient.fixWorldNode(player.getOid(), destination);
if (!rc) {
Log.debug("InstanceEntryReqHook: fixWorldNode failed " + player + " node=" + destination);
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
final InstanceClient.InstanceInfo instanceInfo = InstanceClient.getInstanceInfo(destination.getInstanceOid(), 8);
EnginePlugin.setObjectProperty(player.getOid(), Namespace.OBJECT_MANAGER, "currentInstanceName", instanceInfo.templateID);
Log.debug("INSTANCE: storing current instance prop: " + instanceInfo.templateID);
Log.debug("instanceReq: sending template (scene) name: " + state.instanceInfo.templateName);
final Event worldFileEvent = new WorldFileEvent(state.instanceInfo.templateName, destination.getLoc());
con.send(worldFileEvent.toBytes());
player.sceneLoading(true);
final WorldManagerClient.WorldNodeCorrectMessage correctMsg = new WorldManagerClient.WorldNodeCorrectMessage(player.getOid(), destination);
con.send(correctMsg.toBuffer());
if ((entryFlags & 0x1) != 0x0) {
ProxyPlugin.this.pushInstanceRestorePoint(player, restoreLoc);
}
final WorldManagerClient.TargetedExtensionMessage instanceEnd = new WorldManagerClient.TargetedExtensionMessage(player.getOid(), player.getOid());
instanceEnd.setExtensionType("ao.SCENE_END");
instanceEnd.setProperty("action", "instance");
instanceEnd.setProperty("name", state.instanceInfo.name);
instanceEnd.setProperty("templateName", state.instanceInfo.templateName);
final ArrayList<Namespace> loadWM = new ArrayList<Namespace>(1);
loadWM.add(WorldManagerClient.NAMESPACE);
final OID oid = ObjectManagerClient.loadSubObject(player.getOid(), loadWM);
if (oid == null) {
Log.error("InstanceEntryReqHook: load wm sub-object failed " + player);
if (previousLoc != null && destination != previousLoc) {
Log.error("InstanceEntryReqHook: attempting to restore previous location " + player + " previous=" + previousLoc);
destination = previousLoc;
entryFlags &= 0xFFFFFFFD;
continue;
}
}
final Integer result = WorldManagerClient.spawn(player.getOid(), null, instanceEnd);
if (result >= 0) {
WorldManagerClient.correctWorldNode(player.getOid(), destination);
ProxyPlugin.this.updateInstancePerception(player.getOid(), previousLoc.getInstanceOid(), destination.getInstanceOid(), instanceInfo.name);
Log.info("ProxyPlugin: INSTANCE_END player=" + player + " destination=" + destination);
if ((entryFlags & 0x2) != 0x0) {
final LinkedList restoreStack = state.restoreStack;
final InstanceRestorePoint top = restoreStack.get(restoreStack.size() - 1);
if (!top.getFallbackFlag()) {
restoreStack.remove(restoreStack.size() - 1);
EnginePlugin.setObjectProperty(player.getOid(), Namespace.OBJECT_MANAGER, "instanceStack", restoreStack);
}
}
ProxyPlugin.this.instanceEntryCount++;
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.TRUE);
return;
}
Log.error("InstanceEntryReqHook: spawn failed " + player);
if (result != -2 || previousLoc == null || destination == previousLoc) {
Engine.getAgent().sendBooleanResponse(entryMessage, Boolean.FALSE);
return;
}
Log.error("InstanceEntryReqHook: attempting to restore previous location " + player + " previous=" + previousLoc);
destination = previousLoc;
entryFlags &= 0xFFFFFFFD;
}
}
}
private class PlayerTimeout implements Runnable
{
public void run() {
while (true) {
try {
Log.debug("PlayerTimeout thread running..");
this.timeoutPlayers();
}
catch (Exception e) {
Log.exception("PlayerTimeout", e);
}
try {
Thread.sleep(10000L);
}
catch (InterruptedException ex) {}
}
}
private void timeoutPlayers() {
final List<Player> timedoutPlayers = ProxyPlugin.this.playerManager.getTimedoutPlayers(ProxyPlugin.idleTimeout * 1000, ProxyPlugin.silenceTimeout * 1000, ProxyPlugin.silenceLoadingTimeout * 1000);
for (final Player player : timedoutPlayers) {
if (!ProxyPlugin.this.isAdmin(player.getOid())) {
Log.info("ProxyPlugin: IDLE_TIMEOUT remote=" + player.getConnection() + " player=" + player);
player.getConnection().close();
}
}
}
}
private static class PlayerHeartbeat implements ProxyExtensionHook
{
public void processExtensionEvent(final ExtensionMessageEvent event, final Player player, final ProxyPlugin proxy) {
final Map<String, Serializable> props = new HashMap<String, Serializable>();
props.put("ext_msg_subtype", "ao.heartbeat");
final WorldManagerClient.TargetedExtensionMessage msg = new WorldManagerClient.TargetedExtensionMessage(WorldManagerClient.MSG_TYPE_EXTENSION, player.getOid(), player.getOid(), false, props);
Engine.getAgent().sendBroadcast(msg);
}
}
static class AsyncRPCCallback implements ResponseCallback
{
Player player;
String debugPrefix;
int responders;
AsyncRPCCallback(final Player player, final String debugPrefix) {
this.responders = 0;
this.player = player;
this.debugPrefix = debugPrefix;
}
public synchronized void handleResponse(final ResponseMessage response) {
--this.responders;
Log.debug(this.debugPrefix + ", fromAgent=" + response.getSenderName() + " playerOid=" + this.player.getOid() + " responders=" + this.responders);
if (this.responders < 1) {
this.notify();
}
}
public synchronized void waitForResponses(final int expectedResponses) {
Log.debug(this.debugPrefix + ", playerOid=" + this.player.getOid() + " responders=" + this.responders + " expectedResponses=" + expectedResponses);
this.responders += expectedResponses;
Log.debug(this.debugPrefix + ", playerOid=" + this.player.getOid() + " responders=" + this.responders + " expectedResponses=" + expectedResponses + " after");
while (this.responders > 0) {
try {
this.wait();
}
catch (InterruptedException e) {
ProxyPlugin.log.error("waitForResponses wait InterruptedException: " + e.getMessage() + " " + e.getLocalizedMessage());
}
catch (Exception e2) {
ProxyPlugin.log.error("waitForResponses wait InterruptedException: " + e2.getMessage() + " " + e2.getLocalizedMessage());
}
}
}
}
protected class ProxyJMX implements ProxyJMXMBean
{
public int getMaxConcurrentUsers() {
return ProxyPlugin.MaxConcurrentUsers;
}
public void setMaxConcurrentUsers(final int users) {
if (users >= 0) {
ProxyPlugin.MaxConcurrentUsers = users;
}
}
public int getIdleTimeout() {
return ProxyPlugin.idleTimeout;
}
public void setIdleTimeout(final int timeout) {
if (timeout > 0) {
ProxyPlugin.idleTimeout = timeout;
}
}
public int getSilenceTimeout() {
return ProxyPlugin.silenceTimeout;
}
public void setSilenceTimeout(final int timeout) {
if (timeout > 0) {
ProxyPlugin.silenceTimeout = timeout;
}
}
public int getCurrentUsers() {
return ProxyPlugin.this.playerManager.getPlayerCount();
}
public int getPeakUsers() {
return ProxyPlugin.this.playerManager.getPeakPlayerCount();
}
public int getLoginCount() {
return ProxyPlugin.this.playerManager.getLoginCount();
}
public int getLogoutCount() {
return ProxyPlugin.this.playerManager.getLogoutCount();
}
public int getClientPort() {
return ProxyPlugin.this.clientPort;
}
public int getMaxMessagesBeforeConnectionReset() {
return ProxyPlugin.maxMessagesBeforeConnectionReset;
}
public void setMaxMessagesBeforeConnectionReset(final int count) {
if (count > 0) {
ProxyPlugin.maxMessagesBeforeConnectionReset = count;
}
}
public int getMaxByteCountBeforeConnectionReset() {
return ProxyPlugin.maxByteCountBeforeConnectionReset;
}
public void setMaxByteCountBeforeConnectionReset(final int bytes) {
if (bytes > 0) {
ProxyPlugin.maxByteCountBeforeConnectionReset = bytes;
}
}
public String getCapacityErrorMessage() {
return ProxyPlugin.this.capacityError;
}
public void setCapacityErrorMessage(final String errorMessage) {
if (errorMessage != null) {
ProxyPlugin.this.capacityError = errorMessage;
}
}
}
class PeriodicGC implements Runnable
{
public void run() {
int count = 1;
while (true) {
try {
Thread.sleep(60000L);
}
catch (InterruptedException ex) {}
System.out.println("Proxy running GC " + count);
System.gc();
++count;
}
}
}
public interface ProxyJMXMBean
{
int getMaxConcurrentUsers();
void setMaxConcurrentUsers(final int p0);
int getIdleTimeout();
void setIdleTimeout(final int p0);
int getSilenceTimeout();
void setSilenceTimeout(final int p0);
int getCurrentUsers();
int getPeakUsers();
int getLoginCount();
int getLogoutCount();
int getClientPort();
int getMaxMessagesBeforeConnectionReset();
void setMaxMessagesBeforeConnectionReset(final int p0);
int getMaxByteCountBeforeConnectionReset();
void setMaxByteCountBeforeConnectionReset(final int p0);
String getCapacityErrorMessage();
void setCapacityErrorMessage(final String p0);
}
public interface CommandAccessCheck
{
boolean allowed(final CommandEvent p0, final ProxyPlugin p1);
}
public interface CommandParser
{
void parse(final CommandEvent p0);
}
}
