shingara-blather 0.4.8

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

@@ -0,0 +1,187 @@
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class SASL < Features # :nodoc:
+    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.logger.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.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.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
+          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')
+      end
+    end #Anonymous
+  end #SASL
+
+end #Stream
+end

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 # :nodoc:
+    @@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

@@ -0,0 +1,102 @@
+require 'nokogiri'
+
+module Blather # :nodoc:
+class Stream # :nodoc:
+
+  class Parser < Nokogiri::XML::SAX::Document # :nodoc:
+    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
+    end
+
+    def receive_data(string)
+      Blather.logger.debug "PARSING: (#{string})" if @@debug
+      @parser << string
+      self
+    end
+    alias_method :<<, :receive_data
+
+    def start_element_namespace(elem, attrs, prefix, uri, namespaces)
+      Blather.logger.debug "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
+
+      if !@receiver.stopped?
+        @current << node if @current
+        @current = node
+      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]]
+
+      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.logger.debug "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.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

data/lib/blather/stream.rb

@@ -0,0 +1,231 @@
+module Blather
+
+  # # A pure XMPP stream.
+  #
+  # Blather::Stream can be used to build your own handler system if Blather's
+  # doesn't suit your needs. It will take care of the entire connection
+  # process then start sending Stanza objects back to the registered client.
+  #
+  # The client you register with Blather::Stream needs to implement the following
+  # methods:
+  # * #post_init(stream, jid = nil)
+  #   Called after the stream has been initiated.
+  #   @param [Blather::Stream] stream is the connected stream object
+  #   @param [Blather::JID, nil] jid is the full JID as recognized by the server
+  #
+  # * #receive_data(stanza)
+  #   Called every time the stream receives a new stanza
+  #   @param [Blather::Stanza] stanza a stanza object from the server
+  #
+  # * #unbind
+  #   Called when the stream is shutdown. This will be called regardless of which
+  #   side shut the stream down.
+  #
+  # @example Create a new stream and handle it with our own class
+  #     class MyClient
+  #       attr :jid
+  #
+  #       def post_init(stream, jid = nil)
+  #         @stream = stream
+  #         self.jid = jid
+  #         p "Stream Started"
+  #       end
+  #
+  #       # Pretty print the stream
+  #       def receive_data(stanza)
+  #         pp stanza
+  #       end
+  #
+  #       def unbind
+  #         p "Stream Ended"
+  #       end
+  #
+  #       def write(what)
+  #         @stream.write what
+  #       end
+  #     end
+  #
+  #     client = Blather::Stream.start MyClient.new, "jid@domain/res", "pass"
+  #     client.write "[pure xml over the wire]"
+  class Stream < EventMachine::Connection
+    class NoConnection < RuntimeError; end
+
+    STREAM_NS = 'http://etherx.jabber.org/streams'
+    attr_accessor :password
+    attr_reader :jid
+
+    # Start the stream between client and server
+    #
+    # @param [Object] client an object that will respond to #post_init,
+    # #unbind #receive_data
+    # @param [Blather::JID, #to_s] jid the jid to authenticate with
+    # @param [String] pass the password to authenticate with
+    # @param [String, nil] host the hostname or IP to connect to. Default is
+    # to use the domain on the JID
+    # @param [Fixnum, nil] port the port to connect on. Default is the XMPP
+    # default of 5222
+    def self.start(client, jid, pass, host = nil, port = 5222)
+      jid = JID.new jid
+      if host
+        connect host, port, self, client, jid, pass
+      else
+        require 'resolv'
+        srv = []
+        Resolv::DNS.open do |dns|
+          srv = dns.getresources(
+            "_xmpp-client._tcp.#{jid.domain}",
+            Resolv::DNS::Resource::IN::SRV
+          )
+        end
+
+        if srv.empty?
+          connect jid.domain, port, self, client, jid, pass
+        else
+          srv.sort! do |a,b|
+            (a.priority != b.priority) ? (a.priority <=> b.priority) :
+                                         (b.weight <=> a.weight)
+          end
+
+          srv.detect do |r|
+            not connect(r.target.to_s, r.port, self, client, jid, pass) === false
+          end
+        end
+      end
+    end
+
+    # Attempt a connection
+    # Stream will raise +NoConnection+ if it receives #unbind before #post_init
+    # this catches that and returns false prompting for another attempt
+    # @private
+    def self.connect(host, port, conn, client, jid, pass)
+      EM.connect host, port, conn, client, jid, pass
+    rescue NoConnection
+      false
+    end
+
+    [:started, :stopped, :ready, :negotiating].each do |state|
+      define_method("#{state}?") { @state == state }
+    end
+
+    # Send data over the wire
+    #
+    # @todo Queue if not ready
+    #
+    # @param [#to_xml, #to_s] stanza the stanza to send over the wire
+    def send(stanza)
+      Blather.logger.debug "SENDING: (#{caller[1]}) #{stanza}"
+      send_data stanza.respond_to?(:to_xml) ? stanza.to_xml : stanza.to_s
+    end
+
+    # Called by EM.connect to initialize stream variables
+    # @private
+    def initialize(client, jid, pass)
+      super()
+
+      @error = nil
+      @receiver = @client = client
+
+      self.jid = jid
+      @to = self.jid.domain
+      @password = pass
+    end
+
+    # Called when EM completes the connection to the server
+    # this kicks off the starttls/authorize/bind process
+    # @private
+    def connection_completed
+#      @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }
+      start
+    end
+
+    # Called by EM with data from the wire
+    # @private
+    def receive_data(data)
+      Blather.logger.debug "\n#{'-'*30}\n"
+      Blather.logger.debug "STREAM IN: #{data}"
+      @parser << data
+
+    rescue ParseError => e
+      @error = e
+      send "<stream:error><xml-not-well-formed xmlns='#{StreamError::STREAM_ERR_NS}'/></stream:error>"
+      stop
+    end
+
+    # Called by EM after the connection has started
+    # @private
+    def post_init
+      @connected = true
+    end
+
+    # Called by EM when the connection is closed
+    # @private
+    def unbind
+      raise NoConnection unless @connected
+
+#      @keepalive.cancel
+      @state = :stopped
+      @client.receive_data @error if @error
+      @client.unbind
+    end
+
+    # Called by the parser with parsed nodes
+    # @private
+    def receive(node)
+      Blather.logger.debug "RECEIVING (#{node.element_name}) #{node}"
+      @node = node
+
+      if @node.namespace && @node.namespace.prefix == 'stream'
+        case @node.element_name
+        when 'stream'
+          @state = :ready if @state == :stopped
+          return
+        when 'error'
+          handle_stream_error
+          return
+        when 'end'
+          stop
+          return
+        when 'features'
+          @state = :negotiating
+          @receiver = Features.new(
+            self,
+            proc { ready! },
+            proc { |err| @error = err; stop }
+          )
+        end
+      end
+      @receiver.receive_data @node.to_stanza
+    end
+
+    # Ensure the JID gets attached to the client
+    # @private
+    def jid=(new_jid)
+      Blather.logger.debug "NEW JID: #{new_jid}"
+      @jid = JID.new new_jid
+    end
+
+  protected
+    # Stop the stream
+    # @private
+    def stop
+      unless @state == :stopped
+        @state = :stopped
+        send '</stream:stream>'
+      end
+    end
+
+    # @private
+    def handle_stream_error
+      @error = StreamError.import(@node)
+      stop
+    end
+
+    # @private
+    def ready!
+      @state = :started
+      @receiver = @client
+      @client.post_init self, @jid
+    end
+  end  # Stream
+
+end  # Blather