rbot 0.9.9 → 0.9.10

data/lib/rbot/httputil.rb

@@ -3,8 +3,9 @@ module Utils
 
 require 'resolv'
 require 'net/http'
+require 'net/https'
 Net::HTTP.version_1_2
-  
+
 # class for making http requests easier (mainly for plugins to use)
 # this class can check the bot proxy configuration to determine if a proxy
 # needs to be used, which includes support for per-url proxy configuration.
@@ -25,9 +26,22 @@ class HttpUtil
     BotConfig.register BotConfigArrayValue.new('http.proxy_exclude',
       :default => [],
       :desc => "List of regexps to check against a URI's hostname/ip to see if we should use avoid the proxy to access this URI and access it directly")
+    BotConfig.register BotConfigIntegerValue.new('http.max_redir',
+      :default => 5,
+      :desc => "Maximum number of redirections to be used when getting a document")
+    BotConfig.register BotConfigIntegerValue.new('http.expire_time',
+      :default => 60,
+      :desc => "After how many minutes since last use a cached document is considered to be expired")
+    BotConfig.register BotConfigIntegerValue.new('http.max_cache_time',
+      :default => 60*24,
+      :desc => "After how many minutes since first use a cached document is considered to be expired")
+    BotConfig.register BotConfigIntegerValue.new('http.no_expire_cache',
+      :default => false,
+      :desc => "Set this to true if you want the bot to never expire the cached pages")
 
   def initialize(bot)
     @bot = bot
+    @cache = Hash.new
     @headers = {
       'User-Agent' => "rbot http util #{$version} (http://linuxbrit.co.uk/rbot/)",
     }
@@ -47,7 +61,7 @@ class HttpUtil
     begin
       list.concat Resolv.getaddresses(uri.host)
     rescue StandardError => err
-      puts "warning: couldn't resolve host uri.host"
+      warning "couldn't resolve host uri.host"
     end
 
     unless @bot.config["http.proxy_exclude"].empty?
@@ -79,7 +93,7 @@ class HttpUtil
   # uri:: Uri to create a proxy for
   #
   # return a net/http Proxy object, which is configured correctly for
-  # proxying based on the bot's proxy configuration. 
+  # proxying based on the bot's proxy configuration.
   # This will include per-url proxy configuration based on the bot config
   # +http_proxy_include/exclude+ options.
   def get_proxy(uri)
@@ -97,7 +111,7 @@ class HttpUtil
         proxy = URI.parse @bot.config["http.proxy_uri"] rescue nil
       end
       if proxy
-        debug "proxy is set to #{proxy.uri}"
+        debug "proxy is set to #{proxy.host} port #{proxy.port}"
         if proxy_required(uri)
           proxy_host = proxy.host
           proxy_port = proxy.port
@@ -106,36 +120,190 @@ class HttpUtil
         end
       end
     end
-    
-    return Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port, proxy_user, proxy_port)
+
+    h = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port, proxy_user, proxy_port)
+    h.use_ssl = true if uri.scheme == "https"
+    return h
   end
 
   # uri::         uri to query (Uri object)
   # readtimeout:: timeout for reading the response
   # opentimeout:: timeout for opening the connection
   #
-  # simple get request, returns response body if the status code is 200 and
-  # the request doesn't timeout.
-  def get(uri, readtimeout=10, opentimeout=5)
+  # simple get request, returns (if possible) response body following redirs
+  # and caching if requested
+  # if a block is given, it yields the urls it gets redirected to
+  # TODO we really need something to implement proper caching
+  def get(uri_or_str, readtimeout=10, opentimeout=5, max_redir=@bot.config["http.max_redir"], cache=false)
+    if uri_or_str.class <= URI
+      uri = uri_or_str
+    else
+      uri = URI.parse(uri_or_str.to_s)
+    end
+
     proxy = get_proxy(uri)
     proxy.open_timeout = opentimeout
     proxy.read_timeout = readtimeout
-   
+
     begin
       proxy.start() {|http|
+        yield uri.request_uri() if block_given?
         resp = http.get(uri.request_uri(), @headers)
-        if resp.code == "200"
+        case resp
+        when Net::HTTPSuccess
+          if cache && !(resp.key?('cache-control') && resp['cache-control']=='must-revalidate')
+            k = uri.to_s
+            @cache[k] = Hash.new
+            @cache[k][:body] = resp.body
+            @cache[k][:last_mod] = Time.httpdate(resp['last-modified']) if resp.key?('last-modified')
+            if resp.key?('date')
+              @cache[k][:first_use] = Time.httpdate(resp['date'])
+              @cache[k][:last_use] = Time.httpdate(resp['date'])
+            else
+              now = Time.new
+              @cache[k][:first_use] = now
+              @cache[k][:last_use] = now
+            end
+            @cache[k][:count] = 1
+          end
           return resp.body
+        when Net::HTTPRedirection
+          debug "Redirecting #{uri} to #{resp['location']}"
+          yield resp['location'] if block_given?
+          if max_redir > 0
+            return get( URI.parse(resp['location']), readtimeout, opentimeout, max_redir-1, cache)
+          else
+            warning "Max redirection reached, not going to #{resp['location']}"
+          end
+        else
+          debug "HttpUtil.get return code #{resp.code} #{resp.body}"
+        end
+        return nil
+      }
+    rescue StandardError, Timeout::Error => e
+      error "HttpUtil.get exception: #{e.inspect}, while trying to get #{uri}"
+      debug e.backtrace.join("\n")
+    end
+    return nil
+  end
+
+  # just like the above, but only gets the head
+  def head(uri_or_str, readtimeout=10, opentimeout=5, max_redir=@bot.config["http.max_redir"])
+    if uri_or_str.class <= URI
+      uri = uri_or_str
+    else
+      uri = URI.parse(uri_or_str.to_s)
+    end
+
+    proxy = get_proxy(uri)
+    proxy.open_timeout = opentimeout
+    proxy.read_timeout = readtimeout
+
+    begin
+      proxy.start() {|http|
+        yield uri.request_uri() if block_given?
+        resp = http.head(uri.request_uri(), @headers)
+        case resp
+        when Net::HTTPSuccess
+          return resp
+        when Net::HTTPRedirection
+          debug "Redirecting #{uri} to #{resp['location']}"
+          yield resp['location'] if block_given?
+          if max_redir > 0
+            return head( URI.parse(resp['location']), readtimeout, opentimeout, max_redir-1)
+          else
+            warning "Max redirection reached, not going to #{resp['location']}"
+          end
         else
-          puts "HttpUtil.get return code #{resp.code} #{resp.body}"
+          debug "HttpUtil.head return code #{resp.code}"
         end
         return nil
       }
     rescue StandardError, Timeout::Error => e
-      $stderr.puts "HttpUtil.get exception: #{e}, while trying to get #{uri}"
+      error "HttpUtil.head exception: #{e.inspect}, while trying to get #{uri}"
+      debug e.backtrace.join("\n")
     end
     return nil
   end
+
+  # gets a page from the cache if it's still (assumed to be) valid
+  # TODO remove stale cached pages, except when called with noexpire=true
+  def get_cached(uri_or_str, readtimeout=10, opentimeout=5,
+                 max_redir=@bot.config['http.max_redir'],
+                 noexpire=@bot.config['http.no_expire_cache'])
+    if uri_or_str.class <= URI
+      uri = uri_or_str
+    else
+      uri = URI.parse(uri_or_str.to_s)
+    end
+
+    k = uri.to_s
+    if !@cache.key?(k)
+      remove_stale_cache unless noexpire
+      return get(uri, readtimeout, opentimeout, max_redir, true)
+    end
+    now = Time.new
+    begin
+      # See if the last-modified header can be used
+      # Assumption: the page was not modified if both the header
+      # and the cached copy have the last-modified value, and it's the same time
+      # If only one of the cached copy and the header have the value, or if the
+      # value is different, we assume that the cached copyis invalid and therefore
+      # get a new one.
+      # On our first try, we tested for last-modified in the webpage first,
+      # and then on the local cache. however, this is stupid (in general),
+      # so we only test for the remote page if the local copy had the header
+      # in the first place.
+      if @cache[k].key?(:last_mod)
+        h = head(uri, readtimeout, opentimeout, max_redir)
+        if h.key?('last-modified')
+          if Time.httpdate(h['last-modified']) == @cache[k][:last_mod]
+            if h.key?('date')
+              @cache[k][:last_use] = Time.httpdate(h['date'])
+            else
+              @cache[k][:last_use] = now
+            end
+            @cache[k][:count] += 1
+            return @cache[k][:body]
+          end
+          remove_stale_cache unless noexpire
+          return get(uri, readtimeout, opentimeout, max_redir, true)
+        end
+        remove_stale_cache unless noexpire
+        return get(uri, readtimeout, opentimeout, max_redir, true)
+      end
+    rescue => e
+      warning "Error #{e.inspect} getting the page #{uri}, using cache"
+      debug e.backtrace.join("\n")
+      return @cache[k][:body]
+    end
+    # If we still haven't returned, we are dealing with a non-redirected document
+    # that doesn't have the last-modified attribute
+    debug "Could not use last-modified attribute for URL #{uri}, guessing cache validity"
+    if noexpire or !expired?(@cache[k], now)
+      @cache[k][:count] += 1
+      @cache[k][:last_use] = now
+      debug "Using cache"
+      return @cache[k][:body]
+    end
+    debug "Cache expired, getting anew"
+    @cache.delete(k)
+    remove_stale_cache unless noexpire
+    return get(uri, readtimeout, opentimeout, max_redir, true)
+  end
+
+  def expired?(hash, time)
+    (time - hash[:last_use] > @bot.config['http.expire_time']*60) or
+    (time - hash[:first_use] > @bot.config['http.max_cache_time']*60)
+  end
+
+  def remove_stale_cache
+    now = Time.new
+    @cache.reject! { |k, val|
+      !val.key?(:last_modified) && expired?(val, now)
+    }
+  end
+
 end
 end
 end

data/lib/rbot/ircbot.rb

@@ -1,21 +1,77 @@
 require 'thread'
+
 require 'etc'
 require 'fileutils'
+require 'logger'
 
 $debug = false unless $debug
-# print +message+ if debugging is enabled
-def debug(message=nil)
-  print "DEBUG: #{message}\n" if($debug && message)
-  #yield
+$daemonize = false unless $daemonize
+
+$dateformat = "%Y/%m/%d %H:%M:%S"
+$logger = Logger.new($stderr)
+$logger.datetime_format = $dateformat
+$logger.level = $cl_loglevel if $cl_loglevel
+$logger.level = 0 if $debug
+
+def rawlog(level, message=nil, who_pos=1)
+  call_stack = caller
+  if call_stack.length > who_pos
+    who = call_stack[who_pos].sub(%r{(?:.+)/([^/]+):(\d+)(:in .*)?}) { "#{$1}:#{$2}#{$3}" }
+  else
+    who = "(unknown)"
+  end
+  # Output each line. To distinguish between separate messages and multi-line
+  # messages originating at the same time, we blank #{who} after the first message
+  # is output.
+  message.to_s.each_line { |l|
+    $logger.add(level, l.chomp, who)
+    who.gsub!(/./," ")
+  }
+end
+
+def log_session_start
+  $logger << "\n\n=== #{botclass} session started on #{Time.now.strftime($dateformat)} ===\n\n"
+end
+
+def log_session_end
+  $logger << "\n\n=== #{botclass} session ended on #{Time.now.strftime($dateformat)} ===\n\n"
+end
+
+def debug(message=nil, who_pos=1)
+  rawlog(Logger::Severity::DEBUG, message, who_pos)
 end
 
+def log(message=nil, who_pos=1)
+  rawlog(Logger::Severity::INFO, message, who_pos)
+end
+
+def warning(message=nil, who_pos=1)
+  rawlog(Logger::Severity::WARN, message, who_pos)
+end
+
+def error(message=nil, who_pos=1)
+  rawlog(Logger::Severity::ERROR, message, who_pos)
+end
+
+def fatal(message=nil, who_pos=1)
+  rawlog(Logger::Severity::FATAL, message, who_pos)
+end
+
+debug "debug test"
+log "log test"
+warning "warning test"
+error "error test"
+fatal "fatal test"
+
+# The following global is used for the improved signal handling.
+$interrupted = 0
+
 # these first
 require 'rbot/rbotconfig'
 require 'rbot/config'
 require 'rbot/utils'
 
 require 'rbot/rfc2812'
-require 'rbot/keywords'
 require 'rbot/ircsocket'
 require 'rbot/auth'
 require 'rbot/timer'
@@ -34,25 +90,25 @@ module Irc
 class IrcBot
   # the bot's current nickname
   attr_reader :nick
-  
+
   # the bot's IrcAuth data
   attr_reader :auth
-  
+
   # the bot's BotConfig data
   attr_reader :config
-  
+
   # the botclass for this bot (determines configdir among other things)
   attr_reader :botclass
-  
+
   # used to perform actions periodically (saves configuration once per minute
   # by default)
   attr_reader :timer
-  
+
   # bot's Language data
   attr_reader :lang
 
-  # bot's configured addressing prefixes
-  attr_reader :addressing_prefixes
+  # capabilities info for the server
+  attr_reader :capabilities
 
   # channel info for channels the bot is in
   attr_reader :channels
@@ -65,6 +121,9 @@ class IrcBot
   # and restore objects in their own namespaces.)
   attr_reader :registry
 
+  # bot's plugins. This is an instance of class Plugins
+  attr_reader :plugins
+
   # bot's httputil help object, for fetching resources via http. Sets up
   # proxies etc as defined by the bot configuration/environment
   attr_reader :httputil
@@ -72,13 +131,14 @@ class IrcBot
   # create a new IrcBot with botclass +botclass+
   def initialize(botclass, params = {})
     # BotConfig for the core bot
+    # TODO should we split socket stuff into ircsocket, etc?
     BotConfig.register BotConfigStringValue.new('server.name',
       :default => "localhost", :requires_restart => true,
       :desc => "What server should the bot connect to?",
       :wizard => true)
     BotConfig.register BotConfigIntegerValue.new('server.port',
       :default => 6667, :type => :integer, :requires_restart => true,
-      :desc => "What port should the bot connect to?", 
+      :desc => "What port should the bot connect to?",
       :validate => Proc.new {|v| v > 0}, :wizard => true)
     BotConfig.register BotConfigStringValue.new('server.password',
       :default => false, :requires_restart => true,
@@ -91,6 +151,23 @@ class IrcBot
     BotConfig.register BotConfigIntegerValue.new('server.reconnect_wait',
       :default => 5, :validate => Proc.new{|v| v >= 0},
       :desc => "Seconds to wait before attempting to reconnect, on disconnect")
+    BotConfig.register BotConfigFloatValue.new('server.sendq_delay',
+      :default => 2.0, :validate => Proc.new{|v| v >= 0},
+      :desc => "(flood prevention) the delay between sending messages to the server (in seconds)",
+      :on_change => Proc.new {|bot, v| bot.socket.sendq_delay = v })
+    BotConfig.register BotConfigIntegerValue.new('server.sendq_burst',
+      :default => 4, :validate => Proc.new{|v| v >= 0},
+      :desc => "(flood prevention) max lines to burst to the server before throttling. Most ircd's allow bursts of up 5 lines",
+      :on_change => Proc.new {|bot, v| bot.socket.sendq_burst = v })
+    BotConfig.register BotConfigStringValue.new('server.byterate',
+      :default => "400/2", :validate => Proc.new{|v| v.match(/\d+\/\d/)},
+      :desc => "(flood prevention) max bytes/seconds rate to send the server. Most ircd's have limits of 512 bytes/2 seconds",
+      :on_change => Proc.new {|bot, v| bot.socket.byterate = v })
+    BotConfig.register BotConfigIntegerValue.new('server.ping_timeout',
+      :default => 30, :validate => Proc.new{|v| v >= 0},
+      :on_change => Proc.new {|bot, v| bot.start_server_pings},
+      :desc => "reconnect if server doesn't respond to PING within this many seconds (set to 0 to disable)")
+
     BotConfig.register BotConfigStringValue.new('irc.nick', :default => "rbot",
       :desc => "IRC nickname the bot should attempt to use", :wizard => true,
       :on_change => Proc.new{|bot, v| bot.sendq "NICK #{v}" })
@@ -100,65 +177,173 @@ class IrcBot
     BotConfig.register BotConfigArrayValue.new('irc.join_channels',
       :default => [], :wizard => true,
       :desc => "What channels the bot should always join at startup. List multiple channels using commas to separate. If a channel requires a password, use a space after the channel name. e.g: '#chan1, #chan2, #secretchan secritpass, #chan3'")
+    BotConfig.register BotConfigArrayValue.new('irc.ignore_users',
+      :default => [], 
+      :desc => "Which users to ignore input from. This is mainly to avoid bot-wars triggered by creative people")
+
     BotConfig.register BotConfigIntegerValue.new('core.save_every',
       :default => 60, :validate => Proc.new{|v| v >= 0},
       # TODO change timer via on_change proc
-      :desc => "How often the bot should persist all configuration to disk (in case of a server crash, for example")
-    BotConfig.register BotConfigFloatValue.new('server.sendq_delay',
-      :default => 2.0, :validate => Proc.new{|v| v >= 0},
-      :desc => "(flood prevention) the delay between sending messages to the server (in seconds)",
-      :on_change => Proc.new {|bot, v| bot.socket.sendq_delay = v })
-    BotConfig.register BotConfigIntegerValue.new('server.sendq_burst',
-      :default => 4, :validate => Proc.new{|v| v >= 0},
-      :desc => "(flood prevention) max lines to burst to the server before throttling. Most ircd's allow bursts of up 5 lines, with non-burst limits of 512 bytes/2 seconds",
-      :on_change => Proc.new {|bot, v| bot.socket.sendq_burst = v })
+      :desc => "How often the bot should persist all configuration to disk (in case of a server crash, for example)")
+
+    BotConfig.register BotConfigBooleanValue.new('core.run_as_daemon',
+      :default => false, :requires_restart => true,
+      :desc => "Should the bot run as a daemon?")
+
+    BotConfig.register BotConfigStringValue.new('log.file',
+      :default => false, :requires_restart => true,
+      :desc => "Name of the logfile to which console messages will be redirected when the bot is run as a daemon")
+    BotConfig.register BotConfigIntegerValue.new('log.level',
+      :default => 1, :requires_restart => false,
+      :validate => Proc.new { |v| (0..5).include?(v) },
+      :on_change => Proc.new { |bot, v|
+        $logger.level = v
+      },
+      :desc => "The minimum logging level (0=DEBUG,1=INFO,2=WARN,3=ERROR,4=FATAL) for console messages")
+    BotConfig.register BotConfigIntegerValue.new('log.keep',
+      :default => 1, :requires_restart => true,
+      :validate => Proc.new { |v| v >= 0 },
+      :desc => "How many old console messages logfiles to keep")
+    BotConfig.register BotConfigIntegerValue.new('log.max_size',
+      :default => 10, :requires_restart => true,
+      :validate => Proc.new { |v| v > 0 },
+      :desc => "Maximum console messages logfile size (in megabytes)")
 
     @argv = params[:argv]
 
     unless FileTest.directory? Config::datadir
-      puts "data directory '#{Config::datadir}' not found, did you install.rb?"
+      error "data directory '#{Config::datadir}' not found, did you setup.rb?"
       exit 2
     end
-    
-    botclass = "/home/#{Etc.getlogin}/.rbot" unless botclass
+
+    unless botclass and not botclass.empty?
+      # We want to find a sensible default.
+      #  * On POSIX systems we prefer ~/.rbot for the effective uid of the process
+      #  * On Windows (at least the NT versions) we want to put our stuff in the
+      #    Application Data folder.
+      # We don't use any particular O/S detection magic, exploiting the fact that
+      # Etc.getpwuid is nil on Windows
+      if Etc.getpwuid(Process::Sys.geteuid)
+        botclass = Etc.getpwuid(Process::Sys.geteuid)[:dir].dup
+      else
+        if ENV.has_key?('APPDATA')
+          botclass = ENV['APPDATA'].dup
+          botclass.gsub!("\\","/")
+        end
+      end
+      botclass += "/.rbot"
+    end
+    botclass = File.expand_path(botclass)
     @botclass = botclass.gsub(/\/$/, "")
 
     unless FileTest.directory? botclass
-      puts "no #{botclass} directory found, creating from templates.."
+      log "no #{botclass} directory found, creating from templates.."
       if FileTest.exist? botclass
-        puts "Error: file #{botclass} exists but isn't a directory"
+        error "file #{botclass} exists but isn't a directory"
         exit 2
       end
       FileUtils.cp_r Config::datadir+'/templates', botclass
     end
-    
+
     Dir.mkdir("#{botclass}/logs") unless File.exist?("#{botclass}/logs")
+    Dir.mkdir("#{botclass}/registry") unless File.exist?("#{botclass}/registry")
 
+    @ping_timer = nil
+    @pong_timer = nil
+    @last_ping = nil
     @startup_time = Time.new
     @config = BotConfig.new(self)
+
+    if @config['core.run_as_daemon']
+      $daemonize = true
+    end
+
+    @logfile = @config['log.file']
+    if @logfile.class!=String || @logfile.empty?
+      @logfile = "#{botclass}/#{File.basename(botclass).gsub(/^\.+/,'')}.log"
+    end
+
+    # See http://blog.humlab.umu.se/samuel/archives/000107.html
+    # for the backgrounding code 
+    if $daemonize
+      begin
+        exit if fork
+        Process.setsid
+        exit if fork
+      rescue NotImplementedError
+        warning "Could not background, fork not supported"
+      rescue => e
+        warning "Could not background. #{e.inspect}"
+      end
+      Dir.chdir botclass
+      # File.umask 0000                # Ensure sensible umask. Adjust as needed.
+      log "Redirecting standard input/output/error"
+      begin
+        STDIN.reopen "/dev/null"
+      rescue Errno::ENOENT
+        # On Windows, there's not such thing as /dev/null
+        STDIN.reopen "NUL"
+      end
+      def STDOUT.write(str=nil)
+        log str, 2
+        return str.to_s.length
+      end
+      def STDERR.write(str=nil)
+        if str.to_s.match(/:\d+: warning:/)
+          warning str, 2
+        else
+          error str, 2
+        end
+        return str.to_s.length
+      end
+    end
+
+    # Set the new logfile and loglevel. This must be done after the daemonizing
+    $logger = Logger.new(@logfile, @config['log.keep'], @config['log.max_size']*1024*1024)
+    $logger.datetime_format= $dateformat
+    $logger.level = @config['log.level']
+    $logger.level = $cl_loglevel if $cl_loglevel
+    $logger.level = 0 if $debug
+
+    log_session_start
+
     @timer = Timer::Timer.new(1.0) # only need per-second granularity
     @registry = BotRegistry.new self
+    @save_mutex = Mutex.new
     @timer.add(@config['core.save_every']) { save } if @config['core.save_every']
     @channels = Hash.new
     @logs = Hash.new
-    
     @httputil = Utils::HttpUtil.new(self)
     @lang = Language::Language.new(@config['core.language'])
-    @keywords = Keywords.new(self)
-    @auth = IrcAuth.new(self)
+    begin
+      @auth = IrcAuth.new(self)
+    rescue => e
+      fatal e.inspect
+      fatal e.backtrace.join("\n")
+      log_session_end
+      exit 2
+    end
 
     Dir.mkdir("#{botclass}/plugins") unless File.exist?("#{botclass}/plugins")
     @plugins = Plugins::Plugins.new(self, ["#{botclass}/plugins"])
 
     @socket = IrcSocket.new(@config['server.name'], @config['server.port'], @config['server.bindhost'], @config['server.sendq_delay'], @config['server.sendq_burst'])
     @nick = @config['irc.nick']
-    if @config['core.address_prefix']
-      @addressing_prefixes = @config['core.address_prefix'].split(" ")
-    else
-      @addressing_prefixes = Array.new
-    end
-    
+
     @client = IrcClient.new
+    @client[:isupport] = proc { |data|
+      if data[:capab]
+        sendq "CAPAB IDENTIFY-MSG"
+      end
+    }
+    @client[:datastr] = proc { |data|
+      debug data.inspect
+      if data[:text] == "IDENTIFY-MSG"
+        @capabilities["identify-msg".to_sym] = true
+      else
+        debug "Not handling RPL_DATASTR #{data[:servermessage]}"
+      end
+    }
     @client[:privmsg] = proc { |data|
       message = PrivMessage.new(self, data[:source], data[:target], data[:message])
       onprivmsg(message)
@@ -170,18 +355,21 @@ class IrcBot
     }
     @client[:motd] = proc { |data|
       data[:motd].each_line { |line|
-        log "MOTD: #{line}", "server"
+        irclog "MOTD: #{line}", "server"
       }
     }
-    @client[:nicktaken] = proc { |data| 
+    @client[:nicktaken] = proc { |data|
       nickchg "#{data[:nick]}_"
+      @plugins.delegate "nicktaken", data[:nick]
     }
-    @client[:badnick] = proc {|data| 
-      puts "WARNING, bad nick (#{data[:nick]})"
+    @client[:badnick] = proc {|data|
+      warning "bad nick (#{data[:nick]})"
     }
     @client[:ping] = proc {|data|
-      # (jump the queue for pongs)
-      @socket.puts "PONG #{data[:pingid]}"
+      @socket.queue "PONG #{data[:pingid]}"
+    }
+    @client[:pong] = proc {|data|
+      @last_ping = nil
     }
     @client[:nick] = proc {|data|
       sourcenick = data[:sourcenick]
@@ -193,7 +381,7 @@ class IrcBot
       end
       @channels.each {|k,v|
         if(v.users.has_key?(sourcenick))
-          log "@ #{sourcenick} is now known as #{nick}", k
+          irclog "@ #{sourcenick} is now known as #{nick}", k
           v.users[nick] = v.users[sourcenick]
           v.users.delete(sourcenick)
         end
@@ -207,11 +395,11 @@ class IrcBot
       sourceurl = data[:sourceaddress]
       message = data[:message]
       m = QuitMessage.new(self, data[:source], data[:sourcenick], data[:message])
-      if(data[:sourcenick] =~ /#{@nick}/i)
+      if(data[:sourcenick] =~ /#{Regexp.escape(@nick)}/i)
       else
         @channels.each {|k,v|
           if(v.users.has_key?(sourcenick))
-            log "@ Quit: #{sourcenick}: #{message}", k
+            irclog "@ Quit: #{sourcenick}: #{message}", k
             v.users.delete(sourcenick)
           end
         }
@@ -226,10 +414,10 @@ class IrcBot
       channel = data[:channel]
       targets = data[:targets]
       modestring = data[:modestring]
-      log "@ Mode #{modestring} #{targets} by #{sourcenick}", channel
+      irclog "@ Mode #{modestring} #{targets} by #{sourcenick}", channel
     }
     @client[:welcome] = proc {|data|
-      log "joined server #{data[:source]} as #{data[:nick]}", "server"
+      irclog "joined server #{data[:source]} as #{data[:nick]}", "server"
       debug "I think my nick is #{@nick}, server thinks #{data[:nick]}"
       if data[:nick] && data[:nick].length > 0
         @nick = data[:nick]
@@ -255,11 +443,11 @@ class IrcBot
       onpart(m)
     }
     @client[:kick] = proc {|data|
-      m = KickMessage.new(self, data[:source], data[:target],data[:channel],data[:message]) 
+      m = KickMessage.new(self, data[:source], data[:target],data[:channel],data[:message])
       onkick(m)
     }
     @client[:invite] = proc {|data|
-      if(data[:target] =~ /^#{@nick}$/i)
+      if(data[:target] =~ /^#{Regexp.escape(@nick)}$/i)
         join data[:channel] if (@auth.allow?("join", data[:source], data[:sourcenick]))
       end
     }
@@ -269,9 +457,9 @@ class IrcBot
       topic = data[:topic]
       timestamp = data[:unixtime] || Time.now.to_i
       if(sourcenick == @nick)
-        log "@ I set topic \"#{topic}\"", channel
+        irclog "@ I set topic \"#{topic}\"", channel
       else
-        log "@ #{sourcenick} set topic \"#{topic}\"", channel
+        irclog "@ #{sourcenick} set topic \"#{topic}\"", channel
       end
       m = TopicMessage.new(self, data[:source], data[:channel], timestamp, data[:topic])
 
@@ -288,66 +476,117 @@ class IrcBot
       channel = data[:channel]
       users = data[:users]
       unless(@channels[channel])
-        puts "bug: got names for channel '#{channel}' I didn't think I was in\n"
-        exit 2
+        warning "got names for channel '#{channel}' I didn't think I was in\n"
+        # exit 2
       end
       @channels[channel].users.clear
       users.each {|u|
         @channels[channel].users[u[0].sub(/^[@&~+]/, '')] = ["mode", u[1]]
       }
+      @plugins.delegate "names", data[:channel], data[:users]
     }
     @client[:unknown] = proc {|data|
       #debug "UNKNOWN: #{data[:serverstring]}"
-      log data[:serverstring], ":unknown"
+      irclog data[:serverstring], ".unknown"
     }
   end
 
+  def got_sig(sig)
+    debug "received #{sig}, queueing quit"
+    $interrupted += 1
+    debug "interrupted #{$interrupted} times"
+    if $interrupted >= 5
+      debug "drastic!"
+      log_session_end
+      exit 2
+    elsif $interrupted >= 3
+      debug "quitting"
+      quit
+    end
+  end
+
   # connect the bot to IRC
   def connect
-    trap("SIGTERM") { quit }
-    trap("SIGHUP") { quit }
-    trap("SIGINT") { quit }
     begin
+      trap("SIGINT") { got_sig("SIGINT") }
+      trap("SIGTERM") { got_sig("SIGTERM") }
+      trap("SIGHUP") { got_sig("SIGHUP") }
+    rescue ArgumentError => e
+      debug "failed to trap signals (#{e.inspect}): running on Windows?"
+    rescue => e
+      debug "failed to trap signals: #{e.inspect}"
+    end
+    begin
+      quit if $interrupted > 0
       @socket.connect
-      rescue => e
-      raise "failed to connect to IRC server at #{@config['server.name']} #{@config['server.port']}: " + e
+    rescue => e
+      raise e.class, "failed to connect to IRC server at #{@config['server.name']} #{@config['server.port']}: " + e
     end
-    @socket.puts "PASS " + @config['server.password'] if @config['server.password']
-    @socket.puts "NICK #{@nick}\nUSER #{@config['irc.user']} 4 #{@config['server.name']} :Ruby bot. (c) Tom Gilbert"
+    @socket.emergency_puts "PASS " + @config['server.password'] if @config['server.password']
+    @socket.emergency_puts "NICK #{@nick}\nUSER #{@config['irc.user']} 4 #{@config['server.name']} :Ruby bot. (c) Tom Gilbert"
+    @capabilities = Hash.new
+    start_server_pings
   end
 
   # begin event handling loop
   def mainloop
     while true
-      connect
-      @timer.start
-      
       begin
-        while true
+	quit if $interrupted > 0
+        connect
+        @timer.start
+
+        while @socket.connected?
           if @socket.select
             break unless reply = @socket.gets
             @client.process reply
           end
+	  quit if $interrupted > 0
         end
-      rescue TimeoutError, SocketError => e
-        puts "network exception: connection closed: #{e}"
-        puts e.backtrace.join("\n")
-        @socket.close # now we reconnect
-      rescue => e # TODO be selective, only grab Network errors
-        puts "unexpected exception: connection closed: #{e}"
-        puts e.backtrace.join("\n")
+
+      # I despair of this. Some of my users get "connection reset by peer"
+      # exceptions that ARENT SocketError's. How am I supposed to handle
+      # that?
+      rescue SystemExit
+        log_session_end
+        exit 0
+      rescue Errno::ETIMEDOUT, TimeoutError, SocketError => e
+        error "network exception: #{e.class}: #{e}"
+        debug e.backtrace.join("\n")
+      rescue BDB::Fatal => e
+        fatal "fatal bdb error: #{e.class}: #{e}"
+        fatal e.backtrace.join("\n")
+        DBTree.stats
+        # Why restart? DB problems are serious stuff ...
+        # restart("Oops, we seem to have registry problems ...")
+        log_session_end
+        exit 2
+      rescue Exception => e
+        error "non-net exception: #{e.class}: #{e}"
+        error e.backtrace.join("\n")
+      rescue => e
+        fatal "unexpected exception: #{e.class}: #{e}"
+        fatal e.backtrace.join("\n")
+        log_session_end
         exit 2
       end
-      
-      puts "disconnected"
+
+      stop_server_pings
       @channels.clear
-      @socket.clearq
-      
-      puts "waiting to reconnect"
+      if @socket.connected?
+        @socket.clearq
+        @socket.shutdown
+      end
+
+      log "disconnected"
+
+      quit if $interrupted > 0
+
+      log "waiting to reconnect"
       sleep @config['server.reconnect_wait']
     end
   end
-  
+
   # type:: message type
   # where:: message target
   # message:: message text
@@ -355,12 +594,16 @@ class IrcBot
   # Type can be PRIVMSG, NOTICE, etc, but those you should really use the
   # relevant say() or notice() methods. This one should be used for IRCd
   # extensions you want to use in modules.
-  def sendmsg(type, where, message)
-    # limit it 440 chars + CRLF.. so we have to split long lines
-    left = 440 - type.length - where.length - 3
+  def sendmsg(type, where, message, chan=nil, ring=0)
+    # limit it according to the byterate, splitting the message
+    # taking into consideration the actual message length
+    # and all the extra stuff
+    # TODO allow something to do for commands that produce too many messages
+    # TODO example: math 10**10000
+    left = @socket.bytes_per - type.length - where.length - 4
     begin
       if(left >= message.length)
-        sendq("#{type} #{where} :#{message}")
+        sendq "#{type} #{where} :#{message}", chan, ring
         log_sent(type, where, message)
         return
       end
@@ -370,46 +613,88 @@ class IrcBot
         message = line.slice!(lastspace, line.length) + message
         message.gsub!(/^\s+/, "")
       end
-      sendq("#{type} #{where} :#{line}")
+      sendq "#{type} #{where} :#{line}", chan, ring
       log_sent(type, where, line)
     end while(message.length > 0)
   end
 
   # queue an arbitraty message for the server
-  def sendq(message="")
+  def sendq(message="", chan=nil, ring=0)
     # temporary
-    @socket.queue(message)
+    @socket.queue(message, chan, ring)
   end
 
   # send a notice message to channel/nick +where+
-  def notice(where, message)
+  def notice(where, message, mchan=nil, mring=-1)
+    if mchan == ""
+      chan = where
+    else
+      chan = mchan
+    end
+    if mring < 0
+      if where =~ /^#/
+        ring = 2
+      else
+        ring = 1
+      end
+    else
+      ring = mring
+    end
     message.each_line { |line|
       line.chomp!
       next unless(line.length > 0)
-      sendmsg("NOTICE", where, line)
+      sendmsg "NOTICE", where, line, chan, ring
     }
   end
 
   # say something (PRIVMSG) to channel/nick +where+
-  def say(where, message)
+  def say(where, message, mchan="", mring=-1)
+    if mchan == ""
+      chan = where
+    else
+      chan = mchan
+    end
+    if mring < 0
+      if where =~ /^#/
+        ring = 2
+      else
+        ring = 1
+      end
+    else
+      ring = mring
+    end
     message.to_s.gsub(/[\r\n]+/, "\n").each_line { |line|
       line.chomp!
       next unless(line.length > 0)
       unless((where =~ /^#/) && (@channels.has_key?(where) && @channels[where].quiet))
-        sendmsg("PRIVMSG", where, line)
+        sendmsg "PRIVMSG", where, line, chan, ring 
       end
     }
   end
 
   # perform a CTCP action with message +message+ to channel/nick +where+
-  def action(where, message)
-    sendq("PRIVMSG #{where} :\001ACTION #{message}\001")
+  def action(where, message, mchan="", mring=-1)
+    if mchan == ""
+      chan = where
+    else
+      chan = mchan
+    end
+    if mring < 0
+      if where =~ /^#/
+        ring = 2
+      else
+        ring = 1
+      end
+    else
+      ring = mring
+    end
+    sendq "PRIVMSG #{where} :\001ACTION #{message}\001", chan, ring
     if(where =~ /^#/)
-      log "* #{@nick} #{message}", where
+      irclog "* #{@nick} #{message}", where
     elsif (where =~ /^(\S*)!.*$/)
-         log "* #{@nick}[#{where}] #{message}", $1
+      irclog "* #{@nick}[#{where}] #{message}", $1
     else
-         log "* #{@nick}[#{where}] #{message}", where
+      irclog "* #{@nick}[#{where}] #{message}", where
     end
   end
 
@@ -418,11 +703,12 @@ class IrcBot
     say where, @lang.get("okay")
   end
 
-  # log message +message+ to a file determined by +where+. +where+ can be a
-  # channel name, or a nick for private message logging
-  def log(message, where="server")
-    message.chomp!
+  # log IRC-related message +message+ to a file determined by +where+.
+  # +where+ can be a channel name, or a nick for private message logging
+  def irclog(message, where="server")
+    message = message.chomp
     stamp = Time.now.strftime("%Y/%m/%d %H:%M:%S")
+    where = where.gsub(/[:!?$*()\/\\<>|"']/, "_")
     unless(@logs.has_key?(where))
       @logs[where] = File.new("#{@botclass}/logs/#{where}", "a")
       @logs[where].sync = true
@@ -430,93 +716,111 @@ class IrcBot
     @logs[where].puts "[#{stamp}] #{message}"
     #debug "[#{stamp}] <#{where}> #{message}"
   end
-  
+
   # set topic of channel +where+ to +topic+
   def topic(where, topic)
-    sendq "TOPIC #{where} :#{topic}"
+    sendq "TOPIC #{where} :#{topic}", where, 2
   end
 
   # disconnect from the server and cleanup all plugins and modules
   def shutdown(message = nil)
-    trap("SIGTERM", "DEFAULT")
-    trap("SIGHUP", "DEFAULT")
-    trap("SIGINT", "DEFAULT")
+    debug "Shutting down ..."
+    ## No we don't restore them ... let everything run through
+    # begin
+    #   trap("SIGINT", "DEFAULT")
+    #   trap("SIGTERM", "DEFAULT")
+    #   trap("SIGHUP", "DEFAULT")
+    # rescue => e
+    #   debug "failed to restore signals: #{e.inspect}\nProbably running on windows?"
+    # end
     message = @lang.get("quit") if (message.nil? || message.empty?)
-    @socket.clearq
-    save
-    @plugins.cleanup
+    if @socket.connected?
+      debug "Clearing socket"
+      @socket.clearq
+      debug "Sending quit message"
+      @socket.emergency_puts "QUIT :#{message}"
+      debug "Flushing socket"
+      @socket.flush
+      debug "Shutting down socket"
+      @socket.shutdown
+    end
+    debug "Logging quits"
     @channels.each_value {|v|
-      log "@ quit (#{message})", v.name
+      irclog "@ quit (#{message})", v.name
     }
-    @socket.puts "QUIT :#{message}"
-    @socket.flush
-    @socket.shutdown
-    @registry.close
-    puts "rbot quit (#{message})"
+    debug "Saving"
+    save
+    debug "Cleaning up"
+    @plugins.cleanup
+    # debug "Closing registries"
+    # @registry.close
+    debug "Cleaning up the db environment"
+    DBTree.cleanup_env
+    log "rbot quit (#{message})"
   end
-  
+
   # message:: optional IRC quit message
   # quit IRC, shutdown the bot
   def quit(message=nil)
-    shutdown(message)
-    exit 0
+    begin
+      shutdown(message)
+    ensure
+      exit 0
+    end
   end
 
   # totally shutdown and respawn the bot
-  def restart
-    shutdown("restarting, back in #{@config['server.reconnect_wait']}...")
+  def restart(message = false)
+    msg = message ? message : "restarting, back in #{@config['server.reconnect_wait']}..."
+    shutdown(msg)
     sleep @config['server.reconnect_wait']
     # now we re-exec
+    # Note, this fails on Windows
     exec($0, *@argv)
   end
 
-  # call the save method for bot's config, keywords, auth and all plugins
+  # call the save method for bot's config, auth and all plugins
   def save
-    @registry.flush
-    @config.save
-    @keywords.save
-    @auth.save
-    @plugins.save
+    @save_mutex.synchronize do
+      @config.save
+      @auth.save
+      @plugins.save
+      DBTree.cleanup_logs
+    end
   end
 
-  # call the rescan method for the bot's lang, keywords and all plugins
+  # call the rescan method for the bot's lang and all plugins
   def rescan
     @lang.rescan
     @plugins.rescan
-    @keywords.rescan
   end
-  
+
   # channel:: channel to join
   # key::     optional channel key if channel is +s
   # join a channel
   def join(channel, key=nil)
     if(key)
-      sendq "JOIN #{channel} :#{key}"
+      sendq "JOIN #{channel} :#{key}", channel, 2
     else
-      sendq "JOIN #{channel}"
+      sendq "JOIN #{channel}", channel, 2
     end
   end
 
   # part a channel
   def part(channel, message="")
-    sendq "PART #{channel} :#{message}"
+    sendq "PART #{channel} :#{message}", channel, 2
   end
 
   # attempt to change bot's nick to +name+
-  # FIXME
-  # if rbot is already taken, this happens:
-  #   <giblet> rbot_, nick rbot
-  #   --- rbot_ is now known as rbot__
-  # he should of course just keep his existing nick and report the error :P
   def nickchg(name)
       sendq "NICK #{name}"
   end
 
   # changing mode
   def mode(channel, mode, target)
-      sendq "MODE #{channel} #{mode} #{target}"
+      sendq "MODE #{channel} #{mode} #{target}", channel, 2
   end
-  
+
   # m::     message asking for help
   # topic:: optional topic help is requested for
   # respond to online help requests
@@ -524,7 +828,7 @@ class IrcBot
     topic = nil if topic == ""
     case topic
     when nil
-      helpstr = "help topics: core, auth, keywords"
+      helpstr = "help topics: core, auth"
       helpstr += @plugins.helptopics
       helpstr += " (help <topic> for more info)"
     when /^core$/i
@@ -535,10 +839,6 @@ class IrcBot
       helpstr = @auth.help
     when /^auth\s+(.+)$/i
       helpstr = @auth.help $1
-    when /^keywords$/i
-      helpstr = @keywords.help
-    when /^keywords\s+(.+)$/i
-      helpstr = @keywords.help $1
     else
       unless(helpstr = @plugins.help(topic))
         helpstr = "no help for topic #{topic}"
@@ -551,9 +851,49 @@ class IrcBot
   def status
     secs_up = Time.new - @startup_time
     uptime = Utils.secs_to_string secs_up
-    return "Uptime #{uptime}, #{@plugins.length} plugins active, #{@registry.length} items stored in registry, #{@socket.lines_sent} lines sent, #{@socket.lines_received} received."
+    # return "Uptime #{uptime}, #{@plugins.length} plugins active, #{@registry.length} items stored in registry, #{@socket.lines_sent} lines sent, #{@socket.lines_received} received."
+    return "Uptime #{uptime}, #{@plugins.length} plugins active, #{@socket.lines_sent} lines sent, #{@socket.lines_received} received."
+  end
+
+  # we'll ping the server every 30 seconds or so, and expect a response
+  # before the next one come around..
+  def start_server_pings
+    stop_server_pings
+    return unless @config['server.ping_timeout'] > 0
+    # we want to respond to a hung server within 30 secs or so
+    @ping_timer = @timer.add(30) {
+      @last_ping = Time.now
+      @socket.queue "PING :rbot"
+    }
+    @pong_timer = @timer.add(10) {
+      unless @last_ping.nil?
+        diff = Time.now - @last_ping
+        unless diff < @config['server.ping_timeout']
+          debug "no PONG from server for #{diff} seconds, reconnecting"
+          begin
+            @socket.shutdown
+          rescue
+            debug "couldn't shutdown connection (already shutdown?)"
+          end
+          @last_ping = nil
+          raise TimeoutError, "no PONG from server in #{diff} seconds"
+        end
+      end
+    }
   end
 
+  def stop_server_pings
+    @last_ping = nil
+    # stop existing timers if running
+    unless @ping_timer.nil?
+      @timer.remove @ping_timer
+      @ping_timer = nil
+    end
+    unless @pong_timer.nil?
+      @timer.remove @pong_timer
+      @pong_timer = nil
+    end
+  end
 
   private
 
@@ -580,8 +920,8 @@ class IrcBot
         return "say <channel>|<nick> <message> => say <message> to <channel> or in private message to <nick>"
       when "action"
         return "action <channel>|<nick> <message> => does a /me <message> to <channel> or in private message to <nick>"
-      when "topic"
-        return "topic <channel> <message> => set topic of <channel> to <message>"
+	#       when "topic"
+	#         return "topic <channel> <message> => set topic of <channel> to <message>"
       when "quiet"
         return "quiet [in here|<channel>] => with no arguments, stop speaking in all channels, if \"in here\", stop speaking in this channel, or stop speaking in <channel>"
       when "talk"
@@ -602,28 +942,31 @@ class IrcBot
     # log it first
     if(m.action?)
       if(m.private?)
-        log "* [#{m.sourcenick}(#{m.sourceaddress})] #{m.message}", m.sourcenick
+        irclog "* [#{m.sourcenick}(#{m.sourceaddress})] #{m.message}", m.sourcenick
       else
-        log "* #{m.sourcenick} #{m.message}", m.target
+        irclog "* #{m.sourcenick} #{m.message}", m.target
       end
     else
       if(m.public?)
-        log "<#{m.sourcenick}> #{m.message}", m.target
+        irclog "<#{m.sourcenick}> #{m.message}", m.target
       else
-        log "[#{m.sourcenick}(#{m.sourceaddress})] #{m.message}", m.sourcenick
+        irclog "[#{m.sourcenick}(#{m.sourceaddress})] #{m.message}", m.sourcenick
       end
     end
 
+    @config['irc.ignore_users'].each { |mask| return if Irc.netmaskmatch(mask,m.source) }
+
     # pass it off to plugins that want to hear everything
     @plugins.delegate "listen", m
 
     if(m.private? && m.message =~ /^\001PING\s+(.+)\001/)
       notice m.sourcenick, "\001PING #$1\001"
-      log "@ #{m.sourcenick} pinged me"
+      irclog "@ #{m.sourcenick} pinged me"
       return
     end
 
     if(m.address?)
+      delegate_privmsg(m)
       case m.message
         when (/^join\s+(\S+)\s+(\S+)$/i)
           join $1, $2 if(@auth.allow?("join", m.source, m.replyto))
@@ -635,8 +978,8 @@ class IrcBot
           part $1 if(@auth.allow?("join", m.source, m.replyto))
         when (/^quit(?:\s+(.*))?$/i)
           quit $1 if(@auth.allow?("quit", m.source, m.replyto))
-        when (/^restart$/i)
-          restart if(@auth.allow?("quit", m.source, m.replyto))
+        when (/^restart(?:\s+(.*))?$/i)
+          restart $1 if(@auth.allow?("quit", m.source, m.replyto))
         when (/^hide$/i)
           join 0 if(@auth.allow?("join", m.source, m.replyto))
         when (/^save$/i)
@@ -650,16 +993,19 @@ class IrcBot
           say $1, $2 if(@auth.allow?("say", m.source, m.replyto))
         when (/^action\s+(\S+)\s+(.*)$/i)
           action $1, $2 if(@auth.allow?("say", m.source, m.replyto))
-        when (/^topic\s+(\S+)\s+(.*)$/i)
-          topic $1, $2 if(@auth.allow?("topic", m.source, m.replyto))
+	  # when (/^topic\s+(\S+)\s+(.*)$/i)
+          #   topic $1, $2 if(@auth.allow?("topic", m.source, m.replyto))
         when (/^mode\s+(\S+)\s+(\S+)\s+(.*)$/i)
           mode $1, $2, $3 if(@auth.allow?("mode", m.source, m.replyto))
         when (/^ping$/i)
           say m.replyto, "pong"
         when (/^rescan$/i)
           if(@auth.allow?("config", m.source, m.replyto))
-            m.okay
+            m.reply "saving ..."
+            save
+            m.reply "rescanning ..."
             rescan
+            m.reply "done. #{@plugins.status(true)}"
           end
         when (/^quiet$/i)
           if(auth.allow?("talk", m.source, m.replyto))
@@ -704,18 +1050,14 @@ class IrcBot
         when (/^(hello|howdy|hola|salut|bonjour|sup|niihau|hey|hi(\W|$)|yo(\W|$)).*/i)
           say m.replyto, @lang.get("hello_X") % m.sourcenick if(m.public?)
           say m.replyto, @lang.get("hello") if(m.private?)
-        else
-          delegate_privmsg(m)
       end
     else
       # stuff to handle when not addressed
       case m.message
-        when (/^\s*(hello|howdy|hola|salut|bonjour|sup|niihau|hey|hi(\W|$)|yo(\W|$))[\s,-.]+#{@nick}$/i)
+        when (/^\s*(hello|howdy|hola|salut|bonjour|sup|niihau|hey|hi|yo(\W|$))[\s,-.]+#{Regexp.escape(@nick)}$/i)
           say m.replyto, @lang.get("hello_X") % m.sourcenick
-        when (/^#{@nick}!*$/)
+        when (/^#{Regexp.escape(@nick)}!*$/)
           say m.replyto, @lang.get("hello_X") % m.sourcenick
-        else
-          @keywords.privmsg(m)
       end
     end
   end
@@ -725,19 +1067,19 @@ class IrcBot
     case type
       when "NOTICE"
         if(where =~ /^#/)
-          log "-=#{@nick}=- #{message}", where
+          irclog "-=#{@nick}=- #{message}", where
         elsif (where =~ /(\S*)!.*/)
-             log "[-=#{where}=-] #{message}", $1
+             irclog "[-=#{where}=-] #{message}", $1
         else
-             log "[-=#{where}=-] #{message}"
+             irclog "[-=#{where}=-] #{message}"
         end
       when "PRIVMSG"
         if(where =~ /^#/)
-          log "<#{@nick}> #{message}", where
+          irclog "<#{@nick}> #{message}", where
         elsif (where =~ /^(\S*)!.*$/)
-          log "[msg(#{where})] #{message}", $1
+          irclog "[msg(#{where})] #{message}", $1
         else
-          log "[msg(#{where})] #{message}", where
+          irclog "[msg(#{where})] #{message}", where
         end
     end
   end
@@ -746,9 +1088,9 @@ class IrcBot
     @channels[m.channel] = IRCChannel.new(m.channel) unless(@channels.has_key?(m.channel))
     if(m.address?)
       debug "joined channel #{m.channel}"
-      log "@ Joined channel #{m.channel}", m.channel
+      irclog "@ Joined channel #{m.channel}", m.channel
     else
-      log "@ #{m.sourcenick} joined channel #{m.channel}", m.channel
+      irclog "@ #{m.sourcenick} joined channel #{m.channel}", m.channel
       @channels[m.channel].users[m.sourcenick] = Hash.new
       @channels[m.channel].users[m.sourcenick]["mode"] = ""
     end
@@ -760,13 +1102,18 @@ class IrcBot
   def onpart(m)
     if(m.address?)
       debug "left channel #{m.channel}"
-      log "@ Left channel #{m.channel} (#{m.message})", m.channel
+      irclog "@ Left channel #{m.channel} (#{m.message})", m.channel
       @channels.delete(m.channel)
     else
-      log "@ #{m.sourcenick} left channel #{m.channel} (#{m.message})", m.channel
-      @channels[m.channel].users.delete(m.sourcenick)
+      irclog "@ #{m.sourcenick} left channel #{m.channel} (#{m.message})", m.channel
+      if @channels.has_key?(m.channel)
+        @channels[m.channel].users.delete(m.sourcenick)
+      else
+        warning "got part for channel '#{channel}' I didn't think I was in\n"
+        # exit 2
+      end
     end
-    
+
     # delegate to plugins
     @plugins.delegate("listen", m)
     @plugins.delegate("part", m)
@@ -777,10 +1124,10 @@ class IrcBot
     if(m.address?)
       debug "kicked from channel #{m.channel}"
       @channels.delete(m.channel)
-      log "@ You have been kicked from #{m.channel} by #{m.sourcenick} (#{m.message})", m.channel
+      irclog "@ You have been kicked from #{m.channel} by #{m.sourcenick} (#{m.message})", m.channel
     else
       @channels[m.channel].users.delete(m.sourcenick)
-      log "@ #{m.target} has been kicked from #{m.channel} by #{m.sourcenick} (#{m.message})", m.channel
+      irclog "@ #{m.target} has been kicked from #{m.channel} by #{m.sourcenick} (#{m.message})", m.channel
     end
 
     @plugins.delegate("listen", m)
@@ -793,16 +1140,15 @@ class IrcBot
     @channels[m.channel].topic.timestamp = m.timestamp if !m.timestamp.nil?
     @channels[m.channel].topic.by = m.source if !m.source.nil?
 
-	  debug "topic of channel #{m.channel} is now #{@channels[m.channel].topic}"
+    debug "topic of channel #{m.channel} is now #{@channels[m.channel].topic}"
   end
 
-  # delegate a privmsg to auth, keyword or plugin handlers
+  # delegate a privmsg to auth or plugin handlers
   def delegate_privmsg(message)
-    [@auth, @plugins, @keywords].each {|m|
+    [@auth, @plugins].each {|m|
       break if m.privmsg(message)
     }
   end
-
 end
 
 end