def bombsenabled(self, irc, msg, args, channel, value):
        """[value]

        Sets the value of the allowBombs config value for the channel. Restricted to users with channel timebombadmin capability."""
        statusDescription = "are currently"
        if value:
            # tmp = ircdb.channels.getChannel(channel).defaultAllow - problems with multithreading?
            # ircdb.channels.getChannel(channel).defaultAllow = False
            hasCap = ircdb.checkCapability(msg.prefix, "timebombadmin")
            if (channel == "#powder" or channel == "#powder-dev") and not ircdb.checkCapability(msg.prefix, "admin"):
                irc.error("You need the admin capability to do that")
                return
            # ircdb.channels.getChannel(channel).defaultAllow = tmp

            if hasCap:
                oldValue = self.registryValue("allowBombs", channel)
                try:
                    conf.supybot.plugins.Timebomb.allowBombs.get(channel).set(value)
                except registry.InvalidRegistryValue:
                    irc.error("Value must be either True or False (or On or Off)")
                    return
                if self.registryValue("allowBombs", channel) == oldValue:
                    statusDescription = "were already"
                else:
                    statusDescription = "have now been"
            else:
                irc.error("You need the timebombadmin capability to do that")
                return

        if self.registryValue("allowBombs", channel):
            irc.reply("Timebombs {} enabled in{}".format(statusDescription, channel))
        else:
            irc.reply("Timebombs {} disabled in{}".format(statusDescription, channel))

 def getUser(self, **kw):
     """ will return a user object tagged with a hostmask for use or None
     """
     if 'protocol' not in kw:
         raise KeyError, 'Need a protocol name'
     else:
         user = None
         if 'username' not in kw:
             raise KeyError, 'Need a username'
         try:
             user = ircdb.users.getUser(kw['username'])
         except KeyError:
             return False
         cap = self.registryValue('capability')
         pcap = self.registryValue('%s.capability' % kw['protocol'])
         if cap:
             if not ircdb.checkCapability(kw['username'], cap):
                 return False
         if pcap:
             if not ircdb.checkCapability(kw['username'], pcap):
                 return False
         if 'password' in kw:
             if not user.checkPassword(kw['password']):
                 return False
         elif 'blob' in kw:
             if not self.checkKey(kw['username'], kw['blob']):
                 return False
         else:
             return False
         user.gwhm = self.buildHostmask(kw['username'], kw['protocol'],
                 kw['peer'])
         user.addAuth(user.gwhm)
         return user

 def doPrivmsg(self, irc, msg):
     assert self is irc.callbacks[0], \
            'Owner isn\'t first callback: %r' % irc.callbacks
     if ircmsgs.isCtcp(msg):
         return
     s = callbacks.addressed(irc.nick, msg)
     if s:
         ignored = ircdb.checkIgnored(msg.prefix)
         if ignored:
             self.log.info('Ignoring command from %s.', msg.prefix)
             return
         maximum = conf.supybot.abuse.flood.command.maximum()
         self.commands.enqueue(msg)
         if conf.supybot.abuse.flood.command() \
            and self.commands.len(msg) > maximum \
            and not ircdb.checkCapability(msg.prefix, 'owner') \
            and not ircdb.checkCapability(msg.prefix, 'admin'):
             punishment = conf.supybot.abuse.flood.command.punishment()
             banmask = ircutils.banmask(msg.prefix)
             self.log.info('Ignoring %s for %s seconds due to an apparent '
                           'command flood.', banmask, punishment)
             ircdb.ignores.add(banmask, time.time() + punishment)
             irc.reply('You\'ve given me %s commands within the last '
                       'minute; I\'m now ignoring you for %s. Try #fedora-botgames.' %
                       (maximum,
                        utils.timeElapsed(punishment, seconds=False)))
             return
         try:
             tokens = callbacks.tokenize(s, channel=msg.args[0])
             self.Proxy(irc, msg, tokens)
         except SyntaxError, e:
             irc.queueMsg(callbacks.error(msg, str(e)))

	def floodPunish(self, irc, msg, floodType, dummy = False):
		channel = msg.args[0]

		if (not irc.nick in irc.state.channels[channel].ops) and\
		   (not irc.nick in irc.state.channels[channel].halfops):
			self.log.warning("%s flooded in %s, but not opped.",\
				msg.nick, channel)
			return

		if msg.nick in self.immunities:
			self.log.debug("Not punnishing %s, they are immune.",
				msg.nick)
			return

		if msg.nick in irc.state.channels[channel].ops or\
		   msg.nick in irc.state.channels[channel].halfops or\
		   msg.nick in irc.state.channels[channel].voices:
			self.log.debug("%s flooded in %s. But"\
				+ " I will not punish them because they have"\
				+ " special access.", msg.nick, channel)
			return

		if ircdb.checkCapability(msg.prefix, 'trusted') or\
		   ircdb.checkCapability(msg.prefix, 'admin') or\
		   ircdb.checkCapability(msg.prefix, channel + ',op'):
			self.log.debug("%s flooded in %s. But"\
				+ " I will not punish them because they are"\
				+ " trusted.", msg.nick, channel)
			return

		if msg.host in self.offenses and self.offenses[msg.host] > 2:
			hostmask = irc.state.nickToHostmask(msg.nick)
			banmaskstyle = conf.supybot.protocols.irc.banmask
			banmask = banmaskstyle.makeBanmask(hostmask)
			if not dummy:
				irc.queueMsg(ircmsgs.ban(channel, banmask))
			self.log.warning("Banned %s (%s) from %s for repeated"\
				+ " flooding.", banmask, msg.nick, channel)

		reason = floodType + " flood detected."
		if floodType == "Paste":
			reason += " Use a pastebin like pastebin.ubuntu.com or gist.github.com."

		if not dummy:
			irc.queueMsg(ircmsgs.kick(channel, msg.nick, reason))

		self.log.warning("Kicked %s from %s for %s flooding.",\
				msg.nick, channel, floodType)

		# Don't schedule the same nick twice
		if not (msg.host in self.offenses):
			schedule.addEvent(self.clearOffenses, time.time()+300,
					args=[msg.host])
			self.offenses[msg.host] = 0 # Incremented below
		self.offenses[msg.host] += 1

		self.immunities[msg.nick] = True
		schedule.addEvent(self.unImmunify, time.time()+3,
				args=[msg.nick])

 def _kban(self, irc, msg, args, bannedNick, reason):
 # Check that they're not trying to make us kickban ourself.
     channel = msg.args[0]
     if not irc.isNick(bannedNick[0]):
         self.log.warning('%q tried to kban a non nick: %q',
                          msg.prefix, bannedNick)
         raise callbacks.ArgumentError
     elif bannedNick == irc.nick:
         self.log.warning('%q tried to make me kban myself.', msg.prefix)
         irc.error('I cowardly refuse to kickban myself.')
         return
     if not reason:
         reason = msg.nick
     try:
         bannedHostmask = irc.state.nickToHostmask(bannedNick)
     except KeyError:
         irc.error(format('I haven\'t seen %s.', bannedNick), Raise=True)
     capability = ircdb.makeChannelCapability(channel, 'op')
     banmaskstyle = conf.supybot.protocols.irc.banmask
     banmask = banmaskstyle.makeBanmask(bannedHostmask, ["host", "user"])
     # Check (again) that they're not trying to make us kickban ourself.
     if ircutils.hostmaskPatternEqual(banmask, irc.prefix):
         if ircutils.hostmaskPatternEqual(bannedHostmask, irc.prefix):
             self.log.warning('%q tried to make me kban myself.',msg.prefix)
             irc.error('I cowardly refuse to ban myself.')
             return
         else:
             self.log.warning('Using exact hostmask since banmask would '
                              'ban myself.')
             banmask = bannedHostmask
     # Now, let's actually get to it.  Check to make sure they have
     # #channel,op and the bannee doesn't have #channel,op; or that the
     # bannee and the banner are both the same person.
     def doBan():
         if irc.state.channels[channel].isOp(bannedNick):
             irc.queueMsg(ircmsgs.deop(channel, bannedNick))
         irc.queueMsg(ircmsgs.ban(channel, banmask))
         irc.queueMsg(ircmsgs.kick(channel, bannedNick, reason))
         def f():
             if channel in irc.state.channels and \
                banmask in irc.state.channels[channel].bans:
                 irc.queueMsg(ircmsgs.unban(channel, banmask))
         schedule.addEvent(f, 3600)
     if bannedNick == msg.nick:
         doBan()
     elif ircdb.checkCapability(msg.prefix, capability):
         if ircdb.checkCapability(bannedHostmask, capability):
             self.log.warning('%s tried to ban %q, but both have %s',
                              msg.prefix, bannedHostmask, capability)
             irc.error(format('%s has %s too, you can\'t ban him/her/it.',
                              bannedNick, capability))
         else:
             doBan()
     else:
         self.log.warning('%q attempted kban without %s',
                          msg.prefix, capability)
         irc.errorNoCapability(capability)
         exact,nick,user,host

 def votes(self, irc, msg, args, channel, pid):
     """[channel] <id>
     Retrieves the vote count for a poll.
     """
     if channel and msg.args[0] in irc.state.channels:
         if msg.args[0] != channel:
             if ircdb.checkCapability(msg.prefix, 'admin') or ircdb.checkCapability(msg.prefix, 'owner'):
                 irc.error("Not Implemented")
             else:
                 irc.errorInvalid('argument', channel)
         elif msg.args[0] == channel:
             irc.error("Not Implemented")

        def do(type):
            cap = ircdb.makeChannelCapability(channel, type)
            cap_auto = ircdb.makeChannelCapability(channel, "auto" + type)
            try:
                apply_mode = ircdb.checkCapability(
                    msg.prefix,
                    cap,
                    ignoreOwner=not self.registryValue("owner"),
                    ignoreChannelOp=True,
                    ignoreDefaultAllow=True,
                )
            except KeyError:
                apply_mode = False
            if self.registryValue("alternativeCapabilities", channel):
                try:
                    override = ircdb.checkCapability(
                        msg.prefix,
                        cap_auto,
                        ignoreOwner=not self.registryValue("owner"),
                        ignoreChannelOp=True,
                        ignoreDefaultAllow=True,
                    )
                except KeyError:
                    override = False
            else:
                override = False
            if apply_mode or override:
                if override or self.registryValue(type, channel):
                    self.log.info("Scheduling auto-%s of %s in %s.", type, msg.prefix, channel)

                    def dismiss():
                        """Determines whether or not a mode has already
                        been applied."""
                        l = getattr(irc.state.channels[channel], type + "s")
                        return msg.nick in l

                    msgmaker = getattr(ircmsgs, type)
                    schedule_msg(msgmaker(channel, msg.nick), dismiss)
                    raise Continue  # Even if fallthrough, let's only do one.
                elif not fallthrough:
                    self.log.debug(
                        "%s has %s, but supybot.plugins.AutoMode.%s"
                        " is not enabled in %s, refusing to fall "
                        "through.",
                        msg.prefix,
                        cap,
                        type,
                        channel,
                    )
                    raise Continue

    def newpoll(self, irc, msg, args, channel, interval, answers, question):
        """<number of minutes for announce interval> <"answer,answer,..."> question
        Creates a new poll with the given question and answers. <channel> is
        only necessary if the message isn't sent in the channel itself."""

        capability = ircdb.makeChannelCapability(channel, 'op')
        if not ircdb.checkCapability(msg.prefix, capability):
            irc.error('Need ops')
            return

        db = self.getDb(channel)
        cursor = db.cursor()
        self._execute_query(cursor, 'INSERT INTO polls VALUES (?,?,?,?,?)', None, datetime.datetime.now(), 1, None, question)
        pollid = cursor.lastrowid

        # used to add choices into db. each choice represented by character, starting at capital A (code 65)
        def genAnswers():
            for i, answer in enumerate(answers, start=65):
                yield pollid, chr(i), answer

        cursor.executemany('INSERT INTO choices VALUES (?,?,?)', genAnswers())

        db.commit()

        irc.reply('Started new poll #%s' % pollid)

        # function called by schedule event. can not have args
        def runPoll():
            self._runPoll(irc, channel, pollid)

        # start schedule. will announce poll/choices to channel at interval
        schedule.addPeriodicEvent(runPoll, interval*60, name='%s_poll_%s' % (channel, pollid))
        self.poll_schedules.append('%s_poll_%s' % (channel, pollid))

 def _preCheck(self, irc, msg, target, action):
     if self.registryValue('requireRegistration', target):
         try:
             foo = ircdb.users.getUser(msg.prefix)
         except KeyError:
             irc.errorNotRegistered(Raise=True)
     capability = self.registryValue('requireCapability', target)
     if capability:
         if not ircdb.checkCapability(msg.prefix, capability):
             irc.errorNoCapability(capability, Raise=True)
     if irc.isChannel(target):
         if self.registryValue('requirePresenceInChannel', target) and \
            msg.nick not in irc.state.channels[target].users:
             irc.error(format(_('You must be in %s to %q in there.'),
                              target, action), Raise=True)
         c = ircdb.channels.getChannel(target)
         if c.lobotomized:
             irc.error(format(_('I\'m lobotomized in %s.'), target),
                       Raise=True)
         if not c._checkCapability(self.name()):
             irc.error(_('That channel has set its capabilities so as to '
                       'disallow the use of this plugin.'), Raise=True)
     elif action == 'say' and not self.registryValue('allowPrivateTarget'):
         irc.error(format(_('%q cannot be used to send private messages.'),
                          action),
                   Raise=True)

	def checkAndAct (self,irc,prefix,chan,kind,items,text,msg):
		protected = ircdb.makeChannelCapability(chan.name, 'protected')
		if ircdb.checkCapability(prefix, protected):
			return
		for pattern in list(items.keys()):
			item = chan.kinds[kind][pattern]
			if item.enable == '1':
				for match in re.finditer(item.re, text):
					if match:
						act = item.action
						account = ''
						gecos = ''
						if prefix.split('!')[0] in chan.nicks:
							(prefix,account,gecos) = chan.nicks[prefix.split('!')[0]]
						act = act.replace('$nick',prefix.split('!')[0])
						act = act.replace('$hostmask',prefix)
						act = act.replace('$account',account)
						act = act.replace('$username',gecos)
						act = act.replace('$id',str(item.uid))
						act = act.replace('$channel',chan.name)
						act = act.replace('$*',text)
						if act.find(' :') != -1:
							a = text.split(' :')
							if len(a) > 1:
							    act = act.replace('$text',text.split(' :')[1])
						for (i, j) in enumerate(match.groups()):
							act = re.sub(r'\$' + str(i+1), match.group(i+1), act)
						self.act(irc,msg,chan.name,act,item.owner)
						break

    def _checkManageCapabilities(self, irc, msg, channel):
        """Check if the user has any of the required capabilities to manage
        the channel topic.

        The list of required capabilities is in requireManageCapability
        channel config.

        Also allow if the user is a chanop. Since they can change the topic
        manually anyway.
        """
        c = irc.state.channels[channel]
        if msg.nick in c.ops or msg.nick in c.halfops or 't' not in c.modes:
            return True
        capabilities = self.registryValue('requireManageCapability', channel)
        if capabilities:
            for capability in re.split(r'\s*;\s*', capabilities):
                if capability.startswith('channel,'):
                    capability = ircdb.makeChannelCapability(
                        channel, capability[8:])
                if capability and ircdb.checkCapability(msg.prefix, capability):
                    return
            capabilities = self.registryValue('requireManageCapability',
                    channel)
            irc.errorNoCapability(capabilities, Raise=True)
        else:
            return

    def voice(self, irc, msg, args, channel, nicks):
        """[<channel>] [<nick> ...]

        If you have the #channel,voice capability, this will voice all the
        <nick>s you provide.  If you don't provide any <nick>s, this will
        voice you. <channel> is only necessary if the message isn't sent in the
        channel itself.
        """
        if nicks:
            if len(nicks) == 1 and msg.nick in nicks:
                capability = "voice"
            else:
                capability = "op"
        else:
            nicks = [msg.nick]
            capability = "voice"
        capability = ircdb.makeChannelCapability(channel, capability)
        if ircdb.checkCapability(msg.prefix, capability):

            def f(L):
                return ircmsgs.voices(channel, L)

            self._sendMsgs(irc, nicks, f)
        else:
            irc.errorNoCapability(capability)

 def add(self, channel, user, id, option):
     db = self._getDb(channel)
     cursor = db.cursor()
     # Only the poll starter or an admin can add options
     cursor.execute("""SELECT started_by FROM polls
                       WHERE id=%s""",
                       id)
     if cursor.rowcount == 0:
         raise dbi.NoRecordError
     if not ((user.id == cursor.fetchone()[0]) or
             (ircdb.checkCapability(user.id, 'admin'))):
         raise PollError, \
                 'That poll isn\'t yours and you aren\'t an admin.'
     # and NOBODY can add options once a poll has votes
     cursor.execute("""SELECT COUNT(user_id) FROM votes
                       WHERE poll_id=%s""",
                       id)
     if int(cursor.fetchone()[0]) != 0:
         raise PollError, 'Cannot add options to a poll with votes.'
     # Get the next highest id
     cursor.execute("""SELECT MAX(id)+1 FROM options
                       WHERE poll_id=%s""",
                       id)
     option_id = cursor.fetchone()[0] or 1
     cursor.execute("""INSERT INTO options VALUES
                       (%s, %s, %s)""",
                       option_id, id, option)
     db.commit()

    def boosterset(self, irc, msg, args, text):
        """<booster>

        Sets a new booster"""
        channell = msg.args[0]
        network = irc.network
        nick = msg.nick
        global targett
        global boosterr
        #if nick in self.registryValue('blacklist').split(' '):
             #irc.error("You've been blacklisted!", Raise=True
        if msg.args[0] in self.registryValue('channels').split(' '):
            global targett
        else: irc.error('Not a valid channel! Please contact Vlad', Raise=True)
        if nick in irc.state.channels[channell].ops:
            capability='ops'
            if not ircdb.checkCapability(msg.prefix, capability):
                irc.errorNoCapability(capability, Raise=True)
            
            target_line = linecache.getline(channell+network, 1).rstrip("\n")
            booster_line = linecache.getline(channell+network, 2).rstrip("\n")
            reason_line = linecache.getline(channell+network, 3).rstrip("\n")
            boosterrx = text
            oldfile = open(channell+network, 'w')
            oldfile.write(target_line+"\n")
            oldfile.write(boosterrx+"\n")
            oldfile.flush()
            linecache.clearcache()
            irc.reply('Done.')

    def tell(self, irc, msg, args, target, text):
        """<nick> <text>

        Tells the <nick> whatever <text> is.  Use nested commands to your
        benefit here.
        """
        if irc.nested:
            irc.error("This command cannot be nested.", Raise=True)
        if target.lower() == "me":
            target = msg.nick
        if ircutils.isChannel(target):
            irc.error("Dude, just give the command.  No need for the tell.")
            return
        if not ircutils.isNick(target):
            irc.errorInvalid("nick", target)
        if ircutils.nickEqual(target, irc.nick):
            irc.error("You just told me, why should I tell myself?", Raise=True)
        if target not in irc.state.nicksToHostmasks and not ircdb.checkCapability(msg.prefix, "owner"):
            # We'll let owners do this.
            s = "I haven't seen %s, I'll let you do the telling." % target
            irc.error(s, Raise=True)
        if irc.action:
            irc.action = False
            text = "* %s %s" % (irc.nick, text)
        s = "%s wants me to tell you: %s" % (msg.nick, text)
        irc.replySuccess()
        irc.reply(s, to=target, private=True)

 def checkChangeAllowed(self, irc, msg, channel, user, record):
     if user.id == record.by:
         return True
     cap = ircdb.makeChannelCapability(channel, 'op')
     if ircdb.checkCapability(msg.prefix, cap):
         return True
     irc.errorNoCapability(cap)

 def inFilter(self, irc, msg):
     self.filtering = True
     # We need to check for bad words here rather than in doPrivmsg because
     # messages don't get to doPrivmsg if the user is ignored.
     if msg.command == 'PRIVMSG':
         channel = msg.args[0]
         self.updateRegexp(channel)
         s = ircutils.stripFormatting(msg.args[1])
         if ircutils.isChannel(channel) and self.registryValue('kick', channel):
             if self.words and self.regexp.search(s):
                 c = irc.state.channels[channel]
                 cap = ircdb.makeChannelCapability(channel, 'op')
                 if c.isHalfopPlus(irc.nick):
                     if c.isHalfopPlus(msg.nick) or \
                             ircdb.checkCapability(msg.prefix, cap):
                         self.log.debug("Not kicking %s from %s, because "
                                        "they are halfop+ or can't be "
                                        "kicked.", msg.nick, channel)
                     else:
                         message = self.registryValue('kick.message', channel)
                         irc.queueMsg(ircmsgs.kick(channel, msg.nick, message))
                 else:
                     self.log.warning('Should kick %s from %s, but not opped.',
                                      msg.nick, channel)
     return msg

        def add(self, irc, msg, args, user, capability):
            """<name|hostmask> <capability>

            Gives the user specified by <name> (or the user to whom <hostmask>
            currently maps) the specified capability <capability>
            """
            # Ok, the concepts that are important with capabilities:
            #
            ### 1) No user should be able to elevate their privilege to owner.
            ### 2) Admin users are *not* superior to #channel.ops, and don't
            ###    have God-like powers over channels.
            ### 3) We assume that Admin users are two things: non-malicious and
            ###    and greedy for power.  So they'll try to elevate their
            ###    privilege to owner, but they won't try to crash the bot for
            ###    no reason.

            # Thus, the owner capability can't be given in the bot.  Admin
            # users can only give out capabilities they have themselves (which
            # will depend on supybot.capabilities and its child default) but
            # generally means they can't mess with channel capabilities.
            if ircutils.strEqual(capability, 'owner'):
                irc.error(_('The "owner" capability can\'t be added in the '
                          'bot.  Use the supybot-adduser program (or edit the '
                          'users.conf file yourself) to add an owner '
                          'capability.'))
                return
            if ircdb.isAntiCapability(capability) or \
               ircdb.checkCapability(msg.prefix, capability):
                user.addCapability(capability)
                ircdb.users.setUser(user)
                irc.replySuccess()
            else:
                irc.error(_('You can\'t add capabilities you don\'t have.'))

    def _slot(self, lastItem):
        irc = lastItem.irc
        msg = lastItem.msg
        channel = lastItem.channel
        prefix = lastItem.prefix
        nick = prefix.split('!')[0]
        kind = lastItem.kind

        try:
            ircdb.users.getUser(msg.prefix) # May raise KeyError
            capability = self.registryValue('exempt')
            if capability:
                if ircdb.checkCapability(msg.prefix, capability):
                    return
        except KeyError:
            pass
        punishment = self.registryValue('%s.punishment' % kind, channel)
        reason = _('%s flood detected') % kind
        if punishment == 'kick':
            msg = ircmsgs.kick(channel, nick, reason)
            irc.queueMsg(msg)
        elif punishment == 'ban':
            msg = ircmsgs.ban(channel, prefix)
            irc.queueMsg(msg)
        elif punishment == 'kban':
            msg = ircmsgs.kick(channel, nick, reason)
            irc.queueMsg(msg)
            msg = ircmsgs.ban(channel, prefix)
            irc.queueMsg(msg)
        elif punishment.startswith('mode'):
            msg = ircmsgs.mode(channel, punishment[len('mode'):])
            irc.queueMsg(msg)
        elif punishment.startswith('command '):
            tokens = callbacks.tokenize(punishment[len('command '):])
            self.Proxy(irc, msg, tokens)

    def delquote(self, irc, msg, args, optlist, qid):
        """[--channel <#channel>] <id>
        Delete the quote number 'id', only by the creator of the quote in
        the first 5 minutes or by an admin. If --channel is supplied the
        quote is fetched from that channel database."""
        channel = msg.args[0]
        for (option, arg) in optlist:
            if option == 'channel':
                if not ircutils.isChannel(arg):
                    irc.error(format(_('%s is not a valid channel.'), arg),
                              Raise=True)
                channel = arg

        q = self.db.getQuoteById(channel, qid)

        if q is not None:
            if ircdb.checkCapability(msg.prefix, 'admin'):
                self.db.delQuoteById(channel, qid)
                irc.replySuccess()
            elif (time.time() - 300) <= q[3]:
                if q[2].lower() == msg.nick.lower():
                    self.db.delQuoteById(channel, qid)
                    irc.replySuccess()
                else:
                    irc.error(format(_("This quote only can be deleted by %s "
                                       "or an admin."), q[2]))
            else:
                irc.error(format(_("Too late, it has already passed 5 minutes."
                                   " Ask an admin."), qid, channel))
        else:
            irc.error(format(_("No such quote %s in %s's database."),
                             qid, channel))