vines 0.1.0

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

@@ -0,0 +1,153 @@
+# 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
+          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 = (self['to'] || '').strip
+          unless to.empty? || JID.new(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
+          validate_to_address
+
+          items = self.xpath('ns:query/ns:item', 'ns' => NS)
+          raise StanzaErrors::BadRequest.new(self, 'modify') if items.size != 1
+          item = items.first
+
+          jid = (item['jid'] || '').strip.empty? ? nil : JID.new(item['jid'].strip)
+          raise StanzaErrors::BadRequest.new(self, 'modify') unless jid && 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 router.local_jid?(contact.jid)
+            user = storage(contact.jid.domain).find_user(contact.jid)
+            remove(contact, user)
+          else
+            remove(contact, nil)
+          end
+        end
+
+        def remove(contact, user=nil)
+          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'))
+
+          presence = [%w[to unsubscribe], %w[from unsubscribed]].map do |meth, type|
+            if contact.send("subscribed_#{meth}?")
+              doc = Document.new
+              doc.create_element('presence',
+                'from' => stream.user.jid.bare.to_s,
+                'to'   => contact.jid.to_s,
+                'type' => type)
+            end
+          end.compact
+
+          if router.local_jid?(contact.jid)
+            router.interested_resources(contact.jid).each do |recipient|
+              presence.each {|el| recipient.write(el) }
+              doc = Document.new
+              el = doc.create_element('presence',
+                'from' => stream.user.jid.bare.to_s,
+                'to'   => recipient.user.jid.to_s,
+                'type' => 'unavailable')
+              recipient.write(el)
+            end
+            push_roster_updates(contact.jid, Contact.new(
+              :jid => stream.user.jid,
+              :subscription => 'none'))
+          else
+            presence.each {|el| router.route(el) }
+          end
+        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)
+          doc = Document.new
+          el = doc.create_element('iq', 'type' => 'set') do |node|
+            node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
+              query << contact.to_roster_xml
+            end
+          end
+          router.interested_resources(to).each do |recipient|
+            el['id'] = Kit.uuid
+            el['to'] = recipient.user.jid.to_s
+            recipient.write(el)
+          end
+        end
+
+        def send_result_iq
+          doc = Document.new
+          node = doc.create_element('iq', 'id' => self['id'], 'type' => 'result')
+          stream.write(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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
+          doc = Document.new
+          result = doc.create_element('iq',
+            'from' => stream.domain,
+            'id'   => self['id'],
+            'type' => 'result')
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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
+          if local?
+            get? ? vcard_query : vcard_update
+          else
+            self['from'] = stream.user.jid.to_s
+            route
+          end
+        end
+
+        private
+
+        def vcard_query
+          jid = (self['to'] || '').strip
+          jid = jid.empty? ? stream.user.jid.bare : JID.new(jid).bare
+          card = storage.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 = (self['to'] || '').strip
+          unless to.empty? || to == stream.user.jid.bare.to_s
+            raise StanzaErrors::Forbidden.new(self, 'auth')
+          end
+
+          storage.save_vcard(stream.user.jid, elements.first)
+
+          doc = Document.new
+          result = doc.create_element('iq',
+            'id'   => self['id'],
+            'to'   => stream.user.jid.to_s,
+            'type' => 'result')
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/message.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Message < Stanza
+      register "/message"
+
+      TYPE, TO, FROM = %w[type to 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 = (self[TO] || '').strip
+          to = to.empty? ? stream.user.jid.bare : JID.new(to)
+          recipients = router.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.rb

@@ -0,0 +1,119 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Presence < Stanza
+      register "/presence"
+
+      VALID_TYPES = %w[subscribe subscribed unsubscribe unsubscribed unavailable probe error].freeze
+
+      VALID_TYPES.each do |type|
+        define_method "#{type}?" do
+          self['type'] == type
+        end
+      end
+
+      def process
+        stream.last_broadcast_presence = @node.clone unless self['to']
+        unless self['type'].nil?
+          raise StanzaErrors::BadRequest.new(self, 'modify')
+        end
+        dir = outbound? ? 'outbound' : 'inbound'
+        method("#{dir}_broadcast_presence").call
+      end
+
+      def outbound?
+        stream.class != Vines::Stream::Server
+      end
+
+      def inbound?
+        stream.class == Vines::Stream::Server
+      end
+
+      def outbound_broadcast_presence
+        self['from'] = stream.user.jid.to_s
+        to, type = %w[to type].map {|a| (self[a] || '').strip }
+        initial = to.empty? && type.empty? && !stream.available?
+
+        recipients = if to.empty?
+          stream.available_subscribers
+        else
+          stream.user.subscribed_from?(to) ? router.available_resources(to) : []
+        end
+        broadcast(recipients + router.available_resources(stream.user.jid))
+
+        if initial
+          stream.available_subscribed_to_resources.each do |recipient|
+            if recipient.last_broadcast_presence
+              el = recipient.last_broadcast_presence.clone
+              el['to'] = stream.user.jid.to_s
+              el['from'] = recipient.user.jid.to_s
+              stream.write(el)
+            end
+          end
+          stream.available!
+        end
+
+        stream.remote_subscribers(to).each do |contact|
+          node = @node.clone
+          node['to'] = contact.jid.bare.to_s
+          router.route(node) rescue nil # ignore RemoteServerNotFound
+          send_probe(contact.jid.bare) if initial
+        end
+      end
+
+      def inbound_broadcast_presence
+        broadcast(router.available_resources(self['to']))
+      end
+
+      private
+
+      def send_probe(to)
+        to = JID.new(to)
+        doc = Document.new
+        probe = doc.create_element('presence',
+          'from' => stream.user.jid.bare.to_s,
+          'id'   => Kit.uuid,
+          'to'   => to.bare.to_s,
+          'type' => 'probe')
+        router.route(probe)
+      end
+
+      def send_subscribed_roster_push(recipient, jid, state)
+        doc = Document.new
+        node = doc.create_element('iq',
+          'id'  => Kit.uuid,
+          'to'  => recipient.user.jid.to_s,
+          'type' => 'set')
+        node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
+          query << doc.create_element('item', 'jid' => jid.to_s, 'subscription' => state)
+        end
+        recipient.write(node)
+      end
+
+      def auto_reply_to_subscription_request(from, type)
+        doc = Document.new
+        node = doc.create_element('presence') do |el|
+          el['from'] = from.to_s
+          el['id'] = self['id'] if self['id']
+          el['to'] = stream.user.jid.bare.to_s
+          el['type'] = type
+        end
+        stream.write(node)
+      end
+
+      # Validate that the incoming stanza has a 'to' attribute and strip any
+      # resource part from it so it's a bare jid. Return the bare JID object
+      # that was stamped.
+      def stamp_to
+        to = (self['to'] || '').strip
+        raise StanzaErrors::BadRequest.new(self, 'modify') if to.empty?
+        to = JID.new(to).bare
+        malformed = [to.node, to.domain].any? {|part| (part || '').strip.empty? }
+        raise StanzaErrors::JidMalformed.new(self, 'modify') if malformed
+        self['to'] = to.to_s
+        to
+      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,38 @@
+# 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 = (self['to'] || '').strip
+          raise StanzaErrors::BadRequest.new(self, 'modify') if to.empty?
+          to = JID.new(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
+            router.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