X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=lib%2Frbot%2Fbotuser.rb;h=83fb26240333a0456a743fe662b3c61f26ebce01;hb=b1debac35f5e45545066da07027ddaaf6c9faca7;hp=5ae7fc2b2b72e2474a4ba71e8e0c68d6fb944039;hpb=d2cd565d48bc38cba05fa311b8e57d7c93499d50;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git diff --git a/lib/rbot/botuser.rb b/lib/rbot/botuser.rb index 5ae7fc2b..83fb2624 100644 --- a/lib/rbot/botuser.rb +++ b/lib/rbot/botuser.rb @@ -8,26 +8,47 @@ # License:: GPLv2 require 'singleton' +require 'set' +# 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 +63,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 +111,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 +126,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 @@ -177,8 +200,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 @@ -186,27 +236,84 @@ module Irc attr_reader :password attr_reader :netmasks attr_reader :perm + # Please remember to #set_changed() the Auth.manager + # when modifying data + attr_reader :data attr_writer :login_by_mask attr_writer :autologin + attr_writer :transient + + # Checks if the BotUser is transient + def transient? + @transient + end + + # Checks if the BotUser is permanent (not transient) + def permanent? + !@permanent + end + + # Sets if the BotUser is permanent or not + def permanent=(bool) + @transient=!bool + 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 + + # @data = AuthNotifyingHash.new + @data = {} end # Inspection def inspect - str = "<#{self.class}:#{'0x%08x' % self.object_id}:" + str = "<#{self.class}:#{'0x%08x' % self.object_id}" + str << " (transient)" if @transient + str << ":" str << " @username=#{@username.inspect}" str << " @netmasks=#{@netmasks.inspect}" str << " @perm=#{@perm.inspect}" str << " @login_by_mask=#{@login_by_mask}" str << " @autologin=#{@autologin}" + if @data.empty? + str << " no data" + else + str << " data for #{@data.keys.join(', ')}" + end str << ">" end @@ -223,7 +330,8 @@ module Irc :netmasks => @netmasks, :perm => @perm, :login_by_mask => @login_by_mask, - :autologin => @autologin + :autologin => @autologin, + :data => @data } end @@ -236,13 +344,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? @@ -259,6 +367,7 @@ module Irc @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) + @data.replace(h[:data]) if h.has_key?(:data) end # This method sets the password if the proposed new password @@ -352,7 +461,7 @@ module Irc # 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 +487,6 @@ module Irc end - # This is the default BotUser: it's used for all users which haven't # identified with the bot # @@ -493,10 +601,10 @@ module Irc end - # This is the AuthManagerClass singleton, used to manage User/BotUser connections and - # everything + # This is the ManagerClass singleton, used to manage + # Irc::User/Irc::Bot::Auth::BotUser connections and everything # - class AuthManagerClass + class ManagerClass include Singleton @@ -545,11 +653,12 @@ module Irc [everyone, botowner].each { |x| @allbotusers[x.username.to_sym] = x } + @transients = Set.new end def load_array(ary, forced) unless ary - warn "Tried to load an empty array" + warning "Tried to load an empty array" return end raise "Won't load with unsaved changes" if @has_changes and not forced @@ -561,14 +670,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 @@ -628,15 +738,43 @@ module Irc # def autologin(user) ircuser = user.to_irc_user - debug "Trying to autlogin #{ircuser}" + 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) } + # Check with transient users + @transients.each { |bu| + return bu if bu.login(ircuser) + } + # Finally, create a transient if we're set to allow it + if @bot.config['auth.autouser'] + bu = create_transient_botuser(ircuser) + 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) + @transients << bu + rescue + warning "failed to create transient for #{user}" + error $! + end + return bu + end + # Checks if User _user_ can do _cmd_ on _chan_. # # Permission are checked in this order, until a true or false @@ -696,12 +834,61 @@ module Irc end - # Returns the only instance of AuthManagerClass + # Returns the only instance of ManagerClass + # + 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 + + # Bot-specific data can be stored with Irc::Users. This is + # internally obtained by storing data to the associated BotUser, + # but this is a detail plugin writers shouldn't care about. + # bot_data(:key) can be used to retrieve a particular data set. + # This method is intended for data retrieval, and if the retrieved + # data is modified directly there is no guarantee the changes will + # be saved back. Use #set_bot_data() for that. # - def Auth.authmanager - return AuthManagerClass.instance + def bot_data(key=nil) + return self.botuser.data if key.nil? + return self.botuser.data[key] end + # This method is used to store bot-specific data for the receiver. + # If no block is passed, _value_ is stored for the key _key_; + # if a block is passed, it will be called with the previous + # _key_ value as parameter, and its return value will be stored + # as the new value. If _value_ is present in the block form, it + # will be used to initialize _key_ if it's missing + # + def set_bot_data(key,value=nil,&block) + if not block_given? + self.botuser.data[key]=value + Irc::Bot::Auth.manager.set_changed + return value + end + if value and not bot_data.has_key?(key) + set_bot_data(key, value) + end + r = value + begin + r = yield bot_data(key) + ensure + Irc::Bot::Auth.manager.set_changed + end + return r + end end end