mack-notifier 0.8.1 → 0.8.2

data/lib/gems/xmpp4r-0.4/lib/xmpp4r/callbacks.rb

@@ -0,0 +1,124 @@
+# =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
+  ##
+  # This class manages a list of callbacks.
+  #
+  # ==Callbacks management and priority
+  #
+  # Callbacks are managed by the class CallbackList. When they are added, a
+  # priority (just a number or anything Comparable with other priorities) is
+  # specified. The biggest the priority is, the earliest the callback will be
+  # considered.
+  #
+  # 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
+  #  c1 = false
+  #  c2 = false
+  #  c3 = false
+  #  cbl.add(10) { c1 = true; 1 }
+  #  cbl.add(5) { c2 = true; true }
+  #  cbl.add(0) { c3 = true }
+  #  cbl.process('aa')
+  #  puts "#{c1} #{c2} #{c3}"
+  # This example would display "true true false" as callbacks processing was
+  # stopped after the second callback returned true.
+  #
+  # 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,
+  #           and Helpers shouldn't register something else unless there's a
+  #           very good reason to.
+  # < 100::   all those numbers are normally available for your application.
+  #           That's enough, don't you think ?
+  class CallbackList
+
+    # Create a new list of callbacks
+    def initialize
+      @list = []
+    end
+
+    ##
+    # Add a callback to the list
+    #
+    # List will be sorted afterwards
+    #
+    # prio:: [Integer] the callback's priority, the higher, the sooner.
+    # ref:: [String] the callback's reference
+    # block:: [Block] a block to execute
+    # 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.sort! { |a, b| b.priority <=> a.priority }
+      self
+    end
+
+    ##
+    # Delete a callback by reference
+    # ref:: [String] the reference of the callback to delete
+    # return:: [CallBackList] The list, for chaining
+    def delete(ref)
+      @list.delete_if { |item| item.ref == ref }
+      self
+    end
+
+    ##
+    # Number of elements in the list
+    # return:: [Integer] The number of elements
+    def length
+      @list.length
+    end
+
+    ##
+    # Process an element through all my callbacks. returns e.consumed?
+    # e:: [Object] The elements to pass to the callback. You can pass
+    # several, but of course, you block must know how to handle them.
+    # return:: [Boolean] true if the element has been consumed
+    def process(*e)
+      # If somebody adds a new callback the list will get modified
+      # and sorted(!) while still iterating through it. So we use a
+      # local copy of @list. Any freshly added callback will receive
+      # the next stanzas, not the current.
+      list = @list.dup
+
+      # process through callbacks
+      list.each do |item|
+        return true if item.block.call(*e) == true
+      end
+      false
+    end
+  end
+
+  # This class is used to store callbacks inside CallbackList. See the
+  # CallbackList class for more detailed explanations.
+  class Callback
+
+    # The Callback's priority
+    attr_reader :priority
+
+    # The Callback's reference, using for deleting purposes
+    attr_reader :ref
+
+    # The Callback's block to execute
+    attr_reader :block
+
+    ##
+    # Create a new callback
+    # 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 {})
+      @priority = priority
+      @ref = ref
+      @block = block
+    end
+  end
+end

data/lib/gems/xmpp4r-0.4/lib/xmpp4r/caps.rb

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

data/lib/gems/xmpp4r-0.4/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/gems/xmpp4r-0.4/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/gems/xmpp4r-0.4/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

data/lib/gems/xmpp4r-0.4/lib/xmpp4r/client.rb

@@ -0,0 +1,317 @@
+# =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 'resolv'
+require 'xmpp4r/connection'
+require 'xmpp4r/sasl'
+
+module Jabber
+
+  # The client class provides everything needed to build a basic XMPP
+  # Client.
+  #
+  # If you want your connection to survive disconnects and timeouts,
+  # catch exception in Stream#on_exception and re-call Client#connect
+  # and Client#auth. Don't forget to re-send initial Presence and
+  # everything else you need to setup your session.
+  class Client  < Connection
+
+    # The client's JID
+    attr_reader :jid
+
+    ##
+    # Create a new Client.
+    #
+    # Remember to *always* put a resource in your JID unless the server can do SASL.
+    def initialize(jid)
+      super()
+      @jid = (jid.kind_of?(JID) ? jid : JID.new(jid.to_s))
+    end
+
+    ##
+    # connect to the server
+    # (chaining-friendly)
+    #
+    # If you omit the optional host argument SRV records for your jid will
+    # be resolved. If none works, fallback is connecting to the domain part
+    # of the jid.
+    # host:: [String] Optional c2s host, will be extracted from jid if nil
+    # use_ssl:: [Boolean] Optional. Use (old, deprecated) SSL when connecting.
+    # return:: self
+    def connect(host = nil, port = 5222)
+      if host.nil?
+        begin
+          srv = []
+          Resolv::DNS.open { |dns|
+            # If ruby version is too old and SRV is unknown, this will raise a NameError
+            # which is caught below
+            Jabber::debuglog("RESOLVING:\n_xmpp-client._tcp.#{@jid.domain} (SRV)")
+            srv = dns.getresources("_xmpp-client._tcp.#{@jid.domain}", Resolv::DNS::Resource::IN::SRV)
+          }
+          # Sort SRV records: lowest priority first, highest weight first
+          srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
+
+          srv.each { |record|
+            begin
+              connect(record.target.to_s, record.port)
+              # Success
+              return self
+            rescue SocketError, Errno::ECONNREFUSED
+              # Try next SRV record
+            end
+          }
+        rescue NameError
+          Jabber::debuglog "Resolv::DNS does not support SRV records. Please upgrade to ruby-1.8.3 or later!"
+        end
+        # Fallback to normal connect method
+      end
+
+      super(host.nil? ? jid.domain : host, port)
+      self
+    end
+
+    ##
+    # Close the connection,
+    # sends <tt></stream:stream></tt> tag first
+    def close
+      send("</stream:stream>")
+      super
+    end
+
+    ##
+    # Start the stream-parser and send the client-specific stream opening element
+    def start
+      super
+      send(generate_stream_start(@jid.domain)) { |e|
+        if e.name == 'stream'
+          true
+        else
+          false
+        end
+      }
+    end
+
+    ##
+    # Authenticate with the server
+    #
+    # Throws ClientAuthenticationFailure
+    #
+    # Authentication mechanisms are used in the following preference:
+    # * SASL DIGEST-MD5
+    # * SASL PLAIN
+    # * Non-SASL digest
+    # password:: [String]
+    def auth(password)
+      begin
+        if @stream_mechanisms.include? 'DIGEST-MD5'
+          auth_sasl SASL.new(self, 'DIGEST-MD5'), password
+        elsif @stream_mechanisms.include? 'PLAIN'
+          auth_sasl SASL.new(self, 'PLAIN'), password
+        else
+          auth_nonsasl(password)
+        end
+      rescue
+        Jabber::debuglog("#{$!.class}: #{$!}\n#{$!.backtrace.join("\n")}")
+        raise ClientAuthenticationFailure.new, $!.to_s
+      end
+    end
+
+    ##
+    # Use a SASL authentication mechanism and bind to a resource
+    #
+    # If there was no resource given in the jid, the jid/resource
+    # generated by the server will be accepted.
+    #
+    # This method should not be used directly. Instead, Client#auth
+    # may look for the best mechanism suitable.
+    # sasl:: Descendant of [Jabber::SASL::Base]
+    # password:: [String]
+    def auth_sasl(sasl, password)
+      sasl.auth(password)
+
+      # Restart stream after SASL auth
+      stop
+      start
+      # And wait for features - again
+      @features_sem.wait
+
+      # Resource binding (RFC3920 - 7)
+      if @stream_features.has_key? 'bind'
+        iq = Iq.new(:set)
+        bind = iq.add REXML::Element.new('bind')
+        bind.add_namespace @stream_features['bind']
+        if jid.resource
+          resource = bind.add REXML::Element.new('resource')
+          resource.text = jid.resource
+        end
+
+        send_with_id(iq) do |reply|
+          reported_jid = reply.first_element('jid')
+          if reported_jid and reported_jid.text
+            @jid = JID.new(reported_jid.text)
+          end
+        end
+      end
+
+      # Session starting
+      if @stream_features.has_key? 'session'
+        iq = Iq.new(:set)
+        session = iq.add REXML::Element.new('session')
+        session.add_namespace @stream_features['session']
+
+        send_with_id(iq)
+      end
+    end
+
+    ##
+    # See Client#auth_anonymous_sasl
+    def auth_anonymous
+      auth_anonymous_sasl
+    end
+
+
+    ##
+    # Shortcut for anonymous connection to server
+    #
+    # Throws ClientAuthenticationFailure
+    def auth_anonymous_sasl
+      if self.supports_anonymous?
+        begin
+          auth_sasl SASL.new(self, 'ANONYMOUS'), ""
+        rescue
+          Jabber::debuglog("#{$!.class}: #{$!}\n#{$!.backtrace.join("\n")}")
+          raise ClientAuthenticationFailure, $!.to_s
+        end
+      else
+        raise ClientAuthenticationFailure, 'Anonymous authentication unsupported'
+      end
+    end
+
+    ##
+    # Reports whether or not anonymous authentication is reported
+    # by the client.
+    #
+    # Returns true or false
+    def supports_anonymous?
+      @stream_mechanisms.include? 'ANONYMOUS'
+    end
+
+    ##
+    # Send auth with given password and wait for result
+    # (non-SASL)
+    #
+    # Throws ServerError
+    # password:: [String] the password
+    # digest:: [Boolean] use Digest authentication
+    def auth_nonsasl(password, digest=true)
+      authset = nil
+      if digest
+        authset = Iq.new_authset_digest(@jid, @streamid.to_s, password)
+      else
+        authset = Iq.new_authset(@jid, password)
+      end
+      send_with_id(authset)
+      $defout.flush
+
+      true
+    end
+
+    ##
+    # Get instructions and available fields for registration
+    # return:: [instructions, fields] Where instructions is a String and fields is an Array of Strings
+    def register_info
+      instructions = nil
+      fields = []
+
+      reg = Iq.new_registerget
+      reg.to = jid.domain
+      send_with_id(reg) do |answer|
+        if answer.query
+          answer.query.each_element { |e|
+            if e.namespace == 'jabber:iq:register'
+              if e.name == 'instructions'
+                instructions = e.text.strip
+              else
+                fields << e.name
+              end
+            end
+          }
+        end
+
+        true
+      end
+
+      [instructions, fields]
+    end
+
+    ##
+    # Register a new user account
+    # (may be used instead of Client#auth)
+    #
+    # This method may raise ServerError if the registration was
+    # not successful.
+    #
+    # password:: String
+    # fields:: {String=>String} additional registration information
+    #
+    # XEP-0077 Defines the following fields for registration information:
+    # http://www.xmpp.org/extensions/xep-0077.html
+    #
+    # 'username'    => 'Account name associated with the user'
+    # 'nick'        => 'Familiar name of the user'
+    # 'password'    => 'Password or secret for the user'
+    # 'name'        => 'Full name of the user'
+    # 'first'       => 'First name or given name of the user'
+    # 'last'        => 'Last name, surname, or family name of the user'
+    # 'email'       => 'Email address of the user'
+    # 'address'     => 'Street portion of a physical or mailing address'
+    # 'city'        => 'Locality portion of a physical or mailing address'
+    # 'state'       => 'Region portion of a physical or mailing address'
+    # 'zip'         => 'Postal code portion of a physical or mailing address'
+    # 'phone'       => 'Telephone number of the user'
+    # 'url'         => 'URL to web page describing the user'
+    # 'date'        => 'Some date (e.g., birth date, hire date, sign-up date)'
+    #
+    def register(password, fields={})
+      reg = Iq.new_register(jid.node, password)
+      reg.to = jid.domain
+      fields.each { |name,value|
+        reg.query.add(REXML::Element.new(name)).text = value
+      }
+
+      send_with_id(reg)
+    end
+
+    ##
+    # Remove the registration of a user account
+    #
+    # *WARNING:* this deletes your roster and everything else
+    # stored on the server!
+    def remove_registration
+      reg = Iq.new_register
+      reg.to = jid.domain
+      reg.query.add(REXML::Element.new('remove'))
+      send_with_id(reg)
+    end
+
+    ##
+    # Change the client's password
+    #
+    # Threading is suggested, as this code waits
+    # for an answer.
+    #
+    # Raises an exception upon error response (ServerError from
+    # Stream#send_with_id).
+    # new_password:: [String] New password
+    def password=(new_password)
+      iq = Iq.new_query(:set, @jid.domain)
+      iq.query.add_namespace('jabber:iq:register')
+      iq.query.add(REXML::Element.new('username')).text = @jid.node
+      iq.query.add(REXML::Element.new('password')).text = new_password
+
+      err = nil
+      send_with_id(iq)
+    end
+  end
+end