cancer 0.1.0.a1

data/lib/cancer/xeps/xep_0114_component.rb

@@ -0,0 +1,73 @@
+
+module Cancer
+  # Jabber Component Protocol
+  # http://xmpp.org/extensions/xep-0114.html
+  module XEP_0114
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0138', :weak => true
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0114::Helpers
+        
+        alias_method_chain :send_stream_header,    :xep_0114
+        alias_method_chain :process_send_data,     :xep_0114
+        alias_method_chain :process_received_data, :xep_0114
+        alias_method_chain :resolve_options,       :xep_0114
+      end
+      
+      stream.install_controller(Cancer::XEP_0114::Controller)
+    end
+    
+    module Helpers
+      def send_stream_header_with_xep_0114
+        send %(<stream:stream xmlns="jabber:component:accept" xmlns:stream="#{STREAM_NS}" to="#{options[:jid].bare_jid}" version="1.0">)
+      end
+      
+      def process_send_data_with_xep_0114(data)
+        data = data.to_s
+        data.gsub!("jabber:client", "jabber:component:accept")
+        process_send_data_without_xep_0114(data)
+      end
+      
+      def process_received_data_with_xep_0114(data)
+        data = process_received_data_without_xep_0114(data)
+        data.gsub!("jabber:component:accept", "jabber:client") if data
+        data
+      end
+      
+      def resolve_options_with_xep_0114(options)
+        options[:default_port] ||= 5347
+        options[:username] ||= options[:jid].bare_jid.to_s
+      end
+    end
+    
+    class Controller < Cancer::Controller
+      
+      priority 300
+      
+      on { |e| e.xpath('/n:stream', 'n' => STREAM_NS) }
+      def send_handshake(e)
+        send do |x|
+          x.handshake { x.text Digest::SHA1.hexdigest(options[:session_id]+options[:password]) }
+        end
+      end
+      
+      # we use jabber:client here because we replace jabber:component:accept with jabber:client
+      on { |e| e.xpath('/c:handshake', 'c' => "jabber:client") }
+      def handshake_was_accespted
+        fire! Cancer::Events::NamedEvent, :initialized
+        initialization_completed!
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0115_caps.rb

@@ -0,0 +1,180 @@
+
+require 'digest/sha1'
+require 'base64'
+
+module Cancer
+  # Entity Capabilities
+  # http://xmpp.org/extensions/xep-0115.html
+  module XEP_0115
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'im'
+    dependency 'xep-0030'
+    
+    NS = 'http://jabber.org/protocol/caps'
+    NAMESPACES = { 'c' => CLIENT_NS, 'caps' => NS, 'disco' => Cancer::XEP_0030::INFO_NS }
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0115::StreamHelpers
+      end
+      stream.install_controller Cancer::XEP_0115::Controller
+      stream.disco.feature NS
+      
+      stream.presence_enhancer_for :status do |x|
+        controller = self.controllers_by_name['Cancer::XEP_0115::Controller']
+        controller.cache_disco_data(self.disco)
+        x.c(:xmlns => NS, :hash => 'sha-1', :node => CLIENT,
+          :ver => controller.verification_code(self.disco))
+      end
+    end
+    
+    module StreamHelpers
+      def send_capabilities(to=nil, item=self.disco)
+        controller = self.controllers_by_name['Cancer::XEP_0115::Controller']
+        send do |x|
+          
+          controller.cache_disco_data(item)
+          
+          x.presence(to ? {:to => to} : {}) do
+            x.c(:xmlns => NS, :hash => 'sha-1', :node => CLIENT, :ver => controller.verification_code(item))
+          end
+          
+        end
+      end
+    end
+    
+    class Controller < Cancer::Controller
+      
+      def capabilities
+        @capabilities ||= {}
+      end
+      
+      on(:priority => 5) { |e| e.xpath('/c:iq[@type="get"]/disco:query', NAMESPACES) }
+      def catch_capabilities_query(e)
+        query_node = e.xml.first('/c:iq/disco:query', NAMESPACES)
+        
+        if (node = query_node[:node]) and (capabilities = self.capabilities[node.to_s])
+          
+          send_iq(e.sender, :result) do |x|
+            x.query(:xmlns => Cancer::XEP_0030::INFO_NS, :node => node) do
+              
+              capabilities.identities.each do |identity|
+                x.identity(identity)
+              end
+              
+              capabilities.features.each do |feature|
+                x.feature(:var => feature)
+              end
+              
+            end
+          end
+          
+          throw :halt
+        end
+      end
+      
+      on { |e| e.xpath('/c:presence/caps:c', NAMESPACES) }
+      def received_caps(e)
+        caps = e.xml.first('/c:presence/caps:c', NAMESPACES)
+        self.peers[e.sender].client = caps[:node].to_s
+        self.peers[e.sender].capabilities_id = caps[:ver].to_s
+        
+        capabilities_node = "#{caps[:node]}##{caps[:ver]}"
+        unless self.capabilities[capabilities_node]
+          item   = disco_info_for(e.sender, capabilities_node)
+          item ||= disco_info_for(e.sender, capabilities_node)
+          if item and verify_disco_item(item, caps[:ver].to_s, caps[:hash].to_s)
+            self.capabilities[capabilities_node] = item
+          end
+        end
+        
+        self.peers[e.sender].disco = self.capabilities[capabilities_node]
+      end
+      
+      def cache_disco_data(item=self.disco, hash='sha-1')
+        verification_string = verification_code(item, hash)
+        capabilities_node = "#{CLIENT}##{verification_string}"
+        
+        self.capabilities[capabilities_node] = item
+        
+        item
+      end
+      
+      def verification_code(item, hash='sha-1')
+        
+        identities = item.identities.dup
+        features   = item.features.dup
+        
+        fields = [:category, :type, :lang, :name]
+        identities.sort! do |a,b|
+          cmp_result = nil
+          fields.each do |field|
+            value_a = a[field]
+            value_b = b[field]
+            
+            if value_a != value_b
+              cmp_result = value_a.cmp_ioctet(value_b)
+              break
+            end
+          end
+          cmp_result
+        end
+        
+        identities.collect! do |identity|
+          "#{identity[:category]}/#{identity[:type]}/#{identity[:lang]}/#{identity[:name]}<"
+        end
+        
+        if identities.uniq.size < identities.size
+          raise InvalidVerificationString, "this is invalid disco info (duplicate identity)"
+        end
+        
+        
+        features.sort! do |a,b|
+          a.cmp_ioctet(b)
+        end
+        
+        features.collect! { |f| f + "<" }
+        
+        if features.uniq.size < features.size
+          raise InvalidVerificationString, "this is invalid disco info (duplicate feature)"
+        end
+        
+        verification_string = (identities + features).join('')
+        
+        digest_klass = case hash
+        # when 'md2' then nil
+        when 'md5' then Digest::MD5
+        when 'sha-1' then Digest::SHA1
+        # when 'sha-224' then nil
+        when 'sha-256' then Digest::SHA256
+        when 'sha-384' then Digest::SHA384
+        when 'sha-512' then Digest::SHA512
+        else raise UnknownHashMethod, "the hash method #{hash} is not supported"
+        end
+        
+        verification_string = digest_klass.digest(verification_string)
+        
+        return Base64.encode64(verification_string).gsub(/\s|\n/, '')
+        
+      end
+      
+      def verify_disco_item(item, received_ver, hash)
+        generated_ver = verification_code(item, hash)
+        return generated_ver == received_ver
+      rescue InvalidVerificationString
+        return false
+      end
+      
+    end
+    
+    class InvalidVerificationString < RuntimeError ; end
+    class UnknownHashMethod         < RuntimeError ; end
+    
+    class ::Cancer::IM::Peer
+      attr_accessor :client, :capabilities_id, :disco
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0138_compress.rb

@@ -0,0 +1,134 @@
+
+require 'zlib'
+
+module Cancer
+  # Stream Compression
+  # http://xmpp.org/extensions/xep-0138.html
+  module XEP_0138
+    include Cancer::XEP
+    
+    dependency 'core'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0138::Helpers
+        
+        alias_method_chain :process_send_data,     :xep_0138
+        alias_method_chain :process_received_data, :xep_0138
+        alias_method_chain :close,                 :xep_0138
+      end
+      
+      stream.install_controller(Controller)
+      stream.register_compressor('zlib', Zlib)
+    end
+    
+    module Helpers
+      def process_send_data_with_xep_0138(data)
+        data = data.to_s
+        data = @compressor.deflate(data) if @compressor
+        process_send_data_without_xep_0138(data)
+      end
+      
+      def process_received_data_with_xep_0138(data)
+        data = process_received_data_without_xep_0138(data)
+        data = @compressor.inflate(data) if @compressor and data
+        data
+      end
+      
+      def close_with_xep_0138
+        close_without_xep_0138
+        if @compressor and @compressor.respond_to?(:close)
+          @compressor.close
+        end
+        self
+      end
+    
+      def install_compressor(compressor)
+        @compressor = compressor
+      end
+      
+      def available_compressors
+        compressors.keys
+      end
+      
+      def register_compressor(name, klass)
+        compressors[name] = klass
+      end
+      
+      def compressor_class(name)
+        compressors[name]
+      end
+      
+    private
+      
+      def compressors
+        @compressors ||= {}
+      end
+      
+    end
+    
+    class Controller < Cancer::Controller
+      
+      FEATURES_NS = "http://jabber.org/features/compress"
+      PROTOCOL_NS = "http://jabber.org/protocol/compress"
+      
+      priority 250
+      
+      on { |e| e.xpath('/s:features/c:compression/c:method', 'c' => FEATURES_NS, 's' => STREAM_NS) }
+      def try_compression(e)
+        methods = e.xml.all('/stream:features/c:compression/c:method', 'c' => FEATURES_NS)
+        methods = methods.to_a.collect { |m| m.text }
+        @methods = (methods & available_compressors)
+        return if @methods.empty?
+        
+        try_compressor
+      end
+      
+      on { |e| e.xpath('/n:compressed', 'n' => PROTOCOL_NS) }
+      def restart_stream_on_compressed(e)
+        install_compressor(compressor_class(@current_method).new(options))
+        restart_stream
+      end
+      
+      on { |e| e.xpath('/n:failure', 'n' => PROTOCOL_NS) }
+      def retry_other_compression_method_on_failure(e)
+        try_compressor
+      end
+      
+      def try_compressor
+        @current_method = @methods.shift
+        throw :skip unless @current_method
+        
+        send do |x|
+          x.compress(:xmlns => PROTOCOL_NS) do
+            x.method_ { x.text @current_method }
+          end
+        end
+        
+        throw :halt
+      end
+      
+    end
+    
+    class Zlib
+      def initialize(options={})
+        @inflate_io = ::Zlib::Inflate.new
+        @deflate_io = ::Zlib::Deflate.new(options[:compression_level] || ::Zlib::BEST_COMPRESSION)
+      end
+      
+      def inflate(data)
+        @inflate_io.inflate(data)
+      end
+      
+      def deflate(data)
+        @deflate_io.deflate(data, ::Zlib::FULL_FLUSH)
+      end
+      
+      def close
+        @inflate_io.close
+        @deflate_io.close
+      end
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0144_rosterx.rb

@@ -0,0 +1,250 @@
+
+module Cancer
+  # Roster Item Exchange
+  # http://xmpp.org/extensions/xep-0144.html
+  module XEP_0144
+    include Cancer::XEP
+    
+    NS = 'http://jabber.org/protocol/rosterx'
+    NAMESPACES = { 'c' => CLIENT_NS, 'rx' => NS }
+    
+    dependency 'core'
+    dependency 'im'
+    dependency 'xep-0030'
+    dependency 'xep-0115'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0144::StreamHelpers
+      end
+      stream.install_controller   Cancer::XEP_0144::Controller
+      stream.install_event_helper Cancer::XEP_0144::EventDSL
+      stream.disco.feature(NS)
+    end
+    
+    module StreamHelpers
+      
+      def exchange_roster(jid, message=nil, &proc)
+        if contact = roster[jid.to_jid.bare_jid]
+          if contact.peers.empty? or !peer_capabilities(jid).features.include?(NS)
+            send_roster_items_exchange_messages(jid.to_jid.bare_jid, message, &proc)
+          else
+            send_roster_items_exchange_iqs(jid, &proc)
+          end
+        end
+      end
+      
+    private
+      
+      def send_roster_items_exchange_messages(jid, message, &proc)
+        
+        builder = Builder.new(&proc)
+        
+        if builder.send(:build?, :add)
+          send_message(jid) do |x|
+            x.body message if message
+            builder.send(:build, x, :add)
+          end
+        end
+        
+        if builder.send(:build?, :delete)
+          send_message(jid) do |x|
+            x.body message if message
+            builder.send(:build, x, :delete)
+          end
+        end
+        
+        if builder.send(:build?, :modify)
+          send_message(jid) do |x|
+            x.body message if message
+            builder.send(:build, x, :modify)
+          end
+        end
+        
+      end
+      
+      def send_roster_items_exchange_iqs(jid, &proc)
+        
+        builder = Builder.new(&proc)
+        
+        if builder.send(:build?, :add)
+          send_iq(jid, :set) do |x|
+            builder.send(:build, x, :add)
+          end
+        end
+        
+        if builder.send(:build?, :delete)
+          send_iq(jid, :set) do |x|
+            builder.send(:build, x, :delete)
+          end
+        end
+        
+        if builder.send(:build?, :modify)
+          send_iq(jid, :set) do |x|
+            builder.send(:build, x, :modify)
+          end
+        end
+        
+      end
+      
+    end
+    
+    class Builder
+      
+      def initialize(builder)
+        @actions = {
+          :add    => [],
+          :delete => [],
+          :modify => []
+        }
+      end
+      
+      def add(jid, options={})
+        action(:add, jid, options)
+      end
+      
+      def delete(jid, options={})
+        action(:jid, jid, options)
+      end
+      
+      def modify(jid, options={})
+        action(:modify, jid, options)
+      end
+      
+    private
+      
+      def build?(action)
+        @actions[actions.to_sym] and !@actions[actions.to_sym].empty?
+      end
+      
+      def build(builder, action)
+        builder.x_(:xmlns => NS) do
+          @actions[actions.to_sym].each do |item|
+            build_item(builder, action, item)
+          end
+        end
+      end
+      
+      def build_item(builder, action, item)
+        jid, options = *item
+        builder.item({:action => action.to_s, :jid => jid.to_s, :name => options[:name]}.clean) do
+          options[:groups].each do |group|
+            builder.group(group)
+          end
+        end
+      end
+      
+      def action(action, jid, options={})
+        options[:groups] = [options.delete(:groups)], options.delete(:group)].flatten.compact.uniq
+        @actions[actions.to_sym].push([jid, options])
+      end
+      
+    end
+    
+    class Controller < Cancer::Controller
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/rx:x', NAMESPACES) }
+      def handle_iq(e)
+        handle_roster_items(e, e.xml.all('/c:iq/rx:x/rx:item', NAMESPACES))
+        send_iq(e.sender, :result, e.id)
+      end
+      
+      on { |e| e.xpath('/c:message/rx:x', NAMESPACES) }
+      def handle_message(e)
+        handle_roster_items(e, e.xml.all('/c:iq/rx:x/rx:item', NAMESPACES))
+      end
+      
+      def handle_roster_items(e, items)
+        items.each do |item|
+          name   = (item[:name] ? item[:name].to_s : nil)
+          groups = item.all('./rx:group', NAMESPACES).collect { |g| g.text.to_s }
+          fire! Cancer::XEP_0144::Event, e.sender, item[:action].to_s, item[:jid].to_s, name, groups
+        end
+      end
+      
+    end
+    
+    class Event < Cancer::Events::AbstractEvent
+      attr_reader :sender, :jid, :name, :groups, :action
+      def initialize(sender, action, jid, name, groups)
+        @sender, @action, @jid, @name, @groups = sender.to_jid, action.to_sym, jid.to_jid, name, groups
+      end
+    end
+    
+    class EventMatcher < Cancer::Events::Matcher
+      
+      def initialize(options={})
+        @sender = options.delete(:sender)
+        @action = options.delete(:action)
+        @jid    = options.delete(:jid)
+        @name   = options.delete(:name)
+        @groups = options.delete(:groups)
+      end
+      
+      def match?(event)
+        (
+          Cancer::XEP_0144::Event === event and
+          match_sender?(event)              and
+          match_action?(event)              and
+          match_jid?(event)                 and
+          match_name?(event)                and
+          match_groups?(event)
+        )
+      end
+      
+      def match_sender?(event, pattern=@sender)
+        case pattern
+        when String   then event.sender.to_s == pattern
+        when Regexp   then event.sender.to_s =~ pattern
+        when Array    then pattern.any? { |p| match_sender?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_action?(event, pattern=@action)
+        case pattern
+        when Symbol   then event.action == pattern
+        when Array    then pattern.any? { |p| match_action?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_jid?(event, pattern=@jid)
+        case pattern
+        when String   then event.jid.to_s == pattern
+        when Regexp   then event.jid.to_s =~ pattern
+        when Array    then pattern.any? { |p| match_jid?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_name?(event, pattern=@name)
+        case pattern
+        when String   then event.name == pattern
+        when Regexp   then event.name =~ pattern
+        when Array    then pattern.any? { |p| match_name?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_groups?(event, pattern=@groups)
+        case pattern
+        when String   then event.groups.include?(pattern)
+        when Regexp   then event.groups.any? { |group| group =~ pattern }
+        when Array    then pattern.any? { |p| match_groups?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def roster_exchange(options={})
+        Cancer::XEP_0144::EventMatcher.new(options)
+      end
+      
+    end
+    
+  end
+end