public bool OnBeforePacket(IClient client, IPacket packet)
{
switch ((AresId)packet.Id)
{
case AresId.MSG_CHAT_CLIENT_PUBLIC:
ClientPublic pub = (ClientPublic)packet;
if (pub.Message.StartsWith("#hashlink"))
{
server.SendAnnounce("\\\\arlnk://" +
HashConvert.ToHashlinkString(new Channel()
{
Name = server.Config.Name,
Port = server.Config.Port,
LocalIp = server.LocalIp,
ExternalIp = server.ExternalIp,
}));
}
else if (pub.Message.Length > 9 && pub.Message.StartsWith("#decrypt "))
{
var hash = HashConvert.FromHashlinkString <Channel>(pub.Message.Substring(9));
server.SendAnnounce(String.Format("Name: {0}", hash.Name));
server.SendAnnounce(String.Format("Port: {0}", hash.Port));
server.SendAnnounce(String.Format("External Ip: {0}", hash.ExternalIp));
server.SendAnnounce(String.Format("Local Ip: {0}", hash.LocalIp));
}
break;
}
return(true);
}
public ArrayInstance d67(object data, int b)
{
if (data is String || data is ConcatenatedString)
{
return(HashConvert.d67(System.Text.Encoding.UTF8.GetBytes(data.ToString()), b).ToJSArray(Engine));
}
else if (data is ArrayInstance)
{
return(HashConvert.d67(((ArrayInstance)data).ToArray <byte>(), b).ToJSArray(Engine));
}
return(null);
}
public override object Decode(object a)
{
if (a is String || a is ConcatenatedString)
{
var str = a.ToString();
return(HashConvert.FromHashlinkString <ChannelHash>(str, this));
}
else if (a is ArrayInstance)
{
var array = (ArrayInstance)a;
byte[] tmp = array.ToArray <byte>();
return(HashConvert.FromHashlinkArray <ChannelHash>(tmp, this));
}
return(null);
}
public override string Encode()
{
return(HashConvert.ToHashlinkString <ChannelHash>(this));
}
internal static bool HandleCommand(IServer server, IClient client, string text)
{
string cmd = String.Empty;
string args = String.Empty;
int sep = text.IndexOf('\x20');
if (sep == -1)
{
cmd = text;
}
else
{
cmd = text.Substring(0, sep);
if (text.Length > (sep + 1))
{
args = text.Substring(sep + 1);
}
}
switch (cmd)
{
case "id":
server.SendAnnounce(client, String.Format(Strings.UserId, client.Id));
break;
case "vroom":
ushort vroom = 0;
if (UInt16.TryParse(args, out vroom))
{
client.Vroom = vroom;
}
break;
case "admins":
case "listadmins": {
if (client.Admin > AdminLevel.User)
{
var tmp = server.History.Admin.ToList();
tmp.Sort((a, b) => ((int)a.Admin) - ((int)b.Admin));
server.SendAnnounce(client, String.Format("-- Admins: {0} --", tmp.Count));
foreach (var user in tmp)
{
server.SendAnnounce(client, String.Format("{0}: {1}", user.Admin, user.Name));
}
}
}
break;
case "topic":
if (client.Admin > AdminLevel.Moderator)
{
server.Config.Topic = args;
}
break;
case "info":
case "whois": {
if (client.Admin > AdminLevel.User)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null)
{
server.SendAnnounce(client, String.Format("-- Whois: {0} --", target.Name));
server.SendAnnounce(client, String.Format("Id: {0}", target.Id));
server.SendAnnounce(client, String.Format("Level: {0}", target.Admin));
server.SendAnnounce(client, String.Format("Vroom: {0}", target.Vroom));
server.SendAnnounce(client, String.Format("Muzzled: {0}", target.Muzzled));
server.SendAnnounce(client, String.Format("IsCaptcha: {0}", target.IsCaptcha));
server.SendAnnounce(client, String.Format("Address: {0}", target.ExternalIp));
server.SendAnnounce(client, String.Format("DnsEntry: {0}", target.DnsEntry != null ? target.DnsEntry.HostName : "error"));
server.SendAnnounce(client, String.Format("Client: {0}", target.Version));
}
else
{
server.SendAnnounce(client, "-- Userlist Info --");
foreach (var user in server.Users)
{
server.SendAnnounce(client, String.Format("[{0}] - {1}", user.Id, user.Name));
}
}
}
}
break;
case "whowas": {
if (client.Admin > AdminLevel.User)
{
var targets = ParseHistoryCommand(server, args, out args);
if (targets.Count > 0)
{
for (int i = 0; i < targets.Count; i++)
{
var target = targets[i];
server.SendAnnounce(client, String.Format("-- Whowas: {0} --", target.Name));
server.SendAnnounce(client, String.Format("Muzzled: {0}", target.Muzzled));
server.SendAnnounce(client, String.Format("Trusted: {0}", target.Trusted));
server.SendAnnounce(client, String.Format("Address: {0}", target.ClientId.ExternalIp));
server.SendAnnounce(client, String.Format("DnsEntry: {0}", string.IsNullOrEmpty(target.DnsName) ? target.DnsName : "error"));
server.SendAnnounce(client, String.Format("LastSeen: {0} (Server Time)", target.LastSeen));
if (i < (targets.Count - 1))
{
server.SendAnnounce(" ");
}
}
}
else
{
server.SendAnnounce(client, Strings.HistoryNotFound);
}
}
}
break;
case "muzzle": {
if (client.Admin > AdminLevel.User)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null && client.Admin > target.Admin)
{
target.Muzzled = true;
}
}
}
break;
case "unmuzzle": {
if (client.Admin > AdminLevel.User)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null && client.Admin > target.Admin)
{
target.Muzzled = false;
}
}
}
break;
case "kill":
case "kick":
case "disconnect": {
if (client.Admin > AdminLevel.User)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null && client.Admin > target.Admin)
{
server.SendAnnounce(String.Format(Strings.Kicked, target.Name));
target.Disconnect();
}
}
}
break;
case "redirect": {
if (client.Admin > AdminLevel.Moderator)
{
IClient target = ParseUserCommand(server, args, out args);
Channel hash = HashConvert.FromHashlinkString <Channel>(args);
if (hash != null)
{
if (target != null && client.Admin > target.Admin)
{
server.SendPacket(target, new Redirect(hash, String.Format(Strings.Redirected, hash.Name)));
}
}
}
}
break;
case "ban": {
if (client.Admin > AdminLevel.User)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null && client.Admin > target.Admin)
{
server.SendAnnounce(String.Format(Strings.Banned, target.Name));
target.Ban();
}
}
}
break;
case "listbans": {
if (client.Admin > AdminLevel.User)
{
string format = "[{0}] - {1}";
server.SendAnnounce(client, "-- Banned Users --");
for (int i = 0; i < server.History.Bans.Count; i++)
{
var banned = server.History.Bans[i];
var record = server.History.Find((s) => banned.Equals(s));
if (record != null)
{
server.SendAnnounce(client, String.Format(format, i, record.Name));
}
}
}
}
break;
case "unban": {
if (client.Admin > AdminLevel.User)
{
var targets = ParseHistoryCommand(server, args, out args);
if (targets.Count > 0)
{
targets.ForEach((s) => {
server.History.Bans.Remove(s.ClientId);
server.SendAnnounce(String.Format(Strings.Unbanned, s.Name));
});
}
else
{
server.SendAnnounce(client, Strings.HistoryNotFound);
}
}
}
break;
case "cbans":
case "clearbans": {
if (client.Admin > AdminLevel.Moderator)
{
server.History.Bans.Clear();
server.SendAnnounce(String.Format(Strings.BansCleared, client.Name));
}
}
break;
case "bandns": {
if (client.Admin > AdminLevel.Moderator)
{
try {
Regex reg = new Regex(args, RegexOptions.IgnoreCase);
server.History.DnsBans.Add(reg);
server.SendAnnounce(String.Format(Strings.DnsBanAdd, reg.ToString()));
}
catch (ArgumentException ex) {
server.SendAnnounce(client, String.Format(Strings.InvalidPattern, ex.Message));
}
}
}
break;
case "listdnsbans": {
if (client.Admin > AdminLevel.Moderator)
{
string format = "[{0}] - {1}";
server.SendAnnounce(client, "-- Banned Dns Names --");
for (int i = 0; i < server.History.DnsBans.Count; i++)
{
var regex = server.History.DnsBans[i];
server.SendAnnounce(client, String.Format(format, i, regex.ToString()));
}
}
}
break;
case "unbandns":
if (client.Admin > AdminLevel.Moderator)
{
int index = 0;
if (Int32.TryParse(args, out index))
{
if (index < 0)
{
index = 0;
}
if (index >= server.History.DnsBans.Count)
{
server.SendAnnounce(client, Strings.InvalidIndex);
}
else
{
Regex regex = server.History.DnsBans[index];
server.History.DnsBans.RemoveAt(index);
server.SendAnnounce(String.Format(Strings.DnsBanRemove, regex.ToString()));
}
}
else
{
try {
Regex regex = new Regex(args);
server.History.DnsBans.Remove(regex);
server.SendAnnounce(String.Format(Strings.DnsBanRemove, regex.ToString()));
}
catch (ArgumentException ex) {
server.SendAnnounce(client, String.Format(Strings.InvalidPattern, ex.Message));
}
}
}
break;
case "cdnsbans":
case "cleardnsbans": {
if (client.Admin > AdminLevel.Moderator)
{
server.History.DnsBans.Clear();
server.SendAnnounce(String.Format(Strings.DnsBansCleared, client.Name));
}
}
break;
case "banrange":
if (client.Admin > AdminLevel.Moderator)
{
try {
Regex reg = new Regex(args, RegexOptions.IgnoreCase);
server.History.RangeBans.Add(reg);
server.SendAnnounce(String.Format(Strings.RangeBanAdd, reg.ToString()));
}
catch (ArgumentException ex) {
server.SendAnnounce(String.Format(Strings.InvalidPattern, ex.Message));
}
}
break;
case "listrangebans": {
if (client.Admin > AdminLevel.Moderator)
{
string format = "[{0}] - {1}";
server.SendAnnounce(client, "-- Banned IP Addresses --");
for (int i = 0; i < server.History.RangeBans.Count; i++)
{
var regex = server.History.RangeBans[i];
server.SendAnnounce(client, String.Format(format, i, regex.ToString()));
}
}
}
break;
case "unbanrange":
if (client.Admin > AdminLevel.Moderator)
{
int index = 0;
if (Int32.TryParse(args, out index))
{
if (index < 0)
{
index = 0;
}
if (index >= server.History.RangeBans.Count)
{
server.SendAnnounce(client, Strings.InvalidIndex);
}
else
{
Regex regex = server.History.RangeBans[index];
server.History.RangeBans.RemoveAt(index);
server.SendAnnounce(String.Format(Strings.RangeBanRemove, regex.ToString()));
}
}
else
{
try {
Regex regex = new Regex(args);
server.History.RangeBans.Remove(regex);
server.SendAnnounce(String.Format(Strings.RangeBanRemove, regex.ToString()));
}
catch (Exception ex) {
server.SendAnnounce(client, String.Format(Strings.InvalidPattern, ex.Message));
}
}
}
break;
case "crangebans":
case "clearrangebans": {
if (client.Admin > AdminLevel.Moderator)
{
server.History.RangeBans.Clear();
server.SendAnnounce(String.Format(Strings.RangeBansCleared, client.Name));
}
}
break;
case "grant": {
if (client.Admin >= AdminLevel.Host)
{
AdminLevel tmp = 0;
IClient target = ParseUserCommand(server, args, out args);
if (target != null && Enum.TryParse <AdminLevel>(args, out tmp))
{
if (client.LocalHost || client.Admin >= target.Admin)
{
target.Admin = tmp;
}
else
{
target.Admin = (AdminLevel)Math.Min((int)client.Admin, (int)tmp);
}
var password = server.History.Admin.Passwords.Find((s) => s.ClientId.Equals(target));
if (password != null)
{
password.ClientId.Guid = target.Guid;
password.ClientId.ExternalIp = target.ExternalIp;
password.Level = tmp;
}
}
}
}
break;
case "captcha": {
if (client.Admin >= AdminLevel.Host)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null)
{
target.IsCaptcha = true;
}
}
}
break;
case "skipcaptcha": {
if (client.Admin >= AdminLevel.Host)
{
IClient target = ParseUserCommand(server, args, out args);
if (target != null)
{
target.IsCaptcha = false;
}
}
}
break;
case "loadplugin":
if (client.Admin >= AdminLevel.Host)
{
server.PluginHost.LoadPlugin(args);
}
break;
case "killplugin":
if (client.Admin >= AdminLevel.Host)
{
server.PluginHost.KillPlugin(args);
}
break;
case "listplugins":
if (client.Admin > AdminLevel.User)
{
server.SendAnnounce("-- Active plugins --");
foreach (var plugin in server.PluginHost)
{
if (plugin.Enabled)
{
server.SendAnnounce(client, plugin.Name);
}
}
}
break;
}
return(true);
}
