tp-blather 0.8.2

data/lib/blather/stream/features/resource.rb

@@ -0,0 +1,63 @@
+module Blather
+class Stream
+
+  # @private
+  class Resource < Features
+    BIND_NS = 'urn:ietf:params:xml:ns:xmpp-bind'.freeze
+    register BIND_NS
+
+    def initialize(stream, succeed, fail)
+      super
+      @jid = stream.jid
+    end
+
+    def receive_data(stanza)
+      @node = stanza
+      case stanza.element_name
+      when 'bind' then  bind
+      when 'iq'   then  result
+      else              fail!(UnknownResponse.new(@node))
+      end
+    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
+
+      response << (binder = XMPPNode.new('bind', response.document))
+      binder.namespace = BIND_NS
+
+      if @jid.resource
+        binder << (resource = XMPPNode.new('resource', binder.document))
+        resource.content = @jid.resource
+      end
+
+      @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
+      if @node[:type] == 'error'
+        fail! StanzaError.import(@node)
+        return
+      end
+
+      # ensure this is a response to our original request
+      if @id == @node['id']
+        @stream.jid = JID.new @node.find_first('bind_ns:bind/bind_ns:jid', :bind_ns => BIND_NS).content
+        succeed!
+      else
+        fail!("BIND result ID mismatch. Expected: #{@id}. Received: #{@node['id']}")
+      end
+    end
+  end #Resource
+
+end #Stream
+end #Blather

data/lib/blather/stream/features/sasl.rb

@@ -0,0 +1,190 @@
+module Blather
+class Stream
+
+  # @private
+  class SASL < Features
+    class UnknownMechanism < BlatherError
+      register :sasl_unknown_mechanism
+    end
+
+    MECHANISMS = %w[
+      digest-md5
+      plain
+      anonymous
+    ].freeze
+
+    SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze
+    register SASL_NS
+
+    def initialize(stream, succeed, fail)
+      super
+      @jid = @stream.jid
+      @pass = @stream.password
+      @mechanisms = []
+    end
+
+    def receive_data(stanza)
+      @node = stanza
+      case stanza.element_name
+      when 'mechanisms'
+        available_mechanisms = stanza.children.map { |m| m.content.downcase }
+        @mechanisms = MECHANISMS.select { |m| available_mechanisms.include? m }
+        next!
+      when 'failure'
+        next!
+      when 'success'
+        @stream.start
+      else
+        if self.respond_to?(stanza.element_name)
+          self.__send__(stanza.element_name)
+        else
+          fail! UnknownResponse.new(stanza)
+        end
+      end
+    end
+
+  protected
+    def next!
+      if @jid.node == ''
+        process_anonymous
+      else
+        @idx = @idx ? @idx+1 : 0
+        authenticate_with @mechanisms[@idx]
+      end
+    end
+
+    def process_anonymous
+      if @mechanisms.include?('anonymous')
+        authenticate_with 'anonymous'
+      else
+        fail! BlatherError.new('The server does not support ANONYMOUS login. You must provide a node in the JID')
+      end
+    end
+
+    def authenticate_with(method)
+      method = case method
+      when 'digest-md5' then  DigestMD5
+      when 'plain'      then  Plain
+      when 'anonymous'  then  Anonymous
+      when nil          then  fail!(SASLError.import(@node))
+      else                    next!
+      end
+
+      if method.is_a?(Module)
+        extend method
+        authenticate
+      end
+    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'
+      node.content = content if content
+      node.namespace = SASL_NS
+      node[:mechanism] = mechanism
+      node
+    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
+        Blather.log "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.namespace = 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) }
+
+          Blather.log "CHALLENGE RESPONSE: #{@response.inspect}"
+          Blather.log "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
+
+    # @private
+    module Plain
+      def authenticate
+        @stream.send auth_node('PLAIN', b64("#{@jid.stripped}\x00#{@jid.node}\x00#{@pass}"))
+      end
+    end #Plain
+
+    # @private
+    module Anonymous
+      def authenticate
+        @stream.send auth_node('ANONYMOUS')
+      end
+    end #Anonymous
+  end #SASL
+
+end #Stream
+end

data/lib/blather/stream/features/session.rb

@@ -0,0 +1,45 @@
+module Blather
+class Stream
+
+  # @private
+  class Session < Features
+    SESSION_NS = 'urn:ietf:params:xml:ns:xmpp-session'.freeze
+    register SESSION_NS
+
+    def initialize(stream, succeed, fail)
+      super
+      @to = @stream.jid.domain
+    end
+
+    def receive_data(stanza)
+      @node = stanza
+      case stanza.element_name
+      when 'session'  then  session
+      when 'iq'       then  check_response
+      else                  fail!(UnknownResponse.new(stanza))
+      end
+    end
+
+  private
+    def check_response
+      if @node[:type] == 'result'
+        succeed!
+      else
+        fail!(StanzaError.import(@node))
+      end
+    end
+
+    ##
+    # Send a start session command
+    def session
+      response = Stanza::Iq.new :set
+      response.to = @to
+      response << (sess = XMPPNode.new('session', response.document))
+      sess.namespace = SESSION_NS
+
+      @stream.send response
+    end
+  end
+
+end
+end

data/lib/blather/stream/features/tls.rb

@@ -0,0 +1,29 @@
+module Blather
+class Stream
+
+  # @private
+  class TLS < Features
+    class TLSFailure < BlatherError
+      register :tls_failure
+    end
+
+    TLS_NS = 'urn:ietf:params:xml:ns:xmpp-tls'.freeze
+    register TLS_NS
+
+    def receive_data(stanza)
+      case stanza.element_name
+      when 'starttls'
+        @stream.send "<starttls xmlns='#{TLS_NS}'/>"
+      when 'proceed'
+        @stream.start_tls(:verify_peer => true)
+        @stream.start
+#        succeed!
+      else
+        fail! TLSFailure.new
+      end
+    end
+
+  end #TLS
+
+end #Stream
+end #Blather

data/lib/blather/stream/parser.rb

@@ -0,0 +1,102 @@
+module Blather
+class Stream
+
+  # @private
+  class Parser < Nokogiri::XML::SAX::Document
+    NS_TO_IGNORE = %w[jabber:client jabber:component:accept]
+
+    @@debug = false
+    def self.debug; @@debug; end
+    def self.debug=(debug); @@debug = debug; end
+
+    def initialize(receiver)
+      @receiver = receiver
+      @current = nil
+      @namespaces = {}
+      @namespace_definitions = []
+      @parser = Nokogiri::XML::SAX::PushParser.new self
+      @parser.options = Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOENT
+    end
+
+    def receive_data(string)
+      Blather.log "PARSING: (#{string})" if @@debug
+      @parser << string
+      self
+    end
+    alias_method :<<, :receive_data
+
+    def start_element_namespace(elem, attrs, prefix, uri, namespaces)
+      Blather.log "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :uri => uri, :ns => namespaces}.inspect})" if @@debug
+
+      args = [elem]
+      args << @current.document if @current
+      node = XMPPNode.new *args
+      node.document.root = node unless @current
+
+      attrs.each do |attr|
+        node[attr.localname] = attr.value
+      end
+
+      ns_keys = namespaces.map { |pre, href| pre }
+      namespaces.delete_if { |pre, href| NS_TO_IGNORE.include? href }
+      @namespace_definitions.push []
+      namespaces.each do |pre, href|
+        next if @namespace_definitions.flatten.include?(@namespaces[[pre, href]])
+        ns = node.add_namespace(pre, href)
+        @namespaces[[pre, href]] ||= ns
+      end
+      @namespaces[[prefix, uri]] ||= node.add_namespace(prefix, uri) if prefix && !ns_keys.include?(prefix)
+      node.namespace = @namespaces[[prefix, uri]]
+
+      unless @receiver.stopped?
+        @current << node if @current
+        @current = node
+      end
+
+      deliver(node) if elem == 'stream'
+
+      # $stderr.puts "\n\n"
+      # $stderr.puts [elem, attrs, prefix, uri, namespaces].inspect
+      # $stderr.puts @namespaces.inspect
+      # $stderr.puts [@namespaces[[prefix, uri]].prefix, @namespaces[[prefix, uri]].href].inspect if @namespaces[[prefix, uri]]
+      # $stderr.puts node.inspect
+      # $stderr.puts node.document.to_s.gsub(/\n\s*/,'')
+    end
+
+    def end_element_namespace(elem, prefix, uri)
+      Blather.log "END ELEM: #{{:elem => elem, :prefix => prefix, :uri => uri}.inspect}" if @@debug
+
+      if elem == 'stream'
+        node = XMPPNode.new('end')
+        node.namespace = {prefix => uri}
+        deliver node
+      elsif @current.parent != @current.document
+        @namespace_definitions.pop
+        @current = @current.parent
+      else
+        deliver @current
+      end
+    end
+
+    def characters(chars = '')
+      Blather.log "CHARS: #{chars}" if @@debug
+      @current << Nokogiri::XML::Text.new(chars, @current.document) if @current
+    end
+
+    def warning(msg)
+      Blather.log "PARSE WARNING: #{msg}" if @@debug
+    end
+
+    def error(msg)
+      raise ParseError.new(msg)
+    end
+
+  private
+    def deliver(node)
+      @current, @namespaces, @namespace_definitions = nil, {}, []
+      @receiver.receive node
+    end
+  end #Parser
+
+end #Stream
+end #Blather

data/lib/blather/version.rb

@@ -0,0 +1,3 @@
+module Blather
+  VERSION = '0.8.2'
+end

data/lib/blather/xmpp_node.rb

@@ -0,0 +1,94 @@
+module Blather
+
+  # Base XML Node
+  # All XML classes subclass XMPPNode it allows the addition of helpers
+  class XMPPNode < Niceogiri::XML::Node
+    # @private
+    BASE_NAMES = %w[presence message iq].freeze
+
+    # @private
+    @@registrations = {}
+
+    class_attribute :registered_ns, :registered_name
+
+    # Register a new stanza class to a name and/or namespace
+    #
+    # This registers a namespace that is used when looking
+    # up the class name of the object to instantiate when a new
+    # stanza is received
+    #
+    # @param [#to_s] name the name of the node
+    # @param [String, nil] ns the namespace the node belongs to
+    def self.register(name, ns = nil)
+      self.registered_name = name.to_s
+      self.registered_ns = ns
+      @@registrations[[self.registered_name, self.registered_ns]] = self
+    end
+
+    # Find the class to use given the name and namespace of a stanza
+    #
+    # @param [#to_s] name the name to lookup
+    # @param [String, nil] xmlns the namespace the node belongs to
+    # @return [Class, nil] the class appropriate for the name/ns combination
+    def self.class_from_registration(name, ns = nil)
+      @@registrations[[name.to_s, ns]]
+    end
+
+    # Import an XML::Node to the appropriate class
+    #
+    # Looks up the class the node should be then creates it based on the
+    # elements of the XML::Node
+    # @param [XML::Node] node the node to import
+    # @return the appropriate object based on the node name and namespace
+    def self.import(node, *decorators)
+      ns = (node.namespace.href if node.namespace)
+      klass = class_from_registration(node.element_name, ns)
+      if klass && klass != self
+        klass.import(node, *decorators)
+      else
+        new(node.element_name).decorate(*decorators).inherit(node)
+      end
+    end
+
+    # Parse a string as XML and import to the appropriate class
+    #
+    # @param [String] string the string to parse
+    # @return the appropriate object based on the node name and namespace
+    def self.parse(string)
+      import Nokogiri::XML(string).root
+    end
+
+    # Create a new Node object
+    #
+    # @param [String, nil] name the element name
+    # @param [XML::Document, nil] doc the document to attach the node to. If
+    # not provided one will be created
+    # @return a new object with the registered name and namespace
+    def self.new(name = registered_name, doc = nil)
+      super name, doc, BASE_NAMES.include?(name.to_s) ? nil : self.registered_ns
+    end
+
+    def self.decorator_modules
+      [self::InstanceMethods]
+    end
+
+    def decorate(*decorators)
+      decorators.each do |decorator|
+        decorator.decorator_modules.each do |mod|
+          extend mod
+        end
+
+        @handler_hierarchy.unshift decorator.handler_hierarchy.first
+      end
+      self
+    end
+
+    # Turn the object into a proper stanza
+    #
+    # @return a stanza object
+    def to_stanza
+      self.class.import self
+    end
+  end  # XMPPNode
+
+end  # Blather