private void OnReceiveAddonData(AddonDataPacket packet, NetPeer peer)
{
if (ClientAddons.TryGetValue(packet.AddonId, out IAddonClient <IConfig> addon))
{
addon.OnMessageReceived(new NetDataReader(packet.Data));
}
else
{
Logger.Error($"Failed receiving data while addon with id \"{packet.AddonId}\" is not loaded!");
}
}
/// <summary>
/// Returns short informations about the client
/// </summary>
/// <returns></returns>
public override string ToString()
{
return(new StringBuilder(128)
.Append(Version.ToString())
.Append(" pakLib:").Append(Out == null ? "(null)" : Out.GetType().FullName)
.Append(" type:").Append(ClientType)
.Append('(').Append(ClientType).Append(')')
.Append(" addons:").Append(ClientAddons.ToString("G"))
.Append(" state:").Append(ClientState.ToString())
.Append(" IP:").Append(TcpEndpoint)
.Append(" session:").Append(SessionID)
.Append(" acc:").Append(Account == null ? "null" : Account.Name)
.Append(" char:").Append(Player == null ? "null" : Player.Name)
.Append(" class:").Append(Player == null ? "null" : Player.CharacterClass.ID.ToString())
.ToString());
}
public void CreateDefaultConnectionData()
{
defaultdata = new NetDataWriter();
defaultdata.Put(plugin.Config.HostConnectionKey);
defaultdata.Put(plugin.Version.ToString(3));
defaultdata.Put(Server.Port);
defaultdata.Put(CustomNetworkManager.slots);
defaultdata.PutArray(ClientAddons.Select(p => p.Key).ToArray());
if (File.Exists(tokenPath))
{
var bytes = File.ReadAllBytes(tokenPath);
defaultdata.PutBytesWithLength(bytes, 0, bytes.Length);
}
else
{
var bytes = Encoding.UTF8.GetBytes(string.Empty);
defaultdata.PutBytesWithLength(bytes, 0, bytes.Length);
}
}
private void OnUnloadAddons(UnloadAddonPacket packet, NetPeer peer)
{
foreach (var addon in packet.AddonIds)
{
if (!InstalledAddons.TryGetValue(addon, out AddonInfo aInfo))
{
continue;
}
if (UnregisterCommandsFromAddon(addon))
{
Commands.Remove(addon);
}
if (ClientAddons.TryGetValue(addon, out IAddonClient <IConfig> cAddon))
{
cAddon.OnDisable();
}
{
Logger.Info($"Disabled RemoteAddon \"{aInfo.AddonName}\" ({aInfo.AddonVersion}) made by {aInfo.AddonAuthor}");
}
InstalledAddons.Remove(addon);
}
}
private void OnReceiveAddons(SendAddonsInfoPacket packet, NetPeer peer)
{
foreach (var addon in packet.Addons)
{
if (!InstalledAddons.ContainsKey(addon.AddonId))
{
InstalledAddons.Add(addon.AddonId, addon);
}
List <string> MissingInfo = new List <string>();
if (!plugin.Config.Permissions.ReceivePermissions.Contains(AddonSendPermissionTypes.Everything) && addon.SendPermissions.Any(p => p != (byte)AddonSendPermissionTypes.None))
{
foreach (var sendPerm in addon.SendPermissions)
{
if (!plugin.Config.Permissions.ReceivePermissions.Contains((AddonSendPermissionTypes)sendPerm))
{
MissingInfo.Add($" - Missing SEND permission \"{(AddonSendPermissionTypes)sendPerm}\"");
}
}
}
if (!plugin.Config.Permissions.SendPermissions.Contains(AddonReceivePermissionTypes.Everything) && addon.ReceivePermissions.Any(p => p != (byte)AddonReceivePermissionTypes.None))
{
foreach (var sendPerm in addon.ReceivePermissions)
{
if (!plugin.Config.Permissions.SendPermissions.Contains((AddonReceivePermissionTypes)sendPerm))
{
MissingInfo.Add($" - Missing RECEIVE permission \"{(AddonReceivePermissionTypes)sendPerm}\"");
}
}
}
if (MissingInfo.Count != 0)
{
Logger.Info($"Addon \"{addon.AddonName}\" will not work properly, addon requires these permissions\n{string.Join(Environment.NewLine, MissingInfo)}");
}
var config = Encoding.UTF8.GetString(addon.RemoteConfig);
if (!File.Exists(Path.Combine(remoteConfigsPath, $"{addon.AddonName}.yml")))
{
File.WriteAllText(Path.Combine(remoteConfigsPath, $"{addon.AddonName}.yml"), config);
Logger.Info($"Added missing config for addon \"{addon.AddonName}\"!");
}
var rawConfig = File.ReadAllText(Path.Combine(remoteConfigsPath, $"{addon.AddonName}.yml"));
var receivedConfig = Deserializer.Deserialize <Dictionary <string, object> >(config);
var loadedConfig = Deserializer.Deserialize <Dictionary <string, object> >(rawConfig);
var _temp = receivedConfig.Except(loadedConfig);
foreach (var missingval in _temp)
{
if (loadedConfig.ContainsKey(missingval.Key))
{
continue;
}
loadedConfig.Add(missingval.Key, missingval.Value);
Logger.Info($"Added missing config parameter \"{missingval.Key}\" in addon \"{addon.AddonName}\"!");
}
rawConfig = Serializer.Serialize(loadedConfig);
File.WriteAllText(Path.Combine(remoteConfigsPath, $"{addon.AddonName}.yml"), rawConfig);
if (ClientAddons.TryGetValue(addon.AddonId, out IAddonClient <IConfig> clientAddon))
{
clientAddon.OnReady();
}
else
{
Logger.Info($"RemoteAddon \"{addon.AddonName}\" ({addon.AddonVersion}) made by {addon.AddonAuthor} is ready!");
}
PacketProcessor.Send <AddonOkPacket>(NetworkListener, new AddonOkPacket()
{
AddonId = addon.AddonId,
RemoteConfig = Encoding.UTF8.GetBytes(rawConfig)
}, DeliveryMethod.ReliableOrdered);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NPClient"/> class.
/// </summary>
/// <param name="plugin">Plugin class.</param>
public NPClient(MainClass plugin)
{
NPManager.Singleton = this;
this.plugin = plugin;
Logger = new PluginLogger();
string pluginDir = Path.Combine(Paths.Plugins, "NetworkedPlugins");
tokenPath = Path.Combine(pluginDir, $"NPToken_{Server.Port}.token");
if (!Directory.Exists(pluginDir))
{
Directory.CreateDirectory(pluginDir);
}
if (!Directory.Exists(Path.Combine(pluginDir, "addons-" + Server.Port)))
{
Directory.CreateDirectory(Path.Combine(pluginDir, "addons-" + Server.Port));
}
remoteConfigsPath = Path.Combine(pluginDir, "remoteconfigs-" + Server.Port);
if (!Directory.Exists(remoteConfigsPath))
{
Directory.CreateDirectory(remoteConfigsPath);
}
string[] addonsFiles = Directory.GetFiles(Path.Combine(pluginDir, "addons-" + Server.Port), "*.dll");
Log.Info($"Loading {addonsFiles.Length} addons.");
foreach (var file in addonsFiles)
{
Assembly a = Assembly.LoadFrom(file);
try
{
foreach (Type t in a.GetTypes().Where(type => !type.IsAbstract && !type.IsInterface))
{
if (!t.BaseType.IsGenericType || t.BaseType.GetGenericTypeDefinition() != typeof(NPAddonClient <>))
{
continue;
}
IAddonClient <IConfig> addon = null;
var constructor = t.GetConstructor(Type.EmptyTypes);
if (constructor != null)
{
addon = constructor.Invoke(null) as IAddonClient <IConfig>;
}
else
{
var value = Array.Find(t.GetProperties(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public), property => property.PropertyType == t)?.GetValue(null);
if (value != null)
{
addon = value as IAddonClient <IConfig>;
}
}
if (addon == null)
{
continue;
}
var addonType = addon.GetType();
var prop = addonType.GetProperty("DefaultPath", BindingFlags.Public | BindingFlags.Instance);
var field = prop.GetBackingField();
field.SetValue(addon, Path.Combine(pluginDir, $"addons-{Server.Port}"));
prop = addonType.GetProperty("AddonPath", BindingFlags.Public | BindingFlags.Instance);
field = prop.GetBackingField();
field.SetValue(addon, Path.Combine(addon.DefaultPath, addon.AddonName));
prop = addonType.GetProperty("Manager", BindingFlags.Public | BindingFlags.Instance);
field = prop.GetBackingField();
field.SetValue(addon, this);
prop = addonType.GetProperty("Logger", BindingFlags.Public | BindingFlags.Instance);
field = prop.GetBackingField();
field.SetValue(addon, Logger);
if (ClientAddons.ContainsKey(addon.AddonId))
{
Logger.Error($"Addon {addon.AddonName} already already registered with id {addon.AddonId}.");
break;
}
ClientAddons.Add(addon.AddonId, addon);
LoadAddonConfig(addon);
if (!addon.Config.IsEnabled)
{
return;
}
Logger.Info($"Loading addon \"{addon.AddonName}\" ({addon.AddonVersion}) made by {addon.AddonAuthor}.");
addon.OnEnable();
Logger.Info($"Waiting to client connections..");
}
}
catch (Exception ex)
{
Logger.Error($"Failed loading addon {Path.GetFileNameWithoutExtension(file)}. {ex.ToString()}");
}
}
Logger.Info($"Starting CLIENT network...");
eventHandlers = new EventHandlers(this);
}
