em-xmpp 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in em-xmpp.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 crapooze
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Em::Xmpp
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'em-xmpp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install em-xmpp
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/em-xmpp.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em-xmpp/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["crapooze"]
+  gem.email         = ["crapooze@gmail.com"]
+  gem.description   = %q{XMPP client for event machine}
+  gem.summary       = %q{Easy to write and to extend XMPP client}
+  gem.homepage      = "https://github.com/crapooze/em-xmpp"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "em-xmpp"
+  gem.require_paths = ["lib"]
+  gem.version       = Em::Xmpp::VERSION
+  gem.add_dependency "eventmachine"
+  gem.add_dependency "nokogiri"
+  gem.add_dependency "ruby-sasl"
+end

data/lib/em-xmpp/cert_store.rb

@@ -0,0 +1,76 @@
+=begin
+The code from this file was copied from Blather:
+
+
+Copyright (c) 2011 Jeff Smick
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.    
+=end
+
+module EM::Xmpp
+  # An X509 certificate store that validates certificate trust chains.
+  # This uses the #{cert_directory}/*.crt files as the list of trusted root
+  # CA certificates.
+  class CertStore
+    @@certs = nil
+    @cert_directory = nil
+
+    def initialize(cert_directory)
+      @cert_directory = cert_directory
+      @store = OpenSSL::X509::Store.new
+      certs.each {|c| @store.add_cert(c) }
+    end
+
+    # Return true if the certificate is signed by a CA certificate in the
+    # store. If the certificate can be trusted, it's added to the store so
+    # it can be used to trust other certs.
+    def trusted?(pem)
+      if cert = OpenSSL::X509::Certificate.new(pem) rescue nil
+        @store.verify(cert).tap do |trusted|
+          @store.add_cert(cert) if trusted rescue nil
+        end
+      end
+    end
+
+    # Return true if the domain name matches one of the names in the
+    # certificate. In other words, is the certificate provided to us really
+    # for the domain to which we think we're connected?
+    def domain?(pem, domain)
+      if cert = OpenSSL::X509::Certificate.new(pem) rescue nil
+        OpenSSL::SSL.verify_certificate_identity(cert, domain) rescue false
+      end
+    end
+
+    # Return the trusted root CA certificates installed in the @cert_directory. These
+    # certificates are used to start the trust chain needed to validate certs
+    # we receive from clients and servers.
+    def certs
+      unless @@certs
+        pattern = /-{5}BEGIN CERTIFICATE-{5}\n.*?-{5}END CERTIFICATE-{5}\n/m
+        dir = @cert_directory
+        certs = Dir[File.join(dir, '*.crt')].map {|f| File.read(f) }
+        certs = certs.map {|c| c.scan(pattern) }.flatten
+        certs.map! {|c| OpenSSL::X509::Certificate.new(c) }
+        @@certs = certs.reject {|c| c.not_after < Time.now }
+      end
+      @@certs
+    end
+  end
+end

data/lib/em-xmpp/connection.rb

@@ -0,0 +1,116 @@
+
+require 'em-xmpp/namespaces'
+require 'em-xmpp/connector'
+require 'em-xmpp/handler'
+require 'em-xmpp/jid'
+require 'em-xmpp/cert_store'
+require 'eventmachine'
+
+module EM::Xmpp
+  class Connection < EM::Connection
+    include Namespaces
+    include Connector
+
+    attr_reader :jid, :pass
+
+    def initialize(jid, pass, mod=nil, cfg={})
+      @jid        = jid
+      @pass       = pass.dup.freeze
+      self.extend mod if mod
+      certdir     = cfg[:certificates]
+      @certstore  = if certdir
+                      CertStore.new(certdir)
+                    else
+                      nil
+                    end
+    end
+
+    def post_init
+      super
+      @handler = StreamNegotiation.new self
+    end
+
+    def stanza_start(node)
+    end
+
+    def stanza_end(node)
+      @handler.handle(node)
+    end
+
+    def unhandled_stanza(node)
+      raise RuntimeError, "did not handle node:\n#{node}"
+    end
+
+    def jid_received(jid)
+      @jid = JID.parse jid
+    end
+
+    def negotiation_finished
+      @pass    = nil
+      @handler = Routine.new self
+      send_raw presence_stanza()
+      ready
+    end
+
+    def negotiation_failed(node)
+      raise RuntimeError, "could not negotiate a stream:\n#{node}"
+    end
+
+    #should add 'xml:lang'
+
+    def default_presence_config
+      {}
+    end
+
+    def default_message_config
+      {'to' => @jid.domain, 'id' => "em-xmpp.#{rand(65535)}"}
+    end
+
+    def default_iq_config
+      {'type' => 'get', 'id' => "em-xmpp.#{rand(65535)}"}
+    end
+
+    def presence_stanza(cfg={}, &blk)
+      cfg = default_presence_config.merge(cfg)
+      build_xml do |x|
+        x.presence(cfg, &blk)
+      end
+    end
+
+    def message_stanza(cfg={}, &blk)
+      cfg = default_message_config.merge(cfg)
+      build_xml do |x|
+        x.message(cfg, &blk)
+      end
+    end
+
+    def iq_stanza(cfg={}, &blk)
+      cfg = default_iq_config.merge(cfg)
+      build_xml do |x|
+        x.iq(cfg, &blk)
+      end
+    end
+
+    %w{on on_exception on_presence on_iq on_message}.each do |meth|
+      define_method(meth) do |*args,&blk|
+      @handler.send meth, *args, &blk
+      end
+    end
+
+    def ready
+    end
+
+    def start_using_tls_and_reset_stream
+      bool = !! @certstore
+      start_tls(:verify_peer => bool)
+      restart_xml_stream
+    end
+
+    def ssl_verify_peer(pem)
+      @certstore.trusted?(pem).tap do |trusted|
+        close_connection unless trusted
+      end    
+    end
+
+  end
+end

data/lib/em-xmpp/connector.rb

@@ -0,0 +1,244 @@
+
+require 'nokogiri'
+require 'eventmachine'
+require 'em-xmpp/context'
+require 'em-xmpp/namespaces'
+require 'em-xmpp/resolver'
+
+module EM::Xmpp
+  module Connector
+    include Namespaces
+
+    #XML SAX document which delegates its method to a recipient object
+    class ForwardingDocument < Nokogiri::XML::SAX::Document
+      attr_accessor :recipient
+      %w{xmldecl start_document end_document start_element_namespace end_element characters
+      comment warning error cdata_block}.each do |meth|
+        meth2 = "xml_#{meth}"
+        define_method(meth) do |*args| 
+          recipient.send(meth2, *args)  if recipient
+        end
+      end
+    end
+
+    def self.included(obj)
+      obj.extend ClassMethods
+    end
+
+    module ClassMethods
+      def start(jid, pass=nil, mod=nil, cfg={}, server=nil, port=5222, &blk)
+        jid = JID.parse jid
+        if server.nil?
+          record = Resolver.resolve jid.domain
+          if record
+            server = record.target.to_s
+            port   = record.port
+          else
+            server = jid.domain
+          end
+        end
+
+        EM.connect(server, port, self, jid, pass, mod, cfg, &blk)
+      end
+    end
+
+    extend ClassMethods
+
+    def send_raw(data)
+      puts ">> out\n#{data}\n" if $DEBUG
+      send_data data
+    end
+
+    def send_xml(&blk)
+      data = build_xml(&blk)
+      send_raw data
+    end
+
+    def restart_xml_stream
+      @xml_parser.document.recipient = nil
+      post_init
+    end
+
+    def post_init
+      doc = ForwardingDocument.new
+      doc.recipient = self
+      @xml_parser   = Nokogiri::XML::SAX::PushParser.new doc
+      @stack        = []
+      @stanza       = nil
+      @streamdoc    = nil
+
+      open_xml_stream
+    end
+
+    def receive_data(dat)
+      puts "<< in\n#{dat}\n" if $DEBUG
+      @xml_parser << dat
+    end
+
+    def unbind
+      puts "**** unbound ****" if $DEBUG
+    end
+
+    def build_xml(&blk)
+      n = Nokogiri::XML::Builder.new(&blk)
+      n.doc.root.to_xml 
+    end
+
+    private
+
+    def open_xml_stream_tag
+      domain  = @jid.domain
+      version = '1.0'
+      lang    = 'en'
+      start_stream = <<-STREAM 
+                    <stream:stream
+                    to='#{domain}'
+                    version='#{version}'
+                    xml:lang='#{lang}'
+                    xmlns='#{Client}'
+                    xmlns:stream='#{Stream}'
+                    >
+      STREAM
+    end
+
+    def close_xml_stream_tag
+      '</stream:stream>'
+    end
+
+    def open_xml_stream
+      send_raw open_xml_stream_tag
+    end
+
+    def close_xml_stream
+      send_raw close_xml_stream_tag
+    end
+
+    ### XML world
+
+    def xml_xmldecl(version,encoding,standalone)
+    end
+
+    def xml_start_document
+      #XXX set namespaces and stream prefix
+      #    namespace may depend on the type of connection ('jabber:client' or
+      #    'jabber:server')
+      #   currently we do not set any stream's namespace, hence when builidng stanza,
+      #   we must explicitely avoid writing the namespace of iq/presence/message XML nodes
+      @streamdoc      = Nokogiri::XML::Document.new
+    end
+
+    def xml_end_document
+      @streamdoc = @stanza = @stack = @xml_parser = nil
+    end
+
+    def xml_start_element_namespace(name, attrs=[],prefix=nil,uri=nil,ns=[])
+      node = Nokogiri::XML::Node.new(name, @streamdoc)
+      attrs.each do |attr|
+        #attr is a Struct with members localname/prefix/uri/value
+        node[attr.localname] = attr.value
+      end
+      #XXX - if prefix is there maybe we do not want to set uri as default
+      node.default_namespace = uri if uri
+
+      ns.each do |pfx,href|
+        node.add_namespace_definition pfx, href
+      end
+
+      puts "starting: #{name}, stack:#{@stack.size}" if $DEBUG
+      case @stack.size
+      when 0 #the streaming tag starts
+        stream_support(node)
+      when 1 #a stanza starts
+        set_current_stanza!(node)
+        stanza_start node
+      else 
+        @stack.last.add_child node
+      end
+
+      @stack << node 
+    end
+
+    def xml_end_element(name)
+      node = @stack.pop
+      puts "ending: #{name}, stack:#{@stack.size}" if $DEBUG
+
+      case @stack.size
+      when 0 #i.e., the stream support ends
+        xml_stream_closing 
+      when 1 #i.e., we've finished a stanza
+        raise RuntimeError, "should end on a stanza" unless node == @stanza
+        stanza_end node
+      else
+        #the stanza keeps growing
+      end
+    end
+
+    def xml_characters(txt)
+      @stack.last << Nokogiri::XML::Text.new(txt, @streamdoc)
+    end
+
+    def xml_error(err)
+      #raise RuntimeError, err
+    end
+
+    def xml_stream_closing
+      close_xml_stream
+      close_connection
+    end
+
+    def xml_comment(comm)
+      raise NotImplementedError
+    end
+
+    def xml_warning(warn)
+      raise NotImplementedError
+    end
+
+    def xml_cdata_block(data)
+      raise NotImplementedError
+    end
+
+    ### XMPP World
+
+    def stream_support(node)
+      @stanza         = Nokogiri::XML::Node.new('dummy', @streamdoc)
+      node << @stanza
+
+      @streamdoc.root = node
+    end
+
+    def set_current_stanza!(node)
+      @stanza.remove
+
+      @stanza = node
+      @streamdoc.root << @stanza
+    end
+
+    def stanza_start(node)
+      raise NotImplementedError
+    end
+
+    def stanza_end(node)
+      raise NotImplementedError
+    end
+
+    public
+
+    ### TLS World
+
+    def ask_for_tls
+      send_xml do |x|
+        x.starttls(:xmlns => TLS)
+      end
+    end
+
+    def start_using_tls_and_reset_stream
+      start_tls(:verify_peer => false)
+      restart_xml_stream
+    end
+
+    def ssl_verify_peer(pem)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/em-xmpp/context.rb

@@ -0,0 +1,249 @@
+
+require 'em-xmpp/jid'
+require 'em-xmpp/namespaces'
+require 'time'
+
+module EM::Xmpp
+  class Context
+    attr_reader :connection, :stanza, :env
+
+    def []key
+      env[key]
+    end
+
+    def []=key,val
+      env[key]= val
+    end
+
+    def default_env
+      {'modules' => [], 'done' => false}
+    end
+
+    def done!
+      env['ctx.done'] = true
+      self
+    end
+
+    def done?
+      env['ctx.done']
+    end
+
+    def delete_xpath_handler!
+      env.delete 'xpath.handler'
+      self
+    end
+
+    def reuse_handler?
+      env['xpath.handler']
+    end
+
+    def initialize(conn, stanza, env={})
+      @connection = conn
+      @stanza     = stanza
+      @env        = default_env.merge env
+    end
+
+    def xpath(path, args={})
+      stanza.xpath(path, args) || []
+    end
+
+    def xpath?(path, args={})
+      xpath(path, args).any?
+    end
+
+    def read_attr(node, name, sym=:to_s, &blk)
+      val = node[name]
+      if val
+        if blk
+          blk.call val
+        else
+          val.send sym
+        end
+      end
+    end
+
+    def with(modname)
+      mod = if modname.is_a?(Module)
+              modname
+            else
+              self.class.const_get(modname.to_s.capitalize)
+            end
+      env['modules'] << mod
+      obj = self
+      obj.extend mod
+      obj
+    end
+
+    module Stanza
+      include Namespaces
+      %w{type id lang}.each do |w|
+        define_method w do
+          read_attr stanza, w
+        end
+      end
+      def to
+        read_attr(stanza, 'to'){|j| JID.parse(j)}
+      end
+      def from
+        read_attr(stanza, 'from'){|j| JID.parse(j)}
+      end
+    end
+
+    module Presence
+      include Stanza
+      def reply_default_params
+        jid = @connection.jid.full
+        {'from' => jid, 'to' => from, 'id' => id}
+      end
+      def reply(args={},&blk)
+        args = reply_default_params.merge args
+        @connection.presence_stanza(args,&blk)
+      end
+      def priority_node
+        xpath('//xmlns:priority',{'xmlns' => Client}).first
+      end
+      def status_node
+        xpath('//xmlns:status',{'xmlns' => Client}).first
+      end
+      def show_node
+        xpath('//xmlns:show',{'xmlns' => Client}).first
+      end
+      def priority
+        node = priority_node
+        node.content if node
+      end
+      def status
+        node = status_node
+        node.content if node
+      end
+      def show
+        node = show_node
+        node.content if node
+      end
+      def subscription_request?
+        type == 'subscribe'
+      end
+    end
+
+    module Message
+      include Stanza
+      def subject_node
+        xpath('//xmlns:subject',{'xmlns' => Client}).first
+      end
+
+      def subject
+        node = subject_node
+        node.text if node
+      end
+
+      def body_node
+        xpath('//xmlns:body',{'xmlns' => Client}).first
+      end
+
+      def body
+        node = body_node
+        node.text if node
+      end
+
+      def reply_default_params
+        h = {'to' => from, 'type' => type}
+        h['id'] = id.succ if id
+        h
+      end
+
+      def reply(args={},&blk)
+        args = reply_default_params.merge args
+        @connection.message_stanza(args,&blk)
+      end
+    end
+
+    module Iq
+      include Stanza
+      def reply_default_params
+        jid = @connection.jid.full
+        {'from' => jid, 'to' => from, 'type' => 'result', 'id' => id}
+      end
+
+      def reply(args={},&blk)
+        args = reply_default_params.merge args
+        @connection.iq_stanza(args,&blk)
+      end
+    end
+
+    module Delay
+      #does not handle legacy delay
+      def delay_node
+        xpath('//xmlns:delay',{'xmlns' => EM::Xmpp::Namespaces::Delay}).first
+      end
+      def stamp
+        n = delay_node
+        Time.parse read_attr(n, 'stamp') if n
+      end
+    end
+
+    module Discoveries
+      include Iq
+      %w{node}.each do |word|
+        define_method word do
+          n = query_node
+          read_attr(n, word) if n
+        end
+      end
+    end
+
+    module Discoinfos
+      include Discoveries
+      def query_node
+        xpath('//xmlns:query',{'xmlns' => DiscoverInfos}).first
+      end
+    end
+
+    module Discoitems
+      include Discoveries
+      def query_node
+        xpath('//xmlns:query',{'xmlns' => DiscoverItems}).first
+      end
+    end
+
+    module Command
+      def command_node
+        xpath('//xmlns:command',{'xmlns' => Commands}).first
+      end
+
+      %w{node sessionid action}.each do |word|
+        define_method word do
+          n = command_node
+          read_attr(n, word) if n
+        end
+      end
+
+      def previous?
+        action == 'prev'
+      end
+    end
+
+    module Dataforms
+      def x_node
+        xpath('//xmlns:x',{'xmlns' => DataForms}).first
+      end
+
+      def x_type
+        n = x_node
+        read_attr(n, 'type') if n
+      end
+    end
+
+    module Capabilities
+      def c_node
+        xpath('//xmlns:c',{'xmlns' => EM::Xmpp::Namespaces::Capabilities}).first
+      end
+
+      %w{node ver ext}.each do |word|
+        define_method word do
+          n = c_node
+          read_attr(n, word) if n
+        end
+      end
+    end
+  end
+end

data/lib/em-xmpp/handler.rb

@@ -0,0 +1,262 @@
+
+require 'em-xmpp/namespaces'
+require 'em-xmpp/context'
+require 'base64'
+require 'sasl/base'
+require 'sasl'
+
+module EM::Xmpp
+  class Handler
+    include Namespaces
+
+    Xpath = Struct.new(:path, :args, :blk) do
+      def match?(xml)
+        path == :anything or xml.xpath(path, args).any?
+      end
+    end
+
+    def initialize(conn)
+      @connection         = conn
+      @xpaths             = []
+      @exception_xpaths   = []
+
+      stack_decorators
+    end
+
+    def on_presence(&blk)
+      on('//xmlns:presence', 'xmlns' => EM::Xmpp::Namespaces::Client, &blk)
+    end
+
+    def on_message(&blk)
+      on('//xmlns:message', 'xmlns' => EM::Xmpp::Namespaces::Client, &blk)
+    end
+
+    def on_iq(&blk)
+      on('//xmlns:iq', 'xmlns' => EM::Xmpp::Namespaces::Client, &blk)
+    end
+
+    def stack_decorators
+      on_presence { |ctx| ctx.with(:presence) }
+      on_message  { |ctx| ctx.with(:message) }
+      on_iq       { |ctx| ctx.with(:iq) }
+      on('//xmlns:delay', 'xmlns' => Delay) do |ctx|
+        ctx.with(:delay)
+      end
+      on('//xmlns:query', 'xmlns' => DiscoverInfos) do |ctx|
+        ctx.with(:discoinfos)
+      end
+      on('//xmlns:query', 'xmlns' => DiscoverItems) do |ctx|
+        ctx.with(:discoitems)
+      end
+      on('//xmlns:command', 'xmlns' => Commands) do |ctx|
+        ctx.with(:command)
+      end
+      on('//xmlns:x', 'xmlns' => DataForms) do |ctx|
+        ctx.with(:dataforms)
+      end
+    end
+
+    def on(path, args={}, &blk)
+      @xpaths << Xpath.new(path, args, blk)
+    end
+
+    def on_exception(path, args={}, &blk)
+      @exception_xpaths << Xpath.new(path, args, blk)
+    end
+
+    # wraps the stanza in a context and calls handle_context
+    def handle(stanza)
+      handle_context Context.new(@connection, stanza)
+    end
+
+    # runs all xpath_handlers against the stanza context
+    # catches all exception (in which case, the context gets passed to all
+    # exception_xpaths)
+    #
+    # an xpath handler can:
+    # - throw :halt to shortcircuit everything
+    # - set the context to "done!" to avoid invoking handlers
+    # - delete_xpath_handler from the history, this is useful in one-time
+    # handlers such as request/responses
+    def handle_context(ctx)
+      catch :halt do
+        @xpaths = run_xpath_handlers ctx, @xpaths
+      end
+    rescue => err
+      ctx['error'] = err
+      @exception_xpaths = run_xpath_handlers ctx, @exception_xpaths
+    end
+
+    # runs all handlers and returns a list of handlers for the next stanza
+    def run_xpath_handlers(ctx, handlers)
+      handlers.map do |x|
+        if (not ctx.done?) and (x.match?(ctx.stanza))
+          ctx['xpath.handler'] = x
+          ctx = x.blk.call(ctx)
+          raise RuntimeError, "xpath handlers should return a Context" unless ctx.is_a?(Context)
+
+          x if ctx.reuse_handler?
+        else
+          x
+        end
+      end.compact
+    end
+  end
+
+  class XmppSASL < ::SASL::Preferences
+    attr_accessor :handler
+    def initialize(handler)
+      @handler = handler
+    end
+    def realm
+      handler.jid.domain
+    end
+    def digest_uri
+      'xmpp/' + handler.jid.domain
+    end
+    def username
+      handler.jid.node
+    end
+    def has_password?
+      true
+    end
+    def password
+      ret = handler.pass
+    end
+  end
+
+  class Routine < Handler
+  end
+
+  class StreamNegotiation < Handler
+    attr_reader :sasl
+
+    def initialize(conn)
+      super conn
+      @sasl   = nil
+      setup_handlers
+    end
+
+    def c
+      @connection
+    end
+
+    def jid
+      @connection.jid
+    end
+
+    def pass
+      @connection.pass
+    end
+
+    def setup_handlers
+      on('//xmlns:starttls', {'xmlns' => TLS}) do |ctx|
+        @connection.ask_for_tls 
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:proceed', {'xmlns' => TLS }) do |ctx|
+        @connection.start_using_tls_and_reset_stream
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:mechanisms', {'xmlns' => SASL}) do |ctx|
+        search = ctx.xpath('//xmlns:mechanisms', {'xmlns' => SASL})
+        if search.first
+          mechanisms = search.first.children.map(&:content)
+          start_sasl mechanisms
+          ctx.delete_xpath_handler!.done!
+        else
+          raise RuntimeError, "how come there is no mechanism node?"
+        end
+      end
+
+      on('//xmlns:challenge', {'xmlns' => SASL}) do |ctx|
+        sasl_step ctx.stanza
+        ctx.done!
+      end
+
+      on('//xmlns:success', {'xmlns' => SASL}) do |ctx|
+        @connection.restart_xml_stream
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:bind', {'xmlns' => Bind}) do |ctx|
+        bind_to_resource  
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:bind', {'xmlns' => Bind}) do |ctx|
+        jid  = extract_jid ctx.stanza
+
+        if jid
+          @connection.jid_received jid 
+          start_session
+        else
+          raise RuntimeError, "no jid despite binding"
+        end
+
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:session', {'xmlns' => Session}) do |ctx|
+        @connection.negotiation_finished
+        ctx.delete_xpath_handler!.done!
+      end
+
+      on('//xmlns:failure', {'xmlns' => SASL}) do |ctx|
+        @connection.negotiation_failed(ctx.stanza)
+        ctx.done!
+      end
+
+      on(:anything) do |ctx|
+        @connection.unhandled ctx.stanza
+      end
+    end
+
+    def extract_jid(stanza)
+      jid = stanza.xpath('//bind:jid', {'bind' => Bind})
+      jid.text if jid.any?
+    end
+
+    def bind_to_resource(wanted_res=nil)
+      c.send_raw(c.iq_stanza('type' => 'set') do |x|
+        x.bind('xmlns' => Bind) do |y|
+          y.resource(wanted_res) if wanted_res
+        end
+      end)
+    end
+
+    def start_session
+      c.send_raw(c.iq_stanza('type' => 'set', 'to' => jid.domain) do |x|
+        x.session('xmlns' => Session) 
+      end)
+    end
+
+    def start_sasl(methods)
+      @sasl = ::SASL.new(methods, XmppSASL.new(self))
+      msg,val = sasl.start
+      mech = sasl.mechanism
+      reply_sasl(msg,val,mech)
+    end
+
+    def sasl_step(stanza)
+      msg       = stanza.name
+      inStr     = Base64.strict_decode64(stanza.text)
+      meth,str  = sasl.receive msg, inStr
+      b64       = str ? Base64.strict_encode64(str) : ''
+      reply_sasl(meth, b64)
+    end
+
+    def reply_sasl(msg, val=nil, mech=nil)
+      c.send_xml do |x|
+        if val
+          x.send(msg, val, {'xmlns' => SASL, 'mechanism' => mech})
+        else
+          x.send(msg,  {'xmlns' => SASL, 'mechanism' => mech})
+        end
+      end
+    end
+
+  end
+end

data/lib/em-xmpp/jid.rb

@@ -0,0 +1,27 @@
+
+
+module EM::Xmpp
+  JID = Struct.new(:node, :domain, :resource) do
+    def self.parse(str)
+      s1,s2 = str.split('@',2)
+      if s2.nil?
+        self.new(nil, s1, nil)
+      else
+        s2,s3 = s2.split('/',2)
+        self.new(s1,s2,s3)
+      end
+    end
+
+    def bare
+      [node,domain].map(&:to_s).join('@')
+    end
+
+    def full
+      [bare,resource].map(&:to_s).join('/')
+    end
+
+    def to_s
+      full
+    end
+  end
+end

data/lib/em-xmpp/namespaces.rb

@@ -0,0 +1,31 @@
+
+module EM::Xmpp
+  # A handy module with the XMPP namespaces name.
+  module Namespaces
+    Client = 'jabber:client'
+    #In-band registration
+    Registration = 'http://jabber.org/features/iq-register'
+    #XMPP stream-level stanza
+    Stream  = 'http://etherx.jabber.org/streams'
+    #TLS negotiation
+    TLS = 'urn:ietf:params:xml:ns:xmpp-tls'
+    #SASL authentication
+    SASL = 'urn:ietf:params:xml:ns:xmpp-sasl'
+    #XMPP resource binding
+    Bind = 'urn:ietf:params:xml:ns:xmpp-bind'
+    #XMPP session creation
+    Session = 'urn:ietf:params:xml:ns:xmpp-session'
+    #XMPP capabilities discovery
+    Capabilities = "http://jabber.org/protocol/caps"
+    #XMPP item discovery
+    DiscoverItems = "http://jabber.org/protocol/disco#items"
+    #XMPP info discovery
+    DiscoverInfos = "http://jabber.org/protocol/disco#infos"
+    #XMPP commands
+    Commands = "http://jabber.org/protocol/commands"
+    #XMPP delayed delivery
+    Delay = "urn:xmpp:delay"
+    #Jabber Data forms
+    DataForms  = 'jabber:x:data'
+  end
+end

data/lib/em-xmpp/nodes.rb

@@ -0,0 +1,8 @@
+
+module EM::Xmpp
+  # A handy module with the XMPP discovery and pubsub names.
+  # see http://xmpp.org/registrar/nodes.html
+  module Nodes
+    Commands = 'http://jabber.org/protocol/commands'
+  end
+end

data/lib/em-xmpp/resolver.rb

@@ -0,0 +1,23 @@
+
+require 'resolv'
+module EM::Xmpp
+  module Resolver
+    extend self
+
+    def resolve(domain)
+      resolve_all(domain).first
+    end
+
+    def resolve_all(domain)
+      srv = []
+      Resolv::DNS.open do |dns|
+        record = "_xmpp-client._tcp.#{domain}"
+        srv = dns.getresources(record, Resolv::DNS::Resource::IN::SRV)
+      end
+
+      srv.sort do |a,b|
+        (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight)
+      end
+    end
+  end
+end

data/lib/em-xmpp/version.rb

@@ -0,0 +1,5 @@
+module Em
+  module Xmpp
+    VERSION = "0.0.1"
+  end
+end

data/lib/em-xmpp.rb

@@ -0,0 +1,9 @@
+require 'eventmachine'
+require "em-xmpp/version"
+require "em-xmpp/connection"
+
+module EM
+  module Xmpp
+    # Your code goes here...
+  end
+end

data/samples/echo.rb

@@ -0,0 +1,40 @@
+
+$LOAD_PATH.unshift './lib'
+require 'em-xmpp'
+require 'em-xmpp/namespaces'
+require 'em-xmpp/nodes'
+
+if ARGV.empty?
+  puts "usage: #{__FILE__} <jid> [<pass>]"
+  exit 0 
+end
+
+jid     = ARGV.first
+pass    = ARGV[1]
+
+include EM::Xmpp::Namespaces
+include EM::Xmpp::Nodes
+
+module MyClient
+  def ready
+    puts "***** #{@jid} ready for #{self}"
+
+    on_presence do |s|
+      p "*presence> #{s.from} #{s.show} (#{s.status})"
+      send_raw(s.reply('type'=>'subscribed')) if s.subscription_request?
+      s
+    end
+
+    on_message do |s|
+      p "*message> #{s.from}\n#{s.body}\n"
+      send_raw(s.reply do |x|
+        x.body "you sent:#{s.body}"
+      end)
+      s
+    end
+  end
+end
+
+EM.run do
+  EM::Xmpp::Connection.start(jid, pass, MyClient)
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: em-xmpp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- crapooze
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2153101140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153101140
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2153100720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153100720
+- !ruby/object:Gem::Dependency
+  name: ruby-sasl
+  requirement: &2153100300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153100300
+description: XMPP client for event machine
+email:
+- crapooze@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- em-xmpp.gemspec
+- lib/em-xmpp.rb
+- lib/em-xmpp/cert_store.rb
+- lib/em-xmpp/connection.rb
+- lib/em-xmpp/connector.rb
+- lib/em-xmpp/context.rb
+- lib/em-xmpp/handler.rb
+- lib/em-xmpp/jid.rb
+- lib/em-xmpp/namespaces.rb
+- lib/em-xmpp/nodes.rb
+- lib/em-xmpp/resolver.rb
+- lib/em-xmpp/version.rb
+- samples/echo.rb
+homepage: https://github.com/crapooze/em-xmpp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Easy to write and to extend XMPP client
+test_files: []