def match_gline(self, user):
if "o" in user.mode:
return None # don't allow bans to affect opers
if "except_line" not in user.cache:
if "gline_match" in user.cache:
return user.cache["gline_match"]
# Determine whether the user matches
self.expire_glines()
match_against = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.banList.iteritems():
if fnmatch(match_against, mask):
user.cache["gline_match"] = linedata["reason"]
return ""
match_against = irc_lower("{}@{}".format(user.username, user.ip))
for mask in self.banList.iterkeys(): # we just removed expired lines
if fnmatch(match_against, mask):
user.cache["gline_match"] = linedata["reason"]
return ""
return None
else:
if user.cache["except_line"]:
return None
if "gline_match" in user.cache:
return user.cache["gline_match"]
self.expire_glines()
match_against = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.banList.iteritems():
if fnmatch(match_against, mask):
return linedata["reason"]
match_against = irc_lower("{}@{}".format(user.username, user.ip))
for mask in self.banList.iterkeys(): # we just removed expired lines
if fnmatch(match_against, mask):
return linedata["reason"]
return None
def checkPermission(self, user, cmd, data):
if cmd != "JOIN":
return data
channels = data["targetchan"]
if "ban_evaluating" not in user.cache:
user.cache["ban_evaluating"] = channels
return "again"
keys = data["keys"]
for hostmask in (irc_lower(user.prefix()), irc_lower("{}!{}@{}".format(user.nickname, user.username, user.realhost)), irc_lower("{}!{}@{}".format(user.nickname, user.username, user.ip))):
remove = []
for chan in user.cache["ban_evaluating"]:
if "b" in chan.mode:
for mask in chan.mode["b"]:
if fnmatch(hostmask, irc_lower(mask)):
remove.append(chan)
user.sendMessage(irc.ERR_BANNEDFROMCHAN, chan.name, ":Cannot join channel (You're banned)")
break
for chan in remove:
index = channels.index(chan)
channels.pop(index)
keys.pop(index)
data["targetchan"] = channels
data["keys"] = keys
del user.cache["ban_evaluating"]
return data
def match_gline(self, user):
if "o" in user.mode:
return None # don't allow bans to affect opers
if "except_line" not in user.cache:
if "gline_match" in user.cache:
return user.cache["gline_match"]
# Determine whether the user matches
self.expire_glines()
match_against = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.banList.iteritems():
if fnmatch(match_against, mask):
user.cache["gline_match"] = linedata["reason"]
return ""
match_against = irc_lower("{}@{}".format(user.username, user.ip))
for mask in self.banList.iterkeys(): # we just removed expired lines
if fnmatch(match_against, mask):
user.cache["gline_match"] = linedata["reason"]
return ""
return None
else:
if user.cache["except_line"]:
return None
if "gline_match" in user.cache:
return user.cache["gline_match"]
self.expire_glines()
match_against = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.banList.iteritems():
if fnmatch(match_against, mask):
return linedata["reason"]
match_against = irc_lower("{}@{}".format(user.username, user.ip))
for mask in self.banList.iterkeys(): # we just removed expired lines
if fnmatch(match_against, mask):
return linedata["reason"]
return None
def denyChannels(self, user, cmd, data):
if "o" in user.mode:
return data
if cmd != "JOIN":
return data
channels = data["targetchan"]
keys = data["keys"]
remove = []
for channel in channels:
lowerName = irc_lower(channel.name)
safe = False
if "channel_allowchans" in self.ircd.servconfig:
for chanmask in self.ircd.servconfig["channel_allowchans"]:
if fnmatch(lowerName, irc_lower(chanmask)):
safe = True
if not safe:
for chanmask in self.ircd.servconfig["channel_denychans"]:
if fnmatch(lowerName, irc_lower(chanmask)):
remove.append(channel)
user.sendMessage(irc.ERR_CHANNOTALLOWED, channel.name, ":Channel {} is forbidden".format(channel.name))
break
for chan in remove:
index = channels.index(chan)
channels.pop(index)
keys.pop(index)
data["targetchan"] = channels
data["keys"] = keys
return data
def denyChannels(self, user, cmd, data):
if "o" in user.mode:
return data
if cmd != "JOIN":
return data
channels = data["targetchan"]
keys = data["keys"]
remove = []
for channel in channels:
lowerName = irc_lower(channel.name)
safe = False
if "channel_allowchans" in self.ircd.servconfig:
for chanmask in self.ircd.servconfig["channel_allowchans"]:
if fnmatch(lowerName, irc_lower(chanmask)):
safe = True
if not safe:
for chanmask in self.ircd.servconfig["channel_denychans"]:
if fnmatch(lowerName, irc_lower(chanmask)):
remove.append(channel)
user.sendMessage(
irc.ERR_CHANNOTALLOWED, channel.name,
":Channel {} is forbidden".format(channel.name))
break
for chan in remove:
index = channels.index(chan)
channels.pop(index)
keys.pop(index)
data["targetchan"] = channels
data["keys"] = keys
return data
def onUse(self, user, data):
if "target" not in data:
for u in self.ircd.users.itervalues():
if "i" in u.mode:
continue
common_channel = False
for chan in self.ircd.channels.itervalues():
if user in chan.users and u in chan.users:
common_channel = True
break
if not common_channel:
self.sendWhoLine(user, u, "*", None, data["filters"] if "filters" in data else "", data["fields"] if "fields" in data else "")
user.sendMessage(irc.RPL_ENDOFWHO, "*", ":End of /WHO list.")
else:
if data["target"] in self.ircd.channels:
cdata = self.ircd.channels[data["target"]]
in_channel = user in cdata.users # cache this value instead of searching every iteration
if not in_channel and ("p" in cdata.mode or "s" in cdata.mode):
irc.sendMessage(irc.RPL_ENDOFWHO, cdata.name, ":End of /WHO list.")
return
for u in cdata.users.iterkeys():
self.sendWhoLine(user, u, cdata.name, cdata, data["filters"], data["fields"])
user.sendMessage(irc.RPL_ENDOFWHO, cdata.name, ":End of /WHO list.")
else:
for u in self.ircd.users.itervalues():
if fnmatch(irc_lower(u.nickname), irc_lower(data["target"])) or fnmatch(irc_lower(u.hostname), irc_lower(data["target"])):
self.sendWhoLine(user, u, data["target"], None, data["filters"], data["fields"])
user.sendMessage(irc.RPL_ENDOFWHO, data["target"], ":End of /WHO list.") # params[0] is used here for the target so that the original glob pattern is returned
def commandPermission(self, user, cmd, data):
if cmd == "NICK" and data["nick"] in [ self.ircd.servconfig["services_nickserv_nick"], self.ircd.servconfig["services_chanserv_nick"], self.ircd.servconfig["services_bidserv_nick"] ]:
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, data["nick"], ":Invalid nickname: Reserved for Services")
return {}
if self.ircd.servconfig["services_nickserv_nick"] not in self.ircd.users:
return data
nickserv = self.ircd.users[self.ircd.servconfig["services_nickserv_nick"]]
if user not in self.blockedUsers:
return data
if cmd == "PRIVMSG":
to_nickserv = False
for u in data["targetuser"]:
if irc_lower(u.nickname) == irc_lower(nickserv.nickname):
to_nickserv = True
break
if to_nickserv:
data["targetuser"] = [nickserv]
data["targetchan"] = []
data["chanmod"] = []
return data
user.sendMessage("NOTICE", ":You cannot message anyone other than NickServ until you identify or change nicks.", prefix=nickserv.prefix())
return {}
if cmd in [ "PING", "PONG", "NICK", "QUIT", "NS", "NICKSERV", "LOGIN", "ID", "IDENTIFY" ]:
return data
user.sendMessage("NOTICE", ":You cannot use the command \x02{}\x02 until you identify or change nicks.".format(cmd), prefix=nickserv.prefix())
return {}
def onUse(self, user, data):
serverMask = irc_lower(data["servers"])
if fnmatch(irc_lower(self.ircd.name), serverMask):
user.sendMessage(irc.RPL_REHASHING, self.ircd.config, ":Rehashing")
self.ircd.rehash()
for server in self.ircd.servers.itervalues():
if fnmatch(irc_lower(server.name), serverMask):
server.callRemote(ModuleMessage, destserver=server.name, type="Rehash", args=[])
user.sendMessage(irc.RPL_REHASHING, self.ircd.config, ":Rehashing {}".format(server.name))
def irc_NICK(self, prefix, params):
if params and irc_lower(params[0]) in self.services: # Can't use a service nick
self.sendMessage(irc.ERR_NICKNAMEINUSE, params[0], ":Nickname is already in use", prefix=self.service_prefix("NickServ"))
return
oldnick = irc_lower(self.nickname)
IRCUser.irc_NICK(self, prefix, params)
newnick = irc_lower(self.nickname)
if oldnick != newnick:
self.checkNick()
def notifyNick(self, user, oldNick):
lowerNick = irc_lower(user.nickname)
lowerOldNick = irc_lower(oldNick)
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if lowerOldNick in watchedBy:
for watcher in watchedBy[lowerOldNick]:
watcher.sendMessage(irc.RPL_MONOFFLINE, ":{}".format(oldNick))
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONONLINE, ":{}".format(user.nickname))
def checkNick(self):
if self.auth_timer:
self.auth_timer.cancel()
self.auth_timer = None
if irc_lower(self.nickname).startswith(irc_lower(self.ircd.nickserv_guest_prefix)):
return # Don't check guest nicks
d = self.query("SELECT donor_id FROM ircnicks WHERE nick = {0}", irc_lower(self.nickname))
d.addCallback(self.beginVerify, self.nickname)
d.addErrback(self.ohshit)
return d
def notifyNick(self, user, oldNick):
lowerNick = irc_lower(user.nickname)
lowerOldNick = irc_lower(oldNick)
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if lowerOldNick in watchedBy:
for watcher in watchedBy[lowerOldNick]:
watcher.sendMessage(irc.RPL_MONOFFLINE, ":{}".format(oldNick))
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONONLINE,
":{}".format(user.nickname))
def onUse(self, user, data):
serverMask = irc_lower(data["servers"])
if fnmatch(irc_lower(self.ircd.name), serverMask):
user.sendMessage(irc.RPL_REHASHING, self.ircd.config, ":Rehashing")
self.ircd.rehash()
for server in self.ircd.servers.itervalues():
if fnmatch(irc_lower(server.name), serverMask):
server.callRemote(ModuleMessage,
destserver=server.name,
type="Rehash",
args=[])
user.sendMessage(irc.RPL_REHASHING, self.ircd.config,
":Rehashing {}".format(server.name))
def match_eline(self, user):
self.expire_elines()
matchMask = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.exceptList.iteritems():
if fnmatch(matchMask, mask):
user.cache["except_line"] = True
return linedata["reason"]
matchMask = irc_lower("{}@{}".format(user.username, user.ip))
for mask, linedata in self.exceptList.iteritems():
if fnmatch(matchMask, mask):
user.cache["except_line"] = True
return linedata["reason"]
user.cache["except_line"] = False
return None
def match_eline(self, user):
self.expire_elines()
matchMask = irc_lower("{}@{}".format(user.username, user.hostname))
for mask, linedata in self.exceptList.iteritems():
if fnmatch(matchMask, mask):
user.cache["except_line"] = True
return linedata["reason"]
matchMask = irc_lower("{}@{}".format(user.username, user.ip))
for mask, linedata in self.exceptList.iteritems():
if fnmatch(matchMask, mask):
user.cache["except_line"] = True
return linedata["reason"]
user.cache["except_line"] = False
return None
def prep_param(self, adding, mode, param):
if mode in "beI":
hostmask = fix_hostmask(param)
if mode == "b":
for u in self.parent.users.itervalues():
if fnmatch.fnmatch(irc_lower(u.prefix()), hostmask):
u.channels[self.parent.name]["banned"] = adding
elif mode == "e":
for u in self.parent.users.itervalues():
if fnmatch.fnmatch(irc_lower(u.prefix()), hostmask):
u.channels[self.parent.name]["exempt"] = adding
return hostmask
if mode == "l":
return int(param)
return param
def notifyConnect(self, user):
lowerNick = irc_lower(user.nickname)
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONONLINE, ":{}".format(user.nickname))
return True
def changeNick(self, id, nickname):
self.auth_timer = None
if self.nickserv_id == id:
return # Somehow we auth'd and didn't clear the timer?
if irc_lower(self.nickname) != nickname:
return # Changed nick before the timeout. Whatever
self.irc_NICK(None, [self.genNick()])
def checkUnset(self, user, target, param):
mask = irc_lower(param)
if mask in self.tellLists and target in self.tellLists[mask]:
self.tellLists[mask].remove(target)
if "servernoticedata" in target.cache and mask in target.cache["servernoticedata"]:
del target.cache["servernoticedata"][mask]
return [True, mask]
def notify(self, target, namespace, key, oldValue, value):
try:
if target.nickname is None:
return # An unregistered user isn't being monitored
except AttributeError: # don't process channels
return
if oldValue == value:
return
source = None
if namespace in ["client", "user"]:
source = target.nickname
elif namespace in ["server", "ext"]:
source = self.ircd.name
else:
return
lowerNick = irc_lower(target.nickname)
if "monitorwatchedby" in self.ircd.module_data_cache and lowerNick in self.ircd.module_data_cache["monitorwatchedby"]:
watcherList = self.ircd.module_data_cache["monitorwatchedby"][lowerNick]
else:
watcherList = []
watchers = set(watcherList)
watchers.add(target)
if not value and key not in target.metadata[namespace]:
for u in watchers:
if "cap" in u.cache and "metadata-notify" in u.cache["cap"]:
u.sendMessage("METADATA", source, target.nickname, "{}.{}".format(namespace, key), to=None, prefix=None)
else:
for u in watchers:
if "cap" in u.cache and "metadata-notify" in u.cache["cap"]:
u.sendMessage("METADATA", source, target.nickname, "{}.{}".format(namespace, key), ":{}".format(value), to=None, prefix=None)
def notifyQuit(self, user, reason):
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if user.registered == 0:
lowerNick = irc_lower(user.nickname)
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONOFFLINE, ":{}".format(user.nickname))
def irc_PRIVMSG(self, prefix, params):
# You can only PRIVMSG NickServ while identifying
if params and self.auth_timer is not None and irc_lower(params[0]) != "nickserv":
self.sendMessage("NOTICE", ":You can not PRIVMSG anybody but NickServ while identifying a registered nick.", prefix=self.service_prefix("NickServ"))
return
if len(params) > 1 and irc_lower(params[0]) in self.services:
service = irc_lower(params[0])
command, chaff, params = params[1].partition(" ")
params = filter(lambda x: x, params.split(" "))
method = getattr(self, "{}_{}".format(service, command.upper()), None)
if method is None:
method = getattr(self, "{}_USAGE".format(service), None)
method(prefix, params, command)
else:
method(prefix, params)
else:
IRCUser.irc_PRIVMSG(self, prefix, params)
def match_qline(self, user):
if "o" in user.mode:
return None
lowerNick = irc_lower(user.nickname)
for mask, linedata in self.banList.iteritems():
if fnmatch(lowerNick, mask):
return linedata["reason"]
return None
def notifyConnect(self, user):
lowerNick = irc_lower(user.nickname)
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONONLINE,
":{}".format(user.nickname))
return True
def notifyQuit(self, user, reason):
watchedBy = self.ircd.module_data_cache["monitorwatchedby"]
if user.registered == 0:
lowerNick = irc_lower(user.nickname)
if lowerNick in watchedBy:
for watcher in watchedBy[lowerNick]:
watcher.sendMessage(irc.RPL_MONOFFLINE,
":{}".format(user.nickname))
def irc_SQUIT(self, prefix, params):
if irc_lower(prefix) == irc_lower(self.parent.factory.name):
prefix = self.name
assert prefix in self.parent.factory.servers, "Server does not exist"
# Broadcast message to other connected servers
self.relay(":%s SQUIT %s :%s" % (prefix, params[0], params[1]))
# Delete users connected through quitting server from state database
for u in self.parent.factory.users.values():
if u.socket == self.parent.factory.servers[prefix].socket:
for c in u.channels:
self.parent.factory.broadcast(c, ":%s QUIT :%s %s" % (u.name, self.name, u.server))
del self.parent.factory.channels[c].users[u.name]
del self.parent.factory.users[u.name]
# Delete server (and other servers behind it) from state database
for s in self.parent.factory.servers.values():
if s.socket == self.parent.factory.servers[prefix].socket:
del self.parent.factory.servers[s.name]
def checkUnset(self, user, target, param):
mask = irc_lower(param)
if mask in self.tellLists and target in self.tellLists[mask]:
self.tellLists[mask].remove(target)
if "servernoticedata" in target.cache and mask in target.cache[
"servernoticedata"]:
del target.cache["servernoticedata"][mask]
return [True, mask]
def match_qline(self, user):
if "o" in user.mode:
return None
lowerNick = irc_lower(user.nickname)
for mask, linedata in self.banList.iteritems():
if fnmatch(lowerNick, mask):
return linedata["reason"]
return None
def beginVerify(self, result, nickname):
if irc_lower(nickname) != irc_lower(self.nickname):
return # Changed nick too fast, don't even worry about it
elif result:
id = result[0][0]
if self.nickserv_id and self.nickserv_id == id:
if self.auth_timer: # Clear the timer
self.auth_timer.cancel()
self.auth_timer = None
return # Already identified
self.sendMessage("NOTICE", ":This is a registered nick. Please use \x02/msg nickserv login EMAIL PASSWORD\x0F to verify your identity", prefix=self.service_prefix("NickServ"))
if self.auth_timer:
self.auth_timer.cancel() # In case we had another going
self.auth_timer = reactor.callLater(self.ircd.nickserv_timeout, self.changeNick, id, nickname)
elif self.nickserv_id:
# Try to register the nick
d = self.query("SELECT nick FROM ircnicks WHERE donor_id = {0}", self.nickserv_id)
d.addCallback(self.registerNick, nickname)
d.addErrback(self.failedRegisterNick, nickname)
def commandPermission(self, user, cmd, data):
if cmd == "NICK" and data["nick"] in [
self.ircd.servconfig["services_nickserv_nick"],
self.ircd.servconfig["services_chanserv_nick"],
self.ircd.servconfig["services_bidserv_nick"]
]:
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, data["nick"],
":Invalid nickname: Reserved for Services")
return {}
if self.ircd.servconfig[
"services_nickserv_nick"] not in self.ircd.users:
return data
nickserv = self.ircd.users[
self.ircd.servconfig["services_nickserv_nick"]]
if user not in self.blockedUsers:
return data
if cmd == "PRIVMSG":
to_nickserv = False
for u in data["targetuser"]:
if irc_lower(u.nickname) == irc_lower(nickserv.nickname):
to_nickserv = True
break
if to_nickserv:
data["targetuser"] = [nickserv]
data["targetchan"] = []
data["chanmod"] = []
return data
user.sendMessage(
"NOTICE",
":You cannot message anyone other than NickServ until you identify or change nicks.",
prefix=nickserv.prefix())
return {}
if cmd in [
"PING", "PONG", "NICK", "QUIT", "NS", "NICKSERV", "LOGIN",
"ID", "IDENTIFY"
]:
return data
user.sendMessage(
"NOTICE",
":You cannot use the command \x02{}\x02 until you identify or change nicks."
.format(cmd),
prefix=nickserv.prefix())
return {}
def processParams(self, user, params):
if user.registered > 0:
user.sendMessage(irc.ERR_NOTREGISTERED, "LIST",
":You have not registered")
return {}
if params:
chanFilter = irc_lower(params[0]).split(",")
else:
chanFilter = None
return {"user": user, "chanfilter": chanFilter}
def blockNick(self, user, command, data):
if command != "NICK":
return data
newNick = data["nick"]
lowerNick = irc_lower(newNick)
self.expire_qlines()
for mask, linedata in self.banList.iteritems():
if fnmatch(lowerNick, mask):
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, newNick, ":Invalid nickname: {}".format(linedata["reason"]))
return {}
return data
def fix_hostmask(hostmask):
if " " in hostmask:
hostmask = hostmask[:hostmask.find(" ")]
if "!" not in hostmask:
if "@" in hostmask:
hostmask = "*!" + hostmask
else:
hostmask += "!*@*"
elif "@" not in hostmask:
hostmask += "@*"
return irc_lower(hostmask)
def processParams(self, user, params):
if not params:
user.sendMessage(irc.ERR_NONICKNAMEGIVEN, ":No nickname given")
return {}
if not params[0]:
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, "*",
":Erroneous nickname")
return {}
if not VALID_NICKNAME.match(params[0]):
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, params[0],
":Erroneous nickname")
return {}
if params[0] == user.nickname:
return {}
if params[0] in self.ircd.users and (not user.nickname or irc_lower(
params[0]) != irc_lower(user.nickname)):
user.sendMessage(irc.ERR_NICKNAMEINUSE,
self.ircd.users[params[0]].nickname,
":Nickname is already in use")
return {}
return {"user": user, "nick": params[0]}
def processParams(self, user, params):
if user.registered > 0:
user.sendMessage(irc.ERR_NOTREGISTERED, "LIST", ":You have not registered")
return {}
if params:
chanFilter = irc_lower(params[0]).split(",")
else:
chanFilter = None
return {
"user": user,
"chanfilter": chanFilter
}
def checkSet(self, user, target, param):
if "o" not in user.mode:
user.sendMessage(irc.ERR_NOPRIVILEGES, ":Permission denied - Only operators may set user mode s")
return [False, param]
mask = irc_lower(param)
if mask not in self.tellLists:
self.tellLists[mask] = []
self.tellLists[mask].append(target)
if "servernoticedata" not in target.cache:
target.cache["servernoticedata"] = {}
target.cache["servernoticedata"][mask] = epoch(now())
return [True, mask]
def onUse(self, user, data):
if "target" not in data:
for u in self.ircd.users.itervalues():
if "i" in u.mode:
continue
common_channel = False
for chan in self.ircd.channels.itervalues():
if user in chan.users and u in chan.users:
common_channel = True
break
if not common_channel:
self.sendWhoLine(
user, u, "*", None,
data["filters"] if "filters" in data else "",
data["fields"] if "fields" in data else "")
user.sendMessage(irc.RPL_ENDOFWHO, "*", ":End of /WHO list.")
else:
if data["target"] in self.ircd.channels:
cdata = self.ircd.channels[data["target"]]
in_channel = user in cdata.users # cache this value instead of searching every iteration
if not in_channel and ("p" in cdata.mode or "s" in cdata.mode):
irc.sendMessage(irc.RPL_ENDOFWHO, cdata.name,
":End of /WHO list.")
return
for u in cdata.users.iterkeys():
self.sendWhoLine(user, u, cdata.name, cdata,
data["filters"], data["fields"])
user.sendMessage(irc.RPL_ENDOFWHO, cdata.name,
":End of /WHO list.")
else:
for u in self.ircd.users.itervalues():
if fnmatch(irc_lower(u.nickname),
irc_lower(data["target"])) or fnmatch(
irc_lower(u.hostname),
irc_lower(data["target"])):
self.sendWhoLine(user, u, data["target"], None,
data["filters"], data["fields"])
user.sendMessage(
irc.RPL_ENDOFWHO, data["target"], ":End of /WHO list."
) # params[0] is used here for the target so that the original glob pattern is returned
def blockNick(self, user, command, data):
if command != "NICK":
return data
newNick = data["nick"]
lowerNick = irc_lower(newNick)
self.expire_qlines()
for mask, linedata in self.banList.iteritems():
if fnmatch(lowerNick, mask):
user.sendMessage(
irc.ERR_ERRONEUSNICKNAME, newNick,
":Invalid nickname: {}".format(linedata["reason"]))
return {}
return data
def checkSet(self, user, target, param):
if "o" not in user.mode:
user.sendMessage(
irc.ERR_NOPRIVILEGES,
":Permission denied - Only operators may set user mode s")
return [False, param]
mask = irc_lower(param)
if mask not in self.tellLists:
self.tellLists[mask] = []
self.tellLists[mask].append(target)
if "servernoticedata" not in target.cache:
target.cache["servernoticedata"] = {}
target.cache["servernoticedata"][mask] = epoch(now())
return [True, mask]
def ChannelFactory(self, name):
logfile = "{}/{}".format(self.app_log_dir, irc_lower(name))
if not os.path.exists(logfile):
os.makedirs(logfile)
c = Channel(
name,
now(),
{"message": None, "author": "", "created": now()},
CaseInsensitiveDictionary(),
ChannelModes(self, None),
DailyLogFile("log", logfile),
)
c.mode.parent = c
c.mode.combine("nt", [], name)
return c
def notify(self, target, namespace, key, oldValue, value):
try:
if target.nickname is None:
return # An unregistered user isn't being monitored
except AttributeError: # don't process channels
return
if oldValue == value:
return
source = None
if namespace in ["client", "user"]:
source = target.nickname
elif namespace in ["server", "ext"]:
source = self.ircd.name
else:
return
lowerNick = irc_lower(target.nickname)
if "monitorwatchedby" in self.ircd.module_data_cache and lowerNick in self.ircd.module_data_cache[
"monitorwatchedby"]:
watcherList = self.ircd.module_data_cache["monitorwatchedby"][
lowerNick]
else:
watcherList = []
watchers = set(watcherList)
watchers.add(target)
if not value and key not in target.metadata[namespace]:
for u in watchers:
if "cap" in u.cache and "metadata-notify" in u.cache["cap"]:
u.sendMessage("METADATA",
source,
target.nickname,
"{}.{}".format(namespace, key),
to=None,
prefix=None)
else:
for u in watchers:
if "cap" in u.cache and "metadata-notify" in u.cache["cap"]:
u.sendMessage("METADATA",
source,
target.nickname,
"{}.{}".format(namespace, key),
":{}".format(value),
to=None,
prefix=None)
def processParams(self, user, params):
if not params:
user.sendMessage(irc.ERR_NONICKNAMEGIVEN, ":No nickname given")
return {}
if not params[0]:
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, "*", ":Erroneous nickname")
return {}
if not VALID_NICKNAME.match(params[0]):
user.sendMessage(irc.ERR_ERRONEUSNICKNAME, params[0], ":Erroneous nickname")
return {}
if params[0] == user.nickname:
return {}
if params[0] in self.ircd.users and (not user.nickname or irc_lower(params[0]) != irc_lower(user.nickname)):
user.sendMessage(irc.ERR_NICKNAMEINUSE, self.ircd.users[params[0]].nickname, ":Nickname is already in use")
return {}
return {
"user": user,
"nick": params[0]
}
def __init__(self, parent, user, password, nick):
# Service nicks are technically valid and not in use, but you can't have them.
if irc_lower(nick) in self.services:
parent.sendMessage(irc.ERR_NICKNAMEINUSE, nick, ":Nickname is already in use", prefix=parent.factory.server_name)
parent.sendMessage("ERROR",":Closing Link: {}".format(nick))
parent.transport.loseConnection()
raise ValueError("Invalid nickname")
IRCUser.__init__(self, parent, user, password, nick)
self.auth_timer = None
self.nickserv_id = None
if password:
if ":" in password:
username, chaff, password = password.partition(":")
self.auth(username, password)
else:
self.token(password)
else:
self.checkNick()
#Auto-join #desertbus
self.join("#desertbus",None)
def irc_NICK(self, prefix, params):
if not params:
self.sendMessage(irc.ERR_NONICKNAMEGIVEN, ":No nickname given", prefix=self.factory.server_name)
elif not VALID_USERNAME.match(params[0]):
self.sendMessage(
irc.ERR_ERRONEUSNICKNAME, params[0], ":Erroneous nickname", prefix=self.factory.server_name
)
elif params[0] in self.factory.users:
self.sendMessage(
irc.ERR_NICKNAMEINUSE,
self.factory.users[params[0]].nickname,
":Nickname is already in use",
prefix=self.factory.server_name,
)
else:
lower_nick = irc_lower(params[0])
expired = []
for mask, linedata in self.factory.xlines["Q"].iteritems():
if linedata["duration"] != 0 and epoch(now()) > epoch(linedata["created"]) + linedata["duration"]:
expired.append(mask)
continue
if fnmatch.fnmatch(lower_nick, mask):
self.sendMessage(
irc.ERR_ERRONEUSNICKNAME,
self.nick if self.nick else "*",
params[0],
":Invalid nickname: {}".format(linedata["reason"]),
prefix=self.factory.server_name,
)
return
for mask in expired:
del self.factory.xlines["Q"][mask]
if expired:
self.factory.save_options()
self.nick = params[0]
if self.user:
try:
self.type = self.factory.types["user"](self, self.user, self.password, self.nick)
except ValueError:
self.type = None
self.transport.loseConnection()
def sendServerNotice(self, type, message):
type = irc_lower(type)
if type in self.tellLists:
for u in self.tellLists[type]:
u.sendMessage("NOTICE", ":*** {}: {}".format(type.upper(), message))
def onUse(self, user, data):
modifier = data["modifier"]
if modifier == "+":
targetlist = data["targetlist"]
discard = []
for target in targetlist:
if len(target) > 32 or " " in target:
discard.append(target)
for target in discard:
targetlist.remove(target)
if "monitormasks" not in user.cache:
user.cache["monitormasks"] = []
if "monitorwatching" not in user.cache:
user.cache["monitorwatching"] = []
if self.limit and len(
user.cache["monitormasks"]) + len(targetlist) > self.limit:
user.sendMessage(irc.ERR_MONLISTFULL, str(self.limit),
",".join(targetlist), ":Monitor list is full")
return
online = []
offline = []
for target in targetlist:
lowerTarget = irc_lower(target)
if lowerTarget not in user.cache["monitorwatching"]:
user.cache["monitormasks"].append(target)
user.cache["monitorwatching"].append(lowerTarget)
if lowerTarget not in self.ircd.module_data_cache[
"monitorwatchedby"]:
self.ircd.module_data_cache["monitorwatchedby"][
lowerTarget] = []
self.ircd.module_data_cache["monitorwatchedby"][
lowerTarget].append(user)
if target in self.ircd.users:
online.append(target)
else:
offline.append(target)
if online:
onLines = chunk_message(" ".join(online), 400)
for line in onLines:
user.sendMessage(irc.RPL_MONONLINE,
":{}".format(line.replace(" ", ",")))
if offline:
offLines = chunk_message(" ".join(offline), 400)
for line in offLines:
user.sendMessage(irc.RPL_MONOFFLINE,
":{}".format(line.replace(" ", ",")))
elif modifier == "-":
targetlist = data["targetlist"]
if "monitormasks" not in user.cache or "monitorwatching" not in user.cache:
return
for target in targetlist:
lowerTarget = irc_lower(target)
if lowerTarget in user.cache["monitorwatching"]:
user.cache["monitorwatching"].remove(lowerTarget)
watchList = user.cache["monitormasks"]
for mask in watchList:
if irc_lower(mask) == lowerTarget:
user.cache["monitormasks"].remove(mask)
if lowerTarget in self.ircd.module_data_cache[
"monitorwatchedby"]:
self.ircd.module_data_cache["monitorwatchedby"][
lowerTarget].remove(user)
elif modifier == "C":
if "monitormasks" in user.cache:
del user.cache["monitormasks"]
if "monitorwatching" in user.cache:
for target in user.cache["monitorwatching"]:
self.ircd.module_data_cache["monitorwatchedby"][
target].remove(user)
del user.cache["monitorwatching"]
elif modifier == "L":
if "monitormasks" in user.cache:
userlist = chunk_message(" ".join(user.cache["monitormasks"]),
400)
for line in userlist:
user.sendMessage(irc.RPL_MONLIST,
":{}".format(line.replace(" ", ",")))
user.sendMessage(irc.RPL_ENDOFMONLIST, ":End of MONITOR list")
elif modifier == "S":
if "monitormasks" in user.cache:
online = []
offline = []
for target in user.cache["monitormasks"]:
if target in self.ircd.users:
online.append(target)
else:
offline.append(target)
if online:
onlineLines = chunk_message(" ".join(online), 400)
for line in onlineLines:
user.sendMessage(irc.RPL_MONONLINE,
":{}".format(line.replace(" ", ",")))
if offline:
offlineLines = chunk_message(" ".join(offline), 400)
for line in offlineLines:
user.sendMessage(irc.RPL_MONOFFLINE,
":{}".format(line.replace(" ", ",")))
def sendServerNotice(self, type, message):
type = irc_lower(type)
if type in self.tellLists:
for u in self.tellLists[type]:
u.sendMessage("NOTICE",
":*** {}: {}".format(type.upper(), message))
def onUse(self, user, data):
modifier = data["modifier"]
if modifier == "+":
targetlist = data["targetlist"]
discard = []
for target in targetlist:
if len(target) > 32 or " " in target:
discard.append(target)
for target in discard:
targetlist.remove(target)
if "monitormasks" not in user.cache:
user.cache["monitormasks"] = []
if "monitorwatching" not in user.cache:
user.cache["monitorwatching"] = []
if self.limit and len(user.cache["monitormasks"]) + len(targetlist) > self.limit:
user.sendMessage(irc.ERR_MONLISTFULL, str(self.limit), ",".join(targetlist), ":Monitor list is full")
return
online = []
offline = []
for target in targetlist:
lowerTarget = irc_lower(target)
if lowerTarget not in user.cache["monitorwatching"]:
user.cache["monitormasks"].append(target)
user.cache["monitorwatching"].append(lowerTarget)
if lowerTarget not in self.ircd.module_data_cache["monitorwatchedby"]:
self.ircd.module_data_cache["monitorwatchedby"][lowerTarget] = []
self.ircd.module_data_cache["monitorwatchedby"][lowerTarget].append(user)
if target in self.ircd.users:
online.append(target)
else:
offline.append(target)
if online:
onLines = chunk_message(" ".join(online), 400)
for line in onLines:
user.sendMessage(irc.RPL_MONONLINE, ":{}".format(line.replace(" ", ",")))
if offline:
offLines = chunk_message(" ".join(offline), 400)
for line in offLines:
user.sendMessage(irc.RPL_MONOFFLINE, ":{}".format(line.replace(" ", ",")))
elif modifier == "-":
targetlist = data["targetlist"]
if "monitormasks" not in user.cache or "monitorwatching" not in user.cache:
return
for target in targetlist:
lowerTarget = irc_lower(target)
if lowerTarget in user.cache["monitorwatching"]:
user.cache["monitorwatching"].remove(lowerTarget)
watchList = user.cache["monitormasks"]
for mask in watchList:
if irc_lower(mask) == lowerTarget:
user.cache["monitormasks"].remove(mask)
if lowerTarget in self.ircd.module_data_cache["monitorwatchedby"]:
self.ircd.module_data_cache["monitorwatchedby"][lowerTarget].remove(user)
elif modifier == "C":
if "monitormasks" in user.cache:
del user.cache["monitormasks"]
if "monitorwatching" in user.cache:
for target in user.cache["monitorwatching"]:
self.ircd.module_data_cache["monitorwatchedby"][target].remove(user)
del user.cache["monitorwatching"]
elif modifier == "L":
if "monitormasks" in user.cache:
userlist = chunk_message(" ".join(user.cache["monitormasks"]), 400)
for line in userlist:
user.sendMessage(irc.RPL_MONLIST, ":{}".format(line.replace(" ", ",")))
user.sendMessage(irc.RPL_ENDOFMONLIST, ":End of MONITOR list")
elif modifier == "S":
if "monitormasks" in user.cache:
online = []
offline = []
for target in user.cache["monitormasks"]:
if target in self.ircd.users:
online.append(target)
else:
offline.append(target)
if online:
onlineLines = chunk_message(" ".join(online), 400)
for line in onlineLines:
user.sendMessage(irc.RPL_MONONLINE, ":{}".format(line.replace(" ", ",")))
if offline:
offlineLines = chunk_message(" ".join(offline), 400)
for line in offlineLines:
user.sendMessage(irc.RPL_MONOFFLINE, ":{}".format(line.replace(" ", ",")))
