camper_van 0.0.1

data/lib/camper_van/ircd.rb

@@ -0,0 +1,340 @@
+require "socket" # for gethostname
+
+module CamperVan
+
+  # the IRCD is the server that IRC clients connect to. It handles:
+  #
+  # * irc client registration and validation against campfire
+  # * mapping irc commands to internal Commands
+  # * proxying irc commands to campfire channels
+  class IRCD
+
+    # The IRC client
+    attr_reader :client
+
+    # Registration information for campfire authentication,
+    # comes from the PASS command from the irc client
+    attr_reader :subdomain, :api_key
+
+    # Information for the connected user
+    attr_reader :nick, :user, :host
+
+    # A Hash of connected CampfireChannels
+    attr_reader :channels
+
+    # Whether or not this server is actively sending/receiving data.
+    # Set to false when shutting down so extra commands are ignored.
+    attr_reader :active
+
+    MOTD = <<-motd
+      Welcome to CamperVan.
+      To see what campfire rooms are available to the
+      configured subdomain and api key, use the LIST command.
+    motd
+
+    include CommandDefinition # handle :command { ... }
+    include CommandParser     # parses IRC commands
+    include ServerReply       # IRC reply helpers
+    include Utils             # irc translation helpers
+    include Logger            # logging helper
+
+    # Public: initialize an IRC server connection
+    #
+    # client - the EM connection representing the IRC client
+    def initialize(client)
+      @client = client
+      @active = true
+      @channels = {}
+    end
+
+    # The campfire client
+    #
+    # Returns the existing or initializes a new instance of a campfire
+    # client using the configured subdomain and API key.
+    def campfire
+      @campfire ||= Firering::Connection.new(
+        "http://#{subdomain}.campfirenow.com"
+      ) do |c|
+        c.token = api_key
+        c.logger = CamperVan.logger
+      end
+    end
+
+    # Handler for when a client sends an IRC command
+    def receive_line(line)
+      if @active
+        cmd = parse(line)
+        handle cmd
+      end
+    rescue HandlerMissing
+      logger.info "ignoring irc command #{cmd.inspect}: no handler"
+    end
+
+    # Send a line back to the irc client
+    def send_line(line)
+      client.send_line line if @active
+    end
+
+    # Shuts down this connection to the server
+    def shutdown
+      @active = false
+      client.close_connection
+    end
+
+    # IRC registration sequence:
+    #
+    #   PASS <password> (may not be sent!)
+    #   NICK <nickname>
+    #   USER <user info>
+    #
+
+    # PASS command handler
+    handle :pass do |args|
+      if args.empty?
+        numeric_reply :err_needmoreparams, ":must specify a password: subdomain:api_key"
+        shutdown
+      else
+        @subdomain, @api_key = *args.first.split(":")
+      end
+    end
+
+    # NICK command handler
+    #
+    # As a part of the registration sequence, sets the nickname.
+    # If sent after the client is registered, responds with an IRC
+    # error, as nick changes with campfire are disallowed (TODO)
+    handle :nick do |args|
+      if args.empty?
+        numeric_reply :err_nonicknamegiven, ":no nickname given"
+      else
+        if @nick
+          # TODO error
+        else
+          @nick = args.first
+        end
+      end
+    end
+
+    # USER command handler
+    #
+    # Final part of the registration sequence.
+    # If registration is successful, sends a welcome reply sequence.
+    handle :user do |args|
+      if args.size < 4
+        numeric_reply :err_needmoreparams, "Need more params"
+      else
+        @user = args.first
+        # grab the remote IP address for the client
+        @host = client.remote_ip
+
+        unless @api_key
+          command_reply :notice, "AUTH", "*** must specify campfire API key as password ***"
+          shutdown
+          return
+        end
+
+        successful_registration
+      end
+    end
+
+    # PING command handler.
+    #
+    # Responds with a PONG
+    handle :ping do |args|
+      command_reply :pong, *args
+    end
+
+    # LIST command handler
+    #
+    # Sends the list of available campfire channels to the client.
+    handle :list do |args|
+      # hooray async code: have to do gymnastics to make this appear
+      # sequential
+      campfire.rooms do |rooms|
+        sent = 0
+        rooms.each do |room|
+          name = "#" + irc_name(room.name)
+          topic = room.topic
+          room.users do |users|
+            numeric_reply :rpl_list, name, users.size, topic
+            sent += 1
+            if sent == rooms.size
+              numeric_reply :rpl_listend, "End of list"
+            end
+          end
+        end
+      end
+    end
+
+    handle :who do |args|
+      if channel = channels[args.first]
+        channel.list_users
+      else
+        if args.empty?
+          numeric_reply :rpl_endofwho, "End of WHO list"
+        else
+          numeric_reply :rpl_endofwho, args.first, "End of WHO list"
+        end
+      end
+    end
+
+    handle :join do |args|
+      args.each do |channel|
+        join_channel channel
+      end
+    end
+
+    handle :part do |args|
+      name = args.first
+      if channel = channels[name]
+        channel.part
+      else
+        numeric_reply :err_notonchannel, "You're not on that channel"
+      end
+    end
+
+    handle :topic do |args|
+      name, new_topic = *args
+      if channel = channels[name]
+        if new_topic
+          channel.set_topic new_topic
+        else
+          channel.current_topic
+        end
+      else
+        # TODO topic error
+      end
+    end
+
+    handle :privmsg do |args|
+      name, msg = *args
+      if channel = channels[name]
+        channel.privmsg msg
+      else
+        numeric_reply :err_nonicknamegiven, name, "No such nick/channel"
+      end
+    end
+
+    handle :mode do |args|
+      if channel = channels[args.shift]
+
+        if mode = args.first
+          if mode =~ /^[+-][si]$/
+            channel.set_mode mode
+          else
+            mode = mode.gsub(/\W/,'')
+            numeric_reply :err_unknownmode, mode, "Unknown mode #{mode}"
+          end
+        else
+          channel.current_mode
+        end
+
+      else
+        # no error message for this situation, so ignore it silently
+      end
+    end
+
+    handle :away do |args|
+      # ignore silently, there's no campfire API for this
+    end
+
+    handle :quit do |args|
+      channels.values.each do |channel|
+        channel.part
+      end
+      shutdown
+    end
+
+    # Completes a successful registration with the appropriate responses
+    def successful_registration
+      check_campfire_authentication do
+        check_nick_matches_authenticated_user
+        send_welcome
+        send_luser_info
+        send_motd
+      end
+    end
+
+    # Checks that the campfire authentication is successful.
+    #
+    # callback - a block to call if successful.
+    #
+    # Yields to the callback on success (async)
+    #
+    # If it fails, it replies with an error to the client and
+    # disconnects.
+    def check_campfire_authentication(&callback)
+      # invalid user only returns a nil result!
+      campfire.user("me") do |user|
+        if user.name
+          yield
+        else
+          command_reply :notice, "AUTH", "could not connect to campfire: invalid API key"
+          shutdown
+        end
+      end
+    rescue Firering::Connection::HTTPError => e
+      command_reply :notice, "AUTH", "could not connect to campfire: #{e.message}"
+      shutdown
+    end
+
+    # Check to see that the nick as provided during the registration
+    # process matches the authenticated campfire user. If the nicks don't
+    # match, send a nick change to the connected client.
+    def check_nick_matches_authenticated_user
+      campfire.user("me") do |user|
+        name = irc_name user.name
+        if name != nick
+          user_reply :nick, name
+          @nick = name
+        end
+      end
+    end
+
+    def send_welcome
+      hostname = Socket.gethostname
+      numeric_reply :rpl_welcome, "Welcome to CamperVan, #{nick}!#{user}@#{host}"
+      numeric_reply :rpl_yourhost, "Your host is #{hostname}, " +
+        "running CamperVan version #{CamperVan::VERSION}"
+      # using Time.now instead of a global start time since, well, this
+      # particular instance really did just start right now. Give or
+      # take a few seconds.
+      numeric_reply :rpl_created, "This server was created #{Time.now}"
+      numeric_reply :rpl_myinfo, hostname, CamperVan::VERSION,
+        # channel modes: invite-only, secret
+        "is",
+        # user modes: away
+        "a"
+    end
+
+    def send_luser_info
+      numeric_reply :rpl_luserclient, "There is 1 user on 1 channel"
+      numeric_reply :rpl_luserop, 0, "IRC Operators online"
+      numeric_reply :rpl_luserchannels, 0, "channels formed"
+      numeric_reply :rpl_myinfo, "I have 1 client and 0 servers"
+    end
+
+    def send_motd
+      numeric_reply :rpl_motdstart, ":- MOTD for camper_van -"
+      MOTD.split("\n").each do |line|
+        numeric_reply :rpl_motd, ":- #{line.strip}"
+      end
+      numeric_reply :rpl_endofmotd, "END of MOTD"
+    end
+
+    def join_channel(name)
+      campfire.rooms do |rooms|
+        if room = rooms.detect { |r| "#" + irc_name(r.name) == name }
+          channel = Channel.new(name, self, room)
+          if channel.join
+            channels[name] = channel
+          end
+        else
+          numeric_reply :err_nosuchchannel, name, "No such campfire room!"
+        end
+      end
+    end
+
+  end
+end
+

data/lib/camper_van/logger.rb

@@ -0,0 +1,10 @@
+module CamperVan
+  module Logger
+    # Public: the logger for this class
+    #
+    # Returns a Logging::Logger instance
+    def logger
+      CamperVan.logger
+    end
+  end
+end

data/lib/camper_van/server.rb

@@ -0,0 +1,105 @@
+module CamperVan
+
+  # The core EventMachine server instance that listens for IRC
+  # connections and maps them to IRCD instances.
+  module Server
+    # Public: start the server
+    #
+    # bind_address - what address to bind to
+    # port         - what port to listen on
+    # log_options  - an optional hash of additional configuration
+    #                options for the logger (see .initialize_logging)
+    def self.run(bind_address="localhost", port=6667, log_options={})
+
+      initialize_logging log_options
+
+      EM.run do
+        logger = Logging.logger[self.name]
+        logger.info "starting server on #{bind_address}:#{port}"
+        EM.start_server bind_address, port, self
+        trap("INT") do
+          logger.info "SIGINT, shutting down"
+          EM.stop
+        end
+      end
+    end
+
+    # Initialize the logging system
+    #
+    # opts - Hash of logging options
+    #        - :log_level (default :info)
+    #        - :log_to - where to log to (default STDOUT), can be IO or
+    #                    String for log filename
+    def self.initialize_logging(opts={})
+      Logging.consolidate("CamperVan")
+
+      Logging.logger.root.level = opts[:log_level] || :info
+
+      appender = case opts[:log_to]
+      when String
+        Logging.appenders.file(opts[:log_to])
+      when IO
+        Logging.appenders.io(opts[:log_to])
+      when nil
+        Logging.appenders.stdout
+      end
+
+      # YYYY-MM-DDTHH:MM:SS 12345 LEVEL LoggerName : The Log message
+      appender.layout = Logging::Layouts::Pattern.new(:pattern => "%d %5p %5l %c : %m\n")
+
+      Logging.logger.root.add_appenders appender
+    end
+
+    # Using a line-based protocol
+    include EM::Protocols::LineText2
+
+    include Logger
+
+    # Public: returns the instance of the ircd for this connection
+    attr_reader :ircd
+
+    # Public callback once a server connection is established.
+    #
+    # Initializes an IRCD instance for this connection.
+    def post_init(*args)
+      logger.info "got connection from #{remote_ip}"
+
+      # initialize the line-based protocol: IRC is \r\n
+      @lt2_delimiter = "\r\n"
+
+      # start up the IRCD for this connection
+      @ircd = IRCD.new(self)
+    end
+
+    # Public: callback for when a line of the protocol has been
+    # received. Delegates the received line to the ircd instance.
+    #
+    # line - the line received
+    def receive_line(line)
+      logger.debug "irc -> #{line.strip}"
+      ircd.receive_line(line)
+    end
+
+    # Public: send a line to the connected client.
+    #
+    # line - the line to send, sans \r\n delimiter.
+    def send_line(line)
+      logger.debug "irc <- #{line}"
+      send_data line + "\r\n"
+    end
+
+    # Public: callback when a client disconnects
+    def unbind
+      logger.info "closed connection from #{remote_ip}"
+    end
+
+    # Public: return the remote ip address of the connected client
+    #
+    # Returns an IP address string
+    def remote_ip
+      @remote_ip ||= get_peername[4,4].unpack("C4").map { |q| q.to_s }.join(".")
+    end
+
+  end
+
+end

data/lib/camper_van/server_reply.rb

@@ -0,0 +1,94 @@
+module CamperVan
+  module ServerReply
+
+    # not an exhaustive list, just what i'm using
+    NUMERIC_REPLIES = {
+
+      # successful registration / welcome to the network
+      :rpl_welcome            => "001",
+      :rpl_yourhost           => "002",
+      :rpl_created            => "003",
+      :rpl_myinfo             => "004",
+
+      # more welcome messages
+      :rpl_luserclient        => "251",
+      :rpl_luserop            => "252",
+      :rpl_luserchannels      => "254",
+      :rpl_luserme            => "255",
+
+      # MOTD
+      :rpl_motdstart          => "375",
+      :rpl_motd               => "372",
+      :rpl_endofmotd          => "376",
+
+      # MODE
+      :rpl_channelmodeis      => "324",
+
+      # room listing
+      :rpl_list               => "322",
+      :rpl_listend            => "323",
+      :rpl_whoreply           => "352",
+      :rpl_endofwho           => "315",
+
+      # channel joins
+      :rpl_notopic            => "331",
+      :rpl_topic              => "332",
+      :rpl_namereply          => "353",
+      :rpl_endofnames         => "366",
+
+      # errors
+      :err_nosuchnick         => "401", # no privmsgs to nicks allowed
+      :err_nosuchchannel      => "403", # no such channel yo
+
+      :err_nonicknamegiven    => "413",
+
+      :err_notonchannel       => "442",
+
+      :err_needmoreparams     => "461",
+      :err_passwdmismatch     => "464",
+
+      :err_channelisfull      => "471", # room is full
+      :err_unknownmode        => "472",
+      :err_inviteonlychan     => "473", # couldn't join the room, it's locked
+      :err_unavailresource    => "437" # no such room!
+
+    }
+
+    def numeric_reply(code, *args)
+      number = NUMERIC_REPLIES[code]
+      raise ArgumentError, "unknown code #{code}" unless number
+      send_line ":camper_van #{number} #{nick}" << reply_args(args)
+    end
+
+    def command_reply(command, *args)
+      send_line ":camper_van #{command.to_s.upcase}" << reply_args(args)
+    end
+
+    def user_reply(command, *args)
+      send_line ":#{nick}!#{user}@#{host} #{command.to_s.upcase}" << reply_args(args)
+    end
+
+    def campfire_reply(command, username, *args)
+      # TODO instead of @campfire, use user's email address
+      send_line ":#{username}!#{username}@campfire #{command.to_s.upcase}" << reply_args(args)
+    end
+
+    def error_reply(reason)
+      send_line "ERROR :#{reason}"
+    end
+
+    private
+
+    def reply_args(args)
+      reply = ""
+      if args.size > 0
+        if args.last =~ /\s/ && !args.last.start_with?(':')
+          args[-1] = ':' + args.last
+        end
+        reply << " " << args.join(" ")
+      end
+      reply
+    end
+
+  end
+end

data/lib/camper_van/user.rb

@@ -0,0 +1,59 @@
+module CamperVan
+  class User
+
+    # IRC normalization from names
+    include Utils
+
+    # Public: the user's campfire id
+    attr_reader :id
+
+    # Public: the user's campfire name
+    attr_reader :name
+
+    # Public: the user's irc nick
+    attr_reader :nick
+
+    # Public: the user's unix account name for user@host pairs in irc,
+    # mapped from the user's email address
+    attr_reader :account
+
+    # Public: the user's unix server name for user@host pairs in irc,
+    # mapped from the user's email address
+    attr_reader :server
+
+    # Public: whether the user is idle or not. Updated by campfire
+    # Idle/Unidle messages
+    def idle?
+      @idle
+    end
+
+    # Public: set the user's idle state.
+    #
+    # is_idle - true/false
+    attr_writer :idle
+
+    # Public: whether or not the user is an admin
+    def admin?
+      @admin
+    end
+
+    # Public: set the user's admin state
+    #
+    # admin - true/false
+    attr_writer :admin
+
+    # Public: create a new user from a campfire user definition.
+    #
+    # Initializes the user's fields based on the campfire user info.
+    def initialize(user)
+      @id = user.id
+      @name = user.name
+      @account, @server = user.email_address.split("@")
+      @nick = irc_name user.name
+      @idle = false
+      @admin = user.admin
+    end
+
+  end
+end
+

data/lib/camper_van/utils.rb

@@ -0,0 +1,22 @@
+module CamperVan
+  module Utils
+    # TODO make irc-safe substitutions, etc.
+    def irc_name(name)
+      name.gsub('/', '-').
+        gsub(/\W/, ' ').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        gsub(/\s+/, "_").
+        tr("-", "_").
+        downcase
+    end
+
+    def stringify_keys(hash)
+      hash.keys.each do |key|
+        hash[key.to_s] = hash.delete(key)
+      end
+      hash
+    end
+
+  end
+end

data/lib/camper_van/version.rb

@@ -0,0 +1,3 @@
+module CamperVan
+  VERSION = "0.0.1"
+end

data/lib/camper_van.rb

@@ -0,0 +1,28 @@
+require "camper_van/version"
+
+require "eventmachine"
+require "firering"
+require "logging"
+
+module CamperVan
+  require "camper_van/debug_proxy"        # debug proxy
+
+  require "camper_van/utils"              # utility methods
+  require "camper_van/logger"             # logging helper
+  require "camper_van/command_parser"     # irc command parser
+  require "camper_van/command_definition" # command definition and processing
+  require "camper_van/server_reply"       # ircd responses and helpers
+  require "camper_van/user"               # channel/campfire user
+
+  require "camper_van/ircd"               # ircd server
+  require "camper_van/channel"            # campfire room <-> channel bridge
+
+  require "camper_van/server"             # the core campfire EM server
+
+  # Public: return the logger for the module
+  #
+  # Returns a Logging::Logger instance.
+  def self.logger
+    @logger = Logging::Logger[self.name]
+  end
+end