cerberus 0.6 → 0.7

data/lib/vendor/xmpp4r/lib/xmpp4r/rpc/helper/server.rb

@@ -0,0 +1,74 @@
+require 'xmlrpc/server'
+require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
+require 'xmlrpc/utils'         # ParserWriterChooseMixin
+
+require 'xmpp4r/dataforms/x/data'
+require 'xmpp4r/rpc/iq/rpc'
+require 'xmpp4r/rpc/helper/xmlrpcaddons'
+
+module Jabber
+  module RPC
+
+    ##
+    # XMLRPC Server
+    class Server < XMLRPC::BasicServer
+
+      include XMLRPC::ParserWriterChooseMixin
+      include XMLRPC::ParseContentType
+
+      ##
+      # new - creates a new server
+      #
+      def initialize(stream,class_delim=".")
+        super(class_delim)
+        @stream = stream
+        @stream.add_iq_callback(120,"Helpers::RPCServer") { |iq|
+          if iq.type == :set and iq.type != :result
+            handle_iq(iq)
+            true
+          else
+            false
+          end
+        }
+      end
+
+      ##
+      # handles incoming iqs
+      # iq:: [Jabber::IQ] - the jabber iq
+      def handle_iq(iq)
+        if iq.type == :set
+          if iq.query.kind_of?(IqQueryRPC)
+            data = iq.query
+            response = IqQueryRPC.new
+            data.elements.each { |rpc|
+              if rpc
+                response.typed_add(handle_rpc_requests(rpc))
+              end
+            }
+
+            respiq = iq.answer(false)
+            respiq.type = :result
+            respiq.add(response)
+            @stream.send(respiq)
+          end
+        end
+      end
+
+      private
+
+      ##
+      # handles the rpc requests
+      # takes rpcdata:: [String]
+      def handle_rpc_requests(rpcdata)
+        resp = process(rpcdata.to_s)
+        if resp == nil or resp.size <= 0
+          raise Jabber::ErrorResponse.new(:forbidden)
+        else
+          return resp
+        end
+      end
+    end # RPCServer
+  end  # Helpers
+end   # Jabber

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

@@ -0,0 +1,67 @@
+require "xmlrpc/parser"
+require "xmlrpc/create"
+require "xmlrpc/config"
+require "xmlrpc/utils"     # ParserWriterChooseMixin
+
+
+module XMLRPC
+  class Create
+
+    # Avoids warnings
+    remove_method(:methodCall)
+    remove_method(:methodResponse)
+
+    ##
+    # 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
+        begin
+          resp = params.collect do |param|
+            @writer.ele("param", conv2value(param))
+          end
+
+          resp = [@writer.ele("params", *resp)]
+        rescue Exception => e
+          error = XMLRPC::FaultException.new(XMLRPC::BasicServer::ERR_UNCAUGHT_EXCEPTION, "Uncaught exception '#{e.message}' serialising params into response")
+          resp = @writer.ele("fault", conv2value(error.to_h))
+        end
+      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/vendor/xmpp4r/lib/xmpp4r/rpc/iq/rpc.rb

@@ -0,0 +1,23 @@
+# =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/vendor/xmpp4r/lib/xmpp4r/sasl.rb

@@ -0,0 +1,237 @@
+# =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 'digest/md5'
+require 'xmpp4r/base64'
+
+module Jabber
+  ##
+  # Helpers for SASL authentication (RFC2222)
+  #
+  # You might not need to use them directly, they are
+  # invoked by Jabber::Client#auth
+  module SASL
+    NS_SASL = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
+    ##
+    # Factory function to obtain a SASL helper for the specified mechanism
+    def SASL.new(stream, mechanism)
+      case mechanism
+        when 'DIGEST-MD5'
+          DigestMD5.new(stream)
+        when 'PLAIN'
+          Plain.new(stream)
+        when 'ANONYMOUS'
+          Anonymous.new(stream)
+        else
+          raise "Unknown SASL mechanism: #{mechanism}"
+      end
+    end
+
+    ##
+    # SASL mechanism base class (stub)
+    class Base
+      def initialize(stream)
+        @stream = stream
+      end
+
+      private
+
+      def generate_auth(mechanism, text=nil)
+        auth = REXML::Element.new 'auth'
+        auth.add_namespace NS_SASL
+        auth.attributes['mechanism'] = mechanism
+        auth.text = text
+        auth
+      end
+
+      def generate_nonce
+        Digest::MD5.hexdigest(Time.new.to_f.to_s)
+      end
+    end
+
+    ##
+    # SASL PLAIN authentication helper (RFC2595)
+    class Plain < Base
+      ##
+      # Authenticate via sending password in clear-text
+      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).gsub(/\s/, ''))) { |reply|
+          if reply.name != 'success'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+
+        raise error if error
+      end
+    end
+
+    ##
+    # SASL Anonymous authentication helper
+    class Anonymous < Base
+      ##
+      # Authenticate by sending nothing with the ANONYMOUS token
+      def auth(password)
+        auth_text = "#{@stream.jid.node}"
+        error = nil
+        @stream.send(generate_auth('ANONYMOUS', Base64::encode64(auth_text).gsub(/\s/, ''))) { |reply|
+          if reply.name != 'success'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+
+        raise error if error
+      end
+    end
+
+    ##
+    # SASL DIGEST-MD5 authentication helper (RFC2831)
+    class DigestMD5 < Base
+      ##
+      # Sends the wished auth mechanism and wait for a challenge
+      #
+      # (proceed with DigestMD5#auth)
+      def initialize(stream)
+        super
+
+        challenge = {}
+        error = nil
+        @stream.send(generate_auth('DIGEST-MD5')) { |reply|
+          if reply.name == 'challenge' and reply.namespace == NS_SASL
+            challenge = decode_challenge(reply.text)
+          else
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+        raise error if error
+
+        @nonce = challenge['nonce']
+        @realm = challenge['realm']
+      end
+
+      def decode_challenge(challenge)
+        text = Base64::decode64(challenge)
+        res = {}
+
+        state = :key
+        key = ''
+        value = ''
+
+        text.scan(/./) do |ch|
+          if state == :key
+            if ch == '='
+              state = :value
+            else
+              key += ch
+            end
+
+          elsif state == :value
+            if ch == ','
+              res[key] = value
+              key = ''
+              value = ''
+              state = :key
+            elsif ch == '"' and value == ''
+              state = :quote
+            else
+              value += ch
+            end
+
+          elsif state == :quote
+            if ch == '"'
+              state = :value
+            else
+              value += ch
+            end
+          end
+        end
+        res[key] = value unless key == ''
+
+        Jabber::debuglog("SASL DIGEST-MD5 challenge:\n#{text.inspect}\n#{res.inspect}")
+
+        res
+      end
+
+      ##
+      # * Send a response
+      # * Wait for the server's challenge (which aren't checked)
+      # * Send a blind response to the server's challenge
+      def auth(password)
+        response = {}
+        response['nonce'] = @nonce
+        response['charset'] = 'utf-8'
+        response['username'] = @stream.jid.node
+        response['realm'] = @realm || @stream.jid.domain
+        response['cnonce'] = generate_nonce
+        response['nc'] = '00000001'
+        response['qop'] = 'auth'
+        response['digest-uri'] = "xmpp/#{@stream.jid.domain}"
+        response['response'] = response_value(@stream.jid.node, @stream.jid.domain, response['digest-uri'], password, @nonce, response['cnonce'], response['qop'])
+        response.each { |key,value|
+          unless %w(nc qop response charset).include? key
+            response[key] = "\"#{value}\""
+          end
+        }
+
+        response_text = response.collect { |k,v| "#{k}=#{v}" }.join(',')
+        Jabber::debuglog("SASL DIGEST-MD5 response:\n#{response_text}")
+
+        r = REXML::Element.new('response')
+        r.add_namespace NS_SASL
+        r.text = Base64::encode64(response_text).gsub(/\s/, '')
+
+        success_already = false
+        error = nil
+        @stream.send(r) { |reply|
+          if reply.name == 'success'
+            success_already = true
+          elsif reply.name != 'challenge'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+
+        return if success_already
+        raise error if error
+
+        # TODO: check the challenge from the server
+
+        r.text = nil
+        @stream.send(r) { |reply|
+          if reply.name != 'success'
+            error = reply.first_element(nil).name
+          end
+          true
+        }
+
+        raise error if error
+      end
+
+      private
+
+      ##
+      # Function from RFC2831
+      def h(s); Digest::MD5.digest(s); end
+      ##
+      # Function from RFC2831
+      def hh(s); Digest::MD5.hexdigest(s); end
+
+      ##
+      # Calculate the value for the response field
+      def response_value(username, realm, digest_uri, passwd, nonce, cnonce, qop)
+        a1_h = h("#{username}:#{realm}:#{passwd}")
+        a1 = "#{a1_h}:#{nonce}:#{cnonce}"
+        #a2 = "AUTHENTICATE:#{digest_uri}#{(qop == 'auth') ? '' : ':00000000000000000000000000000000'}"
+        a2 = "AUTHENTICATE:#{digest_uri}"
+
+        hh("#{hh(a1)}:#{nonce}:00000001:#{cnonce}:#{qop}:#{hh(a2)}")
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/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/vendor/xmpp4r/lib/xmpp4r/stream.rb

@@ -0,0 +1,497 @@
+# =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/callbacks'
+require 'socket'
+require 'thread'
+require 'xmpp4r/semaphore'
+require 'xmpp4r/streamparser'
+require 'xmpp4r/presence'
+require 'xmpp4r/message'
+require 'xmpp4r/iq'
+require 'xmpp4r/debuglog'
+require 'xmpp4r/idgenerator'
+
+module Jabber
+  ##
+  # The stream class manages a connection stream (a file descriptor using which
+  # XML messages are read and sent)
+  #
+  # You may register callbacks for the three Jabber stanzas
+  # (message, presence and iq) and use the send and send_with_id
+  # methods.
+  #
+  # To ensure the order of received stanzas, callback blocks are
+  # launched in the parser thread. If further blocking operations
+  # are intended in those callbacks, run your own thread there.
+  class Stream
+    DISCONNECTED = 1
+    CONNECTED = 2
+
+    # file descriptor used
+    attr_reader :fd
+
+    # connection status
+    attr_reader :status
+
+    ##
+    # Initialize a new stream
+    def initialize
+      @fd = nil
+      @status = DISCONNECTED
+      @xmlcbs = CallbackList.new
+      @stanzacbs = CallbackList.new
+      @messagecbs = CallbackList.new
+      @iqcbs = CallbackList.new
+      @presencecbs = CallbackList.new
+      @send_lock = Mutex.new
+      @last_send = Time.now
+      @exception_block = nil
+      @threadblocks = []
+      @wakeup_thread = nil
+      @streamid = nil
+      @streamns = 'jabber:client'
+      @features_sem = Semaphore.new
+      @parser_thread = nil
+    end
+
+    ##
+    # Start the XML parser on the fd
+    def start(fd)
+      @stream_mechanisms = []
+      @stream_features = {}
+
+      @fd = fd
+      @parser = StreamParser.new(@fd, self)
+      @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 do
+              Thread.current.abort_on_exception = true
+              close
+              @exception_block.call(e, self, :start)
+            end
+          else
+            Jabber::debuglog "Exception caught in Parser thread! (#{e.class})\n#{e.backtrace.join("\n")}"
+            close!
+            raise
+          end
+        end
+      end
+
+      @status = CONNECTED
+    end
+
+    def stop
+      @parser_thread.kill
+      @parser = nil
+    end
+
+    ##
+    # Mounts a block to handle exceptions if they occur during the
+    # poll send.  This will likely be the first indication that
+    # the socket dropped in a Jabber Session.
+    #
+    # The block has to take three arguments:
+    # * the Exception
+    # * the Jabber::Stream object (self)
+    # * a symbol where it happened, namely :start, :parser, :sending and :end
+    def on_exception(&block)
+      @exception_block = block
+    end
+
+    ##
+    # This method is called by the parser when a failure occurs
+    def parse_failure(e)
+      Jabber::debuglog("EXCEPTION:\n#{e.class}\n#{e.message}\n#{e.backtrace.join("\n")}")
+
+      # A new thread has to be created because close will cause the thread
+      # to commit suicide(???)
+      if @exception_block
+        # New thread, because close will kill the current thread
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          close
+          @exception_block.call(e, self, :parser)
+        end
+      else
+        Jabber::debuglog "Stream#parse_failure was called by XML parser. Dumping " +
+          "backtrace...\n" + e.exception + "\n#{e.backtrace.join("\n")}"
+        close
+        raise
+      end
+    end
+
+    ##
+    # This method is called by the parser upon receiving <tt></stream:stream></tt>
+    def parser_end
+      if @exception_block
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          close
+          @exception_block.call(nil, self, :close)
+        end
+      else
+        close
+      end
+    end
+
+    ##
+    # Returns if this connection is connected to a Jabber service
+    # return:: [Boolean] Connection status
+    def is_connected?
+      return @status == CONNECTED
+    end
+
+    ##
+    # Returns if this connection is NOT connected to a Jabber service
+    #
+    # return:: [Boolean] Connection status
+    def is_disconnected?
+      return @status == DISCONNECTED
+    end
+
+    ##
+    # Processes a received REXML::Element and executes
+    # registered thread blocks and filters against it.
+    #
+    # element:: [REXML::Element] The received element
+    def receive(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_sem.run                   # don't wait for <stream:features/>
+            end
+          when 'features'
+            stanza = element
+            element.each { |e|
+              if e.name == 'mechanisms' and e.namespace == 'urn:ietf:params:xml:ns:xmpp-sasl'
+                e.each_element('mechanism') { |mech|
+                  @stream_mechanisms.push(mech.text)
+                }
+              else
+                @stream_features[e.name] = e.namespace
+              end
+            }
+            Jabber::debuglog("FEATURES: received")
+            @features_sem.run
+          else
+            stanza = element
+        end
+      else
+        # Any stanza, classes are registered by XMPPElement::name_xmlns
+        begin
+          stanza = XMPPStanza::import(element)
+        rescue NoNameXmlnsRegistered
+          stanza = element
+        end
+      end
+
+      # Iterate through blocked threads (= waiting for an answer)
+      #
+      # We're dup'ping the @threadblocks here, so that we won't end up in an
+      # endless loop if Stream#send is being nested. That means, the nested
+      # threadblock won't receive the stanza currently processed, but the next
+      # one.
+      threadblocks = @threadblocks.dup
+      threadblocks.each { |threadblock|
+        exception = nil
+        r = false
+        begin
+          r = threadblock.call(stanza)
+        rescue Exception => e
+          exception = e
+        end
+
+        if r == true
+          @threadblocks.delete(threadblock)
+          threadblock.wakeup
+          return
+        elsif exception
+          @threadblocks.delete(threadblock)
+          threadblock.raise(exception)
+        end
+      }
+
+      Jabber::debuglog("PROCESSING:\n#{stanza.to_s} (#{stanza.class})")
+      return true if @xmlcbs.process(stanza)
+      return true if @stanzacbs.process(stanza)
+      case stanza
+      when Message
+        return true if @messagecbs.process(stanza)
+      when Iq
+        return true if @iqcbs.process(stanza)
+      when Presence
+        return true if @presencecbs.process(stanza)
+      end
+    end
+
+    ##
+    # This is used by Jabber::Stream internally to
+    # keep track of any blocks which were passed to
+    # Stream#send.
+    class ThreadBlock
+      def initialize(block)
+        @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?
+        @waiter.run
+      end
+      def raise(exception)
+        @exception = exception
+        @waiter.run
+      end
+    end
+
+    def send_data(data)
+      @send_lock.synchronize do
+        @last_send = Time.now
+        @fd << data
+        @fd.flush
+      end
+    end
+
+    ##
+    # Sends XML data to the socket and (optionally) waits
+    # to process received data.
+    #
+    # Do not invoke this in a callback but in a seperate thread
+    # because we may not suspend the parser-thread (in whose
+    # context callbacks are executed).
+    #
+    # xml:: [String] The xml data to send
+    # &block:: [Block] The optional block
+    def send(xml, &block)
+      Jabber::debuglog("SENDING:\n#{xml}")
+      @threadblocks.unshift(threadblock = ThreadBlock.new(block)) if block
+      begin
+        # 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 do
+            Thread.current.abort_on_exception = true
+            close!
+            @exception_block.call(e, self, :sending)
+          end
+        else
+          Jabber::debuglog "Exception caught while sending! (#{e.class})\n#{e.backtrace.join("\n")}"
+          close!
+          raise
+        end
+      end
+      # 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)
+      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::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
+    # same Jabber::XMPPStanza#id. There is no need to return true to
+    # complete this! Instead the return value of the block will be
+    # returned. This is a direct result of unique request/response
+    # stanza identification via the id attribute.
+    #
+    # The block may be omitted. Then, the result will be the response
+    # stanza.
+    #
+    # Be aware that if a stanza with <tt>type='error'</tt> is received
+    # the function does not yield but raises an ServerError with
+    # the corresponding error element.
+    #
+    # Please see Stream#send for some implementational details.
+    #
+    # Please read the note about nesting at Stream#send
+    # xml:: [XMPPStanza]
+    def send_with_id(xml, &block)
+      if xml.id.nil?
+        xml.id = Jabber::IdGenerator.instance.generate_id
+      end
+
+      res = nil
+      error = nil
+      send(xml) do |received|
+        if received.kind_of? XMPPStanza and received.id == xml.id
+          if received.type == :error
+            error = (received.error ? received.error : ErrorResponse.new)
+            true
+          elsif block_given?
+            res = yield(received)
+            true
+          else
+            res = received
+            true
+          end
+        else
+          false
+        end
+      end
+
+      unless error.nil?
+        raise ServerError.new(error)
+      end
+
+      res
+    end
+
+    ##
+    # Adds a callback block to process received XML messages
+    #
+    # priority:: [Integer] The callback's priority, the higher, the sooner
+    # ref:: [String] The callback's reference
+    # &block:: [Block] The optional block
+    def add_xml_callback(priority = 0, ref = nil, &block)
+      @xmlcbs.add(priority, ref, block)
+    end
+
+    ##
+    # Delete an XML-messages callback
+    #
+    # ref:: [String] The reference of the callback to delete
+    def delete_xml_callback(ref)
+      @xmlcbs.delete(ref)
+    end
+
+    ##
+    # Adds a callback block to process received Messages
+    #
+    # priority:: [Integer] The callback's priority, the higher, the sooner
+    # ref:: [String] The callback's reference
+    # &block:: [Block] The optional block
+    def add_message_callback(priority = 0, ref = nil, &block)
+      @messagecbs.add(priority, ref, block)
+    end
+
+    ##
+    # Delete an Message callback
+    #
+    # ref:: [String] The reference of the callback to delete
+    def delete_message_callback(ref)
+      @messagecbs.delete(ref)
+    end
+
+    ##
+    # Adds a callback block to process received Stanzas
+    #
+    # priority:: [Integer] The callback's priority, the higher, the sooner
+    # ref:: [String] The callback's reference
+    # &block:: [Block] The optional block
+    def add_stanza_callback(priority = 0, ref = nil, &block)
+      @stanzacbs.add(priority, ref, block)
+    end
+
+    ##
+    # Delete a Stanza callback
+    #
+    # ref:: [String] The reference of the callback to delete
+    def delete_stanza_callback(ref)
+      @stanzacbs.delete(ref)
+    end
+
+    ##
+    # Adds a callback block to process received Presences
+    #
+    # priority:: [Integer] The callback's priority, the higher, the sooner
+    # ref:: [String] The callback's reference
+    # &block:: [Block] The optional block
+    def add_presence_callback(priority = 0, ref = nil, &block)
+      @presencecbs.add(priority, ref, block)
+    end
+
+    ##
+    # Delete a Presence callback
+    #
+    # ref:: [String] The reference of the callback to delete
+    def delete_presence_callback(ref)
+      @presencecbs.delete(ref)
+    end
+
+    ##
+    # Adds a callback block to process received Iqs
+    #
+    # priority:: [Integer] The callback's priority, the higher, the sooner
+    # ref:: [String] The callback's reference
+    # &block:: [Block] The optional block
+    def add_iq_callback(priority = 0, ref = nil, &block)
+      @iqcbs.add(priority, ref, block)
+    end
+
+    ##
+    # Delete an Iq callback
+    #
+    # ref:: [String] The reference of the callback to delete
+    #
+    def delete_iq_callback(ref)
+      @iqcbs.delete(ref)
+    end
+    ##
+    # Closes the connection to the Jabber service
+    def close
+      close!
+    end
+
+    def close!
+      @parser_thread.kill if @parser_thread
+      @fd.close if @fd and !@fd.closed?
+      @status = DISCONNECTED
+    end
+  end
+end