lygneo-vines 0.1.1

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_follower(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?('')
+
+          follower = stream.user.follower(jid)
+          unless follower
+            follower = Follower.new(jid: jid)
+            stream.user.roster << follower
+          end
+          follower.name = item['name']
+          follower.groups = groups
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          send_result_iq
+          push_roster_updates(stream.user.jid, follower)
+        end
+
+        # Remove the follower 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_follower(jid)
+          follower = stream.user.follower(jid)
+          raise StanzaErrors::ItemNotFound.new(self, 'modify') unless follower
+          if local_jid?(follower.jid)
+            user = storage(follower.jid.domain).find_user(follower.jid)
+          end
+
+          if user && user.follower(stream.user.jid)
+            user.follower(stream.user.jid).subscription = 'none'
+            user.follower(stream.user.jid).ask = nil
+          end
+          stream.user.remove_follower(follower.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,
+            Follower.new(jid: follower.jid, subscription: 'remove'))
+
+          if local_jid?(follower.jid)
+            send_unavailable(stream.user.jid, follower.jid) if follower.subscribed_from?
+            send_unsubscribe(follower)
+            if user && user.follower(stream.user.jid)
+              push_roster_updates(follower.jid, user.follower(stream.user.jid))
+            end
+          else
+            send_unsubscribe(follower)
+          end
+        end
+
+        # Notify the follower that it's been removed from the user's roster
+        # and no longer has any presence relationship with the user.
+        def send_unsubscribe(follower)
+          presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
+            presence(follower.jid, type) if follower.send("subscribed_#{meth}?")
+          end.compact
+          broadcast_to_interested_resources(presence, follower.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, follower)
+          stream.interested_resources(to).each do |recipient|
+            follower.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

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

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      # Session support is deprecated, but Adium requires it, so reply with an
+      # iq result stanza.
+      class Session < Iq
+        register "/iq[@id and @type='set']/ns:session", 'ns' => NAMESPACES[:session]
+
+        def process
+          stream.write(to_result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Vcard < Iq
+        NS = NAMESPACES[:vcard]
+
+        register "/iq[@id and @type='get' or @type='set']/ns:vCard", 'ns' => NS
+
+        def process
+          return unless allowed?
+          if local?
+            get? ? vcard_query : vcard_update
+          else
+            self['from'] = stream.user.jid.to_s
+            route
+          end
+        end
+
+        private
+
+        def vcard_query
+          to = validate_to
+          jid = to ? to.bare : stream.user.jid.bare
+          card = storage(jid.domain).find_vcard(jid)
+
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless card
+
+          doc = Document.new
+          result = doc.create_element('iq') do |node|
+            node['from'] = jid.to_s unless jid == stream.user.jid.bare
+            node['id']   = self['id']
+            node['to']   = stream.user.jid.to_s
+            node['type'] = 'result'
+            node << card
+          end
+          stream.write(result)
+        end
+
+        def vcard_update
+          to = validate_to
+          unless to.nil? || to == stream.user.jid.bare
+            raise StanzaErrors::Forbidden.new(self, 'auth')
+          end
+
+          storage.save_vcard(stream.user.jid, elements.first)
+
+          result = to_result
+          result.remove_attribute('from')
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Version < Query
+        NS = NAMESPACES[:version]
+
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NS
+
+        def process
+          return if route_iq || to_pubsub_domain? || !allowed?
+          result = to_result.tap do |node|
+            node << node.document.create_element('query') do |query|
+              query.default_namespace = NS
+              query << node.document.create_element('name', 'Vines')
+              query << node.document.create_element('version', VERSION)
+            end
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

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/message.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Message < Stanza
+      register "/message"
+
+      TYPE, FROM  = %w[type from].map {|s| s.freeze }
+      VALID_TYPES = %w[chat error groupchat headline normal].freeze
+
+      VALID_TYPES.each do |type|
+        define_method "#{type}?" do
+          self[TYPE] == type
+        end
+      end
+
+      def process
+        unless self[TYPE].nil? || VALID_TYPES.include?(self[TYPE])
+          raise StanzaErrors::BadRequest.new(self, 'modify')
+        end
+
+        if local?
+          to = validate_to || stream.user.jid.bare
+          recipients = stream.connected_resources(to)
+          if recipients.empty?
+            if user = storage(to.domain).find_user(to)
+              # TODO Implement offline messaging storage
+              raise StanzaErrors::ServiceUnavailable.new(self, 'cancel')
+            end
+          else
+            broadcast(recipients)
+          end
+        else
+          self[FROM] = stream.user.jid.to_s
+          route
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Error < Presence
+        register "/presence[@type='error']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          # FIXME Implement error handling
+        end
+
+        def process_inbound
+          # FIXME Implement error handling
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/probe.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Probe < Presence
+        register "/presence[@type='probe']"
+
+        def process
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          self['from'] = stream.user.jid.to_s
+          local? ? process_inbound : route
+        end
+
+        def process_inbound
+          to = validate_to
+          raise StanzaErrors::BadRequest.new(self, 'modify') unless to
+
+          user = storage(to.domain).find_user(to)
+          unless user && user.subscribed_from?(stream.user.jid)
+            auto_reply_to_subscription_request(to.bare, 'unsubscribed')
+          else
+            stream.available_resources(to).each do |recipient|
+              el = recipient.last_broadcast_presence.clone
+              el['from'] = recipient.user.jid.to_s
+              el['to'] = stream.user.jid.to_s
+              stream.write(el)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/subscribe.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Subscribe < Presence
+        register "/presence[@type='subscribe']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          to = stamp_to
+          stream.user.request_subscription(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          local? ? process_inbound : route
+          send_roster_push(to)
+        end
+
+        def process_inbound
+          to = stamp_to
+          follower = storage(to.domain).find_user(to)
+          if follower.nil?
+            auto_reply_to_subscription_request(to, 'unsubscribed')
+          elsif follower.subscribed_from?(stream.user.jid)
+            auto_reply_to_subscription_request(to, 'subscribed')
+          else
+            recipients = stream.available_resources(to)
+            if recipients.empty?
+              # TODO store subscription request per RFC 6121 3.1.3 #4
+            else
+              broadcast_to_available_resources([@node], to)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/subscribed.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Subscribed < Presence
+        register "/presence[@type='subscribed']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          to = stamp_to
+          stream.user.add_subscription_from(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          local? ? process_inbound : route
+          send_roster_push(to)
+          send_known_presence(to)
+        end
+
+        def process_inbound
+          to = stamp_to
+          user = storage(to.domain).find_user(to)
+          follower = user.follower(stream.user.jid) if user
+          return unless follower && follower.can_subscribe?
+          follower.subscribe_to
+          storage(to.domain).save_user(user)
+          stream.update_user_streams(user)
+          broadcast_subscription_change(follower)
+        end
+
+        private
+
+        # After approving a follower's subscription to this user's presence,
+        # broadcast this user's most recent presence stanzas to the follower.
+        def send_known_presence(to)
+          stanzas = stream.available_resources(stream.user.jid).map do |stream|
+            stream.last_broadcast_presence.clone.tap do |node|
+              node['from'] = stream.user.jid.to_s
+              node['id'] = Kit.uuid
+            end
+          end
+          broadcast_to_available_resources(stanzas, to)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/unavailable.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unavailable < Presence
+        register "/presence[@type='unavailable']"
+
+        def process
+          inbound? ? inbound_broadcast_presence : outbound_broadcast_presence
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/unsubscribe.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribe < Presence
+        register "/presence[@type='unsubscribe']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          to = stamp_to
+          return unless stream.user.subscribed_to?(to)
+          stream.user.remove_subscription_to(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          local? ? process_inbound : route
+          send_roster_push(to)
+        end
+
+        def process_inbound
+          to = stamp_to
+          user = storage(to.domain).find_user(to)
+          return unless user && user.subscribed_from?(stream.user.jid)
+          follower = user.follower(stream.user.jid)
+          follower.unsubscribe_from
+          storage(to.domain).save_user(user)
+          stream.update_user_streams(user)
+          broadcast_subscription_change(follower)
+          send_unavailable(to, stream.user.jid.bare)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/presence/unsubscribed.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence
+      class Unsubscribed < Presence
+        register "/presence[@type='unsubscribed']"
+
+        def process
+          stamp_from
+          inbound? ? process_inbound : process_outbound
+        end
+
+        def process_outbound
+          to = stamp_to
+          return unless stream.user.subscribed_from?(to)
+          send_unavailable(stream.user.jid, to)
+          stream.user.remove_subscription_from(to)
+          storage.save_user(stream.user)
+          stream.update_user_streams(stream.user)
+          local? ? process_inbound : route
+          send_roster_push(to)
+        end
+
+        def process_inbound
+          to = stamp_to
+          user = storage(to.domain).find_user(to)
+          return unless user && user.subscribed_to?(stream.user.jid)
+          follower = user.follower(stream.user.jid)
+          follower.unsubscribe_to
+          storage(to.domain).save_user(user)
+          stream.update_user_streams(user)
+          broadcast_subscription_change(follower)
+        end
+      end
+    end
+  end
+end