942 lines
31 KiB
C#
942 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Design;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using IRCTokens;
|
|
|
|
namespace IRCStates
|
|
{
|
|
public class Server
|
|
{
|
|
public const string WhoType = "525"; // randomly generated
|
|
private readonly StatefulDecoder _decoder;
|
|
|
|
private Dictionary<string, string> TempCaps;
|
|
|
|
public Server(string name)
|
|
{
|
|
Name = name;
|
|
Registered = false;
|
|
Modes = new List<string>();
|
|
Motd = new List<string>();
|
|
_decoder = new StatefulDecoder();
|
|
Users = new Dictionary<string, User>();
|
|
Channels = new Dictionary<string, Channel>();
|
|
ISupport = new ISupport();
|
|
HasCap = false;
|
|
TempCaps = new Dictionary<string, string>();
|
|
AvailableCaps = new Dictionary<string, string>();
|
|
AgreedCaps = new List<string>();
|
|
}
|
|
|
|
public string Name { get; set; }
|
|
public string NickName { get; set; }
|
|
public string NickNameLower { get; set; }
|
|
public string UserName { get; set; }
|
|
public string HostName { get; set; }
|
|
public string RealName { get; set; }
|
|
public string Account { get; set; }
|
|
public string Away { get; set; }
|
|
|
|
public bool Registered { get; set; }
|
|
public List<string> Modes { get; set; }
|
|
public List<string> Motd { get; set; }
|
|
public Dictionary<string, User> Users { get; set; }
|
|
public Dictionary<string, Channel> Channels { get; set; }
|
|
public Dictionary<string, string> AvailableCaps { get; set; }
|
|
public List<string> AgreedCaps { get; set; }
|
|
|
|
public ISupport ISupport { get; set; }
|
|
public bool HasCap { get; set; }
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"Server(name={Name})";
|
|
}
|
|
|
|
public string CaseFold(string str)
|
|
{
|
|
return Casemap.CaseFold(ISupport.CaseMapping, str);
|
|
}
|
|
|
|
private bool CaseFoldEquals(string s1, string s2)
|
|
{
|
|
return CaseFold(s1) == CaseFold(s2);
|
|
}
|
|
|
|
private bool IsMe(string nickname)
|
|
{
|
|
return CaseFold(nickname) == NickNameLower;
|
|
}
|
|
|
|
private bool HasUser(string nickname)
|
|
{
|
|
return Users.ContainsKey(CaseFold(nickname));
|
|
}
|
|
|
|
private User AddUser(string nickname, string nicknameLower)
|
|
{
|
|
var user = CreateUser(nickname, nicknameLower);
|
|
Users[nicknameLower] = user;
|
|
return user;
|
|
}
|
|
|
|
private User CreateUser(string nickname, string nicknameLower)
|
|
{
|
|
var user = new User();
|
|
user.SetNickName(nickname, nicknameLower);
|
|
return user;
|
|
}
|
|
|
|
private bool IsChannel(string target)
|
|
{
|
|
return !string.IsNullOrEmpty(target) &&
|
|
ISupport.ChanTypes.Contains(target[0].ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
public bool HasChannel(string name)
|
|
{
|
|
return Channels.ContainsKey(CaseFold(name));
|
|
}
|
|
|
|
private Channel GetChannel(string name)
|
|
{
|
|
return HasChannel(name) ? Channels[name] : null;
|
|
}
|
|
|
|
private ChannelUser UserJoin(Channel channel, User user)
|
|
{
|
|
var channelUser = new ChannelUser();
|
|
user.Channels.Add(CaseFold(channel.Name));
|
|
channel.Users[user.NickNameLower] = channelUser;
|
|
return channelUser;
|
|
}
|
|
|
|
private void SelfHostmask(Hostmask hostmask)
|
|
{
|
|
NickName = hostmask.NickName;
|
|
if (hostmask.UserName != null) UserName = hostmask.UserName;
|
|
if (hostmask.HostName != null) HostName = hostmask.HostName;
|
|
}
|
|
|
|
private (Emit, User) UserPart(Line line, string nickName, string channelName, int reasonIndex)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(channelName);
|
|
if (line.Params.Count >= reasonIndex + 1) emit.Text = line.Params[reasonIndex];
|
|
|
|
User user = null;
|
|
if (HasChannel(channelName))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
var nickLower = CaseFold(nickName);
|
|
if (HasUser(nickLower))
|
|
{
|
|
user = Users[nickLower];
|
|
user.Channels.Remove(channelLower);
|
|
channel.Users.Remove(nickLower);
|
|
if (!user.Channels.Any()) Users.Remove(nickLower);
|
|
}
|
|
|
|
if (IsMe(nickName))
|
|
{
|
|
Channels.Remove(channelLower);
|
|
foreach (var userToRemove in channel.Users.Keys.Select(u => Users[u]))
|
|
{
|
|
userToRemove.Channels.Remove(channelLower);
|
|
if (!userToRemove.Channels.Any()) Users.Remove(userToRemove.NickNameLower);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (emit, user);
|
|
}
|
|
|
|
private void SetChannelModes(Channel channel, IEnumerable<(bool, string)> modes, IList<string> parameters)
|
|
{
|
|
foreach (var (add, c) in modes)
|
|
{
|
|
var listMode = ISupport.ChanModes.ListModes.Contains(c);
|
|
if (ISupport.Prefix.Modes.Contains(c))
|
|
{
|
|
var nicknameLower = CaseFold(parameters.First());
|
|
parameters.RemoveAt(0);
|
|
if (!HasUser(nicknameLower)) continue;
|
|
|
|
var channelUser = channel.Users[nicknameLower];
|
|
if (add)
|
|
{
|
|
if (!channelUser.Modes.Contains(c))
|
|
{
|
|
channelUser.Modes.Add(c);
|
|
}
|
|
}
|
|
else if (channelUser.Modes.Contains(c))
|
|
{
|
|
channelUser.Modes.Remove(c);
|
|
}
|
|
}
|
|
else if (add && (listMode ||
|
|
ISupport.ChanModes.SettingBModes.Contains(c) ||
|
|
ISupport.ChanModes.SettingCModes.Contains(c)))
|
|
{
|
|
channel.AddMode(c, parameters.First(), listMode);
|
|
parameters.RemoveAt(0);
|
|
}
|
|
else if (!add && (listMode || ISupport.ChanModes.SettingBModes.Contains(c)))
|
|
{
|
|
channel.RemoveMode(c, parameters.First());
|
|
parameters.RemoveAt(0);
|
|
}
|
|
else if (add)
|
|
{
|
|
channel.AddMode(c, null, false);
|
|
}
|
|
else
|
|
{
|
|
channel.RemoveMode(c, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public IEnumerable<(Line, Emit)> Receive(byte[] data, int length)
|
|
{
|
|
if (data == null) return null;
|
|
|
|
var lines = _decoder.Push(data, length);
|
|
if (lines == null) throw new ServerDisconnectedException();
|
|
|
|
return lines.Select(l => (l, Parse(l))).ToList();
|
|
}
|
|
|
|
public Emit Parse(Line line)
|
|
{
|
|
if (line == null) return null;
|
|
|
|
var emit = line.Command switch
|
|
{
|
|
Numeric.RPL_WELCOME => HandleWelcome(line),
|
|
Numeric.RPL_ISUPPORT => HandleISupport(line),
|
|
Numeric.RPL_MOTDSTART => HandleMotd(line),
|
|
Numeric.RPL_MOTD => HandleMotd(line),
|
|
Commands.Nick => HandleNick(line),
|
|
Commands.Join => HandleJoin(line),
|
|
Commands.Part => HandlePart(line),
|
|
Commands.Kick => HandleKick(line),
|
|
Commands.Quit => HandleQuit(line),
|
|
Commands.Error => HandleError(line),
|
|
Numeric.RPL_NAMREPLY => HandleNames(line),
|
|
Numeric.RPL_CREATIONTIME => HandleCreationTime(line),
|
|
Commands.Topic => HandleTopic(line),
|
|
Numeric.RPL_TOPIC => HandleTopicNumeric(line),
|
|
Numeric.RPL_TOPICWHOTIME => HandleTopicTime(line),
|
|
Commands.Mode => HandleMode(line),
|
|
Numeric.RPL_CHANNELMODEIS => HandleChannelModeIs(line),
|
|
Numeric.RPL_UMODEIS => HandleUModeIs(line),
|
|
Commands.Privmsg => HandleMessage(line),
|
|
Commands.Notice => HandleMessage(line),
|
|
Commands.Tagmsg => HandleMessage(line),
|
|
Numeric.RPL_VISIBLEHOST => HandleVisibleHost(line),
|
|
Numeric.RPL_WHOREPLY => HandleWhoReply(line),
|
|
Numeric.RPL_WHOSPCRPL => HandleWhox(line),
|
|
Numeric.RPL_WHOISUSER => HandleWhoIsUser(line),
|
|
Commands.Chghost => HandleChghost(line),
|
|
Commands.Setname => HandleSetname(line),
|
|
Commands.Away => HandleAway(line),
|
|
Commands.Account => HandleAccount(line),
|
|
Commands.Cap => HandleCap(line),
|
|
Numeric.RPL_LOGGEDIN => HandleLoggedIn(line),
|
|
Numeric.RPL_LOGGEDOUT => HandleLoggedOut(line),
|
|
_ => null
|
|
};
|
|
|
|
if (emit != null)
|
|
emit.Command = line.Command;
|
|
else
|
|
emit = new Emit();
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleSetname(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var realname = line.Params[0];
|
|
var nicknameLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
if (IsMe(nicknameLower))
|
|
{
|
|
emit.Self = true;
|
|
RealName = realname;
|
|
}
|
|
|
|
if (Users.ContainsKey(nicknameLower))
|
|
{
|
|
var user = Users[nicknameLower];
|
|
emit.User = user;
|
|
user.RealName = realname;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleAway(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var away = line.Params.FirstOrDefault();
|
|
var nicknameLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
if (IsMe(nicknameLower))
|
|
{
|
|
emit.Self = true;
|
|
Away = away;
|
|
}
|
|
|
|
if (Users.ContainsKey(nicknameLower))
|
|
{
|
|
var user = Users[nicknameLower];
|
|
emit.User = user;
|
|
user.Away = away;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleAccount(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var account = line.Params[0].Trim('*');
|
|
var nicknameLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
if (IsMe(nicknameLower))
|
|
{
|
|
emit.Self = true;
|
|
Account = account;
|
|
}
|
|
|
|
if (Users.ContainsKey(nicknameLower))
|
|
{
|
|
var user = Users[nicknameLower];
|
|
emit.User = user;
|
|
user.Account = account;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleCap(Line line)
|
|
{
|
|
HasCap = true;
|
|
var subcommand = line.Params[1].ToUpperInvariant();
|
|
var multiline = line.Params[2] == "*";
|
|
var caps = line.Params[multiline ? 3 : 2];
|
|
|
|
var tokens = new Dictionary<string, string>();
|
|
var tokensStr = new List<string>();
|
|
foreach (var cap in caps.Split(' ', StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
tokensStr.Add(cap);
|
|
var kv = cap.Split('=', 2);
|
|
tokens[kv[0]] = kv.Length > 1 ? kv[1] : string.Empty;
|
|
}
|
|
|
|
var emit = new Emit {Subcommand = subcommand, Finished = !multiline, Tokens = tokensStr};
|
|
|
|
switch (subcommand)
|
|
{
|
|
case "LS":
|
|
TempCaps.UpdateWith(tokens);
|
|
if (!multiline)
|
|
{
|
|
AvailableCaps.UpdateWith(TempCaps);
|
|
TempCaps.Clear();
|
|
}
|
|
|
|
break;
|
|
case "NEW":
|
|
AvailableCaps.UpdateWith(tokens);
|
|
break;
|
|
case "DEL":
|
|
foreach (var key in tokens.Keys.Where(key => AvailableCaps.ContainsKey(key)))
|
|
{
|
|
AvailableCaps.Remove(key);
|
|
if (AgreedCaps.Contains(key)) AgreedCaps.Remove(key);
|
|
}
|
|
|
|
break;
|
|
case "ACK":
|
|
foreach (var key in tokens.Keys)
|
|
if (key.StartsWith('-'))
|
|
{
|
|
var k = key.Substring(1);
|
|
if (AgreedCaps.Contains(k)) AgreedCaps.Remove(k);
|
|
}
|
|
else if (!AgreedCaps.Contains(key) && AvailableCaps.ContainsKey(key))
|
|
{
|
|
AgreedCaps.Add(key);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleLoggedIn(Line line)
|
|
{
|
|
SelfHostmask(new Hostmask(line.Params[1]));
|
|
Account = line.Params[2];
|
|
return new Emit();
|
|
}
|
|
|
|
private Emit HandleChghost(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var username = line.Params[0];
|
|
var hostname = line.Params[1];
|
|
var nicknameLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
if (IsMe(nicknameLower))
|
|
{
|
|
emit.Self = true;
|
|
UserName = username;
|
|
HostName = hostname;
|
|
}
|
|
|
|
if (Users.ContainsKey(nicknameLower))
|
|
{
|
|
var user = Users[nicknameLower];
|
|
emit.User = user;
|
|
user.UserName = username;
|
|
user.HostName = hostname;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleWhoIsUser(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var nickname = line.Params[1];
|
|
var username = line.Params[2];
|
|
var hostname = line.Params[3];
|
|
var realname = line.Params[5];
|
|
|
|
if (IsMe(nickname))
|
|
{
|
|
emit.Self = true;
|
|
UserName = username;
|
|
HostName = hostname;
|
|
RealName = realname;
|
|
}
|
|
|
|
if (HasUser(nickname))
|
|
{
|
|
var user = Users[CaseFold(nickname)];
|
|
emit.User = user;
|
|
user.UserName = username;
|
|
user.HostName = hostname;
|
|
user.RealName = realname;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleWhox(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
if (line.Params[1] == WhoType && line.Params.Count == 8)
|
|
{
|
|
var nickname = line.Params[5];
|
|
var username = line.Params[2];
|
|
var hostname = line.Params[4];
|
|
var realname = line.Params[7];
|
|
var account = line.Params[6] == "0" ? null : line.Params[6];
|
|
|
|
if (IsMe(nickname))
|
|
{
|
|
emit.Self = true;
|
|
UserName = username;
|
|
HostName = hostname;
|
|
RealName = realname;
|
|
Account = account;
|
|
}
|
|
|
|
if (HasUser(nickname))
|
|
{
|
|
var user = Users[CaseFold(nickname)];
|
|
emit.User = user;
|
|
user.UserName = username;
|
|
user.HostName = hostname;
|
|
user.RealName = realname;
|
|
user.Account = account;
|
|
}
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleWhoReply(Line line)
|
|
{
|
|
var emit = new Emit {Target = line.Params[1]};
|
|
var nickname = line.Params[5];
|
|
var username = line.Params[2];
|
|
var hostname = line.Params[3];
|
|
var realname = line.Params[7].Split(' ', 2)[1];
|
|
|
|
if (IsMe(nickname))
|
|
{
|
|
emit.Self = true;
|
|
UserName = username;
|
|
HostName = hostname;
|
|
RealName = realname;
|
|
}
|
|
|
|
if (HasUser(nickname))
|
|
{
|
|
var user = Users[CaseFold(nickname)];
|
|
emit.User = user;
|
|
user.UserName = username;
|
|
user.HostName = hostname;
|
|
user.RealName = realname;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleVisibleHost(Line line)
|
|
{
|
|
var split = line.Params[1].Split('@', 2);
|
|
switch (split.Length)
|
|
{
|
|
case 1:
|
|
HostName = split[0];
|
|
break;
|
|
case 2:
|
|
HostName = split[1];
|
|
UserName = split[0];
|
|
break;
|
|
}
|
|
|
|
return new Emit();
|
|
}
|
|
|
|
private Emit HandleMessage(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var message = line.Params.Count > 1 ? line.Params[1] : null;
|
|
if (message != null) emit.Text = message;
|
|
|
|
var nickLower = CaseFold(line.Hostmask.NickName);
|
|
if (IsMe(nickLower))
|
|
{
|
|
emit.SelfSource = true;
|
|
SelfHostmask(line.Hostmask);
|
|
}
|
|
|
|
var user = HasUser(nickLower)
|
|
? Users[nickLower]
|
|
: AddUser(line.Hostmask.NickName, nickLower);
|
|
emit.User = user;
|
|
|
|
if (line.Hostmask.UserName != null) user.UserName = line.Hostmask.UserName;
|
|
if (line.Hostmask.HostName != null) user.HostName = line.Hostmask.HostName;
|
|
|
|
var target = line.Params[0];
|
|
var statusMsg = new List<string>();
|
|
while (target.Length > 0)
|
|
{
|
|
var t = target[0].ToString(CultureInfo.InvariantCulture);
|
|
if (ISupport.StatusMsg.Contains(t))
|
|
{
|
|
statusMsg.Add(t);
|
|
target = target.Substring(1);
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
emit.Target = line.Params[0];
|
|
|
|
if (IsChannel(target) && HasChannel(target))
|
|
{
|
|
emit.Channel = Channels[CaseFold(target)];
|
|
}
|
|
else if (IsMe(target))
|
|
{
|
|
emit.SelfTarget = true;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleUModeIs(Line line)
|
|
{
|
|
foreach (var c in line.Params[1]
|
|
.TrimStart('+')
|
|
.Select(m => m.ToString(CultureInfo.InvariantCulture))
|
|
.Where(m => !Modes.Contains(m)))
|
|
{
|
|
Modes.Add(c);
|
|
}
|
|
|
|
return new Emit();
|
|
}
|
|
|
|
private Emit HandleChannelModeIs(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
if (HasChannel(line.Params[1]))
|
|
{
|
|
var channel = Channels[CaseFold(line.Params[1])];
|
|
emit.Channel = channel;
|
|
var modes = line.Params[2]
|
|
.TrimStart('+')
|
|
.Select(p => (true, p.ToString(CultureInfo.InvariantCulture)));
|
|
var parameters = line.Params.Skip(3).ToList();
|
|
SetChannelModes(channel, modes, parameters);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleMode(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var target = line.Params[0];
|
|
var modeString = line.Params[1];
|
|
var parameters = line.Params.Skip(2).ToList();
|
|
|
|
var modifier = '+';
|
|
var modes = new List<(bool, string)>();
|
|
var tokens = new List<string>();
|
|
|
|
foreach (var c in modeString)
|
|
{
|
|
if (new[] {'+', '-'}.Contains(c))
|
|
{
|
|
modifier = c;
|
|
}
|
|
else
|
|
{
|
|
modes.Add((modifier == '+', c.ToString(CultureInfo.InvariantCulture)));
|
|
tokens.Add($"{modifier}{c}");
|
|
}
|
|
}
|
|
|
|
emit.Tokens = tokens;
|
|
|
|
if (IsMe(target))
|
|
{
|
|
emit.SelfTarget = true;
|
|
foreach (var (add, c) in modes)
|
|
{
|
|
if (add && !Modes.Contains(c))
|
|
Modes.Add(c);
|
|
else if (Modes.Contains(c)) Modes.Remove(c);
|
|
}
|
|
}
|
|
else if (HasChannel(target))
|
|
{
|
|
var channel = GetChannel(CaseFold(target));
|
|
emit.Channel = channel;
|
|
SetChannelModes(channel, modes, parameters);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleTopicTime(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(line.Params[1]);
|
|
if (Channels.ContainsKey(channelLower))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
channel.TopicSetter = line.Params[2];
|
|
channel.TopicTime = DateTimeOffset
|
|
.FromUnixTimeSeconds(int.Parse(line.Params[3], CultureInfo.InvariantCulture)).DateTime;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleTopicNumeric(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(line.Params[1]);
|
|
if (Channels.ContainsKey(channelLower))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
Channels[channelLower].Topic = line.Params[2];
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleTopic(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(line.Params[0]);
|
|
if (Channels.ContainsKey(channelLower))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
channel.Topic = line.Params[1];
|
|
channel.TopicSetter = line.Hostmask.ToString();
|
|
channel.TopicTime = DateTime.UtcNow;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleCreationTime(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(line.Params[1]);
|
|
if (Channels.ContainsKey(channelLower))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
channel.Created = DateTimeOffset
|
|
.FromUnixTimeSeconds(int.Parse(line.Params[2], CultureInfo.InvariantCulture)).DateTime;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleNames(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var channelLower = CaseFold(line.Params[2]);
|
|
|
|
if (!Channels.ContainsKey(channelLower)) return emit;
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
var nicknames = line.Params[3].Split(' ', StringSplitOptions.RemoveEmptyEntries);
|
|
var users = new List<User>();
|
|
emit.Users = users;
|
|
|
|
foreach (var nick in nicknames)
|
|
{
|
|
var modes = "";
|
|
foreach (var c in nick)
|
|
{
|
|
var mode = ISupport.Prefix.FromPrefix(c);
|
|
if (mode != null)
|
|
modes += mode;
|
|
else
|
|
break;
|
|
}
|
|
|
|
var hostmask = new Hostmask(nick.Substring(modes.Length));
|
|
var nickLower = CaseFold(hostmask.NickName);
|
|
if (!Users.ContainsKey(nickLower)) AddUser(hostmask.NickName, nickLower);
|
|
|
|
var user = Users[nickLower];
|
|
users.Add(user);
|
|
var channelUser = UserJoin(channel, user);
|
|
|
|
if (hostmask.UserName != null) user.UserName = hostmask.UserName;
|
|
if (hostmask.HostName != null) user.HostName = hostmask.HostName;
|
|
|
|
if (IsMe(nickLower)) SelfHostmask(hostmask);
|
|
|
|
foreach (var mode in modes.Select(c => c.ToString(CultureInfo.InvariantCulture)))
|
|
if (!channelUser.Modes.Contains(mode))
|
|
channelUser.Modes.Add(mode);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleError(Line line)
|
|
{
|
|
Users.Clear();
|
|
Channels.Clear();
|
|
return new Emit();
|
|
}
|
|
|
|
private Emit HandleQuit(Line line)
|
|
{
|
|
var emit = new Emit();
|
|
var nickLower = CaseFold(line.Hostmask.NickName);
|
|
if (line.Params.Any()) emit.Text = line.Params[0];
|
|
|
|
if (IsMe(nickLower) || line.Source == null)
|
|
{
|
|
emit.Self = true;
|
|
Users.Clear();
|
|
Channels.Clear();
|
|
}
|
|
else if (Users.ContainsKey(nickLower))
|
|
{
|
|
var user = Users[nickLower];
|
|
Users.Remove(nickLower);
|
|
emit.User = user;
|
|
foreach (var channel in user.Channels.Select(c => Channels[c]))
|
|
channel.Users.Remove(user.NickNameLower);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleLoggedOut(Line line)
|
|
{
|
|
Account = null;
|
|
SelfHostmask(new Hostmask(line.Params[1]));
|
|
return new Emit();
|
|
}
|
|
|
|
private Emit HandleKick(Line line)
|
|
{
|
|
var (emit, kicked) = UserPart(line, line.Params[1], line.Params[0], 2);
|
|
if (kicked != null)
|
|
{
|
|
emit.UserTarget = kicked;
|
|
if (IsMe(kicked.NickName)) emit.Self = true;
|
|
|
|
var kickerLower = CaseFold(line.Hostmask.NickName);
|
|
if (IsMe(kickerLower)) emit.SelfSource = true;
|
|
|
|
emit.UserSource = Users.ContainsKey(kickerLower)
|
|
? Users[kickerLower]
|
|
: CreateUser(line.Hostmask.NickName, kickerLower);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandlePart(Line line)
|
|
{
|
|
var (emit, user) = UserPart(line, line.Hostmask.NickName, line.Params[0], 1);
|
|
if (user != null)
|
|
{
|
|
emit.User = user;
|
|
if (IsMe(user.NickName)) emit.Self = true;
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
|
|
private Emit HandleJoin(Line line)
|
|
{
|
|
var extended = line.Params.Count == 3;
|
|
var account = extended ? line.Params[1].Trim('*') : null;
|
|
var realname = extended ? line.Params[2] : null;
|
|
var emit = new Emit();
|
|
|
|
var channelLower = CaseFold(line.Params[0]);
|
|
var nickLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
// handle own join
|
|
if (IsMe(nickLower))
|
|
{
|
|
emit.Self = true;
|
|
if (!HasChannel(channelLower))
|
|
{
|
|
var channel = new Channel();
|
|
channel.SetName(line.Params[0], channelLower);
|
|
Channels[channelLower] = channel;
|
|
}
|
|
|
|
SelfHostmask(line.Hostmask);
|
|
if (extended)
|
|
{
|
|
Account = account;
|
|
RealName = realname;
|
|
}
|
|
}
|
|
|
|
if (HasChannel(channelLower))
|
|
{
|
|
var channel = Channels[channelLower];
|
|
emit.Channel = channel;
|
|
|
|
if (!HasUser(nickLower)) AddUser(line.Hostmask.NickName, nickLower);
|
|
|
|
var user = Users[nickLower];
|
|
emit.User = user;
|
|
if (line.Hostmask.UserName != null) user.UserName = line.Hostmask.UserName;
|
|
if (line.Hostmask.HostName != null) user.HostName = line.Hostmask.HostName;
|
|
if (extended)
|
|
{
|
|
user.Account = account;
|
|
user.RealName = realname;
|
|
}
|
|
|
|
UserJoin(channel, user);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
|
|
private Emit HandleNick(Line line)
|
|
{
|
|
var nick = line.Params[0];
|
|
var nickLower = CaseFold(line.Hostmask.NickName);
|
|
|
|
var emit = new Emit();
|
|
|
|
if (Users.ContainsKey(nickLower))
|
|
{
|
|
var user = Users[nickLower];
|
|
Users.Remove(nickLower);
|
|
emit.User = user;
|
|
|
|
var oldNickLower = user.NickNameLower;
|
|
var newNickLower = CaseFold(nick);
|
|
user.SetNickName(nick, newNickLower);
|
|
Users[newNickLower] = user;
|
|
foreach (var channelLower in user.Channels)
|
|
{
|
|
var channel = Channels[channelLower];
|
|
var channelUser = channel.Users[oldNickLower];
|
|
channel.Users.Remove(oldNickLower);
|
|
channel.Users[newNickLower] = channelUser;
|
|
}
|
|
}
|
|
|
|
if (IsMe(nickLower))
|
|
{
|
|
emit.Self = true;
|
|
NickName = nick;
|
|
NickNameLower = CaseFold(nick);
|
|
}
|
|
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleMotd(Line line)
|
|
{
|
|
if (line.Command == Numeric.RPL_MOTDSTART) Motd.Clear();
|
|
|
|
var emit = new Emit {Text = line.Params[1]};
|
|
Motd.Add(line.Params[1]);
|
|
return emit;
|
|
}
|
|
|
|
private Emit HandleISupport(Line line)
|
|
{
|
|
ISupport = new ISupport();
|
|
ISupport.Parse(line.Params);
|
|
return new Emit();
|
|
}
|
|
|
|
|
|
private Emit HandleWelcome(Line line)
|
|
{
|
|
NickName = line.Params[0];
|
|
NickNameLower = CaseFold(line.Params[0]);
|
|
Registered = true;
|
|
return new Emit();
|
|
}
|
|
}
|
|
}
|