tp-blather 0.8.2

data/lib/blather/stream.rb

@@ -0,0 +1,266 @@
+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
+    # Connection not found
+    class NoConnection < RuntimeError; end
+    class ConnectionFailed < RuntimeError; end
+    class ConnectionTimeout < RuntimeError; end
+
+    # @private
+    STREAM_NS = 'http://etherx.jabber.org/streams'
+    attr_accessor :password
+    attr_reader :jid
+    @@store = nil
+
+    # 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
+    # @param [String, nil] certs the trusted cert store in pem format to verify
+    # communication with the server is trusted.
+    # @param [Fixnum, nil] connect_timeout the number of seconds for which to wait for a successful connection
+    def self.start(client, jid, pass, host = nil, port = nil, certs_directory = nil, connect_timeout = nil)
+      jid = JID.new jid
+      port ||= 5222
+      if certs_directory
+        @@store = CertStore.new(certs_directory)
+      end
+      if host
+        connect host, port, self, client, jid, pass, connect_timeout
+      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, connect_timeout
+        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, connect_timeout) === 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, connect_timeout = nil)
+      EM.connect host, port, conn, client, jid, pass, connect_timeout
+    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)
+      data = stanza.respond_to?(:to_xml) ? stanza.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::AS_XML) : stanza.to_s
+      Blather.log "SENDING: (#{caller[1]}) #{stanza}"
+      EM.next_tick { send_data data }
+    end
+
+    # Called by EM.connect to initialize stream variables
+    # @private
+    def initialize(client, jid, pass, connect_timeout = nil)
+      super()
+
+      @error = nil
+      @receiver = @client = client
+
+      self.jid = jid
+      @to = self.jid.domain
+      @password = pass
+      @connect_timeout = connect_timeout || 180
+    end
+
+    # Called when EM completes the connection to the server
+    # this kicks off the starttls/authorize/bind process
+    # @private
+    def connection_completed
+      if @connect_timeout
+        @connect_timer = EM::Timer.new @connect_timeout do
+          raise ConnectionTimeout, "Stream timed out after #{@connect_timeout} seconds." unless started?
+        end
+      end
+      @connected = true
+#      @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }
+      start
+    end
+
+    # Called by EM with data from the wire
+    # @private
+    def receive_data(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 to verify the peer certificate. If a certificate store directory
+    # has not been configured don't worry about peer verification. At least it is encrypted
+    # We Log the certificate so that you can add it to the trusted store easily if desired
+    # @private
+    def ssl_verify_peer(pem)
+      # EM is supposed to close the connection when this returns false,
+      # but it only does that for inbound connections, not when we
+      # make a connection to another server.
+      Blather.log "Checking SSL cert: #{pem}"
+      return true if !@@store
+      @@store.trusted?(pem).tap do |trusted|
+        close_connection unless trusted
+      end
+    end
+
+    # Called by EM after the connection has started
+    # @private
+    def post_init
+      @inited = true
+    end
+
+    # Called by EM when the connection is closed
+    # @private
+    def unbind
+      raise NoConnection unless @inited
+      raise ConnectionFailed unless @connected
+
+      @connect_timer.cancel if @connect_timer
+#      @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.log "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.log "USING 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

data/lib/blather/stream/client.rb

@@ -0,0 +1,32 @@
+module Blather
+class Stream
+
+  # @private
+  class Client < Stream
+    LANG = 'en'
+    VERSION = '1.0'
+    NAMESPACE = 'jabber:client'
+
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@to}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='#{STREAM_NS}'
+          version='#{VERSION}'
+          xml:lang='#{LANG}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+
+    def send(stanza)
+      stanza.from = self.jid if stanza.is_a?(Stanza) && !stanza.from.nil?
+      super stanza
+    end
+
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/component.rb

@@ -0,0 +1,39 @@
+module Blather
+class Stream
+
+  # @private
+  class Component < Stream
+    NAMESPACE = 'jabber:component:accept'
+
+    def receive(node) # :nodoc:
+      #if node.element_name == 'handshake'
+      #  ready!
+      #else
+        super
+      #end
+#
+      #if node.document.find_first('/stream:stream[not(stream:error)]', :xmlns => NAMESPACE, :stream => STREAM_NS)
+      #  send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@password)}</handshake>")
+      #end
+    end
+
+    def send(stanza)
+      stanza.from ||= self.jid if stanza.respond_to?(:from) && stanza.respond_to?(:from=)
+      super stanza
+    end
+
+    def start
+      @parser = Parser.new self
+      start_stream = <<-STREAM
+        <stream:stream
+          to='#{@jid}'
+          xmlns='#{NAMESPACE}'
+          xmlns:stream='#{STREAM_NS}'
+        >
+      STREAM
+      send start_stream.gsub(/\s+/, ' ')
+    end
+  end #Client
+
+end #Stream
+end #Blather

data/lib/blather/stream/features.rb

@@ -0,0 +1,70 @@
+module Blather
+class Stream
+
+  # @private
+  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 {
+              if (klass == Blather::Stream::Register && stanza = feature?(:mechanisms))
+                @idx = @features.children.index(stanza)
+                @feature = Blather::Stream::SASL.new @stream, proc { next! }, @fail
+                @feature.receive_data stanza
+              else
+                next!
+              end
+            },
+            (klass == Blather::Stream::SASL && feature?(:register)) ? 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
+
+    def feature?(feature)
+      @features && @features.children.find { |v| v.element_name == feature.to_s }
+    end
+  end
+
+end #Stream
+end #Blather

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

@@ -0,0 +1,38 @@
+module Blather
+  class Stream
+    class Register < Features
+      REGISTER_NS = "http://jabber.org/features/iq-register".freeze
+
+      register REGISTER_NS
+
+      def initialize(stream, succeed, fail)
+        super
+        @jid = @stream.jid
+        @pass = @stream.password
+      end
+
+      def receive_data(stanza)
+        error_node = stanza.xpath("//error").first
+
+        if error_node
+          fail!(BlatherError.new(stanza))
+        elsif stanza['type'] == 'result' && (stanza.content.empty? || stanza.children.find { |v| v.element_name == "query" })
+          succeed!
+        else
+          @stream.send register_query
+        end
+      end
+
+      def register_query
+        node = Blather::Stanza::Iq::Query.new(:set)
+        query_node = node.xpath('//query').first
+        query_node['xmlns'] = 'jabber:iq:register'
+        Nokogiri::XML::Builder.with(query_node) do |xml|
+          xml.username @jid.node
+          xml.password @pass
+        end
+        node
+      end
+    end
+  end
+end