xmpp4r 0.3.2 → 0.4

data/lib/xmpp4r/bytestreams/helper/socks5bytestreams/server.rb

@@ -151,14 +151,18 @@ module Jabber
       ##
       # Start handshake process
       def start
-        auth_ver = @socket.getc
+        if !@socket.respond_to? :getbyte
+          class << @socket; alias getbyte getc; end
+        end
+
+        auth_ver = @socket.getbyte
         if auth_ver != 5
           # Unsupported version
           @socket.close
           return
         end
 
-        auth_nmethods = @socket.getc
+        auth_nmethods = @socket.getbyte
         auth_methods = @socket.read(auth_nmethods)
         unless auth_methods.index("\x00")
           # Client won't accept no authentication
@@ -175,7 +179,7 @@ module Jabber
           @socket.close
           return
         end
-        req_addrlen = @socket.getc
+        req_addrlen = @socket.getbyte
         req_addr = @socket.read(req_addrlen)
         req_port = @socket.read(2)
         if req_port != "\x00\x00"

data/lib/xmpp4r/bytestreams/helper/socks5bytestreams/socks5.rb

@@ -6,10 +6,6 @@ require 'socket'
 
 module Jabber
   module Bytestreams
-    ##
-    # Can be thrown upon communication error with
-    # a SOCKS5 proxy
-    class SOCKS5Error < RuntimeError; end
 
     ##
     # A SOCKS5 client implementation
@@ -47,12 +43,21 @@ module Jabber
       # port:: [Fixnum] Port number
       def connect_domain(domain, port)
         write("\x05\x01\x00\x03#{domain.size.chr}#{domain}#{[port].pack("n")}")
-        buf = read(7 + domain.size)
+        buf = read(4)
         if buf.nil? or buf[0..1] != "\005\000"
           close
           raise SOCKS5Error.new("Invalid SOCKS5 connect: #{buf.inspect}")
         end
 
+        case buf.respond_to?(:bytes) ? buf.bytes.to_a[3] : buf[3]
+          when 1 then read(6)  # IPv4 addr
+          when 3 then read(3 + domain.size) # Domain
+          when 4 then read(18) # IPv6 addr
+          else
+            close
+            raise SOCKS5Error.new("Invalid SOCKS5 address type #{buf[3].to_s}")
+        end
+
         self
       end
     end

data/lib/xmpp4r/bytestreams/helper/socks5bytestreams/target.rb

@@ -7,6 +7,12 @@ module Jabber
     ##
     # SOCKS5 Bytestreams implementation of the target site
     class SOCKS5BytestreamsTarget < SOCKS5Bytestreams
+      ##
+      # See SOCKS5Bytestreams#initialize
+      def initialize(stream, session_id, initiator_jid, target_jid)
+        @connect_timeout = 60
+        super
+      end
       ##
       # Wait until the stream has been established
       #
@@ -39,13 +45,13 @@ module Jabber
                 reply.query.add(StreamHostUsed.new(@streamhost_used.jid))
               else
                 reply.type = :error
-                reply.add(Error.new('item-not-found'))
+                reply.add(ErrorResponse.new('item-not-found'))
               end
               @stream.send(reply)
             rescue Exception => e
               error = e
             end
-              
+
             connect_sem.run
             true
           else
@@ -53,11 +59,15 @@ module Jabber
           end
         }
 
-        connect_sem.wait
+        begin
+          Timeout::timeout(@connect_timeout) { connect_sem.wait }
+        rescue Timeout::Error
+          @stream.delete_iq_callback(self)
+        end
+
         raise error if error
         (@socks != nil)
       end
     end
   end
 end
-

data/lib/xmpp4r/bytestreams/helper/socks5bytestreams/target.rb.orig

@@ -0,0 +1,62 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+module Jabber
+  module Bytestreams
+    ##
+    # SOCKS5 Bytestreams implementation of the target site
+    class SOCKS5BytestreamsTarget < SOCKS5Bytestreams
+      ##
+      # Wait until the stream has been established
+      #
+      # May raise various exceptions
+      def accept
+        error = nil
+        connect_sem = Semaphore.new
+
+        @stream.add_iq_callback(200, self) { |iq|
+          if iq.type == :set and iq.from == @initiator_jid and iq.to == @target_jid and iq.query.kind_of?(IqQueryBytestreams)
+            begin
+              @stream.delete_iq_callback(self)
+
+              iq.query.each_element('streamhost') { |streamhost|
+                if streamhost.host and streamhost.port and not @socks
+                  begin
+                    @socks = connect_socks(streamhost)
+                    @streamhost_used = streamhost
+                  rescue Exception => e
+                    Jabber::debuglog("SOCKS5 Bytestreams: #{e.class}: #{e}\n#{e.backtrace.join("\n")}")
+                    @streamhost_cbs.process(streamhost, :failure, e)
+                  end
+                end
+              }
+
+              reply = iq.answer(false)
+              if @streamhost_used
+                reply.type = :result
+                reply.add(IqQueryBytestreams.new)
+                reply.query.add(StreamHostUsed.new(@streamhost_used.jid))
+              else
+                reply.type = :error
+                reply.add(ErrorResponse.new('item-not-found'))
+              end
+              @stream.send(reply)
+            rescue Exception => e
+              error = e
+            end
+
+            connect_sem.run
+            true
+          else
+            false
+          end
+        }
+
+        connect_sem.wait
+        raise error if error
+        (@socks != nil)
+      end
+    end
+  end
+end

data/lib/xmpp4r/bytestreams/iq/bytestreams.rb

@@ -168,4 +168,3 @@ module Jabber
     end
   end
 end
-

data/lib/xmpp4r/callbacks.rb

@@ -15,7 +15,7 @@ module Jabber
   #
   # Callbacks are processed for a given set of objects as long as they return
   # false. If you want to stop processing, you must return true. Example :
-  #  cbl = CallbackList::new
+  #  cbl = CallbackList.new
   #  c1 = false
   #  c2 = false
   #  c3 = false
@@ -30,7 +30,7 @@ module Jabber
   # In XMPP4R, callbacks' priorities are quite normalized since we want to be
   # able to "cascade" callbacks in a clean way. Here are values your code should
   # take into account :
-  # 
+  #
   # >= 200::  logging & debugging callbacks. Those callbacks should not consume
   #           elements.
   # 100-199:: Where Helpers register their callbacks. The normal value is 100,
@@ -56,7 +56,7 @@ module Jabber
     # return:: [Jabber::CallbackList] The list, for chaining
     def add(prio = 0, ref = nil, proc = nil, &block)
       block = proc if proc
-      @list.push(Callback::new(prio, ref, block))
+      @list.push(Callback.new(prio, ref, block))
       @list.sort! { |a, b| b.priority <=> a.priority }
       self
     end
@@ -107,7 +107,7 @@ module Jabber
     # The Callback's reference, using for deleting purposes
     attr_reader :ref
 
-    # The Callback's block to execute 
+    # The Callback's block to execute
     attr_reader :block
 
     ##
@@ -115,7 +115,7 @@ module Jabber
     # priority:: [Integer] the callback's priority. The higher, the sooner it
     # will be executed
     # ref:: [String] The callback's reference
-    def initialize(priority = 0, ref = nil, block = Proc::new {})
+    def initialize(priority = 0, ref = nil, block = Proc.new {})
       @priority = priority
       @ref = ref
       @block = block

data/lib/xmpp4r/caps.rb

@@ -0,0 +1 @@
+require 'xmpp4r/caps/helper/helper'

data/lib/xmpp4r/caps/c.rb

@@ -0,0 +1,53 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r/xmppelement'
+
+module Jabber
+  module Caps
+    NS_CAPS='http://jabber.org/protocol/caps'
+
+    ##
+    # The <c/> XMPP element, used to advertise entity capabilities.
+    #
+    # See http://www.xmpp.org/extensions/xep-0115.html#protocol.
+    #
+    # You should not need to construct this element directly, see
+    # Jabber::Caps::Helper.
+    class C < XMPPElement
+      name_xmlns 'c', NS_CAPS
+      force_xmlns true
+
+      def initialize(node = nil, ver = nil)
+        super()
+        add_attribute('node', node) if node
+        if ver
+          add_attribute('ver', ver)
+          add_attribute('hash', 'sha-1')
+        end
+      end
+
+      ##
+      # Get the value of this element's 'ver' attribute,
+      # an opaque hash representing this entity's capabilities.
+      def ver
+        attributes['ver']
+      end
+
+      ##
+      # Get the value of this element's 'node' attribute,
+      # a 'unique identifier for the software underlying the entity'
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Get the value of this element's 'hash' attribute,
+      # the algorithm used in generating the 'ver' attribute
+      def hash
+        attributes['hash']
+      end
+    end
+  end
+end

data/lib/xmpp4r/caps/helper/generator.rb

@@ -0,0 +1,160 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r'
+require 'xmpp4r/discovery'
+require 'xmpp4r/dataforms'
+require 'xmpp4r/caps/c'
+require 'digest'
+require 'xmpp4r/base64'
+
+module Jabber
+  module Caps
+    def self.generate_ver_str(identities, features, forms=[])
+      # 1.  Initialize an empty string S.
+      s = ''
+
+      # 2. Sort the service discovery identities [14] by category and
+      # then by type (if it exists) and then by xml:lang (if it
+      # exists), formatted as CATEGORY '/' [TYPE] '/' [LANG] '/'
+      # [NAME]. Note that each slash is included even if the TYPE,
+      # LANG, or NAME is not included.
+      identities.sort! do |identity1,identity2|
+        cmp_result = nil
+        [:category, :type, :xml_lang, :iname].each do |field|
+          value1 = identity1.send(field)
+          value2 = identity2.send(field)
+
+          if value1 != value2
+            cmp_result = value1 <=> value2
+            break
+          end
+        end
+
+
+        cmp_result
+      end
+
+      # 3. For each identity, append the 'category/type/lang/name' to
+      # S, followed by the '<' character.
+      s += identities.collect do |identity|
+        [:category, :type, :xml_lang, :iname].collect do |field|
+          identity.send(field).to_s
+        end.join('/') + '<'
+      end.join
+
+      # 4. Sort the supported service discovery features. [15]
+      features.sort! do |feature1,feature2|
+        feature1.var <=> feature2.var
+      end
+
+      # 5. For each feature, append the feature to S, followed by the
+      # '<' character.
+      s += features.collect do |feature|
+        feature.var.to_s + '<'
+      end.join
+
+      # 6. If the service discovery information response includes
+      # XEP-0128 data forms, sort the forms by the FORM_TYPE (i.e., by
+      # the XML character data of the <value/> element).
+      forms.sort! do |form1,form2|
+        fform_type1 = form1.field('FORM_TYPE')
+        fform_type2 = form2.field('FORM_TYPE')
+        form_type1 = fform_type1 ? fform_type1.values.to_s : nil
+        form_type2 = fform_type2 ? fform_type2.values.to_s : nil
+        form_type1 <=> form_type2
+      end
+
+      # 7. For each extended service discovery information form:
+      forms.each do |form|
+        # 7.1. Append the XML character data of the FORM_TYPE field's
+        # <value/> element, followed by the '<' character.
+        fform_type = form.field('FORM_TYPE')
+        form_type = fform_type ? fform_type.values.to_s : nil
+        s += "#{form_type}<"
+
+        # 7.2. Sort the fields by the value of the "var" attribute.
+        fields = form.fields(false).sort do |field1,field2|
+          field1.var <=> field2.var
+        end
+
+        # 7.3. For each field:
+
+        fields.each do |field|
+          # 7.3.1. Append the value of the "var" attribute, followed by
+          # the '<' character.
+          s += "#{field.var}<"
+
+          # 7.3.2. Sort values by the XML character data of the <value/>
+          # element.
+          values = field.values.sort do |value1,value2|
+            value1 <=> value2
+          end
+
+          # 7.3.3. For each <value/> element, append the XML character
+          # data, followed by the '<' character.
+          s += values.collect do |value|
+            "#{value}<"
+          end.join
+        end
+      end
+
+      # 8. Ensure that S is encoded according to the UTF-8 encoding
+      # (RFC 3269 [16]).
+
+      # (given in XMPP4R)
+
+      s
+    end
+
+    ##
+    # Implementation of the algorithm defined at:
+    # http://www.xmpp.org/extensions/xep-0115.html#ver-gen
+    def self.generate_ver(identities, features, forms=[], hash='sha-1')
+      s = generate_ver_str(identities, features, forms)
+
+      # 9. Compute the verification string by hashing S using the
+      # algorithm specified in the 'hash' attribute (e.g., SHA-1 as
+      # defined in RFC 3174 [17]). The hashed data MUST be generated
+      # with binary output and encoded using Base64 as specified in
+      # Section 4 of RFC 4648 [18] (note: the Base64 output MUST NOT
+      # include whitespace and MUST set padding bits to zero). [19]
+
+      # See http://www.iana.org/assignments/hash-function-text-names
+      hash_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
+                   end
+      if hash_klass
+        Base64::encode64(hash_klass::digest(s)).strip
+      else
+        nil
+      end
+    end
+
+    ##
+    # Generate a ver hash from a Jabber::Discovery::IqQueryDiscoInfo result
+    # query:: [Jabber::Discovery::IqQueryDiscoInfo]
+    def self.generate_ver_from_discoinfo(query, hash='sha-1')
+      identities = []
+      features = []
+      forms = []
+      query.each_element do |element|
+        if element.kind_of? Discovery::Identity
+          identities << element
+        elsif element.kind_of? Discovery::Feature
+          features << element
+        elsif element.kind_of? Dataforms::XData
+          forms << element
+        end
+      end
+      generate_ver(identities, features, forms, hash)
+    end
+  end
+end

data/lib/xmpp4r/caps/helper/helper.rb

@@ -0,0 +1,87 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+require 'xmpp4r'
+require 'xmpp4r/discovery'
+require 'xmpp4r/caps/c'
+require 'xmpp4r/caps/helper/generator'
+
+module Jabber
+  module Caps
+    ##
+    # A Helper to manage advertising and discovery of entity capabilities.
+    #
+    # Following XEP-0115 (ver 1.4 http://www.xmpp.org/extensions/xep-0115.html).
+    # you can use this Helper to, for example, advertise that your client
+    # wishes to receive XEP-0118 User Tune notifications, eg:
+    #
+    # caps_helper=Jabber::Caps::Helper(cl,
+    #   [Jabber::Discovery::Identity.new('client',nil,'bot')],
+    #   [Jabber::Discovery::Feature.new('http://jabber.org/protocol/tune+notify')]
+    # )
+    class Helper
+      attr_accessor :identities, :features, :node
+
+      ##
+      # Construct a new Caps Helper.
+      #
+      # This will send a <presence> message containing
+      # a <c/> (Jabber::Caps::C) stanza to your server.
+      # client:: [Jabber::Stream]
+      # i:: [Array] of [Jabber::Discovery::Identity] objects that this entity  will advertise
+      # f:: [Array] of [Jabber::Discovery::Feature] objects that this entity will advertise
+      # n:: [String] an identifier representing the software underlying this entity
+      def initialize(client,i=[],f=[],n="http://home.gna.org/xmpp4r/##{Jabber::XMPP4R_VERSION}")
+        @stream = client
+        @identities = i
+        @features = f
+        @node = n
+
+        @stream.add_iq_callback(250) do |iq|
+          if iq.type == :get and iq.query.kind_of? Jabber::Discovery::IqQueryDiscoInfo
+            Thread.new do
+              Thread.abort_on_exception = true
+              handle_discoinfo_query(iq)
+            end
+            true
+          else
+            false
+          end
+        end
+
+        p = Jabber::Presence.new()
+        p.add(c)
+        @stream.send(p)
+      end
+
+      ##
+      # Return a <c/> element for inclusion in your own <presence>
+      # stanzas.
+      def c
+        Jabber::Caps::C.new(node, ver)
+      end
+
+      ##
+      # Send actual identities/ features back to a requesting entity
+      def handle_discoinfo_query(iq)
+        caps_reply = Jabber::XMPPStanza.answer(iq)
+        caps_reply.type = :result
+        caps_reply.query = Jabber::Discovery::IqQueryDiscoInfo.new
+        @identities.each { |i| caps_reply.query.add(i) }
+        @features.each { |f| caps_reply.query.add(f) }
+
+        @stream.send(caps_reply)
+      end
+
+      ##
+      # Generate 'ver', an opaque hash used to represent this entity's
+      # capabilities
+      #
+      # See http://www.xmpp.org/extensions/xep-0115.html#ver
+      def ver
+        Caps::generate_ver(@identities, @features)
+      end
+    end
+  end
+end