# Copyright:: Copyright (c) 2006 Giuseppe Bilotta\r
# License:: GPLv2\r
\r
-#--\r
-#####\r
-####\r
-### Discussion on IRC on how to implement it\r
-##\r
-#\r
-# <tango_> a. do we want user groups together with users?\r
-# <markey> hmm\r
-# <markey> let me think about it\r
-# <markey> generally I would say: as simple as possible while keeping it as flexible as need be\r
-# <tango_> I think we can put user groups in place afterwards if we build the structure right\r
-# <markey> prolly, yes\r
-# <tango_> so\r
-# <tango_> each plugin registers a name\r
-# <tango_> so rather than auth level we have +name -name\r
-# <markey> yes\r
-# <markey> much better\r
-# <tango_> the default is +name for every plugin, except when the plugin tells otherwise\r
-# <markey> although.. \r
-# <markey> if I only want to allow you access to one plugin\r
-# <markey> I have lots of typing to do\r
-# <tango_> nope\r
-# <tango_> we allow things like -*\r
-# <markey> ok\r
-# <tango_> and + has precedence\r
-# <tango_> hm no, not good either\r
-# <tango_> because we want bot -* +onething and +* -onething to work\r
-# <markey> but then: one plugin currently can have several levels, no?\r
-# <tango_> of course\r
-# <markey> commandedit, commanddel, commandfoo\r
-# <tango_> name.command ?\r
-# <markey> yep\r
-# <tango_> (then you can't have dots in commands\r
-# <tango_> maybe name:command\r
-# <markey> or name::comand\r
-# <markey> like a namespace\r
-# <tango_> ehehehe yeah I like it :)\r
-# <tango_> tel\r
-# <tango_> brb\r
-# <markey> usermod setcaps eean -*\r
-# <markey> usermod setcaps eean +quiz::edit\r
-# <markey> great\r
-# <markey> or even\r
-# <markey> auth eean -*, +quiz::edit\r
-# <markey> awesome\r
-# <markey> auth eean -*, +quiz::edit, +command, -command::del\r
-# <tango_> yes\r
-# <markey> you know, the default should be -*\r
-# <markey> because\r
-# <markey> in the time between adding the user and changing auth\r
-# <markey> it's insecure\r
-# <markey> user could do havoc\r
-# <markey> useradd eean, then eean does "~quit", before I change auth\r
-# <tango_> nope\r
-# <markey> perhaps we should allow combining useradd with auth\r
-# <tango_> the default should be +* -important stuff\r
-# <markey> ok\r
-# <tango_> how to specify channel stuff?\r
-# <markey> for one, when you issue the command on the channel itself\r
-# <markey> then it's channel relative\r
-# <markey> perhaps\r
-# <markey> or\r
-# <tango_> yes but I was thinking more about the syntax\r
-# <markey> auth eean #rbot -quiz\r
-# <tango_> hm\r
-# <markey> or maybe: treat channels like users: auth #rbot -quiz\r
-# <markey> would shut up quiz in #rbot\r
-# <markey> hm\r
-# <markey> heh\r
-# <tango_> auth * #rbot -quiz\r
-# <markey> not sure I'm making sense here ;)\r
-# <tango_> I think syntax should be auth [usermask] [channelmask] [modes]\r
-# <markey> yes\r
-# <markey> modes separated by comma?\r
-# <tango_> where channelmask is implied to be *\r
-# <tango_> no we can have it spacesplit\r
-# <markey> great\r
-# <markey> ok\r
-# <tango_> modes are detected by +-\r
-# <tango_> so you can do something like auth markey #rbot -quiz #amarok -chuck\r
-# <markey> also I like "auth" a lot more than "usermod foo"\r
-# <markey> yep\r
-# <tango_> I don't understand why the 'mod'\r
-# <tango_> we could have all auth commands start with use\r
-# <tango_> user\r
-# <tango_> user add\r
-# <tango_> user list\r
-# <tango_> user del\r
-# <markey> yes\r
-# <tango_> user auth\r
-# <tango_> hm\r
-# <tango_> and maybe auth as a synonym for user auth\r
-# <markey> this is also uncomfortable: usermod wants the full user mask\r
-# <markey> you have to copy/paste it\r
-# <tango_> no\r
-# <tango_> can't you use *?\r
-# <markey> sorry not sure\r
-# <markey> but this shows, it's not inuitive\r
-# <markey> I've read the docs\r
-# <markey> but didn't know how to use it really\r
-# <tango_> markey!*@*\r
-# <markey> that's not very intuitive\r
-# <tango_> we could use nick as a synonym for nick!*@* if it's too much for you :D\r
-# <markey> usermod markey foo should suffice\r
-# <markey> rememember: you're a hacker. when rbot gets many new users, they will often be noobs\r
-# <markey> gotta make things simple to use\r
-# <tango_> but the hostmask is only needed for the user creation\r
-# <markey> really? then forget what I said, sorry\r
-# <tango_> I think so\r
-# <tango_> ,help auth\r
-# <testbot> Auth module (User authentication) topics: setlevel, useradd, userdel, usermod, auth, levels, users, whoami, identify\r
-# <tango_> ,help usermod\r
-# <testbot> no help for topic usermod\r
-# <tango_> ,help auth usermod\r
-# <testbot> usermod <username> <item> <value> => Modify <username>s settings. Valid <item>s are: hostmask, (+|-)hostmask, password, level (private addressing only)\r
-# <tango_> see? it's username, not nick :D\r
-# <markey> btw, help usermod should also work\r
-# <tango_> ,help auth useradd\r
-# <testbot> useradd <username> => Add user <mask>, you still need to set him up correctly (private addressing only)\r
-# <markey> instead of help auth usermode\r
-# <markey> when it's not ambiguous\r
-# <tango_> and the help for useradd is wrong\r
-# <markey> for the website, we could make a logo contest :) the current logo looks like giblet made it in 5 minutes ;)\r
-# <markey> ah well, for 1.0 maybe\r
-# <tango_> so a user on rbot is given by\r
-# <tango_> username, password, hostmasks, permissions\r
-# <markey> yup\r
-# <tango_> the default permission is +* -importantstuff\r
-# <markey> how defines importantstuff?\r
-# <markey> you mean like core and auth?\r
-# <tango_> yes\r
-# <markey> ok\r
-# <tango_> but we can decide about this :)\r
-# <markey> some plugins are dangerous by default\r
-# <markey> like command plugin\r
-# <markey> you can do all sorts of nasty shit with it\r
-# <tango_> then command plugin will do something like: command.defaultperm("-command")\r
-# <markey> yes, good point\r
-# <tango_> this is then added to the default permissions (user * channel *)\r
-# <tango_> when checking for auth, we go like this:\r
-# <tango_> hm\r
-# <tango_> check user * channel *\r
-# <tango_> then user name channel *\r
-# <tango_> then user * channel name\r
-# <tango_> then user name channel name\r
-# <tango_> for each of these combinations we match against * first, then against command, and then against command::subcommand\r
-# <markey> yup\r
-# <tango_> setting or resetting it depending on wether it's + or -\r
-# <tango_> the final result gives us the permission\r
-# <tango_> implementation detail\r
-# <tango_> username and passwords are strings\r
-# <markey> (I might rename the command plugin, the name is somewhat confusing)\r
-# <tango_> yeah\r
-# <tango_> hostmasks are hostmasks\r
-# <markey> also I'm pondering to restrict it more: disallow access to @bot\r
-# <tango_> permissions are in the form [ [channel, {command => bool, ...}] ...]\r
-#++\r
-\r
require 'singleton'\r
+require 'set'\r
+require 'rbot/maskdb'\r
\r
-module Irc\r
-\r
- # This method raises a TypeError if _user_ is not of class User\r
- #\r
- def Irc.error_if_not_user(user)\r
- raise TypeError, "#{user.inspect} must be of type Irc::User and not #{user.class}" unless user.class <= User\r
- end\r
+# This would be a good idea if it was failproof, but the truth\r
+# is that other methods can indirectly modify the hash. *sigh*\r
+#\r
+# class AuthNotifyingHash < Hash\r
+# %w(clear default= delete delete_if replace invert\r
+# merge! update rehash reject! replace shift []= store).each { |m|\r
+# class_eval {\r
+# define_method(m) { |*a|\r
+# r = super(*a)\r
+# Irc::Bot::Auth.manager.set_changed\r
+# r\r
+# }\r
+# }\r
+# }\r
+# end\r
+# \r
\r
- # This method raises a TypeError if _chan_ is not of class Chan\r
- #\r
- def Irc.error_if_not_channel(chan)\r
- raise TypeError, "#{chan.inspect} must be of type Irc::User and not #{chan.class}" unless chan.class <= Channel\r
- end\r
+module Irc\r
+class Bot\r
\r
\r
# This module contains the actual Authentication stuff\r
#\r
module Auth\r
\r
+ Config.register Config::StringValue.new( 'auth.password',\r
+ :default => 'rbotauth', :wizard => true,\r
+ :on_change => Proc.new {|bot, v| bot.auth.botowner.password = v},\r
+ :desc => _('Password for the bot owner'))\r
+ Config.register Config::BooleanValue.new( 'auth.login_by_mask',\r
+ :default => 'true',\r
+ :desc => _('Set false to prevent new botusers from logging in without a password when the user netmask is known'))\r
+ Config.register Config::BooleanValue.new( 'auth.autologin',\r
+ :default => 'true',\r
+ :desc => _('Set false to prevent new botusers from recognizing IRC users without a need to manually login'))\r
+ Config.register Config::BooleanValue.new( 'auth.autouser',\r
+ :default => 'false',\r
+ :desc => _('Set true to allow new botusers to be created automatically'))\r
+ # Config.register Config::IntegerValue.new( 'auth.default_level',\r
+ # :default => 10, :wizard => true,\r
+ # :desc => 'The default level for new/unknown users' )\r
+\r
# Generate a random password of length _l_\r
#\r
- def random_password(l=8)\r
+ def Auth.random_password(l=8)\r
pwd = ""\r
- 8.times do\r
- pwd += (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr\r
+ l.times do\r
+ pwd << (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr\r
end\r
return pwd\r
end\r
\r
\r
- # An Irc::Auth::Command defines a command by its "path":\r
+ # An Irc::Bot::Auth::Command defines a command by its "path":\r
#\r
# base::command::subcommand::subsubcommand::subsubsubcommand\r
#\r
k.to_sym\r
}\r
@command = path.last\r
- debug "Created command #{@command.inspect} with path #{@path.join(', ')}"\r
+ debug "Created command #{@command.inspect} with path #{@path.pretty_inspect}"\r
+ end\r
+\r
+ # Returs self\r
+ def to_irc_auth_command\r
+ self\r
end\r
- end\r
\r
- # This method raises a TypeError if _user_ is not of class User\r
- #\r
- def Irc.error_if_not_command(cmd)\r
- raise TypeError, "#{cmd.inspect} must be of type Irc::Auth::Command and not #{cmd.class}" unless cmd.class <= Command\r
end\r
\r
+ end\r
+\r
+end\r
+end\r
+\r
+\r
+class String\r
+\r
+ # Returns an Irc::Bot::Auth::Comand from the receiver\r
+ def to_irc_auth_command\r
+ Irc::Bot::Auth::Command.new(self)\r
+ end\r
+\r
+end\r
+\r
+\r
+class Symbol\r
+\r
+ # Returns an Irc::Bot::Auth::Comand from the receiver\r
+ def to_irc_auth_command\r
+ Irc::Bot::Auth::Command.new(self)\r
+ end\r
+\r
+end\r
+\r
+\r
+module Irc\r
+class Bot\r
+\r
+\r
+ module Auth\r
+\r
\r
# This class describes a permission set\r
class PermissionSet\r
\r
+ attr_reader :perm\r
# Create a new (empty) PermissionSet\r
#\r
def initialize\r
\r
# Sets the permission for command _cmd_ to _val_,\r
#\r
- def set_permission(cmd, val)\r
- Irc::error_if_not_command(cmd)\r
+ def set_permission(str, val)\r
+ cmd = str.to_irc_auth_command\r
case val\r
when true, false\r
@perm[cmd.command] = val\r
# Tells if command _cmd_ is permitted. We do this by returning\r
# the value of the deepest Command#path that matches.\r
#\r
- def permit?(cmd)\r
- Irc::error_if_not_command(cmd)\r
+ def permit?(str)\r
+ cmd = str.to_irc_auth_command\r
allow = nil\r
cmd.path.reverse.each { |k|\r
if @perm.has_key?(k)\r
}\r
return allow\r
end\r
+\r
end\r
\r
\r
- # This is the basic class for bot users: they have a username, a password, a\r
- # list of netmasks to match against, and a list of permissions.\r
+ # This is the error that gets raised when an invalid password is met\r
+ #\r
+ class InvalidPassword < RuntimeError\r
+ end\r
+\r
+\r
+ # This is the basic class for bot users: they have a username, a\r
+ # password, a list of netmasks to match against, and a list of\r
+ # permissions. A BotUser can be marked as 'transient', usually meaning\r
+ # it's not intended for permanent storage. Transient BotUsers have lower\r
+ # priority than nontransient ones for autologin purposes.\r
+ #\r
+ # To initialize a BotUser, you pass a _username_ and an optional\r
+ # hash of options. Currently, only two options are recognized:\r
+ #\r
+ # transient:: true or false, determines if the BotUser is transient or\r
+ # permanent (default is false, permanent BotUser).\r
+ #\r
+ # Transient BotUsers are initialized by prepending an\r
+ # asterisk (*) to the username, and appending a sanitized\r
+ # version of the object_id. The username can be empty.\r
+ # A random password is generated.\r
+ #\r
+ # Permanent Botusers need the username as is, and no\r
+ # password is generated.\r
+ #\r
+ # masks:: an array of Netmasks to initialize the NetmaskList. This\r
+ # list is used as-is for permanent BotUsers.\r
+ #\r
+ # Transient BotUsers will alter the list elements which are\r
+ # Irc::User by globbing the nick and any initial nonletter\r
+ # part of the ident.\r
+ #\r
+ # The masks option is optional for permanent BotUsers, but\r
+ # obligatory (non-empty) for transients.\r
#\r
class BotUser\r
\r
attr_reader :username\r
attr_reader :password\r
attr_reader :netmasks\r
+ attr_reader :perm\r
+ attr_writer :login_by_mask\r
+ attr_writer :transient\r
+\r
+ def autologin=(vnew)\r
+ vold = @autologin\r
+ @autologin = vnew\r
+ if vold && !vnew\r
+ @netmasks.each { |n| Auth.manager.maskdb.remove(self, n) }\r
+ elsif vnew && !vold\r
+ @netmasks.each { |n| Auth.manager.maskdb.add(self, n) }\r
+ end\r
+ end\r
+\r
+ # Checks if the BotUser is transient\r
+ def transient?\r
+ @transient\r
+ end\r
+\r
+ # Checks if the BotUser is permanent (not transient)\r
+ def permanent?\r
+ !@transient\r
+ end\r
+\r
+ # Sets if the BotUser is permanent or not\r
+ def permanent=(bool)\r
+ @transient=!bool\r
+ end\r
+\r
+ # Make the BotUser permanent\r
+ def make_permanent(name)\r
+ raise TypError, "permanent already" if permanent?\r
+ @username = BotUser.sanitize_username(name)\r
+ @transient = false\r
+ reset_autologin\r
+ reset_password # or not?\r
+ @netmasks.dup.each do |m|\r
+ delete_netmask(m)\r
+ add_netmask(m.generalize)\r
+ end\r
+ end\r
\r
# Create a new BotUser with given username\r
- def initialize(username)\r
- @username = BotUser.sanitize_username(username)\r
- @password = nil\r
+ def initialize(username, options={})\r
+ opts = {:transient => false}.merge(options)\r
+ @transient = opts[:transient]\r
+\r
+ if @transient\r
+ @username = "*"\r
+ @username << BotUser.sanitize_username(username) if username and not username.to_s.empty?\r
+ @username << BotUser.sanitize_username(object_id)\r
+ reset_password\r
+ @login_by_mask=true\r
+ @autologin=true\r
+ else\r
+ @username = BotUser.sanitize_username(username)\r
+ @password = nil\r
+ reset_login_by_mask\r
+ reset_autologin\r
+ end\r
+\r
@netmasks = NetmaskList.new\r
+ if opts.key?(:masks) and opts[:masks]\r
+ masks = opts[:masks]\r
+ masks = [masks] unless masks.respond_to?(:each)\r
+ masks.each { |m|\r
+ mask = m.to_irc_netmask\r
+ if @transient and User === m\r
+ mask.nick = "*"\r
+ mask.host = m.host.dup\r
+ mask.user = "*" + m.user.sub(/^\w?[^\w]+/,'')\r
+ end\r
+ add_netmask(mask) unless mask.to_s == "*"\r
+ }\r
+ end\r
+ raise "must provide a usable mask for transient BotUser #{@username}" if @transient and @netmasks.empty?\r
+\r
@perm = {}\r
end\r
\r
+ # Inspection\r
+ def inspect\r
+ str = "<#{self.class}:#{'0x%08x' % self.object_id}"\r
+ str << " (transient)" if @transient\r
+ str << ":"\r
+ str << " @username=#{@username.inspect}"\r
+ str << " @netmasks=#{@netmasks.inspect}"\r
+ str << " @perm=#{@perm.inspect}"\r
+ str << " @login_by_mask=#{@login_by_mask}"\r
+ str << " @autologin=#{@autologin}"\r
+ str << ">"\r
+ end\r
+\r
+ # In strings\r
+ def to_s\r
+ @username\r
+ end\r
+\r
+ # Convert into a hash\r
+ def to_hash\r
+ {\r
+ :username => @username,\r
+ :password => @password,\r
+ :netmasks => @netmasks,\r
+ :perm => @perm,\r
+ :login_by_mask => @login_by_mask,\r
+ :autologin => @autologin,\r
+ }\r
+ end\r
+\r
+ # Do we allow logging in without providing the password?\r
+ #\r
+ def login_by_mask?\r
+ @login_by_mask\r
+ end\r
+\r
+ # Reset the login-by-mask option\r
+ #\r
+ def reset_login_by_mask\r
+ @login_by_mask = Auth.manager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask)\r
+ end\r
+\r
+ # Reset the autologin option\r
+ #\r
+ def reset_autologin\r
+ @autologin = Auth.manager.bot.config['auth.autologin'] unless defined?(@autologin)\r
+ end\r
+\r
+ # Do we allow automatic logging in?\r
+ #\r
+ def autologin?\r
+ @autologin\r
+ end\r
+\r
+ # Restore from hash\r
+ def from_hash(h)\r
+ @username = h[:username] if h.has_key?(:username)\r
+ @password = h[:password] if h.has_key?(:password)\r
+ @login_by_mask = h[:login_by_mask] if h.has_key?(:login_by_mask)\r
+ @autologin = h[:autologin] if h.has_key?(:autologin)\r
+ if h.has_key?(:netmasks)\r
+ @netmasks = h[:netmasks]\r
+ @netmasks.each { |n| Auth.manager.maskdb.add(self, n) } if @autologin\r
+ end\r
+ @perm = h[:perm] if h.has_key?(:perm)\r
+ end\r
+\r
+ # This method sets the password if the proposed new password\r
+ # is valid\r
+ def password=(pwd=nil)\r
+ pass = pwd.to_s\r
+ if pass.empty?\r
+ reset_password\r
+ else\r
+ begin\r
+ raise InvalidPassword, "#{pass} contains invalid characters" if pass !~ /^[\x21-\x7e]+$/\r
+ raise InvalidPassword, "#{pass} too short" if pass.length < 4\r
+ @password = pass\r
+ rescue InvalidPassword => e\r
+ raise e\r
+ rescue => e\r
+ raise InvalidPassword, "Exception #{e.inspect} while checking #{pass.inspect} (#{pwd.inspect})"\r
+ end\r
+ end\r
+ end\r
+\r
# Resets the password by creating a new onw\r
def reset_password\r
- @password = random_password\r
+ @password = Auth.random_password\r
end\r
\r
# Sets the permission for command _cmd_ to _val_ on channel _chan_\r
def set_permission(cmd, val, chan="*")\r
k = chan.to_s.to_sym\r
@perm[k] = PermissionSet.new unless @perm.has_key?(k)\r
- case cmd\r
- when String\r
- @perm[k].set_permission(Command.new(cmd), val)\r
- else\r
- @perm[k].set_permission(cmd, val)\r
- end\r
+ @perm[k].set_permission(cmd, val)\r
end\r
\r
# Resets the permission for command _cmd_ on channel _chan_\r
# Adds a Netmask\r
#\r
def add_netmask(mask)\r
- case mask\r
- when Netmask\r
- @netmasks << mask\r
- else\r
- @netmasks << Netmask(mask)\r
+ m = mask.to_irc_netmask\r
+ @netmasks << m\r
+ if self.autologin?\r
+ Auth.manager.maskdb.add(self, m)\r
+ Auth.manager.logout_transients(m) if self.permanent?\r
end\r
end\r
\r
# Removes a Netmask\r
#\r
def delete_netmask(mask)\r
- case mask\r
- when Netmask\r
- m = mask\r
- else\r
- m << Netmask(mask)\r
- end\r
+ m = mask.to_irc_netmask\r
@netmasks.delete(m)\r
- end\r
-\r
- # Removes all <code>Netmask</code>s\r
- def reset_netmask_list\r
- @netmasks = NetmaskList.new\r
+ Auth.manager.maskdb.remove(self, m) if self.autologin?\r
end\r
\r
# This method checks if BotUser has a Netmask that matches _user_\r
- def knows?(user)\r
- Irc::error_if_not_user(user)\r
- known = false\r
- @netmasks.each { |n|\r
- if user.matches?(n)\r
- known = true\r
- break\r
- end\r
- }\r
- return known\r
+ #\r
+ def knows?(usr)\r
+ user = usr.to_irc_user\r
+ !!@netmasks.find { |n| user.matches? n }\r
end\r
\r
# This method gets called when User _user_ wants to log in.\r
# It returns true or false depending on whether the password\r
# is right. If it is, the Netmask of the user is added to the\r
# list of acceptable Netmask unless it's already matched.\r
- def login(user, password)\r
- if password == @password\r
+ def login(user, password=nil)\r
+ if password == @password or (password.nil? and (@login_by_mask || @autologin) and knows?(user))\r
add_netmask(user) unless knows?(user)\r
+ debug "#{user} logged in as #{self.inspect}"\r
return true\r
else\r
return false\r
# and replacing any nonalphanumeric character with _\r
#\r
def BotUser.sanitize_username(name)\r
- return name.to_s.chomp.downcase.gsub(/[^a-z0-9]/,"_")\r
+ candidate = name.to_s.chomp.downcase.gsub(/[^a-z0-9]/,"_")\r
+ raise "sanitized botusername #{candidate} too short" if candidate.length < 3\r
+ return candidate\r
end\r
\r
- # This method sets the password if the proposed new password\r
- # is valid\r
- def password=(pwd=nil)\r
- if pwd\r
- begin\r
- raise InvalidPassword, "#{pwd} contains invalid characters" if pwd !~ /^[A-Za-z0-9]+$/\r
- raise InvalidPassword, "#{pwd} too short" if pwd.length < 4\r
- @password = pwd\r
- rescue InvalidPassword => e\r
- raise e\r
- rescue => e\r
- raise InvalidPassword, "Exception #{e.inspect} while checking #{pwd}"\r
- end\r
- else\r
- reset_password\r
- end\r
- end\r
end\r
\r
-\r
# This is the default BotUser: it's used for all users which haven't\r
# identified with the bot\r
#\r
class DefaultBotUserClass < BotUser\r
+\r
+ private :add_netmask, :delete_netmask\r
+\r
include Singleton\r
+\r
+ # The default BotUser is named 'everyone'\r
+ #\r
def initialize\r
+ reset_login_by_mask\r
+ reset_autologin\r
super("everyone")\r
@default_perm = PermissionSet.new\r
end\r
- private :login, :add_netmask, :delete_netmask\r
+\r
+ # This method returns without changing anything\r
+ #\r
+ def login_by_mask=(val)\r
+ debug "Tried to change the login-by-mask for default bot user, ignoring"\r
+ return @login_by_mask\r
+ end\r
+\r
+ # The default botuser allows logins by mask\r
+ #\r
+ def reset_login_by_mask\r
+ @login_by_mask = true\r
+ end\r
+\r
+ # This method returns without changing anything\r
+ #\r
+ def autologin=(val)\r
+ debug "Tried to change the autologin for default bot user, ignoring"\r
+ return\r
+ end\r
+\r
+ # The default botuser doesn't allow autologin (meaningless)\r
+ #\r
+ def reset_autologin\r
+ @autologin = false\r
+ end\r
\r
# Sets the default permission for the default user (i.e. the ones\r
# set by the BotModule writers) on all channels\r
#\r
def set_default_permission(cmd, val)\r
@default_perm.set_permission(Command.new(cmd), val)\r
- debug "Default permissions now:\n#{@default_perm.inspect}"\r
+ debug "Default permissions now: #{@default_perm.pretty_inspect}"\r
end\r
\r
# default knows everybody\r
#\r
def knows?(user)\r
- Irc::error_if_not_user(user)\r
- return true\r
+ return true if user.to_irc_user\r
end\r
\r
- # Resets the NetmaskList\r
- def reset_netmask_list\r
- super\r
- add_netmask("*!*@*")\r
+ # We always allow logging in as the default user\r
+ def login(user, password)\r
+ return true\r
end\r
\r
# DefaultBotUser will check the default_perm after checking\r
end\r
return allow\r
end\r
+\r
end\r
\r
# Returns the only instance of DefaultBotUserClass\r
# This is the BotOwner: he can do everything\r
#\r
class BotOwnerClass < BotUser\r
+\r
include Singleton\r
+\r
def initialize\r
+ @login_by_mask = false\r
+ @autologin = true\r
super("owner")\r
end\r
\r
def permit?(cmd, chan=nil)\r
return true\r
end\r
+\r
end\r
\r
# Returns the only instance of BotOwnerClass\r
end\r
\r
\r
- # This is the AuthManagerClass singleton, used to manage User/BotUser connections and\r
- # everything\r
+ class BotUser\r
+ # Check if the current BotUser is the default one\r
+ def default?\r
+ return DefaultBotUserClass === self\r
+ end\r
+\r
+ # Check if the current BotUser is the owner\r
+ def owner?\r
+ return BotOwnerClass === self\r
+ end\r
+ end\r
+\r
+\r
+ # This is the ManagerClass singleton, used to manage\r
+ # Irc::User/Irc::Bot::Auth::BotUser connections and everything\r
#\r
- class AuthManagerClass\r
+ class ManagerClass\r
+\r
include Singleton\r
\r
+ attr_reader :maskdb\r
attr_reader :everyone\r
attr_reader :botowner\r
+ attr_reader :bot\r
\r
# The instance manages two <code>Hash</code>es: one that maps\r
# <code>Irc::User</code>s onto <code>BotUser</code>s, and the other that maps\r
@has_changes = false\r
end\r
\r
+ def set_changed\r
+ @has_changes = true\r
+ end\r
+\r
+ def reset_changed\r
+ @has_changes = false\r
+ end\r
+\r
+ def changed?\r
+ @has_changes\r
+ end\r
+\r
# resets the hashes\r
def reset_hashes\r
@botusers = Hash.new\r
+ @maskdb = NetmaskDb.new\r
@allbotusers = Hash.new\r
- [everyone, botowner].each { |x|\r
+ [everyone, botowner].each do |x|\r
@allbotusers[x.username.to_sym] = x\r
- }\r
- end\r
-\r
- # load botlist from userfile\r
- def load_merge(filename=nil)\r
- # TODO\r
- raise NotImplementedError\r
- @has_changes = true\r
+ end\r
end\r
\r
- def load(filename=nil)\r
+ def load_array(ary, forced)\r
+ unless ary\r
+ warning "Tried to load an empty array"\r
+ return\r
+ end\r
+ raise "Won't load with unsaved changes" if @has_changes and not forced\r
reset_hashes\r
- load_merge(filename)\r
+ ary.each { |x|\r
+ raise TypeError, "#{x} should be a Hash" unless x.kind_of?(Hash)\r
+ u = x[:username]\r
+ unless include?(u)\r
+ create_botuser(u)\r
+ end\r
+ get_botuser(u).from_hash(x)\r
+ get_botuser(u).transient = false\r
+ }\r
+ @has_changes=false\r
end\r
\r
- # save botlist to userfile\r
- def save(filename=nil)\r
- return unless @has_changes\r
- # TODO\r
- raise NotImplementedError\r
+ def save_array\r
+ @allbotusers.values.map { |x|\r
+ x.transient? ? nil : x.to_hash\r
+ }.compact\r
end\r
\r
# checks if we know about a certain BotUser username\r
\r
# Maps <code>Irc::User</code> to BotUser\r
def irc_to_botuser(ircuser)\r
- Irc::error_if_not_user(ircuser)\r
- # TODO check netmasks\r
- return @botusers[ircuser] || everyone\r
+ logged = @botusers[ircuser.to_irc_user]\r
+ return logged if logged\r
+ return autologin(ircuser)\r
end\r
\r
# creates a new BotUser\r
def create_botuser(name, password=nil)\r
n = BotUser.sanitize_username(name)\r
k = n.to_sym\r
- raise "BotUser #{n} exists" if include?(k)\r
+ raise "botuser #{n} exists" if include?(k)\r
bu = BotUser.new(n)\r
bu.password = password\r
@allbotusers[k] = bu\r
+ return bu\r
end\r
\r
- # Logs Irc::User _ircuser_ in to BotUser _botusername_ with password _pwd_\r
+ # returns the botuser with name _name_\r
+ def get_botuser(name)\r
+ @allbotusers.fetch(BotUser.sanitize_username(name).to_sym)\r
+ end\r
+\r
+ # Logs Irc::User _user_ in to BotUser _botusername_ with password _pwd_\r
#\r
# raises an error if _botusername_ is not a known BotUser username\r
#\r
# It is possible to autologin by Netmask, on request\r
#\r
- def login(ircuser, botusername, pwd, bymask = false)\r
- Irc::error_if_not_user(ircuser)\r
- n = BotUser.sanitize_username(name)\r
+ def login(user, botusername, pwd=nil)\r
+ ircuser = user.to_irc_user\r
+ n = BotUser.sanitize_username(botusername)\r
k = n.to_sym\r
raise "No such BotUser #{n}" unless include?(k)\r
if @botusers.has_key?(ircuser)\r
+ return true if @botusers[ircuser].username == n\r
# TODO\r
# @botusers[ircuser].logout(ircuser)\r
end\r
bu = @allbotusers[k]\r
- if bymask && bu.knows?(user)\r
- @botusers[ircuser] = bu\r
- return true\r
- elsif bu.login(ircuser, pwd)\r
+ if bu.login(ircuser, pwd)\r
@botusers[ircuser] = bu\r
return true\r
end\r
return false\r
end\r
\r
+ # Tries to auto-login Irc::User _user_ by looking at the known botusers that allow autologin\r
+ # and trying to login without a password\r
+ #\r
+ def autologin(user)\r
+ ircuser = user.to_irc_user\r
+ debug "Trying to autologin #{ircuser}"\r
+ return @botusers[ircuser] if @botusers.has_key?(ircuser)\r
+ bu = maskdb.find(ircuser)\r
+ if bu\r
+ debug "trying #{bu}"\r
+ bu.login(ircuser) or raise '...what?!'\r
+ @botusers[ircuser] = bu\r
+ return bu\r
+ end\r
+ # Finally, create a transient if we're set to allow it\r
+ if @bot.config['auth.autouser']\r
+ bu = create_transient_botuser(ircuser)\r
+ @botusers[ircuser] = bu\r
+ return bu\r
+ end\r
+ return everyone\r
+ end\r
+\r
+ # Creates a new transient BotUser associated with Irc::User _user_,\r
+ # automatically logging him in. Note that transient botuser creation can\r
+ # fail, typically if we don't have the complete user netmask (e.g. for\r
+ # messages coming in from a linkbot)\r
+ #\r
+ def create_transient_botuser(user)\r
+ ircuser = user.to_irc_user\r
+ bu = everyone\r
+ begin\r
+ bu = BotUser.new(ircuser, :transient => true, :masks => ircuser)\r
+ bu.login(ircuser)\r
+ rescue\r
+ warning "failed to create transient for #{user}"\r
+ error $!\r
+ end\r
+ return bu\r
+ end\r
+\r
+ # Logs out any Irc::User matching Irc::Netmask _m_ and logged in\r
+ # to a transient BotUser\r
+ #\r
+ def logout_transients(m)\r
+ debug "to check: #{@botusers.keys.join ' '}"\r
+ @botusers.keys.each do |iu|\r
+ debug "checking #{iu.fullform} against #{m.fullform}"\r
+ bu = @botusers[iu]\r
+ bu.transient? or next\r
+ iu.matches?(m) or next\r
+ @botusers.delete(iu).autologin = false\r
+ end\r
+ end\r
+\r
+ # Makes transient BotUser _user_ into a permanent BotUser\r
+ # named _name_; if _user_ is an Irc::User, act on the transient\r
+ # BotUser (if any) it's logged in as\r
+ #\r
+ def make_permanent(user, name)\r
+ # TODO merge BotUser instead?\r
+ raise "there's already a BotUser called #{name}" if include?(name)\r
+\r
+ tuser = nil\r
+ case user\r
+ when String, Irc::User\r
+ tuser = irc_to_botuser(user)\r
+ when BotUser\r
+ tuser = user\r
+ else\r
+ raise TypeError, "sorry, don't know how to make #{user.class} into a permanent BotUser"\r
+ end\r
+ return nil unless tuser\r
+ raise TypeError, "#{tuser} is not transient" unless tuser.transient?\r
+\r
+ tuser.make_permanent(name)\r
+ @allbotusers[tuser.username.to_sym] = tuser\r
+\r
+ return tuser\r
+ end\r
+\r
# Checks if User _user_ can do _cmd_ on _chan_.\r
#\r
# Permission are checked in this order, until a true or false\r
# * everyone on _chan_\r
# * everyone on all channels\r
#\r
- def permit?(user, cmdtxt, chan=nil)\r
- botuser = irc_to_botuser(user)\r
- cmd = Command.new(cmdtxt)\r
+ def permit?(user, cmdtxt, channel=nil)\r
+ if user.class <= BotUser\r
+ botuser = user\r
+ else\r
+ botuser = irc_to_botuser(user)\r
+ end\r
+ cmd = cmdtxt.to_irc_auth_command\r
\r
+ chan = channel\r
case chan\r
when User\r
chan = "?"\r
raise "Could not check permission for user #{user.inspect} to run #{cmdtxt.inspect} on #{chan.inspect}"\r
end\r
\r
- # Checks if command _cmd_ is allowed to User _user_ on _chan_\r
+ # Checks if command _cmd_ is allowed to User _user_ on _chan_, optionally\r
+ # telling if the user is authorized\r
+ #\r
def allow?(cmdtxt, user, chan=nil)\r
- permit?(user, cmdtxt, chan)\r
+ if permit?(user, cmdtxt, chan)\r
+ return true\r
+ else\r
+ # cmds = cmdtxt.split('::')\r
+ # @bot.say chan, "you don't have #{cmds.last} (#{cmds.first}) permissions here" if chan\r
+ @bot.say chan, _("%{user}, you don't have '%{command}' permissions here") %\r
+ {:user=>user, :command=>cmdtxt} if chan\r
+ return false\r
+ end\r
end\r
+\r
end\r
\r
- # Returns the only instance of AuthManagerClass\r
+ # Returns the only instance of ManagerClass\r
#\r
- def Auth.authmanager\r
- return AuthManagerClass.instance\r
+ def Auth.manager\r
+ return ManagerClass.instance\r
end\r
+\r
end\r
+end\r
+\r
+ class User\r
+\r
+ # A convenience method to automatically found the botuser\r
+ # associated with the receiver\r
+ #\r
+ def botuser\r
+ Irc::Bot::Auth.manager.irc_to_botuser(self)\r
+ end\r
+ end\r
+\r
end\r
projects / user / henk / code / ruby / rbot.git / blobdiff