/// <summary>
/// Creates an instance of <see cref="ChatMessageEventArgs"/>.
/// </summary>
/// <param name="sender">The sender, or <c>null</c> if the message has no sender.</param>
/// <param name="recipient">The recipient.</param>
/// <param name="message">The chat message.</param>
public ChatMessageEventArgs(IrcIdentity sender, IrcString recipient, IrcString message)
: base(sender, recipient)
{
Throw.If.Null(message, "message");
Message = message;
}
internal static bool ValidateIdentity(IrcIdentity identity, out string errorMessage)
{
errorMessage = null;
if (identity.Nickname == null || identity.Nickname.Length == 0)
{
errorMessage = "Nickname is not set."; return(false);
}
if (!ValidateIdentityPart(identity.Nickname, out errorMessage))
{
return(false);
}
if (identity.Username != null && !ValidateIdentityPart(identity.Username, out errorMessage))
{
return(false);
}
if (identity.Hostname != null && !ValidateIdentityPart(identity.Hostname, out errorMessage))
{
return(false);
}
return(true);
}
private void ProcessQuit(IrcIdentity ident, string channelName, SpamConfig channel)
{
var nickname = ident.Nickname;
Whois.NormalizeIdentity(ident);
var quits = channel.AddUserPart(ident.ToString(), channel.QuitsThresholdSeconds);
if (quits < channel.QuitsThreshold)
{
return;
}
channel.ResetUserPart(ident.ToString());
Log.WriteInfo("Spam", "'{1}' ({0}) is spamming joins/quits in {2}. Redirecting for {3} minutes.", nickname, ident, channelName, channel.QuitsBanMinutes);
Bootstrap.Client.Client.Mode(channelName, "+b", ident + "$" + Bootstrap.Client.Settings.RedirectChannel);
// In case they manage to come back before ban takes place
Bootstrap.Client.Client.Kick(nickname, channelName, string.Format("Fix your connection. Banned for {0} minutes", channel.QuitsBanMinutes));
Bootstrap.Client.Client.Notice(nickname, string.Format("You have been banned from {0} for {1} minutes for rapidly rejoining the channel.", channelName, channel.QuitsBanMinutes));
Bootstrap.Client.ModeList.AddLateModeRequest(
new LateModeRequest
{
Channel = channelName,
Recipient = ident.ToString(),
Mode = "-b",
Time = DateTime.UtcNow.AddMinutes(channel.QuitsBanMinutes),
Reason = "Quit/leave flood"
}
);
}
/// <summary>
/// Creates a new instance of <see cref="KickEventArgs"/>.
/// </summary>
/// <param name="sender">The user doing the kicking.</param>
/// <param name="recipient">The user being kicked out of the channel.</param>
/// <param name="channel">The channel the user is being kicked from.</param>
/// <param name="reason">The reason the user is being kicked, or <c>null</c> if none is given.</param>
public KickEventArgs(IrcIdentity sender, IrcString recipient, IrcString channel, IrcString reason)
: base(sender, recipient)
{
Throw.If.Null(channel, "channel");
Channel = channel; Reason = reason;
}
public static IrcIdentity NormalizeIdentity(IrcIdentity originalIdent)
{
var ident = new IrcIdentity
{
Hostname = originalIdent.Hostname,
Nickname = originalIdent.Nickname,
Username = originalIdent.Username,
};
if (ident.Username == null)
{
ident.Username = "******";
}
if (ident.Hostname == null)
{
ident.Hostname = "*";
}
else if (ident.Hostname != "*")
{
//ident.Username = "******";
}
// We don't want to accidentally ban *!*@*
if (ident.Username != "*" || ident.Hostname != "*")
{
ident.Nickname = "*";
}
return(ident);
}
/// <summary>
/// Creates a new instance of <see cref="ModeEventArgs"/>.
/// </summary>
/// <param name="sender">The user changing the mode.</param>
/// <param name="recipient">The target of the mode change. This may be a channel or a user.</param>
/// <param name="command">The mode change, for example +o or +v.</param>
/// <param name="parameters">The mode change parameters.</param>
public ModeEventArgs(IrcIdentity sender, IrcString recipient, IrcString command, IrcString[] parameters)
: base(sender, recipient)
{
Throw.If.Null(command, "command").NullElements(parameters, "parameters");
Command = command; _parameters = (IrcString[])parameters.Clone();
}
/// <summary>
/// Creates a new instance of <see cref="InvitationEventArgs"/>.
/// </summary>
/// <param name="sender">The sender of the invitation.</param>
/// <param name="recipient">The recipient of the invitation.</param>
/// <param name="channel">The channel the invitation is for.</param>
public InvitationEventArgs(IrcIdentity sender, IrcString recipient, IrcString channel)
: base(sender, recipient)
{
Throw.If.Null(channel, "channel");
Channel = channel;
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (!IrcIdentity.TryParse(nick, out var ident))
{
command.Reply("Invalid identity.");
return;
}
var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient);
if (!channel.WeAreOpped)
{
if (channel.HasChanServ)
{
Bootstrap.Client.Client.Message("ChanServ", string.Format("op {0}", channel.Name));
}
else
{
command.Reply("I'm not opped, send help.");
return;
}
}
var isQuiet = command.MatchedCommand != "unban";
Bootstrap.Client.Whois.Query(ident,
whoisData =>
{
if (whoisData.Identity.Nickname != null)
{
ident = whoisData.Identity;
Whois.NormalizeIdentity(ident);
}
else
{
if (ident.Username == null)
{
ident.Username = "******";
}
if (ident.Hostname == null)
{
ident.Hostname = "*";
}
}
Log.WriteInfo("Unban", "'{0}' unbanned '{1}' in {2}", command.Event.Sender, ident, command.Event.Recipient);
Bootstrap.Client.Client.Mode(command.Event.Recipient, isQuiet ? "-q" : "-b", ident);
command.ReplyAsNotice("{0} {1}", isQuiet ? "Unmuted" : "Unbanned", ident);
}
);
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (nick.Length == 0 || !IrcIdentity.TryParse(nick, out var ident))
{
ident = command.Event.Sender;
}
Bootstrap.Client.Whois.Query(ident,
whoisData =>
{
if (whoisData.Identity.Nickname == null)
{
command.Reply("There is no user by that nick on the network.");
return;
}
ident = whoisData.Identity;
if (ident.Nickname.ToString().ToLowerInvariant() == Bootstrap.Client.TrueNickname.ToLowerInvariant())
{
command.Reply("That's me, dummy.");
return;
}
if (!Users.TryGetUser(ident, out var user))
{
command.Reply("This user has no permissions.");
return;
}
var permissions = new List <string>();
if (user.Permissions.ContainsKey("*"))
{
permissions.AddRange(user.Permissions["*"]);
}
if (user.Permissions.ContainsKey(command.Event.Recipient))
{
permissions.AddRange(user.Permissions[command.Event.Recipient]);
}
if (!permissions.Any())
{
command.Reply("This user has no permissions in this channel.");
return;
}
command.Reply("{0} has following permissions in this channel: {1}", ident.Nickname, string.Join(", ", permissions.Distinct()));
}
);
}
public User(IrcIdentity user)
{
this.user = user;
this.NewBotId();
this.HasBeenPresented = false;
this.TalkTo = false;
this.Translate = false;
this.Language = null;
}
public static string GetReceiver(IrcIdentity sender, Channel channel)
{
if (null != channel)
{
return channel.Name;
}
return sender.Username;
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (!IrcIdentity.TryParse(nick, out var ident))
{
command.Reply("Invalid identity.");
return;
}
if (string.Equals(ident.Nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase))
{
command.Reply("Don't you even dare.");
return;
}
var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient);
if (!channel.WeAreOpped)
{
if (channel.HasChanServ)
{
Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name);
}
else
{
command.Reply("I'm not opped, send help.");
return;
}
}
var reason = command.Arguments.Groups["reason"].Value.Trim();
if (command.MatchedCommand == "duckoff" && reason.Length == 0)
{
reason = "Quack, motherducker";
}
Log.WriteInfo("Kick", "'{0}' kicked '{1}' in {2} (reason: {3})", command.Event.Sender, ident, command.Event.Recipient, reason.Length == 0 ? "no reason given" : reason);
if (command.MatchedCommand == "remove")
{
Bootstrap.Client.Client.Remove(ident.Nickname, command.Event.Recipient, reason.Length == 0 ? null : reason);
}
else
{
Bootstrap.Client.Client.Kick(ident.Nickname, command.Event.Recipient, reason.Length == 0 ? null : reason);
}
command.ReplyAsNotice("Kicked {0}", ident);
}
public void AddAction(IrcIdentity sender, string message)
{
LastActions.Enqueue(
new ChatAction
{
Identity = sender,
Message = message.ToLowerInvariant(),
Time = DateTime.UtcNow,
}
);
}
public void Query(IrcIdentity ident, Action <WhoisData> callback)
{
if (ident.Username != null || ident.Hostname != null)
{
var data = new WhoisData();
data.Identity = ident;
callback.Invoke(data);
}
else
{
QueryAccount(ident, callback);
}
}
public override void OnCommand(CommandArguments command)
{
var nicks = new List <IrcString>();
var input = command.Arguments.Groups["nicks"].Value;
if (input.Length == 0)
{
nicks.Add(command.Event.Sender.Nickname);
}
else
{
var nicksTemp = input.Split(' ');
foreach (var nick in nicksTemp)
{
if (!IrcIdentity.TryParse(nick, out var ident))
{
command.Reply("'{0}' is a invalid indentity.", nick);
return;
}
nicks.Add(ident.Nickname);
}
}
var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient);
if (channel.WeAreOpped)
{
Bootstrap.Client.Client.Mode(command.Event.Recipient, "+" + new string('o', nicks.Count), nicks.ToArray());
}
else if (channel.HasChanServ)
{
Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name, string.Join(" ", nicks));
}
else
{
command.Reply("I'm not opped, send help.");
return;
}
Log.WriteInfo("Op", "'{0}' gave channel operator to {1} in {2}", command.Event.Sender, string.Join(", ", nicks), command.Event.Recipient);
}
private void ProcessQuit(IrcIdentity ident, string channelName, SpamConfig channel)
{
var nickname = ident.Nickname;
ident = Whois.NormalizeIdentity(ident);
var quits = channel.AddUserPart(ident.ToString(), channel.QuitsThresholdSeconds);
if (quits < channel.QuitsThreshold)
{
return;
}
var banMinutes = channel.AddUserBan(ident.ToString()) * channel.QuitsBanMinutes;
Log.WriteInfo("Spam", "'{1}' ({0}) is spamming joins/quits in {2}. Redirecting for {3} minutes.", nickname, ident, channelName, banMinutes);
Bootstrap.Client.Client.Mode(channelName, "+b", ident + "$" + Bootstrap.Client.Settings.RedirectChannel);
// In case they manage to come back before ban takes place
Bootstrap.Client.Client.Kick(nickname, channelName, $"Fix your connection. Banned for {banMinutes} minutes");
Bootstrap.Client.Client.Notice(nickname, $"Please fix your connection. You have been banned from {channelName} for {banMinutes} minutes for rapidly rejoining the channel.");
if (Bootstrap.Client.ModeList.Find(channelName, ident.ToString(), "-b") != null)
{
Log.WriteInfo("Spam", "There's already a latemode set for '{0}' in {1}", ident, channelName);
return;
}
Bootstrap.Client.ModeList.AddLateModeRequest(
new LateModeRequest
{
Channel = channelName,
Recipient = ident.ToString(),
Mode = "-b",
Time = DateTime.UtcNow.AddMinutes(banMinutes),
Reason = "Quit/leave flood"
}
);
}
private void QueryAccount(IrcIdentity ident, Action <WhoisData> callback)
{
WhoisData data;
if (Pending.ContainsKey(ident.Nickname))
{
data = Pending[ident.Nickname];
}
else
{
data = new WhoisData();
Pending.Add(ident.Nickname, data);
// TODO: create a timeout?
}
data.Callbacks.Add(callback);
Bootstrap.Client.Client.Whois(ident.Nickname);
}
public static void NormalizeIdentity(IrcIdentity ident)
{
if (ident.Username == null)
{
ident.Username = "******";
}
if (ident.Hostname == null)
{
ident.Hostname = "*";
}
else if (ident.Hostname.StartsWith("gateway/web/freenode/ip."))
{
var temp = ident.Hostname.ToString().Split('/');
ident.Hostname = temp[3].Substring(3);
//ident.Nickname = "*";
ident.Username = "******";
}
else if (ident.Hostname.StartsWith("gateway/"))
{
ident.Hostname = "gateway/*";
// IRCCloud: uid indicates a free account, paid accounts have the prefix sid.
if (ident.Username.StartsWith("uid") || ident.Username.StartsWith("sid"))
{
ident.Username = "******" + ident.Username.Substring(1);
}
}
else if (ident.Hostname != "*")
{
ident.Username = "******";
}
// We don't want to accidentally ban *!*@*
if (ident.Username != "*" || ident.Hostname != "*")
{
ident.Nickname = "*";
}
}
internal static void Dispatch(string commandName, string[] parameters, IrcIdentity sender, ServerUser serverUser, Channel channel)
{
if (CommandList.ContainsKey(commandName))
{
var command = CommandList[commandName];
var commandParameters = new CommandParameters
{
CommandName = commandName,
Parameters = parameters,
Sender = sender,
ServerUser = serverUser,
Channel = channel,
Command = command
};
command.Function(commandParameters);
}
else
{
var commandCompressed = commandName;
if (null != parameters && parameters.Length > 0)
{
commandCompressed += string.Format(" ({0})", string.Join(",", parameters));
}
Debug.WriteLine(
string.Format(
"Unknown command {0} (from {1})",
commandCompressed,
(sender != null) ? sender.Nickname.ToString() : "Anonymous"),
null != channel ? channel.ToString() : serverUser.ToString());
var message = string.Format(
"Unknown command {0}",
commandCompressed);
serverUser.SendMessage(Command.GetReceiver(sender, channel), message);
}
}
/// <summary>
/// Creates a new instance of <see cref="TargetedMessageEventArgs"/>.
/// </summary>
/// <param name="sender">The sender, or <c>null</c> if the message has no sender.</param>
/// <param name="recipient">The recipient.</param>
public TargetedMessageEventArgs(IrcIdentity sender, IrcString recipient)
{
Throw.If.Null(recipient, "recipient");
Sender = sender; Recipient = recipient;
}
public WhoisData()
{
Identity = new IrcIdentity();
Callbacks = new List <Action <WhoisData> >();
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (!IrcIdentity.TryParse(nick, out var ident))
{
command.Reply("Invalid identity.");
return;
}
var duration = command.Arguments.Groups["duration"].Value;
var durationTime = default(DateTime);
if (duration.Length > 0)
{
try
{
durationTime = DateTimeParser.Parse(duration, command.Arguments.Groups["durationUnit"].Value);
}
catch (ArgumentException e)
{
command.Reply("{0}", e.Message);
return;
}
}
var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient);
if (!channel.WeAreOpped)
{
if (channel.HasChanServ)
{
Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name);
}
else
{
command.Reply("I'm not opped, send help.");
return;
}
}
var isQuiet = command.MatchedCommand == "quiet" || command.MatchedCommand == "mute";
Bootstrap.Client.Whois.Query(ident,
whoisData =>
{
if (whoisData.Identity.Nickname == null)
{
command.Reply("There is no user by that nick on the network. Try {0}!*@* to {1} anyone with that nick, or specify a full hostmask.", ident.Nickname, isQuiet ? "quiet" : "ban");
return;
}
ident = whoisData.Identity;
var nickname = ident.Nickname;
if (string.Equals(nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase))
{
command.Reply("Don't you even dare.");
return;
}
ident = Whois.NormalizeIdentity(ident);
if (Bootstrap.Client.ModeList.Find(command.Event.Recipient, ident.ToString(), isQuiet ? "-q" : "-b") != null)
{
command.Reply("{0} is already {1} in this channel.", ident, isQuiet ? "muted" : "banned");
return;
}
Log.WriteInfo("Ban", "'{0}' {1} '{2}' from {3}", command.Event.Sender, isQuiet ? "quieted" : "banned", ident, command.Event.Recipient);
var reason = command.Arguments.Groups["reason"].Value.Trim();
if (reason.Length == 0)
{
reason = $"Banned by {command.Event.Sender.Nickname}";
}
Bootstrap.Client.Client.Mode(command.Event.Recipient, isQuiet ? "+q" : "+b", ident);
if (!isQuiet && channel.HasUser(nickname))
{
Bootstrap.Client.Client.Kick(nickname, command.Event.Recipient, reason);
}
if (duration.Length > 0)
{
command.ReplyAsNotice("Will {0} {1} {2}", isQuiet ? "unmute" : "unban", ident, durationTime.ToRelativeString());
Bootstrap.Client.ModeList.AddLateModeRequest(
new LateModeRequest
{
Channel = command.Event.Recipient,
Recipient = ident.ToString(),
Sender = command.Event.Sender.ToString(),
Mode = isQuiet ? "-q" : "-b",
Time = durationTime,
Reason = reason
}
);
}
else
{
command.ReplyAsNotice("{0} {1}", isQuiet ? "Muted" : "Banned", ident);
}
}
);
}
public static bool TryGetUser(IrcIdentity ident, out User user)
{
return(UsersList.TryGetValue(string.Format("{0}@{1}", ident.Username, ident.Hostname), out user));
}
private static bool IsWhitelisted(IrcIdentity ident, string channel)
{
// If this user has a "spam.whitelist" permission, allow them to spam
return(Users.TryGetUser(ident, out var user) && user.HasPermission(channel, "spam.whitelist"));
}
/// <summary>
/// Creates a new instance of <see cref="PingReplyEventArgs"/>.
/// </summary>
/// <param name="identity">The user who is replying to your ping request.</param>
/// <param name="delay">The ping time, in milliseconds.</param>
public PingReplyEventArgs(IrcIdentity identity, int delay)
{
Throw.If.Null(identity, "identity").Negative(delay, "delay");
Identity = identity; Delay = delay;
}
/// <summary>
/// Tries to read a buffer and parse out an IRC statement.
/// Additionally, on failure, the reason for failure is returned.
/// </summary>
/// <param name="buffer">The buffer to read from.</param>
/// <param name="offset">The offset to begin reading. The parser may advance this, even if parsing fails.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <param name="statement">The statement, if parsing succeeds, or <c>null</c>.</param>
/// <param name="parseResult">The result of parsing. On failure, this is the reason for the failure.</param>
/// <returns><c>true</c> if parsing succeeded.</returns>
public static bool TryParse(byte[] buffer, ref int offset, int count,
out IrcStatement statement, out IrcStatementParseResult parseResult)
{
Throw.If.Null(buffer, "buffer");
string errorMessage = null;
IrcString[] parts;
statement = null; parseResult = IrcStatementParseResult.NothingToParse;
// First, skip all initial CR/LF.
SkipCrlf(buffer, ref offset, ref count);
// See if we've got a CR or LF anywhere.
int crlfIndex = IrcString.IndexOf(buffer, @byte => @byte == 13 || @byte == 10, offset, count);
if (crlfIndex == -1)
{
if (count >= IrcConstants.MaxStatementLength)
{
parseResult = IrcStatementParseResult.StatementTooLong;
}
return(false);
}
// OK, let's get our string.
var @string = new IrcString(buffer, offset, crlfIndex - offset);
#if DEBUG
var debugString = @string;
#endif
offset += @string.Length + 1; count -= @string.Length + 1;
SkipCrlf(buffer, ref offset, ref count);
if (crlfIndex >= IrcConstants.MaxStatementLength)
{
parseResult = IrcStatementParseResult.StatementTooLong; return(false);
}
// Do we have a prefix?
statement = new IrcStatement();
if (@string.Length >= 1 && @string[0] == (byte)':')
{
parts = @string.Split((byte)' ', 2);
var sourceString = parts[0].Substring(1); IrcIdentity source;
if (!IrcIdentity.TryParse(sourceString, out source))
{
goto invalid;
}
statement.Source = source;
@string = parts.Length >= 2 ? parts[1] : IrcString.Empty;
}
// Now get the command.
parts = @string.Split((byte)' ', 2);
statement.Command = parts[0];
@string = parts.Length >= 2 ? parts[1] : IrcString.Empty;
// Parameters, now...
while (@string.Length > 0)
{
if (@string[0] == (byte)':')
{
statement.Parameters.Add(@string.Substring(1));
break;
}
else
{
parts = @string.Split((byte)' ', 2);
statement.Parameters.Add(parts[0]);
if (parts.Length == 1)
{
break;
}
@string = parts[1];
}
}
// We're done. If everything's kosher, we'll return true.
if (!IrcValidation.ValidateStatement(statement, out errorMessage))
{
goto invalid;
}
parseResult = IrcStatementParseResult.OK;
return(true);
invalid:
#if DEBUG
Console.WriteLine("Invalid statement '{0}' (error '{1}').", debugString, errorMessage);
#endif
statement = null; parseResult = IrcStatementParseResult.InvalidStatement;
return(false);
}
/// <summary>
/// The on message.
/// </summary>
/// <param name="messageType">
/// The message type.
/// </param>
/// <param name="message">
/// The message.
/// </param>
/// <param name="sender">
/// The sender.
/// </param>
internal void OnMessage(EventDispatcher.MessageType messageType, string message, IrcIdentity sender)
{
if (this.ServerUser.IsMe(sender))
{
return;
}
if (messageType == EventDispatcher.MessageType.Message)
{
Commands.Interprete(message, sender, this.ServerUser, this);
}
else
{
Debug.WriteLine(
string.Format(
"Message \"{0}\" (from {1})",
message,
(sender != null) ? sender.Nickname.ToString() : "Anonymous"),
this.ToString());
}
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (!IrcIdentity.TryParse(nick, out var ident))
{
command.Reply("Invalid identity.");
return;
}
var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient);
if (!channel.WeAreOpped)
{
if (channel.HasChanServ)
{
Bootstrap.Client.Client.Message("ChanServ", string.Format("op {0}", channel.Name));
}
else
{
command.Reply("I'm not opped, send help.");
return;
}
}
Bootstrap.Client.Whois.Query(ident,
whoisData =>
{
if (whoisData.Identity.Nickname != null)
{
ident = whoisData.Identity;
}
var nickname = ident.Nickname;
if (nickname.ToString().ToLowerInvariant() == Bootstrap.Client.TrueNickname.ToLowerInvariant())
{
command.Reply("Don't you even dare.");
return;
}
if (whoisData.Identity.Nickname != null)
{
Whois.NormalizeIdentity(ident);
}
else
{
if (ident.Username == null)
{
ident.Username = "******";
}
if (ident.Hostname == null)
{
ident.Hostname = "*";
}
}
var targetChannel = command.Arguments.Groups["channel"].Value.Trim();
if (targetChannel.Length == 0)
{
targetChannel = Bootstrap.Client.Settings.RedirectChannel;
}
else if (!IrcValidation.IsChannelName(targetChannel))
{
command.Reply("Invalid target channel.");
return;
}
if (Bootstrap.Client.ModeList.Find(command.Event.Recipient, ident.ToString(), "-b") != null)
{
command.Reply("{0} is already banned in this channel.", ident);
return;
}
Log.WriteInfo("Redirect", "'{0}' redirected '{1}' from {2} to {3}", command.Event.Sender, ident, command.Event.Recipient, targetChannel);
var reason = string.Format("Redirected to {0} by {1} for 2 hours", targetChannel, command.Event.Sender.Nickname);
Bootstrap.Client.Client.Mode(command.Event.Recipient, "+b", ident + "$" + targetChannel);
if (channel.HasUser(nickname))
{
Bootstrap.Client.Client.Kick(nickname, command.Event.Recipient, reason);
}
command.ReplyAsNotice("Redirected {0} to {1} for 2 hours", ident, targetChannel);
Bootstrap.Client.ModeList.AddLateModeRequest(
new LateModeRequest
{
Channel = command.Event.Recipient,
Recipient = ident.ToString(),
Sender = command.Event.Sender.ToString(),
Mode = "-b",
Time = DateTime.UtcNow.AddHours(2),
Reason = reason
}
);
}
);
}
/// <summary>
/// Creates a new instance of <see cref="JoinLeaveEventArgs"/>.
/// </summary>
/// <param name="identity">The user who joined or left the channel(s).</param>
/// <param name="channels">The list of channels joined or left.</param>
public JoinLeaveEventArgs(IrcIdentity identity, IrcString[] channels)
{
Throw.If.Null(identity, "identity").NullElements(channels, "channels");
Identity = identity; _channels = (IrcString[])channels.Clone();
}
/// <summary>
/// Creates an IRC statement.
/// </summary>
/// <param name="source">The source of the statement, if any. This is called the prefix in the IRC specification.</param>
/// <param name="command">The command or three-digit reply code.</param>
/// <param name="parameters">The parameters of the command.</param>
public IrcStatement(IrcIdentity source, IrcString command, params IrcString[] parameters)
{
Source = source; Command = command; Parameters = new List <IrcString>(parameters);
}
/// <summary>
/// The on leave join.
/// </summary>
/// <param name="isJoin">
/// The is join.
/// </param>
/// <param name="identity">
/// The identity.
/// </param>
internal void OnLeaveJoin(bool isJoin, IrcIdentity identity)
{
Debug.WriteLine(string.Format("{0} {1}", identity.Nickname, isJoin ? "joined" : "left"), this.ToString());
if (identity.Username == this.ServerUser.UserName)
{
this.IsActive = isJoin;
}
else
{
this.EvaluateUserName(identity.Username);
}
}
/// <summary>
/// Creates a new instance of <see cref="QuitEventArgs"/>.
/// </summary>
/// <param name="identity">The user who disconnected.</param>
/// <param name="quitMessage">The quit message, or <c>null</c> if none was given.</param>
public QuitEventArgs(IrcIdentity identity, IrcString quitMessage)
{
Throw.If.Null(identity, "identity");
Identity = identity; QuitMessage = quitMessage;
}
/// <summary>
/// The on command.
/// </summary>
/// <param name="messageType">
/// The message type.
/// </param>
/// <param name="command">
/// The command.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="sender">
/// The sender.
/// </param>
internal void OnCommand(EventDispatcher.MessageType messageType, string command, string[] parameters, IrcIdentity sender)
{
CommandDispatcher.Dispatch(command, parameters, sender, this.ServerUser, this);
}
/// <summary>
/// The interprete.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="serverUser">
/// The server user.
/// </param>
/// <param name="channel">
/// The channel.
/// </param>
internal static void Interprete(string message, IrcIdentity sender, ServerUser serverUser, Channel channel)
{
if (null == sender)
{
return;
}
var user = User.GetOrCreate(sender);
if (user.Translate)
{
var language = Services.DetectLanguage(message, false, user.Language == null ? 0.1 : 0.3);
if ((language != null) && (language != "en"))
{
user.Language = language;
}
if (user.Language != null)
{
message = Services.Translate(user.Language, "en", message);
channel.SendMessage(string.Format("{0} ({1}): {2}", user.NickName, user.Language, message));
}
}
if (!user.TalkTo)
{
return;
}
var answer = AskBot(
ChatBot.Romulus,
message,
sender.Username,
serverUser.NickName);
if (channel != null)
{
answer = string.Format("-> {0}: {1}", sender.Nickname, answer);
}
serverUser.SendMessage(Command.GetReceiver(sender, channel), answer);
}
public static User GetOrCreate(IrcIdentity user)
{
if (null == user)
{
return null;
}
if (!UserDictionary.ContainsKey(user.Username))
{
UserDictionary.Add(user.Username, new User(user));
}
return UserDictionary[user.Username];
}
public override void OnCommand(CommandArguments command)
{
var nick = command.Arguments.Groups["nick"].Value;
if (nick.Length == 0 || !IrcIdentity.TryParse(nick, out var ident))
{
ident = command.Event.Sender;
}
Bootstrap.Client.Whois.Query(ident,
whoisData =>
{
if (whoisData.Identity.Nickname == null)
{
command.Reply("There is no user by that nick on the network.");
return;
}
ident = whoisData.Identity;
if (string.Equals(ident.Nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase))
{
command.Reply("That's me, dummy.");
return;
}
if (!Users.TryGetUser(ident, out var user))
{
if (ident.Nickname == command.Event.Sender)
{
command.Reply("You have no permissions.");
return;
}
command.Reply($"{ident.Nickname} has no permissions.");
return;
}
var permissions = new List <string>();
if (user.Permissions.ContainsKey("*"))
{
permissions.AddRange(user.Permissions["*"]);
}
if (user.Permissions.ContainsKey(command.Event.Recipient))
{
permissions.AddRange(user.Permissions[command.Event.Recipient]);
}
if (ident.Nickname == command.Event.Sender)
{
if (permissions.Count > 0)
{
command.Reply($"You have following permissions in this channel: {string.Join(", ", permissions.Distinct())}");
return;
}
command.Reply("You have no permissions in this channel.");
return;
}
if (permissions.Count > 0)
{
command.Reply($"{ident.Nickname} has following permissions in this channel: {string.Join(", ", permissions.Distinct())}");
return;
}
command.Reply($"{ident.Nickname} has no permissions in this channel.");
}
);
}
public static bool TryGetUser(IrcIdentity ident, out User user)
{
return(UsersList.TryGetValue($"{ident.Username}@{ident.Hostname}", out user));
}
/// <summary>
/// Creates a new instance of <see cref="NameChangeEventArgs"/>.
/// </summary>
/// <param name="identity">The user who is changing their nickname.</param>
/// <param name="newName">The new nickname.</param>
public NameChangeEventArgs(IrcIdentity identity, IrcString newName)
{
Throw.If.Null(identity, "identity").Null(newName, "newName");
Identity = identity; NewName = newName;
}
internal bool IsMe(IrcIdentity identity)
{
return identity.Username == this.UserName;
}
