sprsquish-blather 0.1 → 0.2.3

data/lib/blather/stanza/presence.rb

@@ -0,0 +1,45 @@
+module Blather
+class Stanza
+
+  ##
+  # Base Presence stanza
+  class Presence < Stanza
+    VALID_TYPES = [:unavailable, :subscribe, :subscribed, :unsubscribe, :unsubscribed, :probe, :error]
+
+    register :presence
+
+    ##
+    # Creates a class based on the presence type
+    # either a Status or Subscription object is created based
+    # on the type attribute.
+    # If neither is found it instantiates a Presence object
+    def self.import(node)
+      klass = case node['type']
+      when nil, 'unavailable' then Status
+      when /subscribe/        then Subscription
+      else self
+      end
+      klass.new.inherit(node)
+    end
+
+    ##
+    # Ensure element_name is "presence" for all subclasses
+    def initialize
+      super :presence
+    end
+
+    VALID_TYPES.each do |valid_type|
+      define_method("#{valid_type}?") { self.type == valid_type }
+    end
+
+    ##
+    # Ensures type is one of :unavailable, :subscribe, :subscribed, :unsubscribe, :unsubscribed, :probe or :error
+    def type=(type)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if type && !VALID_TYPES.include?(type.to_sym)
+      super
+    end
+
+  end
+
+end #Stanza
+end

data/lib/blather/stanza.rb

@@ -0,0 +1,101 @@
+module Blather
+  ##
+  # Base XMPP Stanza
+  class Stanza < XMPPNode
+    @@last_id = 0
+    @@handler_list = []
+
+    class_inheritable_array :handler_heirarchy
+
+    ##
+    # Registers a callback onto the callback heirarchy stack
+    #
+    # Thanks to help from ActiveSupport every class
+    # that inherits Stanza can register a callback for itself
+    # which is added to a list and iterated over when looking for
+    # a callback to use
+    def self.register(type, name = nil, ns = nil)
+      @@handler_list << type
+      self.handler_heirarchy ||= []
+      self.handler_heirarchy.unshift type
+
+      name = name || self.name || type
+      super name, ns
+    end
+
+    def self.handler_list
+      @@handler_list
+    end
+
+    ##
+    # Helper method that creates a unique ID for stanzas
+    def self.next_id
+      @@last_id += 1
+      'blather%04x' % @@last_id
+    end
+
+    ##
+    # Creates a new stanza with the same name as the node
+    # then inherits all the node's attributes and properties
+    def self.import(node)
+      self.new(node.element_name).inherit(node)
+    end
+
+    ##
+    # Automatically set the stanza's ID
+    # and attach it to a document so XPath searching works
+    def initialize(name = nil)
+      super
+      XML::Document.new.root = self
+      self.name = name.to_s if name
+      self.id = self.class.next_id
+    end
+
+    ##
+    # Helper method to ask the object if it's an error
+    def error?
+      self.type == :error
+    end
+
+    ##
+    # Copies itself then swaps from and to
+    # then returns the new stanza
+    def reply
+      self.copy(true).reply!
+    end
+
+    ##
+    # Swaps from and to
+    def reply!
+      self.to, self.from = self.from, self.to
+      self
+    end
+
+    attribute_accessor :id, :to_sym => false
+
+    attribute_writer :to, :from
+
+    ##
+    # returns:: JID created from the "to" value of the stanza
+    def to
+      JID.new(attributes[:to]) if attributes[:to]
+    end
+
+    ##
+    # returns:: JID created from the "from" value of the stanza
+    def from
+      JID.new(attributes[:from]) if attributes[:from]
+    end
+
+    attribute_accessor :type
+
+    ##
+    # Transform the stanza into a stanza error
+    # <tt>err_name_or_class</tt> can be the name of the error or the error class to use
+    # <tt>type</tt>, <tt>text</tt>, <tt>extras</tt> are the same as for StanzaError#new
+    def as_error(err_name_or_class, type, text = nil, extras = [])
+      klass = (err_name_or_class.is_a?(Class) ? err_name_or_class : StanzaError.class_from_registration(err_name_or_class))
+      klass.new self, type, text, extras
+    end
+  end
+end

data/lib/blather/stream/client.rb

@@ -0,0 +1,26 @@
+module Blather
+class Stream
+
+  class Client < Stream
+    LANG = 'en'
+    VERSION = '1.0'
+    NAMESPACE = 'jabber:client'
+
+  protected
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@to}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='http://etherx.jabber.org/streams'
+          version='#{VERSION}'
+          xml:lang='#{LANG}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/component.rb

@@ -0,0 +1,34 @@
+module Blather
+class Stream
+
+  class Component < Stream
+    NAMESPACE = 'jabber:component:accept'
+
+    def receive(node) # :nodoc:
+      if node.element_name == 'handshake'
+        @client.stream_started(self)
+      else
+        super
+      end
+
+      if node.element_name == 'stream:stream'
+        send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@pass)}</handshake>")
+      end
+    end
+
+  protected
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@jid}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='http://etherx.jabber.org/streams'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/parser.rb

@@ -0,0 +1,70 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Parser # :nodoc:
+    STREAM_REGEX = %r{(/)?stream:stream}.freeze
+    ERROR_REGEX = /^<(stream:[a-z]+)/.freeze
+
+    @@debug = !false
+    def self.debug; @@debug; end
+    def self.debug=(debug); @@debug = debug; end
+
+    include XML::SaxParser::Callbacks
+
+    def initialize(receiver)
+      @receiver = receiver
+      @current = nil
+      @parser = XML::SaxPushParser.new self
+    end
+
+    def receive_data(string)
+      LOG.debug "PARSING: (#{string})" if @@debug
+      @parser.receive string
+    end
+
+    def on_start_element_ns(elem, attrs, prefix, uri, namespaces)
+      LOG.debug "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :uri => uri, :ns => namespaces}.inspect})" if @@debug
+      elem = "#{"#{prefix}:" if prefix}#{elem}"
+      e = XMPPNode.new elem
+      XML::Namespace.new(e, prefix, uri)
+      attrs.each { |k,v| e.attributes[k] = v if k }
+
+      if elem == 'stream:stream'
+        @receiver.receive e
+
+      elsif !@receiver.stopped?
+        @current << e if @current
+        @current = e
+
+      end
+    end
+
+    def on_characters(chars = '')
+      LOG.debug "CHARS: #{chars}" if @@debug
+      @current << XML::Node.new_text(chars) if @current
+    end
+
+    def on_end_element_ns(elem, prefix, uri)
+      LOG.debug "END ELEM: #{{:elem => elem, :prefix => prefix, :uri => uri}.inspect}" if @@debug
+
+      if !@current && "#{prefix}:#{elem}" =~ STREAM_REGEX
+        @receiver.receive XMPPNode.new('stream:end')
+
+      elsif @current.parent?
+        @current = @current.parent
+
+      else
+        c, @current = @current, nil
+        XML::Document.new.root = c
+        @receiver.receive c
+
+      end
+    end
+
+    def on_error(msg)
+      raise ParseError.new(msg.to_s)
+    end
+  end #Parser
+
+end #Stream
+end #Blather

data/lib/blather/stream/resource.rb

@@ -0,0 +1,48 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Resource < StreamHandler # :nodoc:
+    def initialize(stream, jid)
+      super stream
+      @jid = jid
+    end
+
+  private
+    ##
+    # Respond to the bind request
+    # If @jid has a resource set already request it from the server
+    def bind
+      response = Stanza::Iq.new :set
+      @id = response.id
+
+      binder = XMPPNode.new('bind')
+      binder.namespace = 'urn:ietf:params:xml:ns:xmpp-bind'
+
+      binder << XMPPNode.new('resource', @jid.resource) if @jid.resource
+
+      response << binder
+      @stream.send response
+    end
+
+    ##
+    # Process the result from the server
+    # Sets the sends the JID (now bound to a resource)
+    # back to the stream
+    def result
+      LOG.debug "RESOURE NODE #{@node}"
+      # ensure this is a response to our original request
+      if @id == @node['id']
+        @jid = JID.new @node.find_first('bind/jid').content
+        success @jid
+      end
+    end
+
+    ##
+    # Server returned an error
+    def error
+      failure StanzaError.import(@node)
+    end
+  end #Resource
+
+end #Stream
+end #Blather

data/lib/blather/stream/sasl.rb

@@ -0,0 +1,173 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class SASL < StreamHandler # :nodoc:
+    class UnknownMechanism < BlatherError
+      handler_heirarchy ||= []
+      handler_heirarchy << :unknown_mechanism
+    end
+
+    SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze
+
+    def initialize(stream, jid, pass = nil)
+      super stream
+      @jid = jid
+      @pass = pass
+      @mechanism_idx = 0
+      @mechanisms = []
+    end
+
+    def set_mechanism
+      mod = case (mechanism = @mechanisms[@mechanism_idx].content)
+      when 'DIGEST-MD5' then DigestMD5
+      when 'PLAIN'      then Plain
+      when 'ANONYMOUS'  then Anonymous
+      else
+        # Send a failure node and kill the stream
+        @stream.send "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><invalid-mechanism/></failure>"
+        @failure.call UnknownMechanism.new("Unknown SASL mechanism (#{mechanism})")
+        return false
+      end
+
+      extend mod
+      true
+    end
+
+    ##
+    # Handle incoming nodes
+    # Cycle through possible mechanisms until we either
+    # run out of them or none work
+    def handle(node)
+      if node.element_name == 'failure'
+        if @mechanisms[@mechanism_idx += 1]
+          set_mechanism
+          authenticate
+        else
+          failure node
+        end
+      else
+        super
+      end
+    end
+
+  protected
+    def failure(node = nil)
+      @failure.call SASLError.import(node)
+    end
+
+    ##
+    # Base64 Encoder
+    def b64(str)
+      [str].pack('m').gsub(/\s/,'')
+    end
+
+    ##
+    # Builds a standard auth node
+    def auth_node(mechanism, content = nil)
+      node = XMPPNode.new 'auth', content
+      node['xmlns'] = SASL_NS
+      node['mechanism'] = mechanism
+      node
+    end
+
+    ##
+    # Respond to the <mechanisms> node sent by the server
+    def mechanisms
+      @mechanisms = @node.children
+      authenticate if set_mechanism
+    end
+
+    ##
+    # Digest MD5 authentication
+    module DigestMD5 # :nodoc:
+      ##
+      # Lets the server know we're going to try DigestMD5 authentication
+      def authenticate
+        @stream.send auth_node('DIGEST-MD5')
+      end
+
+      ##
+      # Receive the challenge command.
+      def challenge
+        decode_challenge
+        respond
+      end
+
+    private
+      ##
+      # Decodes digest strings 'foo=bar,baz="faz"'
+      # into {'foo' => 'bar', 'baz' => 'faz'}
+      def decode_challenge
+        text = @node.content.unpack('m').first
+        res = {}
+
+        text.split(',').each do |statement|
+          key, value = statement.split('=')
+          res[key] = value.delete('"') unless key.empty?
+        end
+        LOG.debug "CHALLENGE DECODE: #{res.inspect}"
+
+        @nonce ||= res['nonce']
+        @realm ||= res['realm']
+      end
+
+      ##
+      # Builds the properly encoded challenge response
+      def generate_response
+        a1 = "#{d("#{@response[:username]}:#{@response[:realm]}:#{@pass}")}:#{@response[:nonce]}:#{@response[:cnonce]}"
+        a2 = "AUTHENTICATE:#{@response[:'digest-uri']}"
+        h("#{h(a1)}:#{@response[:nonce]}:#{@response[:nc]}:#{@response[:cnonce]}:#{@response[:qop]}:#{h(a2)}")
+      end
+
+      ##
+      # Send challenge response
+      def respond
+        node = XMPPNode.new 'response'
+        node['xmlns'] = SASL_NS
+
+        unless @initial_response_sent
+          @initial_response_sent = true
+          @response = {
+            :nonce        => @nonce,
+            :charset      => 'utf-8',
+            :username     => @jid.node,
+            :realm        => @realm || @jid.domain,
+            :cnonce       => h(Time.new.to_f.to_s),
+            :nc           => '00000001',
+            :qop          => 'auth',
+            :'digest-uri' => "xmpp/#{@jid.domain}",
+          }
+          @response[:response] = generate_response
+          @response.each { |k,v| @response[k] = "\"#{v}\"" unless [:nc, :qop, :response, :charset].include?(k) }
+
+          LOG.debug "CHALLENGE RESPOSNE: #{@response.inspect}"
+          LOG.debug "CH RESP TXT: #{@response.map { |k,v| "#{k}=#{v}" } * ','}"
+
+          # order is to simplify testing
+          # Ruby 1.9 eliminates the need for this with ordered hashes
+          order = [:nonce, :charset, :username, :realm, :cnonce, :nc, :qop, :'digest-uri', :response]
+          node.content = b64(order.map { |k| v = @response[k]; "#{k}=#{v}" } * ',')
+        end
+
+        @stream.send node
+      end
+
+      def d(s); Digest::MD5.digest(s);    end
+      def h(s); Digest::MD5.hexdigest(s); end
+    end #DigestMD5
+
+    module Plain # :nodoc:
+      def authenticate
+        @stream.send auth_node('PLAIN', b64("#{@jid.stripped}\x00#{@jid.node}\x00#{@pass}"))
+      end
+    end #Plain
+
+    module Anonymous # :nodoc:
+      def authenticate
+        @stream.send auth_node('ANONYMOUS', b64(@jid.node))
+      end
+    end #Anonymous
+  end #SASL
+
+end #Stream
+end

data/lib/blather/stream/session.rb

@@ -0,0 +1,36 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Session < StreamHandler # :nodoc:
+    def initialize(stream, to)
+      super stream
+      @to = to
+    end
+
+  private
+    ##
+    # Send a start session command
+    def session
+      response = Stanza::Iq.new :set
+      response.to = @to
+      sess = XMPPNode.new 'session'
+      sess['xmlns'] = 'urn:ietf:params:xml:ns:xmpp-session'
+      response << sess
+      @stream.send response
+    end
+
+    ##
+    # The server should respond with a <result> node if all is well
+    def result
+      success
+    end
+
+    ##
+    # Server returned an error.
+    def error
+      failure StanzaError.import(@node)
+    end
+  end
+
+end
+end

data/lib/blather/stream/stream_handler.rb

@@ -0,0 +1,39 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class StreamHandler # :nodoc:
+    def on_success(&block); @success = block; end
+    def on_failure(&block); @failure = block; end
+
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def handle(node)
+      @node = node
+      method = @node.element_name == 'iq' ? @node['type'] : @node.element_name
+      if self.respond_to?(method, true)
+        self.__send__ method
+      else
+        @failure.call UnknownResponse.new(@node)
+      end
+    end
+
+  protected
+    ##
+    # Handle error response from the server
+    def error
+      failure
+    end
+
+    def success(message_back = nil)
+      @success.call message_back
+    end
+
+    def failure(err = nil)
+      @failure.call err
+    end
+  end #StreamHandler
+
+end #Stream
+end #Blather

data/lib/blather/stream/tls.rb

@@ -0,0 +1,33 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  # TLS negotiation invovles 3 node types:
+  #   * starttls  -- Server asking for TLS to be started
+  #   * proceed   -- Server saying it's ready for a TLS connection to be started
+  #   * failure   -- Failed TLS negotiation. Failure results in a closed connection.
+  #                  so there's no message to pass back to the tream
+  class TLS < StreamHandler # :nodoc:
+  private
+    ##
+    # After receiving <starttls> from the server send one
+    # back to let it know we're ready to start TLS
+    def starttls
+      @stream.send "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"
+    end
+
+    ##
+    # Server's ready for TLS, so start it up
+    def proceed
+      @stream.start_tls
+      success
+    end
+
+    ##
+    # Negotiations failed
+    def failure
+      super StreamError::TLSFailure.new
+    end
+  end #TLS
+
+end #Stream
+end #Blather