311 lines
11 KiB
Python
311 lines
11 KiB
Python
###
|
|
# Copyright (c) 2008, Terence Simpson
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of version 2 of the GNU General Public License as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
###
|
|
|
|
import supybot.utils as utils
|
|
from supybot.commands import *
|
|
import supybot.plugins as plugins
|
|
import supybot.ircutils as ircutils
|
|
import supybot.ircmsgs as ircmsgs
|
|
import supybot.callbacks as callbacks
|
|
import supybot.ircdb as ircdb
|
|
import supybot.conf as conf
|
|
import supybot.schedule as schedule
|
|
import random, os, sys
|
|
from cPickle import Unpickler, Pickler
|
|
import lp
|
|
|
|
def checkCapab(msg, irc):
|
|
try:
|
|
user = ircdb.users.getUser(msg.prefix[:msg.prefix.find('!')])
|
|
except:
|
|
irc.error(conf.supybot.replies.incorrectAuthentication())
|
|
return False
|
|
try:
|
|
if not user.capabilities.check('Admin'):
|
|
irc.error(conf.supybot.replies.noCapability() % 'Admin')
|
|
return False
|
|
except KeyError:
|
|
irc.error(conf.supybot.replies.noCapability() % 'Admin')
|
|
return False
|
|
return True
|
|
|
|
|
|
class IRCLogin(callbacks.Plugin):
|
|
"""Use @login to login, @reloadusers to reload the user list and @updateusers to update the user database from
|
|
launchpad"""
|
|
threaded = True
|
|
|
|
def __init__(self, irc):
|
|
super(IRCLogin, self).__init__(irc)
|
|
self._irc = hasattr(irc, 'getRealIrc') and irc.getRealIrc() or irc
|
|
|
|
def die(self):
|
|
"""Disable identify-msg, if possible"""
|
|
if getattr(self._irc, '_Freenode_capabed', False):
|
|
# Only the CAP command can disable identify-msg not CAPAB
|
|
self._irc.queueMsg(ircmsgs.IrcMsg('CAP REQ -IDENTIFY-MSG')) # Disable identify-msg
|
|
self._irc._Freenode_capabed = self._irc._Freenode_capabed_notices = False
|
|
|
|
def updateusers(self, irc, msg, args):
|
|
"""Takes no arguments
|
|
|
|
Update the user database from Launchpad"""
|
|
def writePickle(uf, user2nick, nick2user):
|
|
global self
|
|
try:
|
|
fd = open(uf, 'wb')
|
|
except IOError, e:
|
|
self.log.error("Could not write to %s (%s)" % (uf, e))
|
|
return
|
|
except Exception, e:
|
|
self.log.error("Unknown error while opening %s for writing:\n%s" % (uf, e))
|
|
return
|
|
pi = Pickler(fd, 2)
|
|
pi.dump((user2nick, nick2user))
|
|
|
|
if not checkCapab(msg, irc):
|
|
return
|
|
uf = self.registryValue('UserList')
|
|
if not uf:
|
|
self.log.info('no UserList config set')
|
|
irc.error('No UserList config set')
|
|
return
|
|
if not os.path.exists(uf):
|
|
self.log.info('Creating initial userlist')
|
|
else:
|
|
self.log.info('Updating userlist')
|
|
irc.reply('Running...')
|
|
user2nick = {}
|
|
nick2user = {}
|
|
users = lp.getUsers(self.registryValue("teamname"))
|
|
for user in users:
|
|
lpuser = lp.getIRCNick(user, False)
|
|
if not lpuser:
|
|
lpuser = [user]
|
|
user2nick[user] = lpuser
|
|
for nick in lpuser:
|
|
nick2user[nick] = user
|
|
writePickle(uf, user2nick, nick2user)
|
|
self.loadUsers()
|
|
irc.reply('updateusers run complete')
|
|
updateusers = wrap(updateusers)
|
|
|
|
def loadUsers(self):
|
|
uf = self.registryValue('UserList')
|
|
if not uf or not os.path.exists(uf) or not os.access(uf, os.R_OK):
|
|
self.log.info('Not loading non-existant userlist')
|
|
return
|
|
fd = open(uf, 'rb')
|
|
up = Unpickler(fd)
|
|
(self.user2nick, self.nick2user) = up.load()
|
|
nick2user = self.nick2user
|
|
user2nick = self.user2nick
|
|
self.knownusers = [i.lower() for i in nick2user.keys()]
|
|
allusers = [u.name.lower() for u in ircdb.users.itervalues()]
|
|
to_add = [x for x in self.knownusers if x not in allusers]
|
|
for a in to_add:
|
|
self.log.info("Adding %s" % a)
|
|
user = ircdb.users.newUser()
|
|
user.name = a
|
|
rp = ''
|
|
chars = '''1234567890-=~!@#$%^&*()_qwertyuiop[]QWERTYUIOP{}}|asdfghjkl;ASDFGHJKL:zxcvbnm,./ZXCVBNM<>?'''
|
|
for i in range(16):
|
|
rp += chars[random.randint(1,len(chars))-1]
|
|
user.setPassword(rp)
|
|
bu = []
|
|
for u in nick2user.keys():
|
|
try:
|
|
user = ircdb.users.getUser(u.lower())
|
|
if not 'bantracker' in user.capabilities:
|
|
user.addCapability('bantracker')
|
|
except Exception, e:
|
|
bu.append("%s (%s)" % (u, e))
|
|
pass
|
|
if bu:
|
|
self.log.info("Could not add users %s" % bu)
|
|
|
|
def reloadusers(self, irc, msg, args):
|
|
"""Takes no arguments
|
|
|
|
Read the user database and add the users in it"""
|
|
if not checkCapab(msg, irc):
|
|
return
|
|
self.loadUsers()
|
|
irc.replySuccess()
|
|
reloadusers = wrap(reloadusers)
|
|
|
|
def login(self, irc, msg, args):
|
|
"""takes no arguments
|
|
|
|
Allows users who are identified to NickServ to login without a password.
|
|
"""
|
|
if not msg.tagged('identified'):
|
|
irc.error('You are not identified')
|
|
return
|
|
nick = msg.nick.lower()
|
|
user = None
|
|
try:
|
|
user = self.nick2user.get(nick, None)
|
|
if user:
|
|
user = ircdb.users.getUser(user)
|
|
except:
|
|
user = None
|
|
pass
|
|
if not user:
|
|
try:
|
|
user = ircdb.users.getUser(msg.prefix)
|
|
except:
|
|
self.loadUsers()
|
|
try:
|
|
user = ircdb.users.getUser(msg.prefix)
|
|
except:
|
|
for (id, obj) in ircdb.users.users.iteritems():
|
|
if obj.name.lower() == nick:
|
|
user = obj
|
|
if not user:
|
|
irc.error(conf.supybot.replies.incorrectAuthentication())
|
|
return
|
|
try:
|
|
user.addAuth(msg.prefix)
|
|
except:
|
|
pass
|
|
try:
|
|
ircdb.users.setUser(user, flush=False)
|
|
except:
|
|
pass
|
|
irc.replySuccess()
|
|
login = wrap(login)
|
|
|
|
@wrap
|
|
def identifymsg(self, irc, msg, args):
|
|
"""
|
|
takes no arguments.
|
|
Sends a requet for the identify-msg capability.
|
|
"""
|
|
self.do376(irc, msg, force=True)
|
|
irc.replySuccess()
|
|
|
|
@wrap
|
|
def haveidentifymsg(self, irc, msg, args):
|
|
haveCap = getattr(self._irc, "_Freenode_capabed", False)
|
|
irc.reply("identify-msg is %sabled" % (haveCap and "En" or "Dis"))
|
|
|
|
def doPrivmsg(self, irc, msg):
|
|
if not conf.supybot.defaultIgnore(): # Only do this when defaultIgnore is set
|
|
return
|
|
if chr(1) in msg.args[1]:
|
|
return
|
|
try:
|
|
user = ircdb.users.getUser(msg.prefix)
|
|
if user.checkHostmask(msg.prefix):
|
|
#self.log.info("%s is a known user: %r" % (msg.prefix, user))
|
|
return
|
|
except:
|
|
pass
|
|
|
|
text = callbacks.addressed(irc.nick, msg)
|
|
cmd = ''
|
|
if not text or text != "login":
|
|
if msg.args[1]:
|
|
if ircutils.isChannel(msg.args[0]):
|
|
if msg.args[1][0] == '@':
|
|
cmd = msg.args[1][1:]
|
|
else:
|
|
if msg.args[1][0] == '@':
|
|
cmd = msg.args[1][1:]
|
|
else:
|
|
cmd = msg.args[1]
|
|
if cmd != "login":
|
|
return
|
|
else:
|
|
return
|
|
self.log.info("Calling login for %s" % msg.prefix)
|
|
self._callCommand(["login"], irc, msg, [])
|
|
|
|
def do290(self, irc, msg):
|
|
"""hyperiron CAPAB reply"""
|
|
self._irc._Freenode_capabed_notices = False
|
|
if msg.args[1].lower() == "identify-msg":
|
|
self._irc._Freenode_capabed = True
|
|
else:
|
|
self._irc._Freenode_capabed = False
|
|
|
|
def doCap(self, irc, msg):
|
|
"""ircd-seven CAP reply"""
|
|
cmd = msg.args[1].lower()
|
|
args = msg.args[2].lower()
|
|
if cmd == "ls": # Got capability listing
|
|
if "identify-msg" in args: # identify-msg is a capability on this server
|
|
irc.queueMsg(ircmsgs.IrcMsg('CAP REQ IDENTIFY-MSG')) # Request identify-msg
|
|
|
|
if cmd == "ack": # Acknowledge reply
|
|
if "identify-msg" in args: # identify-msg is set
|
|
self._irc._Freenode_capabed = True
|
|
self._irc._Freenode_capabed_notices = True
|
|
|
|
if cmd == 'nak': # Failure reply
|
|
if "identify-msg" in args: # identify-msg is not set
|
|
self._irc._Freenode_capabed = False
|
|
self._irc._Freenode_capabed_notices = False
|
|
|
|
def do421(self, irc, msg):
|
|
"""Invalid command"""
|
|
if msg.args[1].lower() == "cap":
|
|
irc.queueMsg(ircmsgs.IrcMsg("CAPAB IDENTIFY MSG"))
|
|
|
|
def do376(self, irc, msg, force=False): # End of /MOTD command.
|
|
"""
|
|
The new freenode ircd-seven requires using the 'CAP' command
|
|
to set capabilities, rather than hyperirons 'CAPAB' command.
|
|
You request "CAP REQ IDENTIFY-MSG" and the server will respond
|
|
with either "CAP <nick> ACK :identify-msg" to acknowledge, or
|
|
"CAP <nick> NAK :identify-msg" to indicate failure.
|
|
Other than that, it's the same.
|
|
"""
|
|
if not hasattr(self._irc, "_Freenode_capabed") or force: # Do this only once
|
|
self._irc._Freenode_capabed = False
|
|
self._irc._Freenode_capabed_notices = False
|
|
# Try the CAP command first
|
|
irc.queueMsg(ircmsgs.IrcMsg("CAP LS"))
|
|
|
|
do422 = do376
|
|
|
|
def inFilter(self, irc, msg):
|
|
"""
|
|
Strip the leading '+' or '-' from each message
|
|
"""
|
|
|
|
if msg.command not in ("PRIVMSG", "NOTICE"):
|
|
return msg
|
|
|
|
if not getattr(irc, '_Freenode_capabed', False):
|
|
return msg
|
|
|
|
if msg.command == "NOTICE" and not getattr(irc, '_Freenode_capabed_notices', False):
|
|
return msg
|
|
|
|
if msg.tagged('identified') == None:
|
|
first = msg.args[1][0]
|
|
rest = msg.args[1][1:]
|
|
msg.tag('identified', first == '+')
|
|
if first in ('+', '-'):
|
|
msg = ircmsgs.privmsg(msg.args[0], rest, msg=msg)
|
|
assert msg.receivedAt and msg.receivedOn and msg.receivedBy
|
|
|
|
if len(msg.args) >= 2 and msg.args[1] and msg.args[1][0] in ('+', '-'):
|
|
self.do376(irc, msg, True)
|
|
return msg
|
|
|
|
Class = IRCLogin
|