cancer 0.1.0.a1

data/lib/cancer/xeps/xep_0066_oob.rb

@@ -0,0 +1,69 @@
+
+module Cancer
+  # Out of Band Data
+  # http://xmpp.org/extensions/xep-0066.html
+  module XEP_0066
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0095', :weak => true
+    
+    IQ_NS = 'jabber:iq:oob'
+    X_NS  = 'jabber:x:oob'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0066::StreamHelpers
+      end
+      stream.extend_builder do
+        include Cancer::XEP_0066::BuilderHelper
+      end
+      stream.install_controller   Cancer::XEP_0066::Controller
+      stream.install_event_helper Cancer::XEP_0066::EventDSL
+      if stream.respond_to?(:register_stream_method)
+        stream.register_stream_method(Cancer::XEP_0066::StreamMethod, Cancer::XEP_0066::IQ_NS)
+      end
+    end
+    
+    module StreamHelpers
+      
+      def oob_offer(to, uri, desc=nil)
+        send_iq(to, :set) do |x|
+          x.query(:xmlns => Cancer::XEP_0066::IQ_NS) do
+            x.url { x.text(uri.to_s) }
+            x.desc { x.text(desc) } if desc
+          end
+        end
+      end
+      
+    end
+    
+    module BuilderHelper
+      
+      def oob_offer(uri, desc=nil)
+        self.x(:xmlns => Cancer::XEP_0066::X_NS) do
+          self.url { x.text(uri.to_s) }
+          self.desc { x.text(desc) } if desc
+        end
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def oob_offer
+        ( xpath('/c:iq[@type="set"]/oob:query', 'c' => CLIENT_NS, 'oob' => IQ_NS)
+        | xpath('/c:message/oob:x',             'c' => CLIENT_NS, 'oob' => X_NS)
+        )
+      end
+      
+    end
+    
+    class StreamMethod < Cancer::XEP_0095::StreamMethod
+      def handle(to, stream_id, &proc)
+        @stream.oob_offer(to, uri, :stream_id => stream_id)
+      end
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0095_si.rb

@@ -0,0 +1,211 @@
+
+module Cancer
+  # Stream Initiation
+  # http://xmpp.org/extensions/xep-0095.html
+  module XEP_0095
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0020'
+    dependency 'xep-0030'
+    
+    NS = 'http://jabber.org/protocol/si'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0095::StreamHelper
+      end
+      stream.install_controller   Cancer::XEP_0095::Controller
+      stream.install_event_helper Cancer::XEP_0095::EventDSL
+      stream.disco.feature NS
+    end
+    
+    class Profile
+      def initialize(stream)
+        @stream = stream
+      end
+      def enhance_si(si, options={})
+        
+      end
+    end
+    
+    class StreamMethod
+      def initialize(stream)
+        @stream = stream
+      end
+      def handle(to, stream_id, &proc)
+        
+      end
+    end
+    
+    module StreamHelper
+    
+      def profiles
+        @profiles ||= {}
+      end
+      
+      def register_profile(handler, uri)
+        self.profiles[uri.to_s] = handler.new(self)
+      end
+      
+      def stream_methods
+        @stream_methods ||= {}
+      end
+      
+      def register_stream_method(handler, uri)
+        self.stream_methods[uri.to_s] = handler.new(self)
+      end
+      
+      def si_offer(to, options={}, &proc)
+        si_options = {}
+        si_options[:'id']        = options.delete(:id) || rand(1<<20)
+        si_options[:'mime-type'] = options.delete(:mime_type) || options.delete(:'mime-type') || options.delete(:type)
+        si_options[:profile]     = options.delete(:profile)
+        si_options[:xmlns]       = NS
+        
+        profile = self.profiles[si_options[:profile]]
+        
+        result = send_iq(to, :set) do |x|
+          x.si(si_options) do
+            profile.enhance_si(x, options)
+            x.negotiate_features do |form|
+              form.define('stream-method') do |field|
+                field.type = :'list-single'
+                
+                self.stream_methods.keys.each do |uri|
+                  field.add_option uri
+                end
+                
+              end
+            end
+          end
+        end
+        
+        begin
+          form = Cancer::XEP_0004::Form.load(result.first(
+            "/c:iq[@type='result']/si:si/neg:feature/x:x",
+            'c'   => CLIENT_NS,
+            'si'  => Cancer::XEP_0095::NS,
+            'neg' => Cancer::XEP_0020::NS,
+            'x'   => Cancer::XEP_0004::NS
+          ))
+          stream_method = form['stream-method']
+          
+          self.stream_methods[stream_method].handle(to, si_options[:id], &proc)
+        rescue
+          nil
+        end
+      end
+      
+    end
+    
+    class Controller < Cancer::Controller
+      
+      NAMESPACES = { 'c' => CLIENT_NS, 'si' => NS }
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/si:si', NAMESPACES) }
+      def received_si(e)
+        si = e.xml.first('/c:iq/si:si', NAMESPACES)
+        fire! Cancer::XEP_0095::Event, self, e.xml, si
+      end
+      
+      def pending_streams
+        @pending_streams ||= {}
+      end
+      
+      def catch_stream(id, event)
+        self.pending_streams[id.to_s] = event
+      end
+      
+    end
+    
+    class Event < Cancer::Events::AbstractEvent
+      attr_reader :si, :iq, :accept_proc
+      def initialize(controller, iq, si)
+        @controller, @iq, @si = controller, iq, si
+      end
+      
+      def accept!(&proc)
+        form = Cancer::XEP_0004::Form.load(si.all("neg:feature/x:x",
+          'neg' => Cancer::XEP_0020::NS,
+          'x'   => Cancer::XEP_0004::NS))
+        
+        stream_method = (form.field('stream-method').option_values & @controller.stream_methods.keys).first
+        form['stream-method'] = stream_method
+        
+        unless stream_method
+          # error
+          return false
+        end
+        
+        @controller.send_iq(@iq[:from], :result, @iq[:id]) do |x|
+          x.si(:xmlns => Cancer::XEP_0095::NS, :id => @si[:id]) do
+            x.negotiate_features(:set, form)
+          end
+        end
+        
+        # catch stream
+        
+        @accept_proc = proc
+        controller = @controller.controllers_by_name['Cancer::XEP_0095::Controller']
+        controller.catch_stream(@si[:id], self)
+      end
+      
+      def reject!
+        @controller.send_iq(@iq[:from], :error, @iq[:id]) do |x|
+          x.error(:code => 403, :type => :cancel) do
+            x.forbidden(:xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas')
+            x.text_(:xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas') do
+              x.text('Offer Declined')
+            end
+          end
+        end
+      end
+      
+      def caught_stream!(stream)
+        @stream = stream
+        @stream.accept!(&@accept_proc)
+      end
+    end
+    
+    class EventMatcher < Cancer::Events::Matcher
+      
+      def initialize(options={})
+        @mime_type = options[:mime_type] || options[:type]
+        @profile   = options[:profile]
+      end
+      
+      def match?(event)
+        Cancer::XEP_0095::Event === event and match_mime_type?(event) and match_profile?(event)
+      end
+      
+      def match_mime_type?(event, pattern=@mime_type)
+        case pattern
+        when String   then event.si[:'mime-type'] == pattern
+        when Regexp   then event.si[:'mime-type'] =~ pattern
+        when Array    then pattern.any? { |p| match_mime_type?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_profile?(event, pattern=@profile)
+        case pattern
+        when String   then event.si[:profile] == pattern
+        when Regexp   then event.si[:profile] =~ pattern
+        when Array    then pattern.any? { |p| match_profile?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def si(options={})
+        Cancer::XEP_0095::EventMatcher.new(options)
+      end
+      
+    end
+    
+  end
+end

data/lib/cancer/xeps/xep_0096_si_filetransfer.rb

@@ -0,0 +1,173 @@
+
+module Cancer
+  # SI File Transfer
+  # http://xmpp.org/extensions/xep-0096.html
+  module XEP_0096
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0095'
+    
+    NS = 'http://jabber.org/protocol/si/profile/file-transfer'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0096::StreamHelper
+      end
+      stream.install_controller   Cancer::XEP_0096::Controller
+      stream.install_event_helper Cancer::XEP_0096::EventDSL
+      if stream.respond_to?(:register_profile)
+        stream.register_profile(Cancer::XEP_0096::Profile, Cancer::XEP_0096::NS)
+        stream.disco.feature NS
+      end
+    end
+    
+    module StreamHelper
+      def si_file_offer(to, path)
+        si_offer(to, :path => path, :profile => Cancer::XEP_0096::NS) do |f|
+          
+          File.open(path, 'r') do |file|
+            f.write file.read(4096) until file.eof?
+          end
+          
+        end
+      end
+    end
+    
+    class Profile < Cancer::XEP_0095::Profile
+      def enhance_si(si, options={})
+        si.file(:xmlns => Cancer::XEP_0096::NS,
+          :name => File.basename(options[:path]),
+          :size => File.size(options[:path]),
+          :date => fomat_time(File.mtime(options[:path])),
+          :hash => Digest::MD5.file(options[:path]).hexdigest
+        )
+      end
+      
+      def fomat_time(time)
+        def time.xmlschema(fraction_digits=0)
+          sprintf('%d-%02d-%02dT%02d:%02d:%02d',
+            year, mon, day, hour, min, sec) +
+          if fraction_digits == 0
+            ''
+          elsif fraction_digits <= 6
+            '.' + sprintf('%06d', usec)[0, fraction_digits]
+          else
+            '.' + sprintf('%06d', usec) + '0' * (fraction_digits - 6)
+          end +
+          if utc?
+            'Z'
+          else
+            off = utc_offset
+            sign = off < 0 ? '-' : '+'
+            sprintf('%s%02d:%02d', sign, *(off.abs / 60).divmod(60))
+          end
+        end
+        time.xmlschema
+      end
+    end
+    
+    class Controller < Cancer::Controller
+      
+      NAMESPACES = { 'c' => CLIENT_NS, 'si' => Cancer::XEP_0095::NS, 'ft' => NS }
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/si:si/ft:file', NAMESPACES) }
+      def received_si(e)
+        ft = e.xml.first('/c:iq/si:si/ft:file', NAMESPACES)
+        si = ft.parent
+        fire! Cancer::XEP_0096::Event, self, e.xml, si, ft
+      end
+      
+    end
+    
+    class Event < Cancer::XEP_0095::Event
+      attr_reader :si, :iq, :ft
+      attr_reader :status
+      
+      def initialize(controller, iq, si, ft)
+        @controller, @iq, @si, @ft = controller, iq, si, ft
+        @status = :pending
+      end
+      
+      def accept!(options={}, &proc)
+        if options[:path]
+          super() do |f|
+            @status = :active
+            @controller.fire! self
+            
+            File.open(options[:path], 'w+', options[:mode] || 0644) do |file|
+              file.write f.readpartial(4096) until f.eof?
+            end
+            
+            correct_size = lambda { (@ft[:size].nil? or (File.size(options[:path]) == @ft[:size].to_i)) }
+            correct_hash = lambda { (@ft[:hash].nil? or (Digest::MD5.file(options[:path]).hexdigest == @ft[:hash].to_s)) }
+            
+            if correct_size.call and correct_hash.call
+              @status = :completed
+              @controller.fire! self
+            else
+              File.unlink(options[:path])
+              @status = :failed
+              @controller.fire! self
+            end
+          end
+        else
+          super() do |f|
+            @status = :active
+            @controller.fire! self
+            
+            proc.call(f)
+            
+            @status = :completed
+            @controller.fire! self
+          end
+        end
+      end
+      
+      def filename
+        @ft[:name].to_s
+      end
+    end
+    
+    class EventMatcher < Cancer::XEP_0095::EventMatcher
+      
+      def initialize(options={})
+        options[:profile] = NS
+        super(options)
+        @filename = options[:filename]
+        @status   = options[:status] || :pending
+      end
+      
+      def match?(event)
+        Cancer::XEP_0096::Event === event and super(event) and match_filename?(event) and match_status?(event)
+      end
+      
+      def match_filename?(event, pattern=@filename)
+        case pattern
+        when String   then event.filename == pattern
+        when Regexp   then event.filename =~ pattern
+        when Array    then pattern.any? { |p| match_filename?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+      def match_status?(event, pattern=@status)
+        case pattern
+        when Symbol   then event.status == pattern
+        when Array    then pattern.any? { |p| match_status?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def si_file(options={})
+        Cancer::XEP_0096::EventMatcher.new(options)
+      end
+      
+    end
+    
+  end
+end