vinesmod 0.4.5

data/lib/vines/stanza/iq.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq < Stanza
+      register "/iq"
+
+      VALID_TYPES = %w[get set result error].freeze
+
+      VALID_TYPES.each do |type|
+        define_method "#{type}?" do
+          self['type'] == type
+        end
+      end
+
+      def process
+        if self['id'] && VALID_TYPES.include?(self['type'])
+          route_iq or raise StanzaErrors::FeatureNotImplemented.new(@node, 'cancel')
+        else
+          raise StanzaErrors::BadRequest.new(@node, 'modify')
+        end
+      end
+
+      def to_result
+        doc = Document.new
+        doc.create_element('iq',
+          'from' => validate_to || stream.domain,
+          'id'   => self['id'],
+          'to'   => stream.user.jid,
+          'type' => 'result')
+      end
+
+      private
+
+      # Return false if this IQ stanza is addressed to the server, or a pubsub
+      # service hosted here, and must be handled locally. Return true if the
+      # stanza must not be handled locally and has been routed to the appropriate
+      # component, s2s, or c2s stream.
+      def route_iq
+        to = validate_to
+        return false if to.nil? || stream.config.vhost?(to) || to_pubsub_domain?
+        self['from'] = stream.user.jid.to_s
+        local? ? broadcast(stream.connected_resources(to)) : route
+        true
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/auth.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Auth < Query
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NAMESPACES[:non_sasl]
+
+        def process
+          # XEP-0078 says we MUST send a service-unavailable error
+          # here, but Adium 1.4.1 won't login if we do that, so just
+          # swallow this stanza.
+          # raise StanzaErrors::ServiceUnavailable.new(@node, 'cancel')
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/disco_info.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class DiscoInfo < Query
+        NS = NAMESPACES[:disco_info]
+
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              if to_pubsub_domain?
+                identity(query, 'pubsub', 'service')
+                pubsub = [:pubsub_create, :pubsub_delete, :pubsub_instant, :pubsub_item_ids, :pubsub_publish, :pubsub_subscribe]
+                features(query, :disco_info, :ping, :pubsub, *pubsub)
+              else
+                identity(query, 'server', 'im')
+                features = [:disco_info, :disco_items, :ping, :vcard, :version]
+                features << :storage if stream.config.private_storage?(validate_to || stream.domain)
+                features(query, features)
+              end
+            end
+          end
+          stream.write(result)
+        end
+
+        private
+
+        def identity(query, category, type)
+          query << query.document.create_element('identity', 'category' => category, 'type' => type)
+        end
+
+        def features(query, *features)
+          features.flatten.each do |feature|
+            query << query.document.create_element('feature', 'var' => NAMESPACES[feature])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/disco_items.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class DiscoItems < Query
+        NS = NAMESPACES[:disco_items]
+
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NS
+
+        def process
+          return if route_iq || !allowed?
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              unless to_pubsub_domain?
+                to = (validate_to || stream.domain).to_s
+                stream.config.vhost(to).disco_items.each do |domain|
+                  query << el.document.create_element('item', 'jid' => domain)
+                end
+              end
+            end
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/error.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Error < Iq
+        register "/iq[@id and @type='error']"
+
+        def process
+          return if route_iq
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/ping.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Ping < Iq
+        register "/iq[@id and @type='get']/ns:ping", 'ns' => NAMESPACES[:ping]
+
+        def process
+          return if route_iq || !allowed?
+          stream.write(to_result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/private_storage.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      # Implements the Private Storage feature defined in XEP-0049. Clients are
+      # allowed to save arbitrary XML documents on the server, identified by
+      # element name and namespace.
+      class PrivateStorage < Query
+        NS = NAMESPACES[:storage]
+
+        register "/iq[@id and (@type='get' or @type='set')]/ns:query", 'ns' => NS
+
+        def process
+          validate_to_address
+          validate_storage_enabled
+          validate_children_size
+          validate_namespaces
+          get? ? retrieve_fragment : update_fragment
+        end
+
+        private
+
+        def retrieve_fragment
+          found = storage.find_fragment(stream.user.jid, elements.first.elements.first)
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless found
+
+          result = to_result do |node|
+            node << node.document.create_element('query') do |query|
+              query.default_namespace = NS
+              query << found
+            end
+          end
+          stream.write(result)
+        end
+
+        def update_fragment
+          elements.first.elements.each do |node|
+            storage.save_fragment(stream.user.jid, node)
+          end
+          stream.write(to_result)
+        end
+
+        private
+
+        def to_result
+          super.tap do |node|
+            node['from'] = stream.user.jid.to_s
+            yield node if block_given?
+          end
+        end
+
+        def validate_children_size
+          size = elements.first.elements.size
+          if (get? && size != 1) || (set? && size == 0)
+            raise StanzaErrors::NotAcceptable.new(self, 'modify')
+          end
+        end
+
+        def validate_to_address
+          to = validate_to
+          unless to.nil? || to == stream.user.jid.bare
+            raise StanzaErrors::Forbidden.new(self, 'cancel')
+          end
+        end
+
+        def validate_storage_enabled
+          unless stream.config.private_storage?(stream.domain)
+            raise StanzaErrors::ServiceUnavailable.new(self, 'cancel')
+          end
+        end
+
+        def validate_namespaces
+          elements.first.elements.each do |node|
+            if node.namespace.nil? || NAMESPACES.values.include?(node.namespace.href)
+              raise StanzaErrors::NotAcceptable.new(self, 'modify')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/query.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Query < Iq
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/register.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Register < Query
+        NS = NAMESPACES[:register]
+
+        register "/iq[@id and @type='set']/ns:query", 'ns' => NS
+
+        def process
+          if is_stream_owner
+            current_user = storage(stream.domain).find_user(stream.user.jid)
+            password = @node.xpath("//iq/jir:query//jir:password", {"jir"=>"jabber:iq:register"}).text
+            unless password.nil?
+              current_user.password = BCrypt::Password.create(password.to_s)
+              storage.save_user(current_user)
+              stream.write(to_result)
+            else
+             raise StanzaErrors::NotAcceptable.new(self, 'cancel')
+            end
+          else
+
+          end
+        end
+
+        private
+
+        def is_stream_owner
+          stream.user.jid.bare == jid_from_username.bare
+        end
+
+        def jid_from_username
+          username = @node.xpath("//iq/jir:query//jir:username", {"jir"=>"jabber:iq:register"}).text
+          dom = @node.attributes["to"].text
+          JID.new(username, dom)
+        end
+
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/result.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Result < Iq
+        register "/iq[@id and @type='result']"
+
+        def process
+          return if route_iq
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/roster.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Roster < Query
+        NS = NAMESPACES[:roster]
+
+        register "/iq[@id and (@type='get' or @type='set')]/ns:query", 'ns' => NS
+
+        def process
+          validate_to_address
+          get? ? roster_query : update_roster
+        end
+
+        private
+
+        # Send an iq result stanza containing roster items to the user in
+        # response to their roster get request. Requesting the roster makes
+        # this stream an "interested resource" that can now receive roster
+        # updates.
+        def roster_query
+          stream.requested_roster!
+          stream.write(stream.user.to_roster_xml(self['id']))
+        end
+
+        # Roster sets must have no 'to' address or be addressed to the same
+        # JID that sent the stanza. RFC 6121 sections 2.1.5 and 2.3.3.
+        def validate_to_address
+          to = validate_to
+          unless to.nil? || to.bare == stream.user.jid.bare
+            raise StanzaErrors::Forbidden.new(self, 'auth')
+          end
+        end
+
+        # Add, update, or delete the roster item contained in the iq set
+        # stanza received from the client. RFC 6121 sections 2.3, 2.4, 2.5.
+        def update_roster
+          items = self.xpath('ns:query/ns:item', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if items.size != 1
+          item = items.first
+
+          jid = JID.new(item['jid']) rescue (raise StanzaErrors::JidMalformed.new(self, 'modify'))
+          raise StanzaErrors::BadRequest.new(self, 'modify') if jid.empty? || !jid.bare?
+
+          if item['subscription'] == 'remove'
+            remove_contact(jid)
+            return
+          end
+
+          raise StanzaErrors::NotAllowed.new(self, 'modify') if jid == stream.user.jid.bare
+          groups = item.xpath('ns:group', 'ns' => NS).map {|g| g.text.strip }
+          raise StanzaErrors::BadRequest.new(self, 'modify') if groups.uniq!
+          raise StanzaErrors::NotAcceptable.new(self, 'modify') if groups.include?('')
+
+          contact = stream.user.contact(jid)
+          unless contact
+            contact = Contact.new(jid: jid)
+            stream.user.roster << contact
+          end
+          contact.name = item['name']
+          contact.groups = groups
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          send_result_iq
+          push_roster_updates(stream.user.jid, contact)
+        end
+
+        # Remove the contact with this JID from the user's roster and send
+        # roster pushes to the user's interested resources. This is triggered
+        # by receiving an iq set with an item element like
+        # <item jid="alice@wonderland.lit" subscription="remove"/>. RFC 6121
+        # section 2.5.
+        def remove_contact(jid)
+          contact = stream.user.contact(jid)
+          raise StanzaErrors::ItemNotFound.new(self, 'modify') unless contact
+          if local_jid?(contact.jid)
+            user = storage(contact.jid.domain).find_user(contact.jid)
+          end
+
+          if user && user.contact(stream.user.jid)
+            user.contact(stream.user.jid).subscription = 'none'
+            user.contact(stream.user.jid).ask = nil
+          end
+          stream.user.remove_contact(contact.jid)
+          [user, stream.user].compact.each do |save|
+            storage(save.jid.domain).save_user(save)
+            stream.update_user_streams(save)
+          end
+
+          send_result_iq
+          push_roster_updates(stream.user.jid,
+            Contact.new(jid: contact.jid, subscription: 'remove'))
+
+          if local_jid?(contact.jid)
+            send_unavailable(stream.user.jid, contact.jid) if contact.subscribed_from?
+            send_unsubscribe(contact)
+            if user && user.contact(stream.user.jid)
+              push_roster_updates(contact.jid, user.contact(stream.user.jid))
+            end
+          else
+            send_unsubscribe(contact)
+          end
+        end
+
+        # Notify the contact that it's been removed from the user's roster
+        # and no longer has any presence relationship with the user.
+        def send_unsubscribe(contact)
+          presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
+            presence(contact.jid, type) if contact.send("subscribed_#{meth}?")
+          end.compact
+          broadcast_to_interested_resources(presence, contact.jid)
+        end
+
+        def presence(to, type)
+          doc = Document.new
+          doc.create_element('presence',
+            'from' => stream.user.jid.bare.to_s,
+            'id'   => Kit.uuid,
+            'to'   => to.to_s,
+            'type' => type)
+        end
+
+        # Send an iq set stanza to the user's interested resources, letting them
+        # know their roster has been updated.
+        def push_roster_updates(to, contact)
+          stream.interested_resources(to).each do |recipient|
+            contact.send_roster_push(recipient)
+          end
+        end
+
+        def send_result_iq
+          node = to_result
+          node.remove_attribute('from')
+          stream.write(node)
+        end
+      end
+    end
+  end
+end