xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/rpc/helper/xmlrpcaddons.rb

@@ -0,0 +1,57 @@
+require "xmlrpc/parser"
+require "xmlrpc/create"
+require "xmlrpc/config"
+require "xmlrpc/utils"     # ParserWriterChooseMixin
+
+
+module XMLRPC
+  class Create
+    ##
+    # create a Method Call
+    # name:: [String] name of the method
+    # params:: [Array] params of the method as a array
+    def methodCall(name, *params)
+      name = name.to_s
+
+      if name !~ /[a-zA-Z0-9_.:\/]+/
+        raise ArgumentError, "Wrong XML-RPC method-name"
+      end
+
+      parameter = params.collect { |param|
+        @writer.ele("param", conv2value(param))
+      }
+
+      tree = @writer.document(
+               @writer.ele("methodCall",
+                 @writer.tag("methodName", name),
+                 @writer.ele("params", *parameter)
+               )
+             )
+
+      @writer.document_to_str(tree) + "\n"
+    end
+    ##
+    # create a response to a method call
+    # is_ret:: [TrueClass] is this a return (true)  or a error (false)
+    # params:: [Array] a array of params
+
+    def methodResponse(is_ret, *params)
+
+      if is_ret
+        resp = params.collect do |param|
+          @writer.ele("param", conv2value(param))
+        end
+
+        resp = [@writer.ele("params", *resp)]
+      else
+        if params.size != 1 or params[0] === XMLRPC::FaultException
+          raise ArgumentError, "no valid fault-structure given"
+        end
+        resp = @writer.ele("fault", conv2value(params[0].to_h))
+      end
+
+      tree = @writer.document(@writer.ele("methodResponse", resp))
+      @writer.document_to_str(tree) + "\n"
+    end
+  end
+end

data/lib/xmpp4r/rpc/iq/rpc.rb

@@ -0,0 +1,24 @@
+# =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/query'
+
+module Jabber
+  module RPC
+    class IqQueryRPC < IqQuery
+      NS_RPC = 'jabber:iq:rpc'
+      name_xmlns 'query', NS_RPC
+
+      # TODO: Is typed_add with a String right here?
+      def typed_add(e)
+        if e.kind_of? String
+          typed_add(REXML::Document.new(e).root)
+        else
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/sasl.rb

@@ -57,7 +57,7 @@ module Jabber
       def auth(password)
         auth_text = "#{@stream.jid.strip}\x00#{@stream.jid.node}\x00#{password}"
         error = nil
-        @stream.send(generate_auth('PLAIN', Base64::encode64(auth_text).strip)) { |reply|
+        @stream.send(generate_auth('PLAIN', Base64::encode64(auth_text).gsub(/\s/, ''))) { |reply|
           if reply.name != 'success'
             error = reply.first_element(nil).name
           end

data/lib/xmpp4r/semaphore.rb

@@ -0,0 +1,38 @@
+# =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 implements semaphore for threads synchronization.
+  class Semaphore
+
+    ##
+    # Initialize new semaphore
+    #
+    # val:: [Integer] number of threads, that can enter to section
+    def initialize(val=0)
+      @tickets = val
+      @lock = Mutex.new
+      @cond = ConditionVariable.new
+    end
+
+    ##
+    # Waits until are available some free tickets
+    def wait
+      @lock.synchronize {
+        @cond.wait(@lock) while !(@tickets > 0)
+        @tickets -= 1
+      }
+    end
+
+    ##
+    # Unlocks guarded section, increments number of free tickets
+    def run
+      @lock.synchronize {
+        @tickets += 1
+        @cond.signal
+      }
+    end
+  end
+end

data/lib/xmpp4r/stream.rb

@@ -2,10 +2,10 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'callbacks'
+require 'xmpp4r/callbacks'
 require 'socket'
 require 'thread'
-Thread::abort_on_exception = true
+require 'xmpp4r/semaphore'
 require 'xmpp4r/streamparser'
 require 'xmpp4r/presence'
 require 'xmpp4r/message'
@@ -40,6 +40,9 @@ module Jabber
     # Create a new stream
     # (just initializes)
     def initialize(threaded = true)
+      unless threaded
+        raise "Non-threaded mode was removed from XMPP4R."
+      end
       @fd = nil
       @status = DISCONNECTED
       @xmlcbs = CallbackList::new
@@ -47,20 +50,15 @@ module Jabber
       @messagecbs = CallbackList::new
       @iqcbs = CallbackList::new
       @presencecbs = CallbackList::new
-      unless threaded
-        $stderr.puts "Non-threaded mode is currently broken, re-enabling threaded"
-        threaded = true
-      end
-      @threaded = threaded
-      @stanzaqueue = []
-      @stanzaqueue_lock = Mutex::new
+      @send_lock = Mutex.new
+      @last_send = Time.now
       @exception_block = nil
       @threadblocks = []
-#      @pollCounter = 10
-      @waiting_thread = nil
       @wakeup_thread = nil
       @streamid = nil
-      @features_lock = Mutex.new
+      @streamns = 'jabber:client'
+      @features_sem = Semaphore.new
+      @parser_thread = nil
     end
 
     ##
@@ -71,36 +69,42 @@ module Jabber
 
       @fd = fd
       @parser = StreamParser.new(@fd, self)
-      @parserThread = Thread.new do
+      @parser_thread = Thread.new do
+        Thread.current.abort_on_exception = true
         begin
           @parser.parse
+          Jabber::debuglog("DISCONNECTED\n")
+
+          if @exception_block
+            Thread.new { close!; @exception_block.call(nil, self, :disconnected) }
+          else
+            close!
+          end
         rescue Exception => e
           Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
 
           if @exception_block
-            Thread.new { close; @exception_block.call(e, self, :start) }
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              close
+              @exception_block.call(e, self, :start)
+            end
           else
-            puts "Exception caught in Parser thread!"
-            close
+            if Jabber::debug
+              puts "Exception caught in Parser thread! (#{e.class})"
+              puts e.backtrace
+            end
+            close!
             raise
           end
         end
       end
-#      @pollThread = Thread.new do
-#        begin
-#        poll
-#        rescue
-#          puts "Exception caught in Poll thread, dumping backtrace and" +
-#            " exiting...\n" + $!.exception + "\n"
-#          puts $!.backtrace
-#          exit
-#        end
-#      end
+
       @status = CONNECTED
     end
 
     def stop
-      @parserThread.kill
+      @parser_thread.kill
       @parser = nil
     end
 
@@ -126,10 +130,11 @@ module Jabber
       # to commit suicide(???)
       if @exception_block
         # New thread, because close will kill the current thread
-        Thread.new {
+        Thread.new do
+          Thread.current.abort_on_exception = true
           close
           @exception_block.call(e, self, :parser)
-        }
+        end
       else
         puts "Stream#parse_failure was called by XML parser. Dumping " +
         "backtrace...\n" + e.exception + "\n"
@@ -143,10 +148,11 @@ module Jabber
     # This method is called by the parser upon receiving <tt></stream:stream></tt>
     def parser_end
       if @exception_block
-        Thread.new {
+        Thread.new do
+          Thread.current.abort_on_exception = true
           close
           @exception_block.call(nil, self, :close)
-        }
+        end
       else
         close
       end
@@ -171,30 +177,31 @@ module Jabber
     # Processes a received REXML::Element and executes 
     # registered thread blocks and filters against it.
     #
-    # If in threaded mode, a new thread will be spawned
-    # for the call to receive_nonthreaded.
     # element:: [REXML::Element] The received element
     def receive(element)
-      if @threaded
-        # Don't spawn a new thread here. An implicit feature
-        # of XMPP is constant order of stanzas.
-        receive_nonthreaded(element)
-      else
-        receive_nonthreaded(element)
-      end
-    end
-    
-    def receive_nonthreaded(element)
       Jabber::debuglog("RECEIVED:\n#{element.to_s}")
+
+      if element.namespace('').to_s == '' # REXML namespaces are always strings
+        element.add_namespace(@streamns)
+      end
+
       case element.prefix
       when 'stream'
         case element.name
           when 'stream'
             stanza = element
             @streamid = element.attributes['id']
+            @streamns = element.namespace('') if element.namespace('')
+
+            # Hack: component streams are basically client streams.
+            # Someday we may want to create special stanza classes
+            # for components/s2s deriving from normal stanzas but
+            # posessing these namespaces
+            @streamns = 'jabber:client' if @streamns == 'jabber:component:accept'
+
             unless element.attributes['version']  # isn't XMPP compliant, so
               Jabber::debuglog("FEATURES: server not XMPP compliant, will not wait for features")
-              @features_lock.unlock               # don't wait for <stream:features/>
+              @features_sem.run                   # don't wait for <stream:features/> 
             end
           when 'features'
             stanza = element
@@ -208,20 +215,16 @@ module Jabber
               end
             }
             Jabber::debuglog("FEATURES: received")
-            @features_lock.unlock
+            @features_sem.run
           else
             stanza = element
         end
       else
-        case element.name
-          when 'message'
-            stanza = Message::import(element)
-          when 'iq'
-            stanza = Iq::import(element)
-          when 'presence'
-            stanza = Presence::import(element)
-          else
-            stanza = element
+        # Any stanza, classes are registered by XMPPElement::name_xmlns
+        begin
+          stanza = XMPPStanza::import(element)
+        rescue NoNameXmlnsRegistered
+          stanza = element
         end
       end
 
@@ -251,23 +254,7 @@ module Jabber
         end
       }
 
-      if @threaded
-        process_one(stanza)
-      else
-        # stanzaqueue will be read when the user call process
-        @stanzaqueue_lock.lock
-        @stanzaqueue.push(stanza)
-        @stanzaqueue_lock.unlock
-        @waiting_thread.wakeup if @waiting_thread
-      end
-    end
-    private :receive_nonthreaded
-
-    ##
-    # Process |element| until it is consumed. Returns element.consumed?
-    # element  The element to process
-    def process_one(stanza)
-      Jabber::debuglog("PROCESSING:\n#{stanza.to_s}")
+      Jabber::debuglog("PROCESSING:\n#{stanza.to_s} (#{stanza.class})")
       return true if @xmlcbs.process(stanza)
       return true if @stanzacbs.process(stanza)
       case stanza
@@ -279,61 +266,6 @@ module Jabber
         return true if @presencecbs.process(stanza)
       end
     end
-    private :process_one
-
-    ##
-    # Process |max| XML stanzas and call listeners for all of them. 
-    #
-    # max:: [Integer] the number of stanzas to process (nil means process
-    # all available)
-    def process(max = nil)
-      n = 0
-      @stanzaqueue_lock.lock
-      while @stanzaqueue.size > 0 and (max == nil or n < max)
-        e = @stanzaqueue.shift
-        @stanzaqueue_lock.unlock
-        process_one(e)
-        n += 1
-        @stanzaqueue_lock.lock
-      end
-      @stanzaqueue_lock.unlock
-      n
-    end
-
-    ##
-    # Process an XML stanza and call the listeners for it. If no stanza is
-    # currently available, wait for max |time| seconds before returning.
-    # 
-    # time:: [Integer] time to wait in seconds. If nil, wait infinitely.
-    # all available)
-    def wait_and_process(time = nil)
-      if time == 0 
-        return process(1)
-      end
-      @stanzaqueue_lock.lock
-      if @stanzaqueue.size > 0
-        e = @stanzaqueue.shift
-        @stanzaqueue_lock.unlock
-        process_one(e)
-        return 1
-      end
-
-      @waiting_thread = Thread.current
-      @wakeup_thread = Thread.new { sleep time ; @waiting_thread.wakeup if @waiting_thread }
-      @waiting_thread.stop
-      @wakeup_thread.kill if @wakeup_thread
-      @wakeup_thread = nil
-      @waiting_thread = nil
-
-      @stanzaqueue_lock.lock
-      if @stanzaqueue.size > 0
-        e = @stanzaqueue.shift
-        @stanzaqueue_lock.unlock
-        process_one(e)
-        return 1
-      end
-      return 0
-    end
 
     ##
     # This is used by Jabber::Stream internally to
@@ -341,18 +273,32 @@ module Jabber
     # Stream#send.
     class ThreadBlock
       def initialize(block)
-        @thread = Thread.current
         @block = block
+        @waiter = Semaphore.new
+        @exception = nil
       end
       def call(*args)
         @block.call(*args)
       end
+      def wait
+        @waiter.wait
+        raise @exception if @exception
+      end
       def wakeup
         # TODO: Handle threadblock removal if !alive?
-        @thread.wakeup if @thread.alive?
+        @waiter.run
       end
       def raise(exception)
-        @thread.raise(exception) if @thread.alive?
+        @exception = exception
+        @waiter.run
+      end
+    end
+
+    def send_data(data)
+      @send_lock.synchronize do
+        @last_send = Time.now
+        @fd << data
+        @fd.flush
       end
     end
 
@@ -368,31 +314,46 @@ module Jabber
     # &block:: [Block] The optional block
     def send(xml, &block)
       Jabber::debuglog("SENDING:\n#{xml}")
-      @threadblocks.unshift(ThreadBlock.new(block)) if block
-      Thread.critical = true # we don't want to be interupted before we stop!
+      @threadblocks.unshift(threadblock = ThreadBlock.new(block)) if block
       begin
-        @fd << xml.to_s
-        @fd.flush
+        # Temporarily remove stanza's namespace to
+        # reduce bandwidth consumption
+        if xml.kind_of? XMPPStanza and xml.namespace == 'jabber:client'
+          xml.delete_namespace
+          send_data(xml.to_s)
+          xml.add_namespace(@streamns)
+        else
+          send_data(xml.to_s)
+        end
       rescue Exception => e
         Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
 
-        if @exception_block 
-          Thread.new { close!; @exception_block.call(e, self, :sending) }
+        if @exception_block
+          Thread.new do
+            Thread.current.abort_on_exception = true
+            close!
+            @exception_block.call(e, self, :sending)
+          end
         else
-          puts "Exception caught while sending!"
+          if Jabber::debug
+            puts "Exception caught while sending! (#{e.class})"
+            puts e.backtrace
+          end
           close!
           raise
         end
       end
-      Thread.critical = false
       # The parser thread might be running this (think of a callback running send())
       # If this is the case, we mustn't stop (or we would cause a deadlock)
-      Thread.stop if block and Thread.current != @parserThread
-      @pollCounter = 10
+      if block and Thread.current != @parser_thread
+        threadblock.wait
+      elsif block
+        Jabber::debuglog("WARNING:\nCannot stop current thread in Jabber::Stream#send because it is the parser thread!")
+      end
     end
 
     ##
-    # Send an XMMP stanza with an Jabber::XMLStanza#id. The id will be
+    # Send an XMMP stanza with an Jabber::XMPPStanza#id. The id will be
     # generated by Jabber::IdGenerator if not already set.
     #
     # The block will be called once: when receiving a stanza with the
@@ -407,7 +368,7 @@ module Jabber
     # Please see Stream#send for some implementational details.
     #
     # Please read the note about nesting at Stream#send
-    # xml:: [XMLStanza]
+    # xml:: [XMPPStanza]
     def send_with_id(xml, &block)
       if xml.id.nil?
         xml.id = Jabber::IdGenerator.instance.generate_id
@@ -416,7 +377,7 @@ module Jabber
       res = nil
       error = nil
       send(xml) do |received|
-        if received.kind_of? XMLStanza and received.id == xml.id
+        if received.kind_of? XMPPStanza and received.id == xml.id
           if received.type == :error
             error = (received.error ? received.error : Error.new)
             true
@@ -436,27 +397,6 @@ module Jabber
       res
     end
 
-    ##
-    # Starts a polling thread to send "keep alive" data to prevent
-    # the Jabber connection from closing for inactivity.
-    #
-    # Currently not working!
-    def poll
-      sleep 10
-      while true
-        sleep 2
-#        @pollCounter = @pollCounter - 1
-#        if @pollCounter < 0
-#          begin
-#            send("  \t  ")
-#          rescue
-#            Thread.new {@exception_block.call if @exception_block}
-#            break
-#          end
-#        end
-      end
-    end
-
     ##
     # Adds a callback block to process received XML messages
     # 
@@ -554,8 +494,7 @@ module Jabber
     end
 
     def close!
-      @parserThread.kill if @parserThread
-#      @pollThread.kill
+      @parser_thread.kill if @parser_thread
       @fd.close if @fd and !@fd.closed?
       @status = DISCONNECTED
     end