blather 0.1

data/lib/blather/core/stream/parser.rb

@@ -0,0 +1,74 @@
+module Blather # :nodoc:
+module Stream # :nodoc:
+
+  class Parser # :nodoc:
+    STREAM_REGEX = %r{(/)?stream:stream}.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::SaxParser.new
+      @parser.callbacks = self
+    end
+
+    def parse(string)
+      LOG.debug "PARSING: #{string}" if @@debug
+      if string =~ STREAM_REGEX && $1
+        @receiver.receive XMPPNode.new('stream:end')
+      else
+        string << "</stream:stream>" if string =~ STREAM_REGEX && !$1
+
+        @parser.string = string
+        @parser.parse
+      end
+    end
+
+    def on_start_element(elem, attrs)
+      LOG.debug "START ELEM: (#{[elem, attrs].inspect})" if @@debug
+      e = XMPPNode.new elem
+      attrs.each { |n,v| e[n] = v }
+
+      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_cdata_block(block)
+      LOG.debug "CDATA: #{block}" if @@debug
+      @current << XML::Node.new_cdata(block) if @current
+    end
+
+    def on_end_element(elem)
+      return if elem =~ STREAM_REGEX
+
+      LOG.debug "END ELEM: (#{@current}) #{elem}" if @@debug
+      if @current.parent?
+        @current = @current.parent
+
+      else
+        c, @current = @current, nil
+        @receiver.receive c
+
+      end
+    end
+  end #Parser
+
+end #Stream
+end #Blather

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

@@ -0,0 +1,51 @@
+module Blather # :nodoc:
+module Stream # :nodoc:
+
+  class Resource # :nodoc:
+    def initialize(stream, jid)
+      @stream = stream
+      @jid = jid
+      @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
+
+    def bind
+      binder = XMPPNode.new('bind')
+      binder.xmlns = 'urn:ietf:params:xml:ns:xmpp-bind'
+
+      binder << XMPPNode.new('resource', @jid.resource) if @jid.resource
+
+      response = Stanza::Iq.new :set
+      @id = response.id
+      response << binder
+
+      @stream.send response
+    end
+
+    def result
+      LOG.debug "RESOURE NODE #{@node}"
+      if @id == @node['id']
+        @jid = JID.new @node.find_first('bind').content_from(:jid)
+        @callbacks[:success].call(@jid) if @callbacks[:success]
+      end
+    end
+
+    def error
+      @callbacks[:failure].call if @callbacks[:failure]
+    end
+  end #Resource
+
+end #Stream
+end #Blather

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

@@ -0,0 +1,135 @@
+module Blather # :nodoc:
+module Stream # :nodoc:
+
+  class SASL # :nodoc:
+    SASL_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
+    def initialize(stream, jid, pass = nil)
+      @stream = stream
+      @jid = jid
+      @pass = pass
+      @callbacks = {}
+
+      init_callbacks
+    end
+
+    def init_callbacks
+      @callbacks['mechanisms'] = proc { set_mechanism; authenticate }
+    end
+
+    def set_mechanism
+      mod = case (mechanism = @node.first.content)
+      when 'DIGEST-MD5' then DigestMD5
+      when 'PLAIN'      then Plain
+      when 'ANONYMOUS'  then Anonymous
+      else raise "Unknown SASL mechanism (#{mechanism})"
+      end
+
+      extend mod
+    end
+
+    def receive(node)
+      @node = node
+      @callbacks[@node.element_name].call if @callbacks[@node.element_name]
+    end
+
+    def success(&callback)
+      @callbacks['success'] = callback
+    end
+
+    def failure(&callback)
+      @callbacks['failure'] = callback
+    end
+
+  protected
+    def b64(str)
+      [str].pack('m').gsub(/\s/,'')
+    end
+
+    def auth_node(mechanism, content = nil)
+      node = XMPPNode.new 'auth', content
+      node['xmlns'] = SASL_NS
+      node['mechanism'] = mechanism
+      node
+    end
+
+    module DigestMD5 # :nodoc:
+      def self.extended(obj)
+        obj.instance_eval { @callbacks['challenge'] = proc { decode_challenge; respond } }
+      end
+
+      def authenticate
+        @stream.send auth_node('DIGEST-MD5')
+      end
+
+    private
+      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
+
+      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
+
+      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
+          order = [:nonce, :charset, :username, :realm, :cnonce, :nc, :qop, :'digest-uri']
+          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/core/stream/session.rb

@@ -0,0 +1,43 @@
+module Blather # :nodoc:
+module Stream # :nodoc:
+
+  class Session # :nodoc:
+    def initialize(stream, to)
+      @stream = 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
+
+    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
+
+    def result
+      @callbacks[:success].call(@jid) if @callbacks[:success]
+    end
+
+    def error
+      @callbacks[:failure].call if @callbacks[:failure]
+    end
+  end
+
+end
+end

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

@@ -0,0 +1,29 @@
+module Blather # :nodoc:
+module 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 { }
+      }
+    end
+
+    def success(&callback)
+      @callbacks['success'] = callback
+    end
+
+    def failure(&callback)
+      @callbacks['failure'] = callback
+    end
+
+    def receive(node)
+      @callbacks[node.element_name].call if @callbacks[node.element_name]
+    end
+  end #TLS
+
+end #Stream
+end #Blather

data/lib/blather/core/sugar.rb

@@ -0,0 +1,150 @@
+module LibXML # :nodoc:
+  module XML # :nodoc:
+
+    class Attributes
+      # Helper method for removing attributes
+      def remove(name)
+        name = name.to_s
+        self.each { |a| a.remove! or break if a.name == name }
+      end
+    end #Attributes
+
+  end #XML
+end #LibXML
+
+## Thanks to ActiveSupport for everything below this line
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => value.duplicable? ? value.dup : value)
+        end
+      end
+
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end #Class
+
+class Object # :nodoc:
+  def duplicable?; true; end
+end
+
+class NilClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class Symbol #:nodoc:
+  def duplicable?; false; end
+end
+
+class Numeric #:nodoc:
+  def duplicable?; false; end
+end