rbot 0.9.10 → 0.9.12

data/data/rbot/plugins/nickrecover.rb

@@ -0,0 +1,97 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Nick recovery
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# Copyright:: (C) 2008 Giuseppe Bilotta
+#
+# This plugin tries to automatically recover the bot's wanted nick
+# in case it couldn't be achieved.
+
+class NickRecoverPlugin < Plugin
+  
+  Config.register Config::IntegerValue.new('irc.nick_retry',
+    :default => 60, :valiedate => Proc.new { |v| v >= 0 },
+    :on_change => Proc.new do |bot, v|
+      if v > 0
+        bot.plugin['nickrecover'].start_recovery(v)
+      else
+        bot.plugin['nickrecover'].stop_recovery
+      end
+    end, :requires_restart => false,
+    :desc => _("Time in seconds to wait between attempts to recover the nick. set to 0 to disable nick recovery."))
+
+  def help(plugin,topic="")
+    [
+      _("the nickrecover plugin takes care of recovering the bot nick by trying to change nick until it succeeds."),
+      _("the plugin waits irc.nick_retry seconds between attempts."),
+      _("set irc.nick_retry to 0 to disable it.")
+    ].join(' ')
+  end
+
+  def enabled?
+    @bot.config['irc.nick_retry'] > 0
+  end
+
+  def poll_time
+    @bot.config['irc.nick_retry']
+  end
+
+  def wanted_nick
+    @bot.wanted_nick
+  end
+
+  def has_nick?
+    @bot.nick.downcase == wanted_nick.downcase
+  end
+
+  def recover
+    @bot.nickchg wanted_nick
+  end
+
+  def stop_recovery
+    @bot.timer.remove(@recovery) if @recovery
+  end
+
+  def start_recovery(time=self.poll_time)
+    if @recovery
+      @bot.timer.reschedule(@recovery, poll_time)
+    else
+      @recovery = @bot.timer.add(time) do
+        has_nick? ? stop_recovery : recover
+      end
+    end
+  end
+
+  def initialize
+    super
+    @recovery = nil
+  end
+
+  def connect
+    if enabled?
+      start_recovery unless has_nick?
+    end
+  end
+
+  def nick(m)
+    return unless m.address?
+    # if recovery is enabled and the nick is not the wanted nick,
+    # launch the recovery process. Stop it otherwise
+    if enabled? and m.newnick.downcase != wanted_nick.downcase
+      start_recovery
+    else
+      stop_recovery
+    end
+  end
+
+  def cleanup
+    stop_recovery
+  end
+
+end
+
+plugin = NickRecoverPlugin.new
+

data/data/rbot/plugins/nickserv.rb

@@ -1,51 +1,82 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Nickserv management plugin for rbot
+#
+# Author:: Tom Gilbert (giblet) <tom@linuxbrit.co.uk>
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+#
+# Copyright:: (C) 2002-2005 Tom Gilbert
+# Copyright:: (C) 2006 Tom Gilbert, Giuseppe Bilotta
+# Copyright:: (C) 2006-2007 Giuseppe Bilotta
+#
 # Automatically lookup nicks in @registry and identify when asked
+#
 # Takes over proper nick if required and nick is registered
-# TODO allow custom IDENTIFY and GHOST names
-# TODO instead of nickserv.wait it would be ideal if we could just
-# set up "don't send further commands until you receive this particular message"
+
+# TODO:: allow custom IDENTIFY and GHOST names
+#
+# FIXME:: identified? status returns false after a rescan, even if the bot
+#         previously identified successfully
 
 class NickServPlugin < Plugin
   
-  BotConfig.register BotConfigStringValue.new('nickserv.name',
-    :default => "NickServ", :requires_restart => false,
-    :desc => "Name of the nick server")
-  BotConfig.register BotConfigStringValue.new('nickserv.ident_request',
+  Config.register Config::StringValue.new('nickserv.name',
+    :default => "nickserv", :requires_restart => false,
+    :desc => _("Name of the nick server (all lowercase)"))
+
+  Config.register Config::StringValue.new('nickserv.ident_request',
     :default => "IDENTIFY", :requires_restart => false,
     :on_change => Proc.new { |bot, v| bot.plugins.delegate "set_ident_request", v },
-    :desc => "String to look for to see if the nick server is asking us to identify")
-  BotConfig.register BotConfigBooleanValue.new('nickserv.wants_nick',
-    :default => true, :requires_restart => false,
-    :desc => "Set to false if the nick server doesn't expect the nick as a parameter in the identify command")
-  BotConfig.register BotConfigIntegerValue.new('nickserv.wait',
+    :desc => _("String to look for to see if the nick server is asking us to identify"))
+  Config.register Config::StringValue.new('nickserv.nick_avail',
+    :default => "not (currently )?online|killed|recovered|disconnesso|libero",
+    :requires_restart => false,
+    :on_change => Proc.new { |bot, v| bot.plugins.delegate "set_nick_avail", v },
+    :desc => _("String to look for to see if the nick server is informing us that our nick is now available"))
+  Config.register Config::StringValue.new('nickserv.identified_string',
+    :default => "((Password|Contrase|Mot de passe).+(acce[pt]t|r[ie]cog?n).+)?(you|tu|vous).+(identif|r[ie]cog?n)",
+    :requires_restart => false,
+    :on_change => Proc.new { |bot, v| bot.plugins.delegate "set_identified_string", v },
+    :desc => _("String to look for to see if the nick server is informing us that we have identified successfully"))
+
+  Config.register Config::BooleanValue.new('nickserv.wants_nick',
+    :default => false, :requires_restart => false,
+    :desc => _("Set to false if the nick server doesn't expect the nick as a parameter in the identify command"))
+
+  Config.register Config::IntegerValue.new('nickserv.wait',
     :default => 30, :validate => Proc.new { |v| v > 0 }, :requires_restart => false,
-    :desc => "Seconds to wait after sending a message to nickserv, e.g. after ghosting")
+    :desc => _("Seconds to wait after sending a message to nickserv, e.g. after ghosting"))
 
   def help(plugin, topic="")
     case topic
     when ""
-      return "nickserv plugin: handles nickserv protected IRC nicks. topics password, register, identify, listnicks"
+      return _("nickserv plugin: handles nickserv protected IRC nicks. topics password, register, identify, listnicks")
     when "password"
-      return "nickserv password <nick> <passwd>: remember the password for nick <nick> and use it to identify in future"
+      return _("nickserv password [<nick>] <passwd>: remember the password for nick <nick> and use it to identify in future")
     when "register"
-      return "nickserv register [<password> [<email>]]: register the current nick, choosing a random password unless <password> is supplied - current nick must not already be registered for this to work. Also specify email if required by your services"
+      return _("nickserv register [<password> [<email>]]: register the current nick, choosing a random password unless <password> is supplied - current nick must not already be registered for this to work. Also specify email if required by your services")
     when "identify"
-      return "nickserv identify: identify with nickserv - shouldn't be needed - bot should identify with nickserv immediately on request - however this could be useful after splits or service disruptions, or when you just set the password for the current nick"
+      return _("nickserv identify: identify with nickserv - shouldn't be needed - bot should identify with nickserv immediately on request - however this could be useful after splits or service disruptions, or when you just set the password for the current nick")
     when "listnicks"
-      return "nickserv listnicks: lists nicknames and associated password the bot knows about - you will need config level auth access to do this one and it will reply by privmsg only"
+      return _("nickserv listnicks: lists nicknames and associated password the bot knows about - you will need config level auth access to do this one and it will reply by privmsg only")
     end
   end
   
   def genpasswd
-    # generate a random password
-    passwd = ""
-    8.times do
-      passwd += (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
-    end
-    return passwd
+    return Irc::Bot::Auth.random_password
   end
 
   def set_ident_request(val)
-    @ident_request = Regexp.new(val)
+    @ident_request = Regexp.new(val, true)
+  end
+
+  def set_nick_avail(val)
+    @nick_avail = Regexp.new(val, true)
+  end
+
+  def set_identified_string(val)
+    @identified_string = Regexp.new(val, true)
   end
 
   def initialize
@@ -60,10 +91,30 @@ class NickServPlugin < Plugin
       end
     end
     set_ident_request(@bot.config['nickserv.ident_request'])
+    set_nick_avail(@bot.config['nickserv.nick_avail'])
+    set_identified_string(@bot.config['nickserv.identified_string'])
+    @identified = false
+  end
+
+  # Returns the nickserv name
+  def ns_nick
+    @bot.config['nickserv.name']
+  end
+
+  # say something to nickserv
+  def ns_say(msg)
+    @bot.say ns_nick, msg
   end
 
   def password(m, params)
-    @registry[params[:nick]] = params[:passwd]
+    nick = params[:nick] || @bot.nick
+    passwd = params[:passwd]
+    if nick == @bot.nick
+      ns_say "SET PASSWORD #{passwd}"
+    else
+      m.reply(_("I'm only changing this in my database, I won't inform %{ns_nick} of the change") % {:ns_nick => ns_nick})
+    end
+    @registry[nick] = passwd
     m.okay
   end
 
@@ -71,7 +122,7 @@ class NickServPlugin < Plugin
     passwd = params[:passwd] ? params[:passwd] : genpasswd
     message = "REGISTER #{passwd}"
     message += " #{params[:email]}" if params[:email]
-    @bot.sendmsg "PRIVMSG", @bot.config['nickserv.name'], message
+    ns_say message
     @registry[@bot.nick] = passwd
     m.okay
   end
@@ -82,17 +133,17 @@ class NickServPlugin < Plugin
         @bot.say m.sourcenick, "#{k} => #{v}"
       }
     else
-      m.reply "none known"
+      m.reply _("none known")
     end
   end
 
   def do_identify(nick=@bot.nick)
     if @registry.has_key?(nick)
       if @bot.config['nickserv.wants_nick']
-        @bot.sendmsg "PRIVMSG", @bot.config['nickserv.name'], "IDENTIFY #{nick} #{@registry[nick]}"
+        ns_say "IDENTIFY #{nick} #{@registry[nick]}"
       else
         if nick == @bot.nick
-          @bot.sendmsg "PRIVMSG", @bot.config['nickserv.name'], "IDENTIFY #{@registry[nick]}"
+          ns_say "IDENTIFY #{@registry[nick]}"
         else
           # We cannot identify for different nicks if we can't use the nickname ...
           return false
@@ -100,50 +151,62 @@ class NickServPlugin < Plugin
       end
       return true
     end
-    return false
+    return nil
   end
 
   def identify(m, params)
-    if do_identify
+    ided = do_identify
+    case ided
+    when true
       m.okay
+    when false
+      m.reply _("I cannot identify for a this nick")
+    when nil
+      m.reply(_("I dunno the nickserv password for the nickname %{botnick} :(") % {:botnick => @bot.nick})
     else
-      m.reply "I dunno the nickserv password for the nickname #{@bot.nick} :("
+      m.reply _("uh ... something went wrong ...")
     end
   end
   
   def connect
+    @identified = false
     do_identify
   end
   
   def nicktaken(nick)
     if @registry.has_key?(nick)
-      @bot.sendmsg "PRIVMSG", @bot.config['nickserv.name'], "GHOST #{nick} #{@registry[nick]}"
-      if do_identify nick
-        sleep @bot.config['nickserv.wait']
-        @bot.nickchg nick
-        # We need to wait after changing nick, otherwise the server
-        # might refuse to execute further commangs, e.g. subsequent JOIN
-        # commands until the nick has changed.
-        sleep @bot.config['nickserv.wait']
-      else
-        debug "Failed to identify for nick #{nick}, cannot take over"
-      end
+      ns_say "GHOST #{nick} #{@registry[nick]}"
     end
   end
 
-  def listen(m)
-    return unless(m.kind_of? NoticeMessage)
+  def notice(m)
+    return unless m.source.downcase == ns_nick.downcase
 
-    if (m.sourcenick == @bot.config['nickserv.name'] && m.message =~ @ident_request)
+    case m.message
+    when @ident_request
       debug "nickserv asked us to identify for nick #{@bot.nick}"
       do_identify
+    when @nick_avail
+      debug "our nick seems to be free now"
+      @bot.nickchg @bot.config['irc.nick']
+    when @identified_string
+      debug "we identified successfully to nickserv"
+      @identified = true
+      @bot.plugins.delegate('identified')
     end
   end
 
+  def identified?
+    return @identified
+  end
+
 end
 plugin = NickServPlugin.new
-plugin.map 'nickserv password :nick :passwd', :action => "password"
+plugin.map 'nickserv password [:nick] :passwd', :action => "password"
 plugin.map 'nickserv register :passwd :email', :action => 'nick_register',
            :defaults => {:passwd => false, :email => false}
 plugin.map 'nickserv listnicks', :action => "listnicks"
 plugin.map 'nickserv identify', :action => "identify"
+
+plugin.default_auth('*', false)
+

data/data/rbot/plugins/nslookup.rb

@@ -12,32 +12,28 @@ class DnsPlugin < Plugin
   end
   
   def name_to_ip(m, params)
-    Thread.new do
-      begin
-        a = getaddresses(params[:host])
-        if a.length > 0
-          m.reply m.params + ": " + a.join(", ")
-        else
-          m.reply "#{params[:host]}: not found"
-        end
-      rescue StandardError => err
+    begin
+      a = getaddresses(params[:host])
+      if a.length > 0
+        m.reply m.params + ": " + a.join(", ")
+      else
         m.reply "#{params[:host]}: not found"
       end
+    rescue StandardError => err
+      m.reply "#{params[:host]}: not found"
     end
   end
   
   def ip_to_name(m, params)
-    Thread.new do
-       begin
-         a = gethostname(params[:ip])
-         m.reply m.params + ": " + a if a
-       rescue StandardError => err
-         m.reply "#{params[:ip]}: not found (does not reverse resolve)"
-       end
-     end
+    begin
+      a = gethostname(params[:ip])
+      m.reply m.params + ": " + a if a
+    rescue StandardError => err
+      m.reply "#{params[:ip]}: not found (does not reverse resolve)"
+    end
   end
 end
 plugin = DnsPlugin.new
-plugin.map 'dns :ip', :action => 'ip_to_name', 
+plugin.map 'dns :ip', :action => 'ip_to_name', :thread => true,
                       :requirements => {:ip => /^\d+\.\d+\.\d+\.\d+$/}
-plugin.map 'dns :host', :action => 'name_to_ip'
+plugin.map 'dns :host', :action => 'name_to_ip', :thread => true

data/data/rbot/plugins/plugin.header

@@ -0,0 +1,11 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Plugin title
+#
+# Author:: Your Name Goes Here <and.your@email>
+# Copyright:: (C) YYYY Your Name
+# License:: plugin licence
+#
+# More documentation, if needed/wanted
+

data/data/rbot/plugins/quakeauth.rb

@@ -1,15 +1,26 @@
-# automatically auths with Q on quakenet servers
+#-- vim:sw=2:et
+#++
+#
+# :title: QuakeNet Auth Plugin
+#
+# Author:: Raine Virta <rane@kapsi.fi>
+# Copyright:: (C) 2008 Raine Virta
+# License:: GPL v2
+#
+# Automatically auths with Q on QuakeNet servers
 
 class QPlugin < Plugin
   
   def help(plugin, topic="")
     case topic
     when ""
-      return "quath plugin: handles Q auths. topics set, identify"
+      return "qauth plugin: handles Q auths. topics set, identify, register"
     when "set"
-      return "nickserv set <user> <passwd>: set the Q user and password and use it to identify in future"
+      return "qauth set <user> <password>: set the Q user and password and use it to identify in future"
     when "identify"
-      return "quath identify: identify with Q (if user and auth are set)"
+      return "qauth identify: identify with Q (if user and auth are set)"
+    when "register"
+      return "qauth register <email>: register with Q, an email on how to proceed will be sent to the email address you provide"
     end
   end
   
@@ -28,24 +39,76 @@ class QPlugin < Plugin
 
   def set(m, params)
     @registry['quakenet.user'] = params[:nick]
-    @registry['quakenet.auth'] = params[:passwd]
+    @registry['quakenet.auth'] = params[:password]
     m.okay
   end
   
   def connect
     identify(nil, nil)
   end
+
   def identify(m, params)
+    @source = m.replyto
+    @registry['quakenet.auth'] = params[:password] if params[:password]
+
     if @registry.has_key?('quakenet.user') && @registry.has_key?('quakenet.auth')
-      debug "authing with Q using  #{@registry['quakenet.user']} #{@registry['quakenet.auth']}"
-      @bot.sendmsg "PRIVMSG", "Q@CServe.quakenet.org", "auth #{@registry['quakenet.user']} #{@registry['quakenet.auth']}"                                                    
-      m.okay if m
+      user = @registry['quakenet.user']
+      pass = @registry['quakenet.auth']
+
+      debug "authing with Q using #{user} #{pass}"
+      msg_q "auth #{user} #{pass}"
     else
-      m.reply "not configured, try 'qauth set :nick :passwd'" if m
+      m.reply "not configured, try 'qauth set :nick :password' or 'qauth register :email'" if m
     end
   end
 
+  def notice(m)
+    if m.source.user == "TheQBot" && m.source.host = "CServe.quakenet.org"
+      case m.message
+      when /a user with that name already exists/i
+        @bot.say @source, "user with my name already exists, identify if it belongs to you"
+      when /created successfully/
+        @registry['quakenet.user'] = @bot.nick
+        @bot.say @source, "an email on how to proceed should have been sent to #{@email} -- 'qauth identify <password>' next"
+      when /too many accounts exist from this email address/i
+        @bot.say @source, "too many accounts on that email address"
+      when /registration service is unavailable/
+        @bot.say @source, "the registration service is unavailable, try again later"
+      when /password incorrect/
+        @bot.say @source, "username or password incorrect" if @source
+      when /you are now logged in/i
+        @bot.say @source, "authed successfully" if @source
+      when /auth is not available/
+        @bot.say @source, "already authed" if @source
+      end
+    end
+  end
+
+  def register_nick(m, params)
+    # check nick for invalid characters
+    if @bot.nick =~ /[`~\^\[\]{}|_\\]/
+      m.reply "for me to be able to register, my nick cannot have any of the following characters: `~^[]{}|_\\"
+      return
+    end
+
+    @email  = params[:email]
+    @source = m.replyto
+
+    msg_q "hello #{@email} #{@email}"
+  end
+
+  def msg_q(message)
+    @bot.say "Q@CServe.quakenet.org", message if on_quakenet?
+  end
+
+  def on_quakenet?
+    @bot.server.hostname.split(".")[-2] == "quakenet"
+  end
 end
+
 plugin = QPlugin.new
-plugin.map 'qauth set :nick :passwd', :action => "set"
-plugin.map 'qauth identify', :action => "identify"
+plugin.map 'qauth set :nick :password', :action => "set"
+plugin.map 'qauth identify [:password]', :action => "identify"
+plugin.map 'qauth register :email', :action => "register_nick"
+
+plugin.default_auth('*', false)