cancer 0.1.0.a1

data/lib/cancer/xeps/xep_0020_feature_neg.rb

@@ -0,0 +1,35 @@
+
+module Cancer
+  # Feature Negotiation
+  # http://xmpp.org/extensions/xep-0020.html
+  module XEP_0020
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0004'
+    
+    NS = 'http://jabber.org/protocol/feature-neg'
+    
+    def self.enhance_stream(stream)
+      stream.extend_builder do
+        include Cancer::XEP_0020::BuilderHelper
+      end
+    end
+    
+    module BuilderHelper
+      
+      # type can bet :get and :set
+      def negotiate_features(type=:get, form=nil, &proc)
+        self.feature(:xmlns => Cancer::XEP_0020::NS) do
+          if form
+            self.x(form, :type => (type == :get ? :form : :submit), :verbose => (type == :get))
+          else
+            self.x(:type => (type == :get ? :form : :submit), :verbose => (type == :get), &proc)
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0030_disco.rb

@@ -0,0 +1,167 @@
+
+module Cancer
+  # Service Discovery
+  # http://xmpp.org/extensions/xep-0030.html
+  module XEP_0030
+    include Cancer::XEP
+    
+    ITEMS_NS = "http://jabber.org/protocol/disco#items"
+    INFO_NS  = "http://jabber.org/protocol/disco#info"
+    
+    dependency 'core'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0030::StreamHelpers
+      end
+      stream.install_controller(Cancer::XEP_0030::Controller)
+      stream.disco.identity(:category => 'client', :type => 'pc', :name => 'Cancer')
+      stream.disco.feature INFO_NS
+      stream.disco.feature ITEMS_NS
+    end
+    
+    class Item
+      
+      attr_reader :jid, :node, :name
+      attr_reader :features, :identities, :items
+      
+      def initialize(stream, options={})
+        @stream = stream
+        
+        @jid  = options[:jid].to_jid if options[:jid]
+        @node = options[:node]
+        @name = options[:name]
+        
+        @items      = {}
+        @features   = []
+        @identities = []
+      end
+      
+      def items
+        @items.values
+      end
+      
+      def [](node)
+        @items[node.to_s]
+      end
+      
+      def identity(options={})
+        self.identities.push({
+          :name     => (options[:name]     ? options[:name].to_s     : nil),
+          :type     => (options[:type]     ? options[:type].to_s     : nil),
+          :category => (options[:category] ? options[:category].to_s : nil)
+        })
+      end
+      
+      def feature(var)
+        self.features.push(var.to_s)
+      end
+      
+      def item(options={})
+        item = self[options[:node].to_s] || Item.new(@stream, options)
+        yield(item) if block_given?
+        @stream.disco_items[options[:node].to_s] = item
+        @items[options[:node].to_s] = item
+        item
+      end
+      
+    end
+    
+    class Controller < Cancer::Controller
+      
+      on { |e| e.xpath('/c:iq[@type="get"]/d:query', 'c' => CLIENT_NS, 'd' => INFO_NS) }
+      def respond_with_info(e)
+        query_node = e.xml.first('/c:iq/d:query', 'c' => CLIENT_NS, 'd' => INFO_NS)
+        node       = (query_node[:node] ? query_node[:node].to_s : nil)
+        item       = (node ? disco_items[node] : disco)
+        
+        return unless item
+        
+        send_iq(e.sender, :result, e.id, e.receiver) do |x|
+          x.query((node ? {:node => node} : {}).merge(:xmlns => INFO_NS)) do
+            item.identities.each do |identity|
+              x.identity(identity)
+            end
+            item.features.each do |var|
+              x.feature(:var => var)
+            end
+          end
+        end
+        
+      end
+      
+      on { |e| e.xpath("/c:iq[@type='get']/d:query", 'c' => CLIENT_NS, 'd' => ITEMS_NS) }
+      def respond_with_items(e)
+        query_node = e.xml.first('/c:iq/d:query', 'c' => CLIENT_NS, 'd' => ITEMS_NS)
+        node       = (query_node[:node] ? query_node[:node].to_s : nil)
+        item       = (node ? disco_items[node] : disco)
+        
+        return unless item
+        
+        send_iq(e.sender, :result, e.id, e.receiver) do |x|
+          x.query((node ? {:node => node} : {}).merge(:xmlns => ITEMS_NS)) do
+            item.items.each do |i|
+              attributes = {}
+              attributes[:node] = i.node if i.node
+              attributes[:name] = i.name if i.name
+              attributes[:jid]  = i.jid  if i.jid
+              x.item(attributes)
+            end
+          end
+        end
+        
+      end
+      
+    end
+    
+    module StreamHelpers
+      
+      def disco
+        @disco_root ||= Cancer::XEP_0030::Item.new(self)
+      end
+      
+      def disco_items
+        @disco_items ||= {}
+      end
+      
+      def disco_items_for(jid, node=nil)
+        result = send_iq(jid) do |x|
+          attibutes = { :xmlns => Cancer::XEP_0030::ITEMS_NS }
+          attibutes[:node] = node if node
+          x.query attibutes
+        end
+        
+        return nil unless result[:type] == 'result'
+        
+        result = result.all('n:query/n:item', 'n' => Cancer::XEP_0030::ITEMS_NS)
+        result.collect do |item|
+          item.attributes
+        end
+      end
+      
+      def disco_info_for(jid, node=nil)
+        result = send_iq(jid) do |x|
+          attibutes = { :xmlns => Cancer::XEP_0030::INFO_NS }
+          attibutes[:node] = node if node
+          x.query attibutes
+        end
+        
+        return nil unless result[:type] == 'result'
+        
+        return_value = Item.new(:jid => jid, :node => node)
+        
+        result.all('n:query/n:identity', 'n' => Cancer::XEP_0030::INFO_NS) do |e|
+          return_value.identity e
+        end
+        
+        result.all('n:query/n:feature', 'n' => Cancer::XEP_0030::INFO_NS) do |e|
+          return_value.feature e[:var]
+        end
+        
+        return_value
+      end
+      
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0047_ibb.rb

@@ -0,0 +1,322 @@
+
+module Cancer
+  # In-Band Bytestreams
+  # http://xmpp.org/extensions/xep-0047.html
+  module XEP_0047
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0095', :weak => true
+    
+    NS = 'http://jabber.org/protocol/ibb'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0047::StreamHelpers
+      end
+      stream.install_controller   Cancer::XEP_0047::Controller
+      stream.install_event_helper Cancer::XEP_0047::EventDSL
+      if stream.respond_to?(:register_stream_method)
+        stream.register_stream_method(Cancer::XEP_0047::StreamMethod, Cancer::XEP_0047::NS)
+        stream.install_controller Cancer::XEP_0047::IBBController
+      end
+      stream.disco.feature NS
+    end
+    
+    class Controller < Cancer::Controller
+      
+      NAMESPACES = { 'c' => CLIENT_NS, 'ibb' => NS }
+      
+      on { |e| e.xpath('/c:iq/ibb:open', NAMESPACES) }
+      def open_bytestream(e)
+        open_element = e.xml.first('/c:iq/ibb:open', NAMESPACES)
+        bytestream = Bytestream.new(
+          self,
+          e.sender,
+          open_element['block-size'].to_i,
+          open_element['sid'],
+          open_element['stanza'] || 'iq')
+        fire! Event, self, bytestream, e.id
+      end
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/ibb:data', NAMESPACES) }
+      def receive_data(e)
+        data_element = e.xml.first('ibb:data', NAMESPACES)
+        bytestream   = nil
+        
+        if data_element[:sid]
+          bytestream = active_bytestreams[data_element[:sid]]
+        else
+          respond_with_error(:missing_session, e.sender, e.id)
+        end
+        
+        if bytestream
+          bytestream.received_packet(
+            data_element[:seq].to_i,
+            Base64.decode64(data_element.text))
+          acknowledge_data(e.xml)
+        else
+          respond_with_error(:missing_session, e.sender, e.id)
+        end
+      end
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/ibb:close', NAMESPACES) }
+      def close_bytestream(e)
+        close_element = e.xml.first('ibb:close', NAMESPACES)
+        bytestream    = nil
+        
+        if close_element[:sid]
+          bytestream = active_bytestreams[close_element[:sid]]
+        else
+          respond_with_error(:missing_session, e.sender, e.id)
+        end
+        
+        if bytestream
+          bytestream.internal.close unless bytestream.internal.closed?
+          acknowledge_data(e.xml)
+        else
+          respond_with_error(:missing_session, e.sender, e.id)
+        end
+      end
+      
+      def active_bytestreams
+        @active_bytestreams ||= {}
+      end
+      
+      def accept_bytestream(event)
+        active_bytestreams[event.bytestream.stream_id] = event.bytestream
+        send_iq(event.bytestream.peer, :result, event.iq_id)
+      end
+      
+      def reject_bytestream(event)
+        send_iq(event.bytestream.peer, :error, event.iq_id) do |x|
+          x.error(:type => 'cancel') do
+            x.send('not-acceptable', :xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas')
+          end
+        end
+      end
+      
+      def acknowledge_data(iq)
+        send_iq(iq[:from], :result, iq[:id])
+      end
+      
+      def respond_with_error(error_type, to, id)
+        case error_type
+        when :missing_session
+          send_iq(to, :error, id) do |x|
+            x.error(:type => 'cancel') do
+              x.send('item-not-found', :xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas')
+            end
+          end
+          throw :halt
+          
+        end
+      end
+      
+    end
+    
+    module StreamHelpers
+      
+      def open_ibb(to, options={}, &proc)
+        controller = self.controllers_by_name['Cancer::XEP_0047::Controller']
+        
+        bytestream = Bytestream.new(
+          controller,
+          to, options[:block_size], options[:stream_id])
+        
+        controller.active_bytestreams[bytestream.stream_id] = bytestream
+        result = send_iq(to, :set) do |x|
+          x.open(
+            :xmlns => Cancer::XEP_0047::NS,
+            :'block-size' => bytestream.block_size,
+            :sid          => bytestream.stream_id,
+            :stanza       => bytestream.stanza
+          )
+        end
+        
+        if result[:type] == 'result'
+          yield(bytestream)
+          bytestream.close
+        else
+          nil
+        end
+      end
+      
+    end
+    
+    module Bytestream
+      
+      def self.new(controller, peer, block_size=nil, stream_id=nil, stanza=nil)
+        internal, external = * Socket.pair(Socket::AF_LOCAL, Socket::SOCK_STREAM, 0)
+        
+        external.extend self
+        external.setup(controller, internal, peer, block_size, stream_id.to_s, stanza)
+        
+        internal.extend Internal
+        internal.setup(controller, external)
+        internal.read_packets!
+        
+        def external.close
+          sleep 0.1
+          @controller.send_iq(@peer, :set) do |x|
+            x.close(:xmlns => NS, :sid => @stream_id)
+          end
+          self.remove_from_controller
+          super
+        end
+        
+        external
+      end
+      
+      module Internal
+        
+        attr_reader :packets, :controller, :external
+        attr_accessor :read_sec, :write_sec
+        
+        def peer
+          @external.peer
+        end
+        
+        def block_size
+          @external.block_size
+        end
+        
+        def stream_id
+          @external.stream_id
+        end
+        
+        def stanza
+          @external.stanza
+        end
+        
+        def setup(controller, external)
+          @controller, @external = controller, external
+          @read_sec = @write_sec = 0
+          @packets  = {}
+        end
+        
+        def received_packet(sec, packet)
+          self.packets[sec.to_i] = packet
+          while bufferd_packet = self.packets.delete(self.read_sec)
+            begin
+              self.write(bufferd_packet)
+              self.flush
+              self.read_sec += 1
+            rescue IOError
+            end
+          end
+        end
+        
+        def read_packets!
+          @controller.deferred(self) do |ibb|
+            loop do
+              
+              begin
+                packet = ibb.recv_nonblock(4096)
+                if packet and !packet.empty?
+                ibb.send_packet(ibb.write_sec, packet)
+                ibb.write_sec += 1
+                end
+              rescue Errno::EAGAIN, OpenSSL::SSL::ReadAgain
+                IO.select([ibb], nil, nil, 0.5) rescue nil
+                retry
+              rescue IOError
+                break
+              rescue OpenSSL::SSL::SSLError
+                break
+              end
+              
+            end
+          end
+        end
+        
+        def send_packet(sec, packet)
+          @controller.send_iq(self.peer, :set) do |x|
+            x.data(:xmlns => NS, :seq => sec, :sid => self.stream_id) do
+              x.text Base64.encode64(packet)
+            end
+          end
+        end
+        
+      end
+      
+      attr_reader :controller, :internal, :peer, :block_size, :stream_id, :stanza
+      
+      def setup(controller, internal, peer, block_size=nil, stream_id=nil, stanza=nil)
+        @controller, @internal = controller, internal
+        @peer, @block_size, @stream_id, @stanza = 
+         peer,  block_size,  stream_id,  stanza
+        
+        @stanza     ||= 'iq'
+        @stream_id  ||= rand(1<<100).to_s
+        @block_size ||= 4096
+      end
+      
+      def received_packet(sec, packet)
+        self.internal.received_packet(sec, packet)
+      end
+      
+      def remove_from_controller
+        self.controller.active_bytestreams.delete(self.stream_id)
+      end
+      
+    end
+    
+    class Event < Cancer::Events::AbstractEvent
+      attr_reader :bytestream, :iq_id
+      def initialize(controller, bytestream, iq_id)
+        @controller, @bytestream, @iq_id = controller, bytestream, iq_id
+      end
+      
+      def accept!(&proc)
+        @controller.accept_bytestream(self)
+        if block_given?
+          @controller.enqueue(@bytestream, proc) do |bs, proc|
+            proc.call(bs)
+          end
+        end
+      end
+      
+      def reject!
+        @controller.reject_bytestream(self)
+      end
+    end
+    
+    class EventMatcher < Cancer::Events::Matcher
+      
+      def initialize
+      end
+      
+      def match?(event)
+        Event === event
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def ibb
+        Cancer::XEP_0047::EventMatcher.new
+      end
+      
+    end
+    
+    class StreamMethod < Cancer::XEP_0095::StreamMethod
+      def handle(to, id, &proc)
+        @stream.open_ibb(to, :stream_id => id, &proc)
+      end
+    end
+    
+    class IBBController < Cancer::Controller
+      on { |e| e.ibb }
+      def catch_ibb(e)
+        controller = self.controllers_by_name['Cancer::XEP_0095::Controller']
+        si_event = controller.pending_streams[e.bytestream.stream_id.to_s]
+        if si_event
+          si_event.caught_stream!(e)
+        end
+      end
+    end
+    
+  end
+end