blather 0.4.14 → 0.4.15

data/lib/blather.rb

@@ -8,12 +8,16 @@
   logger
 
   blather/core_ext/active_support
+  blather/core_ext/eventmachine
   blather/core_ext/nokogiri
 
   blather/errors
   blather/errors/sasl_error
   blather/errors/stanza_error
   blather/errors/stream_error
+  blather/file_transfer
+  blather/file_transfer/ibb
+  blather/file_transfer/s5b
   blather/jid
   blather/roster
   blather/roster_item
@@ -24,6 +28,10 @@
   blather/stanza/iq/query
   blather/stanza/iq/command
   blather/stanza/iq/roster
+  blather/stanza/iq/ibb
+  blather/stanza/iq/s5b
+  blather/stanza/iq/si
+  blather/stanza/iq/vcard
   blather/stanza/disco
   blather/stanza/disco/disco_info
   blather/stanza/disco/disco_items

data/lib/blather/client/client.rb

@@ -112,9 +112,17 @@ module Blather
       @tmp_handlers[id.to_s] = handler
     end
 
+    # Clear handlers with given guards
+    #
+    # @param [Symbol, nil] type remove filters for a specific handler
+    # @param [guards] guards take a look at the guards documentation
+    def clear_handlers(type, *guards)
+      @handlers[type].delete_if { |g, _| g == guards }
+    end
+
     # Register a handler
     #
-    # @param [Symbol, nil] handler set the filter on a specific handler
+    # @param [Symbol, nil] type set the filter on a specific handler
     # @param [guards] guards take a look at the guards documentation
     # @yield [Blather::Stanza] stanza the incomming stanza
     def register_handler(type, *guards, &handler)

data/lib/blather/client/dsl/pubsub.rb

@@ -87,9 +87,9 @@ module DSL
     # Defaults to the stripped current JID
     # @param [#to_s] host the PubSub host (defaults to the initialized host)
     # @yield [Blather::Stanza] stanza the reply stanza
-    def unsubscribe(node, jid = nil, host = nil)
+    def unsubscribe(node, jid = nil, subid = nil, host = nil)
       jid ||= client.jid.stripped
-      stanza = Stanza::PubSub::Unsubscribe.new(:set, send_to(host), node, jid)
+      stanza = Stanza::PubSub::Unsubscribe.new(:set, send_to(host), node, jid, subid)
       request(stanza) { |n| yield n if block_given? }
     end
 

data/lib/blather/core_ext/active_support.rb

@@ -36,6 +36,7 @@ end
 
 class Symbol  # @private
   def duplicable?; false; end
+  def to_proc; proc { |obj, *args| obj.send(self, *args) }; end
 end
 
 class Numeric  # @private

data/lib/blather/core_ext/eventmachine.rb

@@ -0,0 +1,122 @@
+module EventMachine
+  module Protocols
+    # Basic SOCKS v5 client implementation
+    #
+    # Use as you would any regular connection:
+    #
+    # class MyConn < EM::P::Socks5
+    #   def post_init
+    #     send_data("sup")
+    #   end
+    #
+    #   def receive_data(data)
+    #     send_data("you said: #{data}")
+    #   end
+    # end
+    #
+    # EM.connect socks_host, socks_port, MyConn, host, port
+    #
+    class Socks5 < Connection
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @socks_error_code = nil
+        @buffer = ''
+        @socks_state = :method_negotiation
+        @socks_methods = [0] # TODO: other authentication methods
+        setup_methods
+      end
+
+      def setup_methods
+        class << self
+          def post_init; socks_post_init; end
+          def receive_data(*a); socks_receive_data(*a); end
+        end
+      end
+
+      def restore_methods
+        class << self
+          remove_method :post_init
+          remove_method :receive_data
+        end
+      end
+
+      def socks_post_init
+        packet = [5, @socks_methods.size].pack('CC') + @socks_methods.pack('C*')
+        send_data(packet)
+      end
+
+      def socks_receive_data(data)
+        @buffer << data
+
+        if @socks_state == :method_negotiation
+          return if @buffer.size < 2
+
+          header_resp = @buffer.slice! 0, 2
+          _, method_code = header_resp.unpack("cc")
+
+          if @socks_methods.include?(method_code)
+            @socks_state = :connecting
+            packet = [5, 1, 0].pack("C*")
+
+            if @host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/ # IPv4
+              packet << [1, $1.to_i, $2.to_i, $3.to_i, $4.to_i].pack("C*")
+            elsif @host.include?(":") # IPv6
+              l, r = if @host =~ /^(.*)::(.*)$/
+                [$1,$2].map {|i| i.split ":"}
+              else
+                [@host.split(":"),[]]
+              end
+              dec_groups = (l + Array.new(8-l.size-r.size, '0') + r).map {|i| i.hex}
+              packet << ([4] + dec_groups).pack("Cn8")
+            else # Domain
+              packet << [3, @host.length, @host].pack("CCA*")
+            end
+            packet << [@port].pack("n")
+
+            send_data packet
+          else
+            @socks_state = :invalid
+            @socks_error_code = method_code
+            close_connection
+            return
+          end
+        elsif @socks_state == :connecting
+          return if @buffer.size < 4
+
+          header_resp = @buffer.slice! 0, 4
+          _, response_code, _, address_type = header_resp.unpack("C*")
+
+          if response_code == 0
+            case address_type
+            when 1
+              @buffer.slice! 0, 4
+            when 3
+              len = @buffer.slice! 0, 1
+              @buffer.slice! 0, len.unpack("C").first
+            when 4
+              @buffer.slice! 0, 16
+            else
+              @socks_state = :invalid
+              @socks_error_code = address_type
+              close_connection
+              return
+            end
+            @buffer.slice! 0, 2
+
+            @socks_state = :connected
+            restore_methods
+
+            post_init
+            receive_data(@buffer) unless @buffer.empty?
+          else
+            @socks_state = :invalid
+            @socks_error_code = response_code
+            close_connection
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/blather/errors/stanza_error.rb

@@ -77,6 +77,7 @@ class StanzaError < BlatherError
     node << (error_node = XMPPNode.new('error'))
 
     error_node << (err = XMPPNode.new(@name, error_node.document))
+    error_node['type'] = self.type
     err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
 
     if self.text

data/lib/blather/file_transfer.rb

@@ -0,0 +1,100 @@
+module Blather
+  # File Transfer helper
+  # Takes care of accepting, declining and offering file transfers through the stream
+  class FileTransfer
+
+    # Set this to false if you don't want to use In-Band Bytestreams
+    attr_accessor :allow_ibb
+
+    # Set this to false if you don't want to use SOCKS5 Bytestreams
+    attr_accessor :allow_s5b
+
+    # Create a new FileTransfer
+    #
+    # @param [Blather::Stream] stream the stream the file transfer should use
+    # @param [Blather::Stanza::Iq::Si] iq a si iq used to stream-initiation
+    def initialize(stream, iq = nil)
+      @stream = stream
+      @allow_s5b = true
+      @allow_ibb = true
+
+      @iq = iq
+    end
+
+    # Accept an incoming file-transfer
+    #
+    # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+    # @param [Array] params the params to be passed into the handler
+    def accept(handler, *params)
+      answer = @iq.reply
+
+      answer.si.feature.x.type = :submit
+
+      supported_methods = @iq.si.feature.x.field("stream-method").options.map(&:value)
+      if supported_methods.include?(Stanza::Iq::S5b::NS_S5B) and @allow_s5b
+        answer.si.feature.x.fields = {:var => 'stream-method', :value => Stanza::Iq::S5b::NS_S5B}
+
+        @stream.register_handler :s5b_open, :from => @iq.from do |iq|
+          transfer = Blather::FileTransfer::S5b.new(@stream, iq)
+          transfer.allow_ibb_fallback = true if @allow_ibb
+          transfer.accept(handler, *params)
+          true
+        end
+
+        @stream.write answer
+      elsif supported_methods.include?(Stanza::Iq::Ibb::NS_IBB) and @allow_ibb
+        answer.si.feature.x.fields = {:var => 'stream-method', :value => Stanza::Iq::Ibb::NS_IBB}
+
+        @stream.register_handler :ibb_open, :from => @iq.from do |iq|
+          transfer = Blather::FileTransfer::Ibb.new(@stream, iq)
+          transfer.accept(handler, *params)
+          true
+        end
+
+        @stream.write answer
+      else
+        reason = XMPPNode.new('no-valid-streams')
+        reason.namespace = Blather::Stanza::Iq::Si::NS_SI
+
+        @stream.write StanzaError.new(@iq, 'bad-request', 'cancel', nil, [reason]).to_node
+      end
+    end
+
+    # Decline an incoming file-transfer
+    def decline
+      answer = StanzaError.new(@iq, 'forbidden', 'cancel', 'Offer declined').to_node
+
+      @stream.write answer
+    end
+
+    # Offer a file to somebody, not implemented yet
+    def offer
+      # TODO: implement
+    end
+
+    # Simple handler for incoming file transfers
+    #
+    # You can define your own handler and pass it to the accept method.
+    module SimpleFileReceiver
+      def initialize(path, size)
+        @path = path
+        @size = size
+        @transferred = 0
+      end
+
+      def post_init
+        @file = File.open(@path, "w")
+      end
+
+      def receive_data(data)
+        @transferred += data.size
+        @file.write data
+      end
+
+      def unbind
+        @file.close
+        File.delete(@path) unless @transferred == @size
+      end
+    end
+  end
+end

data/lib/blather/file_transfer/ibb.rb

@@ -0,0 +1,68 @@
+require "base64"
+
+module Blather
+  class FileTransfer
+    # In-Band Bytestreams Transfer helper
+    # Takes care of accepting, declining and offering file transfers through the stream
+    class Ibb
+      def initialize(stream, iq)
+        @stream = stream
+        @iq = iq
+        @seq = 0
+      end
+
+      # Accept an incoming file-transfer
+      #
+      # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+      # @param [Array] params the params to be passed into the handler
+      def accept(handler, *params)
+        @io_read, @io_write = IO.pipe
+        EM::attach @io_read, handler, *params
+
+        @stream.register_handler :ibb_data, :from => @iq.from, :sid => @iq.sid do |iq|
+          if iq.data['seq'] == @seq.to_s
+            begin
+              @io_write << Base64.decode64(iq.data.content)
+
+              @stream.write iq.reply
+
+              @seq += 1
+              @seq = 0 if @seq > 65535
+            rescue Errno::EPIPE => e
+              @stream.write StanzaError.new(iq, 'not-acceptable', :cancel).to_node
+            end
+          else
+            @stream.write StanzaError.new(iq, 'unexpected-request', :wait).to_node
+          end
+          true
+        end
+
+        @stream.register_handler :ibb_close, :from => @iq.from, :sid => @iq.sid do |iq|
+          @stream.write iq.reply
+          @stream.clear_handlers :ibb_data, :from => @iq.from, :sid => @iq.sid
+          @stream.clear_handlers :ibb_close, :from => @iq.from, :sid => @iq.sid
+
+          @io_write.close
+          true
+        end
+
+        @stream.clear_handlers :ibb_open, :from => @iq.from
+        @stream.clear_handlers :ibb_open, :from => @iq.from, :sid => @iq.sid
+        @stream.write @iq.reply
+      end
+
+      # Decline an incoming file-transfer
+      def decline
+        @stream.clear_handlers :ibb_open, :from => @iq.from
+        @stream.clear_handlers :ibb_data, :from => @iq.from, :sid => @iq.sid
+        @stream.clear_handlers :ibb_close, :from => @iq.from, :sid => @iq.sid
+        @stream.write StanzaError.new(@iq, 'not-acceptable', :cancel).to_node
+      end
+
+      # Offer a file to somebody, not implemented yet
+      def offer
+        # TODO: implement
+      end
+    end
+  end
+end

data/lib/blather/file_transfer/s5b.rb

@@ -0,0 +1,104 @@
+module Blather
+  class FileTransfer
+    # SOCKS5 Bytestreams Transfer helper
+    # Takes care of accepting, declining and offering file transfers through the stream
+    class S5b
+
+      # Set this to false if you don't want to fallback to In-Band Bytestreams
+      attr_accessor :allow_ibb_fallback
+
+      def initialize(stream, iq)
+        @stream = stream
+        @iq = iq
+        @allow_ibb_fallback = true
+      end
+
+      # Accept an incoming file-transfer
+      #
+      # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+      # @param [Array] params the params to be passed into the handler
+      def accept(handler, *params)
+        @streamhosts = @iq.streamhosts
+        @socket_address = Digest::SHA1.hexdigest("#{@iq.sid}#{@iq.from}#{@iq.to}")
+
+        @handler = handler
+        @params = params
+
+        connect_next_streamhost
+        @stream.clear_handlers :s5b_open, :from => @iq.from
+      end
+
+      # Decline an incoming file-transfer
+      def decline
+        @stream.clear_handlers :s5b_open, :from => @iq.from
+        @stream.write StanzaError.new(@iq, 'not-acceptable', :auth).to_node
+      end
+
+      # Offer a file to somebody, not implemented yet
+      def offer
+        # TODO: implement
+      end
+
+      private
+
+      def connect_next_streamhost
+        if streamhost = @streamhosts.shift
+          connect(streamhost)
+        else
+          if @allow_ibb_fallback
+            @stream.register_handler :ibb_open, :from => @iq.from, :sid => @iq.sid do |iq|
+              transfer = Blather::FileTransfer::Ibb.new(@stream, iq)
+              transfer.accept(@handler, *@params)
+              true
+            end
+          end
+
+          @stream.write StanzaError.new(@iq, 'item-not-found', :cancel).to_node
+        end
+      end
+
+      def connect(streamhost)
+        begin
+          socket = EM.connect streamhost.host, streamhost.port, SocketConnection, @socket_address, 0, @handler, *@params
+
+          socket.callback do
+            answer = @iq.reply
+            answer.streamhosts = nil
+            answer.streamhost_used = streamhost.jid
+
+            @stream.write answer
+          end
+
+          socket.errback do
+            connect_next_streamhost
+          end
+        rescue EventMachine::ConnectionError => e
+          connect_next_streamhost
+        end
+      end
+
+      class SocketConnection < EM::P::Socks5
+        include EM::Deferrable
+
+        def initialize(host, port, handler, *params)
+          super(host, port)
+          @@handler = handler
+          @params = params
+        end
+
+        def post_init
+          self.succeed
+          class << self
+            include @@handler
+          end
+          send(:initialize, *@params)
+          post_init
+        end
+
+        def unbind
+          self.fail if @socks_state != :connected
+        end
+      end
+    end
+  end
+end