blather 0.2.1 → 0.2.2

data/lib/blather/stream/sasl.rb

@@ -1,66 +1,68 @@
 module Blather # :nodoc:
-module Stream # :nodoc:
+class Stream # :nodoc:
 
-  class SASL # :nodoc:
-    class UnknownMechanism < BlatherError; end
+  class SASL < StreamHandler # :nodoc:
+    class UnknownMechanism < BlatherError
+      handler_heirarchy ||= []
+      handler_heirarchy << :unknown_mechanism
+    end
 
-    SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'
+    SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'.freeze
 
     def initialize(stream, jid, pass = nil)
-      @stream = stream
+      super stream
       @jid = jid
       @pass = pass
-      @callbacks = {}
-      @mechanism = 0
+      @mechanism_idx = 0
       @mechanisms = []
-
-      init_callbacks
-    end
-
-    def init_callbacks
-      @callbacks['mechanisms'] = proc {
-        @mechanisms = @node.children
-        set_mechanism
-        authenticate
-      }
     end
 
     def set_mechanism
-      mod = case (mechanism = @mechanisms[@mechanism].content)
+      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>"
-        raise UnknownMechanism, "Unknown SASL mechanism (#{mechanism})"
+        @failure.call UnknownMechanism.new("Unknown SASL mechanism (#{mechanism})")
+        return false
       end
 
       extend mod
+      true
     end
 
-    def receive(node)
-      @node = node
-      if @node.element_name == 'failure' && @mechanisms[@mechanism += 1]
-        set_mechanism
-        authenticate
+    ##
+    # 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
-        @callbacks[@node.element_name].call if @callbacks[@node.element_name]
+        super
       end
     end
 
-    def success(&callback)
-      @callbacks['success'] = callback
-    end
-
-    def failure(&callback)
-      @callbacks['failure'] = callback
+  protected
+    def failure(node = nil)
+      @failure.call SASLError.import(node)
     end
 
-  protected
+    ##
+    # 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
@@ -68,16 +70,33 @@ module Stream # :nodoc:
       node
     end
 
-    module DigestMD5 # :nodoc:
-      def self.extended(obj)
-        obj.instance_eval { @callbacks['challenge'] = proc { decode_challenge; respond } }
-      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 = {}
@@ -92,12 +111,16 @@ module Stream # :nodoc:
         @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
@@ -121,6 +144,7 @@ module Stream # :nodoc:
           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
@@ -143,7 +167,6 @@ module Stream # :nodoc:
         @stream.send auth_node('ANONYMOUS', b64(@jid.node))
       end
     end #Anonymous
-
   end #SASL
 
 end #Stream

data/lib/blather/stream/session.rb

@@ -1,26 +1,15 @@
 module Blather # :nodoc:
-module Stream # :nodoc:
+class Stream # :nodoc:
 
-  class Session # :nodoc:
+  class Session < StreamHandler # :nodoc:
     def initialize(stream, to)
-      @stream = stream
+      super stream
       @to = to
-      @callbacks = {}
-    end
-
-    def success(&callback)
-      @callbacks[:success] = callback
-    end
-
-    def failure(&callback)
-      @callbacks[:failure] = callback
-    end
-
-    def receive(node)
-      @node = node
-      __send__(@node.element_name == 'iq' ? @node['type'] : @node.element_name)
     end
 
+  private
+    ##
+    # Send a start session command
     def session
       response = Stanza::Iq.new :set
       response.to = @to
@@ -30,12 +19,16 @@ module Stream # :nodoc:
       @stream.send response
     end
 
+    ##
+    # The server should respond with a <result> node if all is well
     def result
-      @callbacks[:success].call(@jid) if @callbacks[:success]
+      success
     end
 
+    ##
+    # Server returned an error.
     def error
-      @callbacks[:failure].call if @callbacks[:failure]
+      failure StanzaError.import(@node)
     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

@@ -1,27 +1,31 @@
 module Blather # :nodoc:
-module Stream # :nodoc:
+class Stream # :nodoc:
 
-  class TLS # :nodoc:
-    def initialize(stream)
-      @stream = stream
-      @callbacks = {
-        'starttls'  => proc { @stream.send "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>" },
-        'proceed'   => proc { @stream.start_tls; @callbacks['success'].call },
-        'success'   => proc { },
-        'failure'   => proc { }
-      }
+  # 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
 
-    def success(&callback)
-      @callbacks['success'] = callback
+    ##
+    # Server's ready for TLS, so start it up
+    def proceed
+      @stream.start_tls
+      success
     end
 
-    def failure(&callback)
-      @callbacks['failure'] = callback
-    end
-
-    def receive(node)
-      @callbacks[node.element_name].call if @callbacks[node.element_name]
+    ##
+    # Negotiations failed
+    def failure
+      super StreamError::TLSFailure.new
     end
   end #TLS
 

data/lib/blather/xmpp_node.rb

@@ -5,9 +5,11 @@ module Blather
   # All XML classes subclass XMPPNode
   # it allows the addition of helpers
   class XMPPNode < XML::Node
+    BASE_NAMES = %w[presence message iq].freeze
+
     @@registrations = {}
 
-    class_inheritable_accessor  :xmlns,
+    class_inheritable_accessor  :ns,
                                 :name
 
     ##
@@ -16,10 +18,10 @@ module Blather
     # This registers a namespace that is used when looking
     # up the class name of the object to instantiate when a new
     # stanza is received
-    def self.register(name, xmlns = nil)
+    def self.register(name, ns = nil)
       self.name = name.to_s
-      self.xmlns = xmlns
-      @@registrations[[self.name, self.xmlns]] = self
+      self.ns = ns
+      @@registrations[[self.name, self.ns]] = self
     end
 
     ##
@@ -34,7 +36,7 @@ module Blather
     # of that class and imports all the <tt>node</tt>'s attributes
     # and children into it.
     def self.import(node)
-      klass = class_from_registration(node.element_name, node.xmlns)
+      klass = class_from_registration(node.element_name, node.namespace)
       if klass && klass != self
         klass.import(node)
       else
@@ -42,6 +44,72 @@ module Blather
       end
     end
 
+    ##
+    # Provides an attribute reader helper. Default behavior is to
+    # conver the values of the attribute into a symbol. This can
+    # be turned off by passing <tt>:to_sym => false</tt>
+    #
+    #   class Node
+    #     attribute_reader :type
+    #     attribute_reader :name, :to_sym => false
+    #   end
+    #
+    #   n = Node.new
+    #   n.attributes[:type] = 'foo'
+    #   n.type == :foo
+    #   n.attributes[:name] = 'bar'
+    #   n.name == 'bar'
+    def self.attribute_reader(*syms)
+      opts = syms.last.is_a?(Hash) ? syms.pop : {}
+      syms.flatten.each do |sym|
+        class_eval(<<-END, __FILE__, __LINE__)
+          def #{sym}
+            attributes[:#{sym}]#{".to_sym unless attributes[:#{sym}].blank?" unless opts[:to_sym] == false}
+          end
+        END
+      end
+    end
+
+    ##
+    # Provides an attribute writer helper.
+    #
+    #   class Node
+    #     attribute_writer :type
+    #   end
+    #
+    #   n = Node.new
+    #   n.type = 'foo'
+    #   n.attributes[:type] == 'foo'
+    def self.attribute_writer(*syms)
+      syms.flatten.each do |sym|
+        next if sym.is_a?(Hash)
+        class_eval(<<-END, __FILE__, __LINE__)
+          def #{sym}=(value)
+            attributes[:#{sym}] = value
+          end
+        END
+      end
+    end
+
+    ##
+    # Provides an attribute accessor helper combining
+    # <tt>attribute_reader</tt> and <tt>attribute_writer</tt>
+    #
+    #   class Node
+    #     attribute_accessor :type
+    #     attribute_accessor :name, :to_sym => false
+    #   end
+    #
+    #   n = Node.new
+    #   n.type = 'foo'
+    #   n.type == :foo
+    #   n.name = 'bar'
+    #   n.name == 'bar'
+    def self.attribute_accessor(*syms)
+      attribute_reader *syms
+      attribute_writer *syms
+    end
+
     ##
     # Automatically sets the namespace registered by the subclass
     def initialize(name = nil, content = nil)
@@ -49,7 +117,7 @@ module Blather
       content = content.to_s if content
 
       super name.to_s, content
-      self.xmlns = self.class.xmlns
+      self.namespace = self.class.ns unless BASE_NAMES.include?(name.to_s)
     end
 
     ##
@@ -58,19 +126,22 @@ module Blather
       self.class.import self
     end
 
-    def xmlns=(ns)
-      attributes['xmlns'] = ns
+    def namespace=(ns)
+      if ns
+        ns = {nil => ns} unless ns.is_a?(Hash)
+        ns.each { |n| XML::Namespace.new self, *n }
+      end
     end
 
-    def xmlns
-      attributes['xmlns']
+    def namespace(prefix = nil)
+      (ns = namespaces.find_by_prefix(prefix)) ? ns.href : nil
     end
 
     ##
     # Remove a child with the name and (optionally) namespace given
     def remove_child(name, ns = nil)
       name = name.to_s
-      self.each { |n| n.remove! if n.element_name == name && (!ns || n.xmlns == ns) }
+      self.detect { |n| n.remove! if n.element_name == name && (!ns || n.namespace == ns) }
     end
 
     ##
@@ -90,7 +161,9 @@ module Blather
     ##
     # Create a copy
     def copy(deep = true)
-      self.class.new(self.element_name).inherit(self)
+      copy = self.class.new.inherit(self)
+      copy.element_name = self.element_name
+      copy
     end
 
     ##
@@ -104,21 +177,22 @@ module Blather
     ##
     # Inherit only <tt>stanza</tt>'s attributes
     def inherit_attrs(attrs)
-      attrs.each  { |a| self[a.name] = a.value }
+      attrs.each  { |a| attributes[a.name] = a.value }
       self
     end
 
     ##
-    # Turn itself into a string and remove all whitespace between nodes
-    def to_s
+    # Turn itself into an XML string and remove all whitespace between nodes
+    def to_xml
       # TODO: Fix this for HTML nodes (and any other that might require whitespace)
-      super.gsub(">\n<", '><')
+      to_s.gsub(">\n<", '><')
     end
 
     ##
     # Override #find to work when a node isn't attached to a document
     def find(what, nslist = nil)
-      (self.doc ? super(what, nslist) : select { |i| i.element_name == what})
+      what = what.to_s
+      (self.doc ? super(what, nslist) : select { |i| i.element_name == what })
     end
   end #XMPPNode