X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=lib%2Frbot%2Fbotuser.rb;h=defb3a47afa9b119f7cbaeb626d41dce29d2cbc2;hb=43864ec494a9c2538934690f32eacb8bfb5cc921;hp=6131a7b76436cbb6a5f4be9856d71aa5694f0226;hpb=a4384d0c8a0d723897cf36fb423ba26fb0d1b083;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git diff --git a/lib/rbot/botuser.rb b/lib/rbot/botuser.rb index 6131a7b7..defb3a47 100644 --- a/lib/rbot/botuser.rb +++ b/lib/rbot/botuser.rb @@ -8,26 +8,48 @@ # License:: GPLv2 require 'singleton' +require 'set' +require 'rbot/maskdb' +# This would be a good idea if it was failproof, but the truth +# is that other methods can indirectly modify the hash. *sigh* +# +# class AuthNotifyingHash < Hash +# %w(clear default= delete delete_if replace invert +# merge! update rehash reject! replace shift []= store).each { |m| +# class_eval { +# define_method(m) { |*a| +# r = super(*a) +# Irc::Bot::Auth.manager.set_changed +# r +# } +# } +# } +# end +# module Irc +class Bot # This module contains the actual Authentication stuff # module Auth - BotConfig.register BotConfigStringValue.new( 'auth.password', + Config.register Config::StringValue.new( 'auth.password', :default => 'rbotauth', :wizard => true, :on_change => Proc.new {|bot, v| bot.auth.botowner.password = v}, :desc => _('Password for the bot owner')) - BotConfig.register BotConfigBooleanValue.new( 'auth.login_by_mask', + Config.register Config::BooleanValue.new( 'auth.login_by_mask', :default => 'true', :desc => _('Set false to prevent new botusers from logging in without a password when the user netmask is known')) - BotConfig.register BotConfigBooleanValue.new( 'auth.autologin', + Config.register Config::BooleanValue.new( 'auth.autologin', :default => 'true', :desc => _('Set false to prevent new botusers from recognizing IRC users without a need to manually login')) - # BotConfig.register BotConfigIntegerValue.new( 'auth.default_level', + Config.register Config::BooleanValue.new( 'auth.autouser', + :default => 'false', + :desc => _('Set true to allow new botusers to be created automatically')) + # Config.register Config::IntegerValue.new( 'auth.default_level', # :default => 10, :wizard => true, # :desc => 'The default level for new/unknown users' ) @@ -42,7 +64,7 @@ module Irc end - # An Irc::Auth::Command defines a command by its "path": + # An Irc::Bot::Auth::Command defines a command by its "path": # # base::command::subcommand::subsubcommand::subsubsubcommand # @@ -90,13 +112,14 @@ module Irc end end +end class String - # Returns an Irc::Auth::Comand from the receiver + # Returns an Irc::Bot::Auth::Comand from the receiver def to_irc_auth_command - Irc::Auth::Command.new(self) + Irc::Bot::Auth::Command.new(self) end end @@ -104,15 +127,16 @@ end class Symbol - # Returns an Irc::Auth::Comand from the receiver + # Returns an Irc::Bot::Auth::Comand from the receiver def to_irc_auth_command - Irc::Auth::Command.new(self) + Irc::Bot::Auth::Command.new(self) end end module Irc +class Bot module Auth @@ -158,6 +182,9 @@ module Irc # def permit?(str) cmd = str.to_irc_auth_command + # TODO user-configurable list of always-allowed commands, + # for admins that want to set permissions -* for everybody + return true if cmd.command == :login allow = nil cmd.path.reverse.each { |k| if @perm.has_key?(k) @@ -177,8 +204,35 @@ module Irc end - # This is the basic class for bot users: they have a username, a password, - # a list of netmasks to match against, and a list of permissions. + # This is the basic class for bot users: they have a username, a + # password, a list of netmasks to match against, and a list of + # permissions. A BotUser can be marked as 'transient', usually meaning + # it's not intended for permanent storage. Transient BotUsers have lower + # priority than nontransient ones for autologin purposes. + # + # To initialize a BotUser, you pass a _username_ and an optional + # hash of options. Currently, only two options are recognized: + # + # transient:: true or false, determines if the BotUser is transient or + # permanent (default is false, permanent BotUser). + # + # Transient BotUsers are initialized by prepending an + # asterisk (*) to the username, and appending a sanitized + # version of the object_id. The username can be empty. + # A random password is generated. + # + # Permanent Botusers need the username as is, and no + # password is generated. + # + # masks:: an array of Netmasks to initialize the NetmaskList. This + # list is used as-is for permanent BotUsers. + # + # Transient BotUsers will alter the list elements which are + # Irc::User by globbing the nick and any initial nonletter + # part of the ident. + # + # The masks option is optional for permanent BotUsers, but + # obligatory (non-empty) for transients. # class BotUser @@ -187,21 +241,89 @@ module Irc attr_reader :netmasks attr_reader :perm attr_writer :login_by_mask - attr_writer :autologin + attr_writer :transient + + def autologin=(vnew) + vold = @autologin + @autologin = vnew + if vold && !vnew + @netmasks.each { |n| Auth.manager.maskdb.remove(self, n) } + elsif vnew && !vold + @netmasks.each { |n| Auth.manager.maskdb.add(self, n) } + end + end + + # Checks if the BotUser is transient + def transient? + @transient + end + + # Checks if the BotUser is permanent (not transient) + def permanent? + !@transient + end + + # Sets if the BotUser is permanent or not + def permanent=(bool) + @transient=!bool + end + + # Make the BotUser permanent + def make_permanent(name) + raise TypeError, "permanent already" if permanent? + @username = BotUser.sanitize_username(name) + @transient = false + reset_autologin + reset_password # or not? + @netmasks.dup.each do |m| + delete_netmask(m) + add_netmask(m.generalize) + end + end # Create a new BotUser with given username - def initialize(username) - @username = BotUser.sanitize_username(username) - @password = nil + def initialize(username, options={}) + opts = {:transient => false}.merge(options) + @transient = opts[:transient] + + if @transient + @username = "*" + @username << BotUser.sanitize_username(username) if username and not username.to_s.empty? + @username << BotUser.sanitize_username(object_id) + reset_password + @login_by_mask=true + @autologin=true + else + @username = BotUser.sanitize_username(username) + @password = nil + reset_login_by_mask + reset_autologin + end + @netmasks = NetmaskList.new + if opts.key?(:masks) and opts[:masks] + masks = opts[:masks] + masks = [masks] unless masks.respond_to?(:each) + masks.each { |m| + mask = m.to_irc_netmask + if @transient and User === m + mask.nick = "*" + mask.host = m.host.dup + mask.user = "*" + m.user.sub(/^\w?[^\w]+/,'') + end + add_netmask(mask) unless mask.to_s == "*" + } + end + raise "must provide a usable mask for transient BotUser #{@username}" if @transient and @netmasks.empty? + @perm = {} - reset_login_by_mask - reset_autologin end # Inspection def inspect - str = "<#{self.class}:#{'0x%08x' % self.object_id}:" + str = self.__to_s__[0..-2] + str << " (transient)" if @transient + str << ":" str << " @username=#{@username.inspect}" str << " @netmasks=#{@netmasks.inspect}" str << " @perm=#{@perm.inspect}" @@ -223,7 +345,7 @@ module Irc :netmasks => @netmasks, :perm => @perm, :login_by_mask => @login_by_mask, - :autologin => @autologin + :autologin => @autologin, } end @@ -236,13 +358,13 @@ module Irc # Reset the login-by-mask option # def reset_login_by_mask - @login_by_mask = Auth.authmanager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask) + @login_by_mask = Auth.manager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask) end # Reset the autologin option # def reset_autologin - @autologin = Auth.authmanager.bot.config['auth.autologin'] unless defined?(@autologin) + @autologin = Auth.manager.bot.config['auth.autologin'] unless defined?(@autologin) end # Do we allow automatic logging in? @@ -255,10 +377,13 @@ module Irc def from_hash(h) @username = h[:username] if h.has_key?(:username) @password = h[:password] if h.has_key?(:password) - @netmasks = h[:netmasks] if h.has_key?(:netmasks) - @perm = h[:perm] if h.has_key?(:perm) @login_by_mask = h[:login_by_mask] if h.has_key?(:login_by_mask) @autologin = h[:autologin] if h.has_key?(:autologin) + if h.has_key?(:netmasks) + @netmasks = h[:netmasks] + @netmasks.each { |n| Auth.manager.maskdb.add(self, n) } if @autologin + end + @perm = h[:perm] if h.has_key?(:perm) end # This method sets the password if the proposed new password @@ -318,7 +443,12 @@ module Irc # Adds a Netmask # def add_netmask(mask) - @netmasks << mask.to_irc_netmask + m = mask.to_irc_netmask + @netmasks << m + if self.autologin? + Auth.manager.maskdb.add(self, m) + Auth.manager.logout_transients(m) if self.permanent? + end end # Removes a Netmask @@ -326,33 +456,21 @@ module Irc def delete_netmask(mask) m = mask.to_irc_netmask @netmasks.delete(m) - end - - # Removes all Netmasks - # - def reset_netmasks - @netmasks = NetmaskList.new + Auth.manager.maskdb.remove(self, m) if self.autologin? end # This method checks if BotUser has a Netmask that matches _user_ # def knows?(usr) user = usr.to_irc_user - known = false - @netmasks.each { |n| - if user.matches?(n) - known = true - break - end - } - return known + !!@netmasks.find { |n| user.matches? n } end # This method gets called when User _user_ wants to log in. # It returns true or false depending on whether the password # is right. If it is, the Netmask of the user is added to the # list of acceptable Netmask unless it's already matched. - def login(user, password) + def login(user, password=nil) if password == @password or (password.nil? and (@login_by_mask || @autologin) and knows?(user)) add_netmask(user) unless knows?(user) debug "#{user} logged in as #{self.inspect}" @@ -378,7 +496,6 @@ module Irc end - # This is the default BotUser: it's used for all users which haven't # identified with the bot # @@ -442,12 +559,6 @@ module Irc return true end - # Resets the NetmaskList - def reset_netmasks - super - add_netmask("*!*@*") - end - # DefaultBotUser will check the default_perm after checking # the global ones # or on all channels if _chan_ is nil @@ -493,13 +604,27 @@ module Irc end - # This is the AuthManagerClass singleton, used to manage User/BotUser connections and - # everything + class BotUser + # Check if the current BotUser is the default one + def default? + return DefaultBotUserClass === self + end + + # Check if the current BotUser is the owner + def owner? + return BotOwnerClass === self + end + end + + + # This is the ManagerClass singleton, used to manage + # Irc::User/Irc::Bot::Auth::BotUser connections and everything # - class AuthManagerClass + class ManagerClass include Singleton + attr_reader :maskdb attr_reader :everyone attr_reader :botowner attr_reader :bot @@ -541,10 +666,11 @@ module Irc # resets the hashes def reset_hashes @botusers = Hash.new + @maskdb = NetmaskDb.new @allbotusers = Hash.new - [everyone, botowner].each { |x| + [everyone, botowner].each do |x| @allbotusers[x.username.to_sym] = x - } + end end def load_array(ary, forced) @@ -561,14 +687,15 @@ module Irc create_botuser(u) end get_botuser(u).from_hash(x) + get_botuser(u).transient = false } @has_changes=false end def save_array @allbotusers.values.map { |x| - x.to_hash - } + x.transient? ? nil : x.to_hash + }.compact end # checks if we know about a certain BotUser username @@ -630,13 +757,81 @@ module Irc ircuser = user.to_irc_user debug "Trying to autologin #{ircuser}" return @botusers[ircuser] if @botusers.has_key?(ircuser) - @allbotusers.each { |n, bu| - debug "Checking with #{n}" - return bu if bu.autologin? and login(ircuser, n) - } + bu = maskdb.find(ircuser) + if bu + debug "trying #{bu}" + bu.login(ircuser) or raise '...what?!' + @botusers[ircuser] = bu + return bu + end + # Finally, create a transient if we're set to allow it + if @bot.config['auth.autouser'] + bu = create_transient_botuser(ircuser) + @botusers[ircuser] = bu + return bu + end return everyone end + # Creates a new transient BotUser associated with Irc::User _user_, + # automatically logging him in. Note that transient botuser creation can + # fail, typically if we don't have the complete user netmask (e.g. for + # messages coming in from a linkbot) + # + def create_transient_botuser(user) + ircuser = user.to_irc_user + bu = everyone + begin + bu = BotUser.new(ircuser, :transient => true, :masks => ircuser) + bu.login(ircuser) + rescue + warning "failed to create transient for #{user}" + error $! + end + return bu + end + + # Logs out any Irc::User matching Irc::Netmask _m_ and logged in + # to a transient BotUser + # + def logout_transients(m) + debug "to check: #{@botusers.keys.join ' '}" + @botusers.keys.each do |iu| + debug "checking #{iu.fullform} against #{m.fullform}" + bu = @botusers[iu] + bu.transient? or next + iu.matches?(m) or next + @botusers.delete(iu).autologin = false + end + end + + # Makes transient BotUser _user_ into a permanent BotUser + # named _name_; if _user_ is an Irc::User, act on the transient + # BotUser (if any) it's logged in as + # + def make_permanent(user, name) + buname = BotUser.sanitize_username(name) + # TODO merge BotUser instead? + raise "there's already a BotUser called #{name}" if include?(buname) + + tuser = nil + case user + when String, Irc::User + tuser = irc_to_botuser(user) + when BotUser + tuser = user + else + raise TypeError, "sorry, don't know how to make #{user.class} into a permanent BotUser" + end + return nil unless tuser + raise TypeError, "#{tuser} is not transient" unless tuser.transient? + + tuser.make_permanent(buname) + @allbotusers[tuser.username.to_sym] = tuser + + return tuser + end + # Checks if User _user_ can do _cmd_ on _chan_. # # Permission are checked in this order, until a true or false @@ -696,12 +891,23 @@ module Irc end - # Returns the only instance of AuthManagerClass + # Returns the only instance of ManagerClass # - def Auth.authmanager - return AuthManagerClass.instance + def Auth.manager + return ManagerClass.instance end end +end + + class User + + # A convenience method to automatically found the botuser + # associated with the receiver + # + def botuser + Irc::Bot::Auth.manager.irc_to_botuser(self) + end + end end