xmpp4r 0.3

data/lib/xmpp4r/roster/iq/roster.rb

@@ -0,0 +1,244 @@
+# =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/query'
+
+module Jabber
+  module Roster
+    ##
+    # Class for handling roster updates
+    #
+    # You must do 'client.send(Iq.new_rosterget)' or else you will
+    # have nothing to put in receive_iq()
+    #
+    # You must require 'xmpp4r/rosterquery' to use this class
+    # as its functionality is not needed for a working XMPP implementation.
+    # This will make [IqQuery] convert all Queries with namespace 'jabber:iq:roster'
+    # to [IqQueryRoster]
+    #
+    # This <query/> contains multiple <item/> children. See RosterItem.
+    class IqQueryRoster < IqQuery
+      ##
+      # Create a new <query xmlns='jabber:iq:roster'/>
+      # stream:: [Stream] Stream to handle
+      def initialize
+        super
+        add_namespace('jabber:iq:roster')
+      end
+      
+      ##
+      # Add an element to the roster
+      #
+      # Converts <item/> elements to RosterItem
+      #
+      # Previous RosterItems with the same JID will
+      # *not* be deleted!
+      def typed_add(element)
+        if element.kind_of?(REXML::Element) && (element.name == 'item')
+          item = RosterItem::new.import(element)
+          super(item)
+        else
+          super(element)
+        end
+      end
+      
+      ##
+      # Iterate through all items
+      # &block:: Yield for every [RosterItem]
+      def each(&block)
+        each_element { |item|
+          # XPath won't work here as it's missing a prefix...
+          yield(item) if item.kind_of?(RosterItem)
+        }
+      end
+      
+      ##
+      # Get roster item by JID
+      # jid:: [JID] or [Nil]
+      # result:: [RosterItem]
+      def [](jid)
+        each { |item|
+          return(item) if item.jid == jid
+        }
+        nil
+      end
+      
+      ##
+      # Get all items
+      # result:: [Array] of [RosterItem]
+      def to_a
+        a = []
+        each { |item|
+          a.push(item)
+        }
+        a
+      end
+      
+      ##
+      # Update roster by <iq/> stanza
+      # (to be fed by an iq_callback)
+      # iq:: [Iq] Containing new roster
+      # filter:: [Boolean] If false import non-roster-like results too
+      def receive_iq(iq, filter=true)
+        if filter && (((iq.type != :set) && (iq.type != :result)) || (iq.queryns != 'jabber:iq:roster'))
+          return
+        end
+        
+        import(iq.query)
+      end
+      
+      ##
+      # Output for "p"
+      #
+      # JIDs of all contained [RosterItem] elements are joined with a comma
+      # result:: [String]
+      def inspect
+        jids = to_a.collect { |item| item.jid.inspect }
+        jids.join(', ')
+      end
+    end
+    
+    ##
+    # Class containing the <item/> elements of the roster
+    #
+    # The 'name' attribute has been renamed to 'iname' here
+    # as 'name' is already used by REXML::Element for the
+    # element's name. It's still name='...' in XML.
+    class RosterItem < REXML::Element
+      ##
+      # Construct a new roster item
+      # jid:: [JID] Jabber ID
+      # iname:: [String] Name in the roster
+      # subscription:: [Symbol] Type of subscription (see RosterItem#subscription=)
+      # ask:: [Symbol] or [Nil] Can be :subscribe
+      def initialize(jid=nil, iname=nil, subscription=nil, ask=nil)
+        super('item')
+        self.jid = jid
+        self.iname = iname
+        self.subscription = subscription
+        self.ask = ask
+      end
+      
+      ##
+      # Create new RosterItem from REXML::Element
+      # item:: [REXML::Element] source element to copy attributes and children from
+      def RosterItem.import(item)
+        RosterItem::new.import(item)
+      end
+    
+      ##
+      # Get name of roster item
+      #
+      # names can be set by the roster's owner himself
+      # return:: [String]
+      def iname
+        attributes['name']
+      end
+      
+      ##
+      # Set name of roster item
+      # val:: [String] Name for this item
+      def iname=(val)
+        attributes['name'] = val
+      end
+      
+      ##
+      # Get JID of roster item
+      # Resource of the JID will _not_ be stripped
+      # return:: [JID]
+      def jid
+        (a = attributes['jid']) ? JID::new(a) : nil
+      end
+      
+      ##
+      # Set JID of roster item
+      # val:: [JID] or nil
+      def jid=(val)
+        attributes['jid'] = val.nil? ? nil : val.to_s
+      end
+      
+      ##
+      # Get subscription type of roster item
+      # result:: [Symbol] or [Nil] The following values are valid according to RFC3921:
+      # * :both
+      # * :from
+      # * :none
+      # * :remove
+      # * :to
+      def subscription
+        case attributes['subscription']
+          when 'both' then :both
+          when 'from' then :from
+          when 'none' then :none
+          when 'remove' then :remove
+          when 'to' then :to
+          else nil
+        end
+      end
+      
+      ##
+      # Set subscription type of roster item
+      # val:: [Symbol] or [Nil] See subscription for possible Symbols
+      def subscription=(val)
+        case val
+          when :both then attributes['subscription'] = 'both'
+          when :from then attributes['subscription'] = 'from'
+          when :none then attributes['subscription'] = 'none'
+          when :remove then attributes['subscription'] = 'remove'
+          when :to then attributes['subscription'] = 'to'
+          else attributes['subscription'] = nil
+        end
+      end
+      
+      ##
+      # Get if asking for subscription
+      # result:: [Symbol] nil or :subscribe
+      def ask
+        case attributes['ask']
+          when 'subscribe' then :subscribe
+          else nil
+        end
+      end
+      
+      ##
+      # Set if asking for subscription
+      # val:: [Symbol] nil or :subscribe
+      def ask=(val)
+        case val
+          when :subscribe then attributes['ask'] = 'subscribe'
+          else attributes['ask'] = nil
+        end
+      end
+      
+      ##
+      # Get groups the item belongs to
+      # result:: [Array] of [String] The groups
+      def groups
+        result = []
+        each_element('group') { |group|
+          result.push(group.text)
+        }
+        result
+      end
+      
+      ##
+      # Set groups the item belongs to,
+      # deletes old groups first.
+      #
+      # See JEP 0083 for nested groups
+      # ary:: [Array] New groups, duplicate values will be removed
+      def groups=(ary)
+        # Delete old group elements
+        delete_elements('group')
+        
+        # Add new group elements
+        ary.uniq.each { |group|
+          add_element('group').text = group
+        }
+      end
+    end
+    
+    IqQuery.add_namespaceclass('jabber:iq:roster', IqQueryRoster)
+  end #Module Roster
+end #Module Jabber

data/lib/xmpp4r/roster/x/roster.rb

@@ -0,0 +1,155 @@
+# =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/x'
+require 'xmpp4r/jid'
+
+module Jabber
+  module Roster
+  ##
+  # Implementation of JEP-0144
+  # for <tt><x xmlns='http://jabber.org/protocol/rosterx'/></tt>
+  # attached to <tt><message/></tt> stanzas
+  #
+  # Should be backwards compatible to JEP-0093,
+  # as only action attribute of roster items are missing there.
+  # Pay attention to the namespace which is <tt>jabber:x:roster</tt>
+  # for JEP-0093!
+    class XRoster < X
+      ##
+      # Initialize a new XRoster element
+      def initialize
+        super()
+        add_namespace('http://jabber.org/protocol/rosterx')
+      end
+      
+      ##
+      # Add an element to the roster attachment
+      #
+      # Converts <item/> elements to XRosterItem
+      def typed_add(element)
+        if element.kind_of?(REXML::Element) && (element.name == 'item')
+          super(XRosterItem::new.import(element))
+        else
+          super(element)
+        end
+      end
+    end #Class XRoster
+    
+    X.add_namespaceclass('jabber:x:roster', XRoster)
+    X.add_namespaceclass('http://jabber.org/protocol/rosterx', XRoster)
+    
+    ##
+    # Class containing an <item/> element
+    #
+    # The 'name' attribute has been renamed to 'iname' here
+    # as 'name' is already used by REXML::Element for the
+    # element's name. It's still name='...' in XML.
+    #
+    # This is all a bit analoguous to Jabber::RosterItem, used by
+    # Jabber::IqQueryRoster. But this class lacks the subscription and
+    # ask attributes.
+    class XRosterItem < REXML::Element
+      ##
+      # Construct a new roster item
+      # jid:: [JID] Jabber ID
+      # iname:: [String] Name in the roster
+      def initialize(jid=nil, iname=nil)
+        super('item')
+        self.jid = jid
+        self.iname = iname
+      end
+      
+      ##
+      # Create new XRosterItem from REXML::Element
+      # item:: [REXML::Element] source element to copy attributes and children from
+      def XRosterItem.import(item)
+        XRosterItem::new.import(item)
+      end
+      
+      ##
+      # Get name of roster item
+      #
+      # names can be set by the roster's owner himself
+      # return:: [String]
+      def iname
+        attributes['name']
+      end
+      
+      ##
+      # Set name of roster item
+      # val:: [String] Name for this item
+      def iname=(val)
+        attributes['name'] = val
+      end
+      
+      ##
+      # Get JID of roster item
+      # Resource of the JID will _not_ be stripped
+      # return:: [JID]
+      def jid
+        JID::new(attributes['jid'])
+      end
+      
+      ##
+      # Set JID of roster item
+      # val:: [JID] or nil
+      def jid=(val)
+        attributes['jid'] = val.nil? ? nil : val.to_s
+      end
+      
+      ##
+      # Get action for this roster item
+      # * :add
+      # * :modify
+      # * :delete
+      # result:: [Symbol] (defaults to :add according to JEP-0144)
+      def action
+        case attributes['action']
+          when 'modify' then :modify
+          when 'delete' then :delete
+          else :add
+        end
+      end
+      
+      ##
+      # Set action for this roster item
+      # (see action)
+      def action=(a)
+        case a
+          when :modify then attributes['action'] = 'modify'
+          when :delete then attributes['action'] = 'delete'
+          else attributes['action'] = 'add'
+        end
+      end
+
+      ##
+      # Get groups the item belongs to
+      # result:: [Array] of [String] The groups
+      def groups
+        result = []
+        each_element('group') { |group|
+          result.push(group.text)
+        }
+        result
+      end
+      
+      ##
+      # Set groups the item belongs to,
+      # deletes old groups first.
+      #
+      # See JEP 0083 for nested groups
+      # ary:: [Array] New groups, duplicate values will be removed
+      def groups=(ary)
+        # Delete old group elements
+        delete_elements('group')
+        
+        # Add new group elements
+        ary.uniq.each { |group|
+          add_element('group').text = group
+        }
+      end
+    end #Class XRosterItem
+  end #Module Roster
+end #Module Jabber

data/lib/xmpp4r/roster.rb

@@ -0,0 +1,4 @@
+require 'xmpp4r/roster/iq/roster.rb'
+require 'xmpp4r/roster/helper/roster.rb'
+require 'xmpp4r/roster/x/roster.rb'
+

data/lib/xmpp4r/sasl.rb

@@ -0,0 +1,167 @@
+require 'base64'
+require 'digest/md5'
+
+module Jabber
+  ##
+  # Helpers for SASL authentication (RFC2222)
+  #
+  # You might not need to use them directly, they are
+  # invoked by Jabber::Client#auth
+  module SASL
+    NS_SASL = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
+    ##
+    # Factory function to obtain a SASL helper for the specified mechanism
+    def SASL::new(stream, mechanism)
+      case mechanism
+        when 'DIGEST-MD5'
+          DigestMD5.new(stream)
+        when 'PLAIN'
+          Plain.new(stream)
+        else
+          raise "Unknown SASL mechanism: #{mechanism}"
+      end
+    end
+
+    ##
+    # SASL mechanism base class (stub)
+    class Base
+      def initialize(stream)
+        @stream = stream
+      end
+
+      private
+
+      def generate_auth(mechanism, text=nil)
+        auth = REXML::Element.new 'auth'
+        auth.add_namespace NS_SASL
+        auth.attributes['mechanism'] = mechanism
+        auth.text = text
+        auth
+      end
+
+      def generate_nonce
+        Digest::MD5.new(Time.new.to_f.to_s).hexdigest
+      end
+    end
+
+    ##
+    # SASL PLAIN authentication helper (RFC2595)
+    class Plain < Base
+      ##
+      # Authenticate via sending password in clear-text
+      def auth(password)
+        auth_text = "#{@stream.jid.strip}\x00#{@stream.jid.node}\x00#{password}"
+        error = nil
+        @stream.send(generate_auth('PLAIN', Base64::encode64(auth_text).strip)) { |reply|
+          if reply.name != 'success'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+        
+        raise error if error
+      end
+    end
+
+    ##
+    # SASL DIGEST-MD5 authentication helper (RFC2831)
+    class DigestMD5 < Base
+      ##
+      # Sends the wished auth mechanism and wait for a challenge
+      #
+      # (proceed with DigestMD5#auth)
+      def initialize(stream)
+        super
+
+        challenge = {}
+        error = nil
+        @stream.send(generate_auth('DIGEST-MD5')) { |reply|
+          if reply.name == 'challenge' and reply.namespace == NS_SASL
+            challenge_text = Base64::decode64(reply.text)
+            challenge_text.split(/,/).each { |s|
+              key, value = s.split(/=/, 2)
+              value.sub!(/^"/, '')
+              value.sub!(/"$/, '')
+              challenge[key] = value
+            }
+          else
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+        raise error if error
+
+        @nonce = challenge['nonce']
+        @realm = challenge['realm']
+      end
+
+      ##
+      # * Send a response
+      # * Wait for the server's challenge (which aren't checked)
+      # * Send a blind response to the server's challenge
+      def auth(password)
+        response = {}
+        response['nonce'] = @nonce
+        response['charset'] = 'utf-8'
+        response['username'] = @stream.jid.node
+        response['realm'] = @realm || @stream.jid.domain
+        response['cnonce'] = generate_nonce
+        response['nc'] = '00000001'
+        response['qop'] = 'auth'
+        response['digest-uri'] = "xmpp/#{@stream.jid.domain}"
+        response['response'] = response_value(@stream.jid.node, @stream.jid.domain, response['digest-uri'], password, @nonce, response['cnonce'], response['qop'])
+        response.each { |key,value|
+          unless %w(nc qop response charset).include? key
+            response[key] = "\"#{value}\""
+          end
+        }
+
+        r = REXML::Element.new('response')
+        r.add_namespace NS_SASL
+        r.text = Base64::encode64(response.collect { |k,v| "#{k}=#{v}" }.join(',')).gsub(/\s/, '')
+        error = nil
+        @stream.send(r) { |reply|
+          if reply.name != 'challenge'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+        
+        raise error if error
+
+        # TODO: check the challenge from the server
+
+        r.text = nil
+        @stream.send(r) { |reply|
+          if reply.name != 'success'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+        
+        raise error if error
+      end
+
+      private
+
+      ##
+      # Function from RFC2831
+      def h(s); Digest::MD5.digest(s); end
+      ##
+      # Function from RFC2831
+      def hh(s); Digest::MD5.hexdigest(s); end
+      
+      ##
+      # Calculate the value for the response field
+      def response_value(username, realm, digest_uri, passwd, nonce, cnonce, qop)
+        a1_h = h("#{username}:#{realm}:#{passwd}")
+        a1 = "#{a1_h}:#{nonce}:#{cnonce}"
+        #a2 = "AUTHENTICATE:#{digest_uri}#{(qop == 'auth') ? '' : ':00000000000000000000000000000000'}"
+        a2 = "AUTHENTICATE:#{digest_uri}"
+
+        hh("#{hh(a1)}:#{nonce}:00000001:#{cnonce}:#{qop}:#{hh(a2)}")
+      end
+    end
+  end
+end