]> git.netwichtig.de Git - user/henk/code/ruby/rbot.git/blob - lib/rbot/botuser.rb
New Irc Framework: netmask generalization now takes into consideration AzzurraNet...
[user/henk/code/ruby/rbot.git] / lib / rbot / botuser.rb
1 #-- vim:sw=2:et\r
2 #++\r
3 # :title: User management\r
4 #\r
5 # rbot user management\r
6 # Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)\r
7 # Copyright:: Copyright (c) 2006 Giuseppe Bilotta\r
8 # License:: GPLv2\r
9 \r
10 require 'singleton'\r
11 require 'set'\r
12 require 'rbot/maskdb'\r
13 \r
14 # This would be a good idea if it was failproof, but the truth\r
15 # is that other methods can indirectly modify the hash. *sigh*\r
16 #\r
17 # class AuthNotifyingHash < Hash\r
18 #   %w(clear default= delete delete_if replace invert\r
19 #      merge! update rehash reject! replace shift []= store).each { |m|\r
20 #     class_eval {\r
21 #       define_method(m) { |*a|\r
22 #         r = super(*a)\r
23 #         Irc::Bot::Auth.manager.set_changed\r
24 #         r\r
25 #       }\r
26 #     }\r
27 #   }\r
28 # end\r
29\r
30 \r
31 module Irc\r
32 class Bot\r
33 \r
34 \r
35   # This module contains the actual Authentication stuff\r
36   #\r
37   module Auth\r
38 \r
39     Config.register Config::StringValue.new( 'auth.password',\r
40       :default => 'rbotauth', :wizard => true,\r
41       :on_change => Proc.new {|bot, v| bot.auth.botowner.password = v},\r
42       :desc => _('Password for the bot owner'))\r
43     Config.register Config::BooleanValue.new( 'auth.login_by_mask',\r
44       :default => 'true',\r
45       :desc => _('Set false to prevent new botusers from logging in without a password when the user netmask is known'))\r
46     Config.register Config::BooleanValue.new( 'auth.autologin',\r
47       :default => 'true',\r
48       :desc => _('Set false to prevent new botusers from recognizing IRC users without a need to manually login'))\r
49     Config.register Config::BooleanValue.new( 'auth.autouser',\r
50       :default => 'false',\r
51       :desc => _('Set true to allow new botusers to be created automatically'))\r
52     # Config.register Config::IntegerValue.new( 'auth.default_level',\r
53     #   :default => 10, :wizard => true,\r
54     #   :desc => 'The default level for new/unknown users' )\r
55 \r
56     # Generate a random password of length _l_\r
57     #\r
58     def Auth.random_password(l=8)\r
59       pwd = ""\r
60       l.times do\r
61         pwd << (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr\r
62       end\r
63       return pwd\r
64     end\r
65 \r
66 \r
67     # An Irc::Bot::Auth::Command defines a command by its "path":\r
68     #\r
69     #   base::command::subcommand::subsubcommand::subsubsubcommand\r
70     #\r
71     class Command\r
72 \r
73       attr_reader :command, :path\r
74 \r
75       # A method that checks if a given _cmd_ is in a form that can be\r
76       # reduced into a canonical command path, and if so, returns it\r
77       #\r
78       def sanitize_command_path(cmd)\r
79         pre = cmd.to_s.downcase.gsub(/^\*?(?:::)?/,"").gsub(/::$/,"")\r
80         return pre if pre.empty?\r
81         return pre if pre =~ /^\S+(::\S+)*$/\r
82         raise TypeError, "#{cmd.inspect} is not a valid command"\r
83       end\r
84 \r
85       # Creates a new Command from a given string; you can then access\r
86       # the command as a symbol with the :command method and the whole\r
87       # path as :path\r
88       #\r
89       #   Command.new("core::auth::save").path => [:"*", :"core", :"core::auth", :"core::auth::save"]\r
90       #\r
91       #   Command.new("core::auth::save").command => :"core::auth::save"\r
92       #\r
93       def initialize(cmd)\r
94         cmdpath = sanitize_command_path(cmd).split('::')\r
95         seq = cmdpath.inject(["*"]) { |list, cmd|\r
96           list << (list.length > 1 ? list.last + "::" : "") + cmd\r
97         }\r
98         @path = seq.map { |k|\r
99           k.to_sym\r
100         }\r
101         @command = path.last\r
102         debug "Created command #{@command.inspect} with path #{@path.pretty_inspect}"\r
103       end\r
104 \r
105       # Returs self\r
106       def to_irc_auth_command\r
107         self\r
108       end\r
109 \r
110     end\r
111 \r
112   end\r
113 \r
114 end\r
115 end\r
116 \r
117 \r
118 class String\r
119 \r
120   # Returns an Irc::Bot::Auth::Comand from the receiver\r
121   def to_irc_auth_command\r
122     Irc::Bot::Auth::Command.new(self)\r
123   end\r
124 \r
125 end\r
126 \r
127 \r
128 class Symbol\r
129 \r
130   # Returns an Irc::Bot::Auth::Comand from the receiver\r
131   def to_irc_auth_command\r
132     Irc::Bot::Auth::Command.new(self)\r
133   end\r
134 \r
135 end\r
136 \r
137 \r
138 module Irc\r
139 class Bot\r
140 \r
141 \r
142   module Auth\r
143 \r
144 \r
145     # This class describes a permission set\r
146     class PermissionSet\r
147 \r
148       attr_reader :perm\r
149       # Create a new (empty) PermissionSet\r
150       #\r
151       def initialize\r
152         @perm = {}\r
153       end\r
154 \r
155       # Inspection simply inspects the internal hash\r
156       def inspect\r
157         @perm.inspect\r
158       end\r
159 \r
160       # Sets the permission for command _cmd_ to _val_,\r
161       #\r
162       def set_permission(str, val)\r
163         cmd = str.to_irc_auth_command\r
164         case val\r
165         when true, false\r
166           @perm[cmd.command] = val\r
167         when nil\r
168           @perm.delete(cmd.command)\r
169         else\r
170           raise TypeError, "#{val.inspect} must be true or false" unless [true,false].include?(val)\r
171         end\r
172       end\r
173 \r
174       # Resets the permission for command _cmd_\r
175       #\r
176       def reset_permission(cmd)\r
177         set_permission(cmd, nil)\r
178       end\r
179 \r
180       # Tells if command _cmd_ is permitted. We do this by returning\r
181       # the value of the deepest Command#path that matches.\r
182       #\r
183       def permit?(str)\r
184         cmd = str.to_irc_auth_command\r
185         # TODO user-configurable list of always-allowed commands,\r
186         # for admins that want to set permissions -* for everybody\r
187         return true if cmd.command == :login\r
188         allow = nil\r
189         cmd.path.reverse.each { |k|\r
190           if @perm.has_key?(k)\r
191             allow = @perm[k]\r
192             break\r
193           end\r
194         }\r
195         return allow\r
196       end\r
197 \r
198     end\r
199 \r
200 \r
201     # This is the error that gets raised when an invalid password is met\r
202     #\r
203     class InvalidPassword < RuntimeError\r
204     end\r
205 \r
206 \r
207     # This is the basic class for bot users: they have a username, a\r
208     # password, a list of netmasks to match against, and a list of\r
209     # permissions. A BotUser can be marked as 'transient', usually meaning\r
210     # it's not intended for permanent storage. Transient BotUsers have lower\r
211     # priority than nontransient ones for autologin purposes.\r
212     #\r
213     # To initialize a BotUser, you pass a _username_ and an optional\r
214     # hash of options. Currently, only two options are recognized:\r
215     #\r
216     # transient:: true or false, determines if the BotUser is transient or\r
217     #             permanent (default is false, permanent BotUser).\r
218     #\r
219     #             Transient BotUsers are initialized by prepending an\r
220     #             asterisk (*) to the username, and appending a sanitized\r
221     #             version of the object_id. The username can be empty.\r
222     #             A random password is generated.\r
223     #\r
224     #             Permanent Botusers need the username as is, and no\r
225     #             password is generated.\r
226     #\r
227     # masks::     an array of Netmasks to initialize the NetmaskList. This\r
228     #             list is used as-is for permanent BotUsers.\r
229     #\r
230     #             Transient BotUsers will alter the list elements which are\r
231     #             Irc::User by globbing the nick and any initial nonletter\r
232     #             part of the ident.\r
233     #\r
234     #             The masks option is optional for permanent BotUsers, but\r
235     #             obligatory (non-empty) for transients.\r
236     #\r
237     class BotUser\r
238 \r
239       attr_reader :username\r
240       attr_reader :password\r
241       attr_reader :netmasks\r
242       attr_reader :perm\r
243       attr_writer :login_by_mask\r
244       attr_writer :transient\r
245 \r
246       def autologin=(vnew)\r
247         vold = @autologin\r
248         @autologin = vnew\r
249         if vold && !vnew\r
250           @netmasks.each { |n| Auth.manager.maskdb.remove(self, n) }\r
251         elsif vnew && !vold\r
252           @netmasks.each { |n| Auth.manager.maskdb.add(self, n) }\r
253         end\r
254       end\r
255 \r
256       # Checks if the BotUser is transient\r
257       def transient?\r
258         @transient\r
259       end\r
260 \r
261       # Checks if the BotUser is permanent (not transient)\r
262       def permanent?\r
263         !@transient\r
264       end\r
265 \r
266       # Sets if the BotUser is permanent or not\r
267       def permanent=(bool)\r
268         @transient=!bool\r
269       end\r
270 \r
271       # Make the BotUser permanent\r
272       def make_permanent(name)\r
273         raise TypeError, "permanent already" if permanent?\r
274         @username = BotUser.sanitize_username(name)\r
275         @transient = false\r
276         reset_autologin\r
277         reset_password # or not?\r
278         @netmasks.dup.each do |m|\r
279           delete_netmask(m)\r
280           add_netmask(m.generalize)\r
281         end\r
282       end\r
283 \r
284       # Create a new BotUser with given username\r
285       def initialize(username, options={})\r
286         opts = {:transient => false}.merge(options)\r
287         @transient = opts[:transient]\r
288 \r
289         if @transient\r
290           @username = "*"\r
291           @username << BotUser.sanitize_username(username) if username and not username.to_s.empty?\r
292           @username << BotUser.sanitize_username(object_id)\r
293           reset_password\r
294           @login_by_mask=true\r
295           @autologin=true\r
296         else\r
297           @username = BotUser.sanitize_username(username)\r
298           @password = nil\r
299           reset_login_by_mask\r
300           reset_autologin\r
301         end\r
302 \r
303         @netmasks = NetmaskList.new\r
304         if opts.key?(:masks) and opts[:masks]\r
305           masks = opts[:masks]\r
306           masks = [masks] unless masks.respond_to?(:each)\r
307           masks.each { |m|\r
308             mask = m.to_irc_netmask\r
309             if @transient and User === m\r
310               mask.nick = "*"\r
311               mask.host = m.host.dup\r
312               mask.user = "*" + m.user.sub(/^\w?[^\w]+/,'')\r
313             end\r
314             add_netmask(mask) unless mask.to_s == "*"\r
315           }\r
316         end\r
317         raise "must provide a usable mask for transient BotUser #{@username}" if @transient and @netmasks.empty?\r
318 \r
319         @perm = {}\r
320       end\r
321 \r
322       # Inspection\r
323       def inspect\r
324         str = self.__to_s__[0..-2]\r
325         str << " (transient)" if @transient\r
326         str << ":"\r
327         str << " @username=#{@username.inspect}"\r
328         str << " @netmasks=#{@netmasks.inspect}"\r
329         str << " @perm=#{@perm.inspect}"\r
330         str << " @login_by_mask=#{@login_by_mask}"\r
331         str << " @autologin=#{@autologin}"\r
332         str << ">"\r
333       end\r
334 \r
335       # In strings\r
336       def to_s\r
337         @username\r
338       end\r
339 \r
340       # Convert into a hash\r
341       def to_hash\r
342         {\r
343           :username => @username,\r
344           :password => @password,\r
345           :netmasks => @netmasks,\r
346           :perm => @perm,\r
347           :login_by_mask => @login_by_mask,\r
348           :autologin => @autologin,\r
349         }\r
350       end\r
351 \r
352       # Do we allow logging in without providing the password?\r
353       #\r
354       def login_by_mask?\r
355         @login_by_mask\r
356       end\r
357 \r
358       # Reset the login-by-mask option\r
359       #\r
360       def reset_login_by_mask\r
361         @login_by_mask = Auth.manager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask)\r
362       end\r
363 \r
364       # Reset the autologin option\r
365       #\r
366       def reset_autologin\r
367         @autologin = Auth.manager.bot.config['auth.autologin'] unless defined?(@autologin)\r
368       end\r
369 \r
370       # Do we allow automatic logging in?\r
371       #\r
372       def autologin?\r
373         @autologin\r
374       end\r
375 \r
376       # Restore from hash\r
377       def from_hash(h)\r
378         @username = h[:username] if h.has_key?(:username)\r
379         @password = h[:password] if h.has_key?(:password)\r
380         @login_by_mask = h[:login_by_mask] if h.has_key?(:login_by_mask)\r
381         @autologin = h[:autologin] if h.has_key?(:autologin)\r
382         if h.has_key?(:netmasks)\r
383           @netmasks = h[:netmasks]\r
384           debug @netmasks\r
385           @netmasks.each { |n| Auth.manager.maskdb.add(self, n) } if @autologin\r
386           debug @netmasks\r
387         end\r
388         @perm = h[:perm] if h.has_key?(:perm)\r
389       end\r
390 \r
391       # This method sets the password if the proposed new password\r
392       # is valid\r
393       def password=(pwd=nil)\r
394         pass = pwd.to_s\r
395         if pass.empty?\r
396           reset_password\r
397         else\r
398           begin\r
399             raise InvalidPassword, "#{pass} contains invalid characters" if pass !~ /^[\x21-\x7e]+$/\r
400             raise InvalidPassword, "#{pass} too short" if pass.length < 4\r
401             @password = pass\r
402           rescue InvalidPassword => e\r
403             raise e\r
404           rescue => e\r
405             raise InvalidPassword, "Exception #{e.inspect} while checking #{pass.inspect} (#{pwd.inspect})"\r
406           end\r
407         end\r
408       end\r
409 \r
410       # Resets the password by creating a new onw\r
411       def reset_password\r
412         @password = Auth.random_password\r
413       end\r
414 \r
415       # Sets the permission for command _cmd_ to _val_ on channel _chan_\r
416       #\r
417       def set_permission(cmd, val, chan="*")\r
418         k = chan.to_s.to_sym\r
419         @perm[k] = PermissionSet.new unless @perm.has_key?(k)\r
420         @perm[k].set_permission(cmd, val)\r
421       end\r
422 \r
423       # Resets the permission for command _cmd_ on channel _chan_\r
424       #\r
425       def reset_permission(cmd, chan ="*")\r
426         set_permission(cmd, nil, chan)\r
427       end\r
428 \r
429       # Checks if BotUser is allowed to do something on channel _chan_,\r
430       # or on all channels if _chan_ is nil\r
431       #\r
432       def permit?(cmd, chan=nil)\r
433         if chan\r
434           k = chan.to_s.to_sym\r
435         else\r
436           k = :*\r
437         end\r
438         allow = nil\r
439         if @perm.has_key?(k)\r
440           allow = @perm[k].permit?(cmd)\r
441         end\r
442         return allow\r
443       end\r
444 \r
445       # Adds a Netmask\r
446       #\r
447       def add_netmask(mask)\r
448         m = mask.to_irc_netmask\r
449         @netmasks << m\r
450         if self.autologin?\r
451           Auth.manager.maskdb.add(self, m)\r
452           Auth.manager.logout_transients(m) if self.permanent?\r
453         end\r
454       end\r
455 \r
456       # Removes a Netmask\r
457       #\r
458       def delete_netmask(mask)\r
459         m = mask.to_irc_netmask\r
460         @netmasks.delete(m)\r
461         Auth.manager.maskdb.remove(self, m) if self.autologin?\r
462       end\r
463 \r
464       # This method checks if BotUser has a Netmask that matches _user_\r
465       #\r
466       def knows?(usr)\r
467         user = usr.to_irc_user\r
468         !!@netmasks.find { |n| user.matches? n }\r
469       end\r
470 \r
471       # This method gets called when User _user_ wants to log in.\r
472       # It returns true or false depending on whether the password\r
473       # is right. If it is, the Netmask of the user is added to the\r
474       # list of acceptable Netmask unless it's already matched.\r
475       def login(user, password=nil)\r
476         if password == @password or (password.nil? and (@login_by_mask || @autologin) and knows?(user))\r
477           add_netmask(user) unless knows?(user)\r
478           debug "#{user} logged in as #{self.inspect}"\r
479           return true\r
480         else\r
481           return false\r
482         end\r
483       end\r
484 \r
485       # # This method gets called when User _user_ has logged out as this BotUser\r
486       # def logout(user)\r
487       #   delete_netmask(user) if knows?(user)\r
488       # end\r
489 \r
490       # This method sanitizes a username by chomping, downcasing\r
491       # and replacing any nonalphanumeric character with _\r
492       #\r
493       def BotUser.sanitize_username(name)\r
494         candidate = name.to_s.chomp.downcase.gsub(/[^a-z0-9]/,"_")\r
495         raise "sanitized botusername #{candidate} too short" if candidate.length < 3\r
496         return candidate\r
497       end\r
498 \r
499     end\r
500 \r
501     # This is the default BotUser: it's used for all users which haven't\r
502     # identified with the bot\r
503     #\r
504     class DefaultBotUserClass < BotUser\r
505 \r
506       private :add_netmask, :delete_netmask\r
507 \r
508       include Singleton\r
509 \r
510       # The default BotUser is named 'everyone'\r
511       #\r
512       def initialize\r
513         reset_login_by_mask\r
514         reset_autologin\r
515         super("everyone")\r
516         @default_perm = PermissionSet.new\r
517       end\r
518 \r
519       # This method returns without changing anything\r
520       #\r
521       def login_by_mask=(val)\r
522         debug "Tried to change the login-by-mask for default bot user, ignoring"\r
523         return @login_by_mask\r
524       end\r
525 \r
526       # The default botuser allows logins by mask\r
527       #\r
528       def reset_login_by_mask\r
529         @login_by_mask = true\r
530       end\r
531 \r
532       # This method returns without changing anything\r
533       #\r
534       def autologin=(val)\r
535         debug "Tried to change the autologin for default bot user, ignoring"\r
536         return\r
537       end\r
538 \r
539       # The default botuser doesn't allow autologin (meaningless)\r
540       #\r
541       def reset_autologin\r
542         @autologin = false\r
543       end\r
544 \r
545       # Sets the default permission for the default user (i.e. the ones\r
546       # set by the BotModule writers) on all channels\r
547       #\r
548       def set_default_permission(cmd, val)\r
549         @default_perm.set_permission(Command.new(cmd), val)\r
550         debug "Default permissions now: #{@default_perm.pretty_inspect}"\r
551       end\r
552 \r
553       # default knows everybody\r
554       #\r
555       def knows?(user)\r
556         return true if user.to_irc_user\r
557       end\r
558 \r
559       # We always allow logging in as the default user\r
560       def login(user, password)\r
561         return true\r
562       end\r
563 \r
564       # DefaultBotUser will check the default_perm after checking\r
565       # the global ones\r
566       # or on all channels if _chan_ is nil\r
567       #\r
568       def permit?(cmd, chan=nil)\r
569         allow = super(cmd, chan)\r
570         if allow.nil? && chan.nil?\r
571           allow = @default_perm.permit?(cmd)\r
572         end\r
573         return allow\r
574       end\r
575 \r
576     end\r
577 \r
578     # Returns the only instance of DefaultBotUserClass\r
579     #\r
580     def Auth.defaultbotuser\r
581       return DefaultBotUserClass.instance\r
582     end\r
583 \r
584     # This is the BotOwner: he can do everything\r
585     #\r
586     class BotOwnerClass < BotUser\r
587 \r
588       include Singleton\r
589 \r
590       def initialize\r
591         @login_by_mask = false\r
592         @autologin = true\r
593         super("owner")\r
594       end\r
595 \r
596       def permit?(cmd, chan=nil)\r
597         return true\r
598       end\r
599 \r
600     end\r
601 \r
602     # Returns the only instance of BotOwnerClass\r
603     #\r
604     def Auth.botowner\r
605       return BotOwnerClass.instance\r
606     end\r
607 \r
608 \r
609     class BotUser\r
610       # Check if the current BotUser is the default one\r
611       def default?\r
612         return DefaultBotUserClass === self\r
613       end\r
614 \r
615       # Check if the current BotUser is the owner\r
616       def owner?\r
617         return BotOwnerClass === self\r
618       end\r
619     end\r
620 \r
621 \r
622     # This is the ManagerClass singleton, used to manage\r
623     # Irc::User/Irc::Bot::Auth::BotUser connections and everything\r
624     #\r
625     class ManagerClass\r
626 \r
627       include Singleton\r
628 \r
629       attr_reader :maskdb\r
630       attr_reader :everyone\r
631       attr_reader :botowner\r
632       attr_reader :bot\r
633 \r
634       # The instance manages two <code>Hash</code>es: one that maps\r
635       # <code>Irc::User</code>s onto <code>BotUser</code>s, and the other that maps\r
636       # usernames onto <code>BotUser</code>\r
637       def initialize\r
638         @everyone = Auth::defaultbotuser\r
639         @botowner = Auth::botowner\r
640         bot_associate(nil)\r
641       end\r
642 \r
643       def bot_associate(bot)\r
644         raise "Cannot associate with a new bot! Save first" if defined?(@has_changes) && @has_changes\r
645 \r
646         reset_hashes\r
647 \r
648         # Associated bot\r
649         @bot = bot\r
650 \r
651         # This variable is set to true when there have been changes\r
652         # to the botusers list, so that we know when to save\r
653         @has_changes = false\r
654       end\r
655 \r
656       def set_changed\r
657         @has_changes = true\r
658       end\r
659 \r
660       def reset_changed\r
661         @has_changes = false\r
662       end\r
663 \r
664       def changed?\r
665         @has_changes\r
666       end\r
667 \r
668       # resets the hashes\r
669       def reset_hashes\r
670         @botusers = Hash.new\r
671         @maskdb = NetmaskDb.new\r
672         @allbotusers = Hash.new\r
673         [everyone, botowner].each do |x|\r
674           @allbotusers[x.username.to_sym] = x\r
675         end\r
676       end\r
677 \r
678       def load_array(ary, forced)\r
679         unless ary\r
680           warning "Tried to load an empty array"\r
681           return\r
682         end\r
683         raise "Won't load with unsaved changes" if @has_changes and not forced\r
684         reset_hashes\r
685         ary.each { |x|\r
686           raise TypeError, "#{x} should be a Hash" unless x.kind_of?(Hash)\r
687           u = x[:username]\r
688           unless include?(u)\r
689             create_botuser(u)\r
690           end\r
691           get_botuser(u).from_hash(x)\r
692           get_botuser(u).transient = false\r
693         }\r
694         @has_changes=false\r
695       end\r
696 \r
697       def save_array\r
698         @allbotusers.values.map { |x|\r
699           x.transient? ? nil : x.to_hash\r
700         }.compact\r
701       end\r
702 \r
703       # checks if we know about a certain BotUser username\r
704       def include?(botusername)\r
705         @allbotusers.has_key?(botusername.to_sym)\r
706       end\r
707 \r
708       # Maps <code>Irc::User</code> to BotUser\r
709       def irc_to_botuser(ircuser)\r
710         logged = @botusers[ircuser.to_irc_user]\r
711         return logged if logged\r
712         return autologin(ircuser)\r
713       end\r
714 \r
715       # creates a new BotUser\r
716       def create_botuser(name, password=nil)\r
717         n = BotUser.sanitize_username(name)\r
718         k = n.to_sym\r
719         raise "botuser #{n} exists" if include?(k)\r
720         bu = BotUser.new(n)\r
721         bu.password = password\r
722         @allbotusers[k] = bu\r
723         return bu\r
724       end\r
725 \r
726       # returns the botuser with name _name_\r
727       def get_botuser(name)\r
728         @allbotusers.fetch(BotUser.sanitize_username(name).to_sym)\r
729       end\r
730 \r
731       # Logs Irc::User _user_ in to BotUser _botusername_ with password _pwd_\r
732       #\r
733       # raises an error if _botusername_ is not a known BotUser username\r
734       #\r
735       # It is possible to autologin by Netmask, on request\r
736       #\r
737       def login(user, botusername, pwd=nil)\r
738         ircuser = user.to_irc_user\r
739         n = BotUser.sanitize_username(botusername)\r
740         k = n.to_sym\r
741         raise "No such BotUser #{n}" unless include?(k)\r
742         if @botusers.has_key?(ircuser)\r
743           return true if @botusers[ircuser].username == n\r
744           # TODO\r
745           # @botusers[ircuser].logout(ircuser)\r
746         end\r
747         bu = @allbotusers[k]\r
748         if bu.login(ircuser, pwd)\r
749           @botusers[ircuser] = bu\r
750           return true\r
751         end\r
752         return false\r
753       end\r
754 \r
755       # Tries to auto-login Irc::User _user_ by looking at the known botusers that allow autologin\r
756       # and trying to login without a password\r
757       #\r
758       def autologin(user)\r
759         ircuser = user.to_irc_user\r
760         debug "Trying to autologin #{ircuser}"\r
761         return @botusers[ircuser] if @botusers.has_key?(ircuser)\r
762         bu = maskdb.find(ircuser)\r
763         if bu\r
764           debug "trying #{bu}"\r
765           bu.login(ircuser) or raise '...what?!'\r
766           @botusers[ircuser] = bu\r
767           return bu\r
768         end\r
769         # Finally, create a transient if we're set to allow it\r
770         if @bot.config['auth.autouser']\r
771           bu = create_transient_botuser(ircuser)\r
772           @botusers[ircuser] = bu\r
773           return bu\r
774         end\r
775         return everyone\r
776       end\r
777 \r
778       # Creates a new transient BotUser associated with Irc::User _user_,\r
779       # automatically logging him in. Note that transient botuser creation can\r
780       # fail, typically if we don't have the complete user netmask (e.g. for\r
781       # messages coming in from a linkbot)\r
782       #\r
783       def create_transient_botuser(user)\r
784         ircuser = user.to_irc_user\r
785         bu = everyone\r
786         begin\r
787           bu = BotUser.new(ircuser, :transient => true, :masks => ircuser)\r
788           bu.login(ircuser)\r
789         rescue\r
790           warning "failed to create transient for #{user}"\r
791           error $!\r
792         end\r
793         return bu\r
794       end\r
795 \r
796       # Logs out any Irc::User matching Irc::Netmask _m_ and logged in\r
797       # to a transient BotUser\r
798       #\r
799       def logout_transients(m)\r
800         debug "to check: #{@botusers.keys.join ' '}"\r
801         @botusers.keys.each do |iu|\r
802           debug "checking #{iu.fullform} against #{m.fullform}"\r
803           bu = @botusers[iu]\r
804           bu.transient? or next\r
805           iu.matches?(m) or next\r
806           @botusers.delete(iu).autologin = false\r
807         end\r
808       end\r
809 \r
810       # Makes transient BotUser _user_ into a permanent BotUser\r
811       # named _name_; if _user_ is an Irc::User, act on the transient\r
812       # BotUser (if any) it's logged in as\r
813       #\r
814       def make_permanent(user, name)\r
815         buname = BotUser.sanitize_username(name)\r
816         # TODO merge BotUser instead?\r
817         raise "there's already a BotUser called #{name}" if include?(buname)\r
818 \r
819         tuser = nil\r
820         case user\r
821         when String, Irc::User\r
822           tuser = irc_to_botuser(user)\r
823         when BotUser\r
824           tuser = user\r
825         else\r
826           raise TypeError, "sorry, don't know how to make #{user.class} into a permanent BotUser"\r
827         end\r
828         return nil unless tuser\r
829         raise TypeError, "#{tuser} is not transient" unless tuser.transient?\r
830 \r
831         tuser.make_permanent(buname)\r
832         @allbotusers[tuser.username.to_sym] = tuser\r
833 \r
834         return tuser\r
835       end\r
836 \r
837       # Checks if User _user_ can do _cmd_ on _chan_.\r
838       #\r
839       # Permission are checked in this order, until a true or false\r
840       # is returned:\r
841       # * associated BotUser on _chan_\r
842       # * associated BotUser on all channels\r
843       # * everyone on _chan_\r
844       # * everyone on all channels\r
845       #\r
846       def permit?(user, cmdtxt, channel=nil)\r
847         if user.class <= BotUser\r
848           botuser = user\r
849         else\r
850           botuser = irc_to_botuser(user)\r
851         end\r
852         cmd = cmdtxt.to_irc_auth_command\r
853 \r
854         chan = channel\r
855         case chan\r
856         when User\r
857           chan = "?"\r
858         when Channel\r
859           chan = chan.name\r
860         end\r
861 \r
862         allow = nil\r
863 \r
864         allow = botuser.permit?(cmd, chan) if chan\r
865         return allow unless allow.nil?\r
866         allow = botuser.permit?(cmd)\r
867         return allow unless allow.nil?\r
868 \r
869         unless botuser == everyone\r
870           allow = everyone.permit?(cmd, chan) if chan\r
871           return allow unless allow.nil?\r
872           allow = everyone.permit?(cmd)\r
873           return allow unless allow.nil?\r
874         end\r
875 \r
876         raise "Could not check permission for user #{user.inspect} to run #{cmdtxt.inspect} on #{chan.inspect}"\r
877       end\r
878 \r
879       # Checks if command _cmd_ is allowed to User _user_ on _chan_, optionally\r
880       # telling if the user is authorized\r
881       #\r
882       def allow?(cmdtxt, user, chan=nil)\r
883         if permit?(user, cmdtxt, chan)\r
884           return true\r
885         else\r
886           # cmds = cmdtxt.split('::')\r
887           # @bot.say chan, "you don't have #{cmds.last} (#{cmds.first}) permissions here" if chan\r
888           @bot.say chan, _("%{user}, you don't have '%{command}' permissions here") %\r
889                         {:user=>user, :command=>cmdtxt} if chan\r
890           return false\r
891         end\r
892       end\r
893 \r
894     end\r
895 \r
896     # Returns the only instance of ManagerClass\r
897     #\r
898     def Auth.manager\r
899       return ManagerClass.instance\r
900     end\r
901 \r
902   end\r
903 end\r
904 \r
905   class User\r
906 \r
907     # A convenience method to automatically found the botuser\r
908     # associated with the receiver\r
909     #\r
910     def botuser\r
911       Irc::Bot::Auth.manager.irc_to_botuser(self)\r
912     end\r
913   end\r
914 \r
915 end\r