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 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 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 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 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 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(" ", ",")))