class Irc::Client

Implements RFC 2812 and prior IRC RFCs.

Clients should register Proc{}s to handle the various server events, and the Client class will handle dispatch.

Attributes

server[R]

the Server we’re connected to

user[R]

the User representing us on that server

Public Class Methods

new() click to toggle source

Create a new Client instance

# File lib/rbot/rfc2812.rb, line 966
def initialize
  # The Server
  @server = Server.new
  # The User representing the client on this Server
  @user = @server.user('*!*@*')

  @handlers = Hash.new

  # This is used by some messages to build lists of users that
  # will be delegated when the ENDOF... message is received
  @tmpusers = []

  # Same as above, just for bans
  @tmpbans = []
end

Public Instance Methods

[]=(key, value) click to toggle source
key

server event to handle

value

proc object called when event occurs

set a handler for a server event

server events currently supported:

TODO handle errors ERR_CHANOPRIVSNEEDED, ERR_CANNOTSENDTOCHAN

welcome

server welcome message on connect

yourhost

your host details (on connection)

created

when the server was started

isupport

information about what this server supports

ping

server pings you (default handler returns a pong)

nicktaken

you tried to change nick to one that’s in use

badnick

you tried to change nick to one that’s invalid

topic

someone changed the topic of a channel

topicinfo

on joining a channel or asking for the topic, tells you who set it and when

names

server sends list of channel members when you join

motd

server message of the day

privmsg

privmsg, the core of IRC, a message to you from someone

public

optionally instead of getting privmsg you can hook to only the public ones…

msg

or only the private ones, or both

kick

someone got kicked from a channel

part

someone left a channel

quit

someone quit IRC

join

someone joined a channel

changetopic

the topic of a channel changed

invite

you are invited to a channel

nick

someone changed their nick

mode

a mode change

notice

someone sends you a notice

unknown

any other message not handled by the above

# File lib/rbot/rfc2812.rb, line 1022
def []=(key, value)
  @handlers[key] = value
end
deletehandler(key) click to toggle source
key

event name

remove a handler for a server event

# File lib/rbot/rfc2812.rb, line 1028
def deletehandler(key)
  @handlers.delete(key)
end
process(serverstring) click to toggle source

takes a server string, checks for PING, PRIVMSG, NOTIFY, etc, and parses numeric server replies, calling the appropriate handler for each, and sending it a hash containing the data from the server

# File lib/rbot/rfc2812.rb, line 1035
def process(serverstring)
  data = Hash.new
  data[:serverstring] = serverstring

  unless serverstring.chomp =~ /^(:(\S+)\s)?(\S+)(\s(.*))?$/
    raise ServerMessageParseError, (serverstring.chomp rescue serverstring)
  end

  prefix, command, params = $2, $3, $5

  unless prefix.nil?
    # Most servers will send a full nick!user@host prefix for
    # messages from users. Therefore, when the prefix doesn't match this
    # syntax it's usually the server hostname.
    #
    # This is not always true, though, since some servers do not send a
    # full hostmask for user messages.
    #
    if prefix =~ /^#{Regexp::Irc::BANG_AT}$/
      data[:source] = @server.user(prefix)
    elsif @server.hostname
      if @server.hostname != prefix
        # TODO: do we want to be able to differentiate messages that are passed on to us from /other/ servers?
        debug "Origin #{prefix} for message\n\t#{serverstring.inspect}\nis neither a user hostmask nor the server hostname\nI'll pretend that it's from the server anyway"
      end
      data[:source] = @server
    else
      @server.instance_variable_set(:@hostname, prefix)
      data[:source] = @server
    end
  end

  # split parameters in an array
  argv = []
  params&.scan(/(?!:)(\S+)|:(.*)/) { argv << ($1 || $2) }

  if command =~ /^(\d+)$/ # Numeric replies
    data[:target] = argv[0]
    # A numeric reply /should/ be directed at the client, except when we're
    # connecting with a used nick, in which case it's directed at '*'
    not_us = !([@user.nick, '*'].include?(data[:target]))
    if not_us
      warning "Server reply #{serverstring.inspect} directed at #{data[:target]} instead of client (#{@user.nick})"
    end

    num = command.to_i
    case num
    when RPL_WELCOME
      data[:message] = argv[1]
      # "Welcome to the Internet Relay Network
      # <nick>!<user>@<host>"
      if not_us
        warning "Server thinks client (#{@user.inspect}) has a different nick"
        @user.nick = data[:target]
      end
      if data[:message] =~ /([^@!\s]+)(?:!([^@!\s]+?))?@(\S+)/
        nick = $1
        user = $2
        host = $3
        warning "Welcome message nick mismatch (#{nick} vs #{data[:target]})" if nick != data[:target]
        @user.user = user if user
        @user.host = host if host
      end
      handle(:welcome, data)
    when RPL_YOURHOST
      # "Your host is <servername>, running version <ver>"
      data[:message] = argv[1]
      handle(:yourhost, data)
    when RPL_CREATED
      # "This server was created <date>"
      data[:message] = argv[1]
      handle(:created, data)
    when RPL_MYINFO
      # "<servername> <version> <available user modes>
      # <available channel modes>"
      @server.parse_my_info(params.split(' ', 2).last)
      data[:servername] = @server.hostname
      data[:version] = @server.version
      data[:usermodes] = @server.usermodes
      data[:chanmodes] = @server.chanmodes
      handle(:myinfo, data)
    when RPL_ISUPPORT
      # "PREFIX=(ov)@+ CHANTYPES=#& :are supported by this server"
      # "MODES=4 CHANLIMIT=#:20 NICKLEN=16 USERLEN=10 HOSTLEN=63
      # TOPICLEN=450 KICKLEN=450 CHANNELLEN=30 KEYLEN=23 CHANTYPES=#
      # PREFIX=(ov)@+ CASEMAPPING=ascii CAPAB IRCD=dancer :are available
      # on this server"
      #
      @server.parse_isupport(argv[1..-2].join(' '))
      handle(:isupport, data)
    when ERR_NICKNAMEINUSE
      # "* <nick> :Nickname is already in use"
      data[:nick] = argv[1]
      data[:message] = argv[2]
      handle(:nicktaken, data)
    when ERR_ERRONEUSNICKNAME
      # "* <nick> :Erroneous nickname"
      data[:nick] = argv[1]
      data[:message] = argv[2]
      handle(:badnick, data)
    when RPL_TOPIC
      data[:channel] = @server.channel(argv[1])
      data[:topic] = argv[2]
      data[:channel].topic.text = data[:topic]

      handle(:topic, data)
    when RPL_TOPIC_INFO
      data[:nick] = @server.user(argv[0])
      data[:channel] = @server.channel(argv[1])

      # This must not be an IRC::User because it might not be an actual User,
      # and we risk overwriting valid User data
      data[:source] = argv[2].to_irc_netmask(:server => @server)

      data[:time] = Time.at(argv[3].to_i)

      data[:channel].topic.set_by = data[:source]
      data[:channel].topic.set_on = data[:time]

      handle(:topicinfo, data)
    when RPL_NAMREPLY
      # "( "=" / "*" / "@" ) <channel>
      # :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )
      # - "@" is used for secret channels, "*" for private
      # channels, and "=" for others (public channels).
      data[:channeltype] = argv[1]
      data[:channel] = chan = @server.channel(argv[2])

      users = []
      argv[3].scan(/\S+/).each do |u|
        # FIXME: beware of servers that allow multiple prefixes
        if(u =~ /^([#{@server.supports[:prefix][:prefixes].join}])?(.*)$/)
          umode = $1
          user = $2
          users << [user, umode]
        end
      end

      users.each do |ar|
        u = @server.user(ar[0])
        chan.add_user(u, :silent => true)
        debug "Adding user #{u}"
        if ar[1]
          ms = @server.mode_for_prefix(ar[1].to_sym)
          debug "\twith mode #{ar[1]} (#{ms})"
          chan.mode[ms].set(u)
        end
      end
      @tmpusers += users
    when RPL_ENDOFNAMES
      data[:channel] = @server.channel(argv[1])
      data[:users] = @tmpusers
      handle(:names, data)
      @tmpusers = Array.new
    when RPL_BANLIST
      data[:channel] = @server.channel(argv[1])
      data[:mask] = argv[2]
      data[:by] = argv[3]
      data[:at] = argv[4]
      @tmpbans << data
    when RPL_ENDOFBANLIST
      data[:channel] = @server.channel(argv[1])
      data[:bans] = @tmpbans
      handle(:banlist, data)
      @tmpbans = Array.new
    when RPL_LUSERCLIENT
      # ":There are <integer> users and <integer>
      # services on <integer> servers"
      data[:message] = argv[1]
      handle(:luserclient, data)
    when RPL_LUSEROP
      # "<integer> :operator(s) online"
      data[:ops] = argv[1].to_i
      handle(:luserop, data)
    when RPL_LUSERUNKNOWN
      # "<integer> :unknown connection(s)"
      data[:unknown] = argv[1].to_i
      handle(:luserunknown, data)
    when RPL_LUSERCHANNELS
      # "<integer> :channels formed"
      data[:channels] = argv[1].to_i
      handle(:luserchannels, data)
    when RPL_LUSERME
      # ":I have <integer> clients and <integer> servers"
      data[:message] = argv[1]
      handle(:luserme, data)
    when ERR_NOMOTD
      # ":MOTD File is missing"
      data[:message] = argv[1]
      handle(:motd_missing, data)
    when RPL_LOCALUSERS
      # ":Current local  users: 3  Max: 4"
      data[:message] = argv[1]
      handle(:localusers, data)
    when RPL_GLOBALUSERS
      # ":Current global users: 3  Max: 4"
      data[:message] = argv[1]
      handle(:globalusers, data)
    when RPL_STATSCONN
      # ":Highest connection count: 4 (4 clients) (251 since server was
      # (re)started)"
      data[:message] = argv[1]
      handle(:statsconn, data)
    when RPL_MOTDSTART
      # "<nick> :- <server> Message of the Day -"
      if argv[1] =~ /^-\s+(\S+)\s/
        server = $1
      else
        warning "Server doesn't have an RFC compliant MOTD start."
      end
      @motd = ''
    when RPL_MOTD
      if argv[1] =~ /^-\s+(.*)$/
        @motd << $1
        @motd << "\n"
      end
    when RPL_ENDOFMOTD
      data[:motd] = @motd
      handle(:motd, data)
    when RPL_DATASTR
      data[:text] = argv[1]
      handle(:datastr, data)
    when RPL_AWAY
      data[:nick] = user = @server.user(argv[1])
      data[:message] = argv[-1]
      user.away = data[:message]
      handle(:away, data)
    when RPL_WHOREPLY
      data[:channel] = channel = @server.channel(argv[1])
      data[:user] = argv[2]
      data[:host] = argv[3]
      data[:userserver] = argv[4]
      data[:nick] = user = @server.user(argv[5])
      if argv[6] =~ /^(H|G)(\*)?(.*)?$/
        data[:away] = ($1 == 'G')
        data[:ircop] = $2
        data[:modes] = $3.scan(/./).map { |mode|
          m = @server.supports[:prefix][:prefixes].index(mode.to_sym)
          @server.supports[:prefix][:modes][m]
        } rescue []
      else
        warning "Strange WHO reply: #{serverstring.inspect}"
      end
      data[:hopcount], data[:real_name] = argv[7].split(' ', 2)

      user.user = data[:user]
      user.host = data[:host]
      user.away = data[:away] # FIXME: doesn't provide the actual message
      # TODO: ircop status
      # TODO: userserver
      # TODO: hopcount
      user.real_name = data[:real_name]

      channel.add_user(user, :silent=>true)
      data[:modes].map do |mode|
        channel.mode[mode].set(user)
      end

      handle(:who, data)
    when RPL_ENDOFWHO
      handle(:eowho, data)
    when RPL_WHOISUSER
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      @whois[:user] = argv[2]
      @whois[:host] = argv[3]
      @whois[:real_name] = argv[-1]

      user = @server.user(@whois[:nick])
      user.user = @whois[:user]
      user.host = @whois[:host]
      user.real_name = @whois[:real_name]
    when RPL_WHOISSERVER
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      @whois[:server] = argv[2]
      @whois[:server_info] = argv[-1]
      # TODO: update user info
    when RPL_WHOISOPERATOR
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      @whois[:operator] = argv[-1]
      # TODO: update user info
    when RPL_WHOISIDLE
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      user = @server.user(@whois[:nick])
      @whois[:idle] = argv[2].to_i
      user.idle_since = Time.now - @whois[:idle]
      if argv[-1] == 'seconds idle, signon time'
        @whois[:signon] = Time.at(argv[3].to_i)
        user.signon = @whois[:signon]
      end
    when RPL_ENDOFWHOIS
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      data[:whois] = @whois.dup
      @whois.clear
      handle(:whois, data)
    when RPL_WHOISCHANNELS
      @whois ||= Hash.new
      @whois[:nick] = argv[1]
      @whois[:channels] ||= []
      user = @server.user(@whois[:nick])
      argv[-1].split.each do |prechan|
        pfx = prechan.scan(/[#{@server.supports[:prefix][:prefixes].join}]/)
        modes = pfx.map { |p| @server.mode_for_prefix p }
        chan = prechan[pfx.length..prechan.length]

        channel = @server.channel(chan)
        channel.add_user(user, :silent => true)
        modes.map { |mode| channel.mode[mode].set(user) }

        @whois[:channels] << [chan, modes]
      end
    when RPL_LISTSTART
      # ignore
    when RPL_LIST
      @list ||= Hash.new
      chan = argv[1]
      users = argv[2]
      topic = argv[3]
      @list[chan] = ListData.new(chan, users, topic)
    when RPL_LISTEND
      @list ||= Hash.new
      data[:list] = @list
      handle(:list, data)
    when RPL_CHANNELMODEIS
      parse_mode(serverstring, argv[1..-1], data)
      handle(:mode, data)
    when RPL_CREATIONTIME
      data[:channel] = @server.channel(argv[1])
      data[:time] = Time.at(argv[2].to_i)
      data[:channel].creation_time = data[:time]
      handle(:creationtime, data)
    when RPL_CHANNEL_URL
      data[:channel] = @server.channel(argv[1])
      data[:url] = argv[2]
      data[:channel].url = data[:url].dup
      handle(:channel_url, data)
    when ERR_NOSUCHNICK
      data[:target] = argv[1]
      data[:message] = argv[2]
      handle(:nosuchtarget, data)
      if (user = @server.get_user(data[:target]))
        @server.delete_user(user)
      end
    when ERR_NOSUCHCHANNEL
      data[:target] = argv[1]
      data[:message] = argv[2]
      handle(:nosuchtarget, data)
      if (channel = @server.get_channel(data[:target]))
        @server.delete_channel(channel)
      end
    else
      warning "Unknown message #{serverstring.inspect}"
      handle(:unknown, data)
    end
    return # We've processed the numeric reply
  end

  # Otherwise, the command should be a single word
  case command.to_sym
  when :PING
    data[:pingid] = argv[0]
    handle(:ping, data)
  when :PONG
    data[:pingid] = argv[0]
    handle(:pong, data)
  when :PRIVMSG
    # you can either bind to 'PRIVMSG', to get every one and
    # parse it yourself, or you can bind to 'MSG', 'PUBLIC',
    # etc and get it all nicely split up for you.

    begin
      data[:target] = @server.user_or_channel(argv[0])
    rescue
      # The previous may fail e.g. when the target is a server or something
      # like that (e.g. $<mask>). In any of these cases, we just use the
      # String as a target
      # FIXME: we probably want to explicitly check for the #<mask> $<mask>
      data[:target] = argv[0]
    end
    data[:message] = argv[1]
    handle(:privmsg, data)

    # Now we split it
    if data[:target].is_a?(Channel)
      handle(:public, data)
    else
      handle(:msg, data)
    end
  when :NOTICE
    begin
      data[:target] = @server.user_or_channel(argv[0])
    rescue
      # The previous may fail e.g. when the target is a server or something
      # like that (e.g. $<mask>). In any of these cases, we just use the
      # String as a target
      # FIXME we probably want to explicitly check for the #<mask> $<mask>
      data[:target] = argv[0]
    end
    data[:message] = argv[1]
    case data[:source]
    when User
      handle(:notice, data)
    else
      # "server notice" (not from user, no one to reply to)
      handle(:snotice, data)
    end
  when :KICK
    data[:channel] = @server.channel(argv[0])
    data[:target] = @server.user(argv[1])
    data[:message] = argv[2]

    @server.delete_user_from_channel(data[:target], data[:channel])
    if data[:target] == @user
      @server.delete_channel(data[:channel])
    end

    handle(:kick, data)
  when :PART
    data[:channel] = @server.channel(argv[0])
    data[:message] = argv[1]

    @server.delete_user_from_channel(data[:source], data[:channel])
    if data[:source] == @user
      @server.delete_channel(data[:channel])
    end

    handle(:part, data)
  when :QUIT
    data[:message] = argv[0]
    data[:was_on] = @server.channels.inject(ChannelList.new) do |list, ch|
      list << ch if ch.has_user?(data[:source])
      list
    end

    @server.delete_user(data[:source])

    handle(:quit, data)
  when :JOIN
    data[:channel] = @server.channel(argv[0])
    data[:channel].add_user(data[:source])

    handle(:join, data)
  when :TOPIC
    data[:channel] = @server.channel(argv[0])
    data[:topic] = Channel::Topic.new(argv[1], data[:source], Time.new)
    data[:channel].topic.replace(data[:topic])

    handle(:changetopic, data)
  when :INVITE
    data[:target] = @server.user(argv[0])
    data[:channel] = @server.channel(argv[1])

    handle(:invite, data)
  when :NICK
    data[:is_on] = @server.channels.inject(ChannelList.new) do |list, ch|
      list << ch if ch.has_user?(data[:source])
      list
    end

    data[:newnick] = argv[0]
    data[:oldnick] = data[:source].nick.dup
    data[:source].nick = data[:newnick]

    debug "#{data[:oldnick]} (now #{data[:newnick]}) was on #{data[:is_on].join(', ')}"

    handle(:nick, data)
  when :MODE
    parse_mode(serverstring, argv, data)
    handle(:mode, data)
  when :ERROR
    data[:message] = argv[1]
    handle(:error, data)
  else
    warning "Unknown message #{serverstring.inspect}"
    handle(:unknown, data)
  end
end
reset() click to toggle source

Clear the server and reset the user

# File lib/rbot/rfc2812.rb, line 983
def reset
  @server.clear
  @user = @server.user('*!*@*')
end

Private Instance Methods

handle(key, data) click to toggle source
key

server event name

data

hash containing data about the event, passed to the proc

call client’s proc for an event, if they set one as a handler

# File lib/rbot/rfc2812.rb, line 1522
def handle(key, data)
  if (@handlers.has_key?(key))
    @handlers[key].call(data)
  end
end
parse_mode(serverstring, argv, data) click to toggle source

RPL_CHANNELMODEIS MODE ([+-]<modes> (<params>)*)* When a MODE message is received by a server, Type C will have parameters too, so we must be able to consume parameters for all but Type D modes

# File lib/rbot/rfc2812.rb, line 1534
def parse_mode(serverstring, argv, data)
  data[:target] = @server.user_or_channel(argv[0])
  data[:modestring] = argv[1..].join(' ')
  # data[:modes] is an array where each element
  # is an array with two elements, the first of which
  # is either :set or :reset, and the second symbol
  # is the mode letter. An optional third element
  # is present e.g. for channel modes that need
  # a parameter
  data[:modes] = []
  case data[:target]
  when User
    # User modes aren't currently handled internally,
    # but we still parse them and delegate to the client
    warning "Unhandled user mode message '#{serverstring}'"
    argv[1..].each do |arg|
      setting = arg[0].chr
      if '+-'.include?(setting)
        setting = setting == '+' ? :set : :reset
        arg[1..].each_byte do |b|
          m = b.chr.intern
          data[:modes] << [setting, m]
        end
      else
        # Although typically User modes don't take an argument,
        # this is not true for all modes on all servers. Since
        # we have no knowledge of which modes take parameters
        # and which don't we just assign it to the last
        # mode. This is not going to do strange things often,
        # as usually User modes are only set one at a time
        warning "Unhandled user mode parameter #{arg} found"
        data[:modes].last << arg
      end
    end
  when Channel
    # array of indices in data[:modes] where parameters
    # are needed
    who_wants_params = []

    modes = argv[1..].dup
    debug modes
    getting_args = false
    while (arg = modes.shift)
      debug arg
      if getting_args
        # getting args for previously set modes
        idx = who_wants_params.shift
        if idx.nil?
          warning "Oops, problems parsing #{serverstring.inspect}"
          break
        end
        data[:modes][idx] << arg
        getting_args = false if who_wants_params.empty?
      else
        debug @server.supports[:chanmodes]
        setting = :set
        arg.each_byte do |c|
          m = c.chr.intern
          case m
          when :+
            setting = :set
          when :-
            setting = :reset
          else
            data[:modes] << [setting, m]
            case m
            when *@server.supports[:chanmodes][:typea]
              who_wants_params << data[:modes].length - 1
            when *@server.supports[:chanmodes][:typeb]
              who_wants_params << data[:modes].length - 1
            when *@server.supports[:chanmodes][:typec]
              if setting == :set
                who_wants_params << data[:modes].length - 1
              end
            when *@server.supports[:chanmodes][:typed]
              # Nothing to do
            when *@server.supports[:prefix][:modes]
              who_wants_params << data[:modes].length - 1
            else
              warning "Ignoring unknown mode #{m} in #{serverstring.inspect}"
              data[:modes].pop
            end
          end
        end
        getting_args = true unless who_wants_params.empty?
      end
    end
    unless who_wants_params.empty?
      warning "Unhandled malformed modeline #{data[:modestring]} (unexpected empty arguments)"
      return
    end

    data[:modes].each do |mode|
      set, key, val = mode
      if val
        data[:target].mode[key].send(set, val)
      else
        data[:target].mode[key].send(set)
      end
    end
  else
    warning "Ignoring #{data[:modestring]} for unrecognized target #{argv[0]} (#{data[:target].inspect})"
  end
end