sprsquish-blather 0.3.4 → 0.4.0

data/lib/blather/stream/{sasl.rb → features/sasl.rb}

@@ -1,64 +1,71 @@
 module Blather # :nodoc:
 class Stream # :nodoc:
 
-  class SASL < StreamHandler # :nodoc:
+  class SASL < Features # :nodoc:
     class UnknownMechanism < BlatherError
-      handler_heirarchy ||= []
-      handler_heirarchy << :unknown_mechanism
+      register :sasl_unknown_mechanism
     end
 
     SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze
+    register SASL_NS
 
-    def initialize(stream, jid, pass = nil)
-      super stream
-      @jid = jid
-      @pass = pass
-      @mechanism_idx = 0
+    def initialize(stream, succeed, fail)
+      super
+      @jid = @stream.jid
+      @pass = @stream.password
       @mechanisms = []
     end
 
-    def set_mechanism
-      mod = if @jid.node == '' && @mechanisms.find { |m| m.content == 'ANONYMOUS' }
-        Anonymous
+    def receive_data(stanza)
+      @node = stanza
+      case stanza.element_name
+      when 'mechanisms'
+        @mechanisms = stanza.children.map { |m| m.content.downcase }
+        next!
+      when 'failure'
+        next!
+      when 'success'
+        @stream.start
       else
-        case (mechanism = @mechanisms[@mechanism_idx].content)
-        when 'DIGEST-MD5' then DigestMD5
-        when 'PLAIN'      then Plain
-        when 'ANONYMOUS'  then Anonymous
+        if self.respond_to?(stanza.element_name)
+          self.__send__(stanza.element_name)
+        else
+          fail! UnknownResponse.new(stanza)
         end
       end
+    end
 
-      if mod
-        extend mod
-        true
+  protected
+    def next!
+      if @jid.node == ''
+        process_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})")
-        false
+        @idx = @idx ? @idx+1 : 0
+        authenticate_with @mechanisms[@idx]
       end
     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
+    def process_anonymous
+      if @mechanisms.include?('anonymous')
+        authenticate_with 'anonymous'
       else
-        super
+        fail! BlatherError.new('The server does not support ANONYMOUS login. You must provide a node in the JID')
       end
     end
 
-  protected
-    def failure(node = nil)
-      @failure.call SASLError.import(node)
+    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
 
     ##
@@ -70,19 +77,13 @@ class Stream # :nodoc:
     ##
     # Builds a standard auth node
     def auth_node(mechanism, content = nil)
-      node = XMPPNode.new 'auth', content
-      node['xmlns'] = SASL_NS
-      node['mechanism'] = mechanism
+      node = XMPPNode.new 'auth'
+      node.content = content if content
+      node.namespace = 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:
@@ -111,7 +112,7 @@ class Stream # :nodoc:
           key, value = statement.split('=')
           res[key] = value.delete('"') unless key.empty?
         end
-        LOG.debug "CHALLENGE DECODE: #{res.inspect}"
+        Blather.logger.debug "CHALLENGE DECODE: #{res.inspect}"
 
         @nonce ||= res['nonce']
         @realm ||= res['realm']
@@ -129,7 +130,7 @@ class Stream # :nodoc:
       # Send challenge response
       def respond
         node = XMPPNode.new 'response'
-        node['xmlns'] = SASL_NS
+        node.namespace = SASL_NS
 
         unless @initial_response_sent
           @initial_response_sent = true
@@ -146,8 +147,8 @@ class Stream # :nodoc:
           @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}" } * ','}"
+          Blather.logger.debug "CHALLENGE RESPONSE: #{@response.inspect}"
+          Blather.logger.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

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

@@ -0,0 +1,44 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Session < Features # :nodoc:
+    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,28 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class TLS < Features # :nodoc:
+    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
+        @stream.start
+#        succeed!
+      else
+        fail! TLSFailure.new
+      end
+    end
+
+  end #TLS
+
+end #Stream
+end #Blather

data/lib/blather/stream/features.rb

@@ -0,0 +1,53 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Features
+    @@features = {}
+    def self.register(ns)
+      @@features[ns] = self
+    end
+
+    def self.from_namespace(ns)
+      @@features[ns]
+    end
+
+    def initialize(stream, succeed, fail)
+      @stream = stream
+      @succeed = succeed
+      @fail = fail
+    end
+
+    def receive_data(stanza)
+      if @feature
+        @feature.receive_data stanza
+      else
+        @features ||= stanza
+        next!
+      end
+    end
+
+    def next!
+      @idx = @idx ? @idx+1 : 0
+      if stanza = @features.children[@idx]
+        if stanza.namespaces['xmlns'] && (klass = self.class.from_namespace(stanza.namespaces['xmlns']))
+          @feature = klass.new @stream, proc { next! }, @fail
+          @feature.receive_data stanza
+        else
+          next!
+        end
+      else
+        succeed!
+      end
+    end
+
+    def succeed!
+      @succeed.call
+    end
+
+    def fail!(msg)
+      @fail.call msg
+    end
+  end
+
+end #Stream
+end #Blather

data/lib/blather/stream/parser.rb

@@ -1,9 +1,10 @@
+require 'nokogiri'
+
 module Blather # :nodoc:
 class Stream # :nodoc:
 
   class Parser # :nodoc:
-    STREAM_REGEX = %r{(/)?stream:stream}.freeze
-    ERROR_REGEX = /^<(stream:[a-z]+)/.freeze
+    NS_TO_IGNORE = %w[jabber:client jabber:component:accept]
 
     @@debug = !false
     def self.debug; @@debug; end
@@ -12,70 +13,93 @@ class Stream # :nodoc:
     def initialize(receiver)
       @receiver = receiver
       @current = nil
-      @parser = XML::SaxPushParser.new self
+      @namespaces = {}
+      @namespace_definitions = []
+      @parser = Nokogiri::XML::SAX::PushParser.new self
     end
 
     def receive_data(string)
-      LOG.debug "PARSING: (#{string})" if @@debug
-      @stream_error = string =~ /stream:error/
-      @parser.receive string
+      Blather.logger.debug "PARSING: (#{string})" if @@debug
+      @parser << string
+      self
     end
+    alias_method :<<, :receive_data
 
-    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
-
-      e = XMPPNode.new elem
-      attrs.each { |k,v| e.attributes[k] = v if k }
+    def start_document; end
+    def end_document; end
+    def warning(*args); end
 
-      if @current && (ns = @current.namespaces.find_by_href(uri))
-        e.namespace = ns
-      else
-        e.namespace = {prefix => uri}
-      end
+    def start_element_ns(elem, attrs, prefix, uri, namespaces)
+      Blather.logger.debug "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :uri => uri, :ns => namespaces}.inspect})" if @@debug
 
-      if elem == 'stream' && !@stream_error
-        XML::Document.new.root = e
-        @receiver.receive e
+      args = [elem]
+      args << @current.document if @current
+      node = XMPPNode.new *args
+      node.document.root = node unless @current
 
-      elsif !@receiver.stopped?
-        @current << e  if @current
-        @current = e
+      attrs.each { |k,v| node[k] = v if k }
 
+      if !@receiver.stopped?
+        @current << node if @current
+        @current = node
       end
-    end
 
-    def on_characters(chars = '')
-      LOG.debug "CHARS: #{chars}" if @@debug
-      @current << XML::Node.new_text(chars) if @current
+      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 && !namespaces[prefix]
+      node.namespace = @namespaces[[prefix, uri]]
+
+      deliver(node) if elem == 'stream'
+
+=begin
+      $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
     end
 
-    def on_end_element_ns(elem, prefix, uri)
-      LOG.debug "END ELEM: #{{:elem => elem, :prefix => prefix, :uri => uri}.inspect}" if @@debug
+    def end_element_ns(elem, prefix, uri)
+      Blather.logger.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?
+      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
-        c, @current = @current, nil
-        XML::Document.new.root = c
-        @receiver.receive c
-
+        deliver @current
       end
     end
 
-    def on_error(err)
-      err_klass = case err.level
-      when XML::Error::WARNING
-        ParseWarning
-      when XML::Error::ERROR, XML::Error::FATAL
-        ParseError
-      end
-      raise err_klass.new(err)
+    def characters(chars = '')
+      Blather.logger.debug "CHARS: #{chars}" if @@debug
+      @current << Nokogiri::XML::Text.new(chars, @current.document) if @current
+    end
+
+    def warning(msg)
+      Blather.logger.debug "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
+end #Blather