vinesmod 0.4.5

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

@@ -0,0 +1,43 @@
+# 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)
+              msg_body = self.css('body').inner_text
+              unless msg_body==""
+                msg = {:from => stream.user.jid.to_s,:body=>msg_body,:to => to.bare.to_s}
+                storage(to.domain).save_offline_message(msg)
+              end                            
+            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,156 @@
+# 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 validate_to
+        unless self['type'].nil?
+          raise StanzaErrors::BadRequest.new(self, 'modify')
+        end
+        dir = outbound? ? 'outbound' : 'inbound'
+        method("#{dir}_broadcast_presence").call
+      end
+
+      def outbound?
+        !inbound?
+      end
+
+      def inbound?
+        stream.class == Vines::Stream::Server ||
+          stream.class == Vines::Stream::Component
+      end
+
+      def outbound_broadcast_presence
+        self['from'] = stream.user.jid.to_s
+        to = validate_to
+        type = (self['type'] || '').strip
+        initial = to.nil? && type.empty? && !stream.available?
+
+        recipients = if to.nil?
+          stream.available_subscribers
+        else
+          stream.user.subscribed_from?(to) ? stream.available_resources(to) : []
+        end
+
+        broadcast(recipients)
+        broadcast(stream.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.remote_subscribed_to_contacts.each do |contact|
+            send_probe(contact.jid.bare)
+          end
+          #offline messages
+          storage.fetch_offline_messages(stream.user.jid).each do |offline_msg|
+            doc = Document.new
+            node = doc.create_element('message') do |el|
+              el['from'] = offline_msg[:from]              
+              el['to'] = stream.user.jid.to_s
+              el['type'] = "chat"
+              el << doc.create_element("body") do |b|
+                b << offline_msg[:body]
+              end
+            end            
+            stream.write(node)
+          end
+          storage.delete_offline_messages(stream.user.jid)          
+          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
+        end
+      end
+
+      def inbound_broadcast_presence
+        broadcast(stream.available_resources(validate_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) rescue nil # ignore RemoteServerNotFound
+      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
+
+      # Send the contact's roster item to the current user's interested streams.
+      # Roster pushes are required, following presence subscription updates, to
+      # notify the user's clients of the contact's current state.
+      def send_roster_push(to)
+        contact = stream.user.contact(to)
+        stream.interested_resources(stream.user.jid).each do |recipient|
+          contact.send_roster_push(recipient)
+        end
+      end
+
+      # Notify the current user's interested streams of a contact's subscription
+      # state change as a result of receiving a subscribed, unsubscribe, or
+      # unsubscribed presence stanza.
+      def broadcast_subscription_change(contact)
+        stamp_from
+        stream.interested_resources(stamp_to).each do |recipient|
+          @node['to'] = recipient.user.jid.to_s
+          recipient.write(@node)
+          contact.send_roster_push(recipient)
+        end
+      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 = validate_to
+        raise StanzaErrors::BadRequest.new(self, 'modify') unless to
+        to.bare.tap do |bare|
+          self['to'] = bare.to_s
+        end
+      end
+
+      # Presence subscription stanzas must be addressed from the user's bare
+      # JID. Return the user's bare JID object that was stamped.
+      def stamp_from
+        stream.user.jid.bare.tap do |bare|
+          self['from'] = bare.to_s
+        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
+          contact = storage(to.domain).find_user(to)
+          if contact.nil?
+            auto_reply_to_subscription_request(to, 'unsubscribed')
+          elsif contact.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)
+          contact = user.contact(stream.user.jid) if user
+          return unless contact && contact.can_subscribe?
+          contact.subscribe_to
+          storage(to.domain).save_user(user)
+          stream.update_user_streams(user)
+          broadcast_subscription_change(contact)
+        end
+
+        private
+
+        # After approving a contact's subscription to this user's presence,
+        # broadcast this user's most recent presence stanzas to the contact.
+        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