jabber4r 0.8.0

data/lib/jabber4r/rexml_1.8_patch.rb

@@ -0,0 +1,16 @@
+if RUBY_VERSION=="1.8.0"
+  module REXML
+    module Parsers
+      class BaseParser
+        # Returns true if there are more events.  Synonymous with !empty?
+        def has_next?
+          return true if @closed # THIS WAS ADDED TO FIX PROBLEM
+          @source.read if @source.buffer.size==0 and !@source.empty?
+          (!@source.empty? and @source.buffer.strip.size>0) or @stack.size>0 or @closed
+        end
+      end
+    end
+  end
+else
+  puts "WARNING: rexml_1.8_patch is needed on Ruby 1.8.0 and not by Ruby #{RUBY_VERSION}"
+end

data/lib/jabber4r/roster.rb

@@ -0,0 +1,322 @@
+# License: see LICENSE.txt
+#  Jabber4R - Jabber Instant Messaging Library for Ruby
+#  Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# 
+
+
+module Jabber
+
+  ##
+  # The Roster class encapsulates the runtime roster of the session instance.
+  # The Roster contains all subscriptions in a Jabber::Roster::RosterItem hash.
+  # 
+  class Roster
+    ITEM_ADDED=1
+    ITEM_DELETED=2
+    RESOURCE_ADDED=4
+    RESOURCE_UPDATED=8
+    RESOURCE_DELETED=16
+    
+    # The Jabber::Session instance
+    attr_reader :session
+    
+    ##
+    # Creates a Roster for the session
+    #
+    # session:: [Jabber::Session] The session instance
+    #
+    def initialize(session)
+      @session = session
+      @map = {}
+      @listeners = {}
+    end
+    
+    ##
+    # The RosterItem class embodies another Jabber user's status (from
+    # the local user's perspective).  RosterItems contain 
+    # Jabber::Roster::RosterItem::Resource objects for each resource
+    # location a foreign user is accessing through.
+    #
+    class RosterItem
+      # The Jabber::Roster instance
+      attr_reader :roster
+      
+      # The Jabber ID (Jabber::JID)
+      attr_accessor :jid
+      
+      # The subscription type
+      attr_accessor :subscription
+      
+      # The (nick)name of this account
+      attr_accessor :name
+      
+      # The group name for this account
+      attr_accessor :group
+      
+      ##
+      # Constructs a RosterItem
+      #
+      # roster:: [Jabber::Roster] The roster instance
+      # subscription:: [String] The subscription type
+      # name:: [String] The (nick)name
+      # group:: [String=nil] The group this account belongs to
+      #
+      def initialize(roster, jid, subscription, name, group=nil)
+        @jid = jid
+        @subscription = subscription
+        @name = name
+        @group = group if group
+        @resources = {}
+        @roster = roster
+      end
+      
+      ##
+      # The Resource class embodies a Resource endpoint in Jabber.
+      # The resource endpoint it what maintains a status (not an account).
+      #
+      class Resource
+      
+        # The name of the resource
+        attr_reader :name
+        
+        # How the resource should be shown
+        attr_reader :show
+        
+        # The status message of the resource
+        attr_reader :status
+        
+        ##
+        # Constructs a new Resource instance
+        #
+        # item:: [Jabber::Roster::RosterItem] The roster item this resource belongs to
+        # name:: [String] The resource name
+        # show:: [String] How the resource should be shown
+        # status:: [String] The status message of the resource
+        #
+        def initialize(item, name, show, status)
+          @item = item
+          @name = name
+          @show = show
+          @status = status
+        end
+        
+        ##
+        # Updates the state of a resource and notifies listeners.
+        #
+        # show:: [String] How the resource should be shown
+        # status:: [String] The status message of the resource
+        #
+        def update(show, status)
+          @show = show
+          @status = status
+          @item.roster.notify_listeners(RESOURCE_UPDATED, self)
+        end
+        
+        ##
+        # Dumps the Resource as a string
+        #
+        # return:: [String] The resource encoded as a string.
+        #
+        def to_s
+          "RESOURCE:#{@name} SHOW:#{@show} STATUS:#{@status}"
+        end
+      end
+      
+      ##
+      # Retrieves the VCard for this (RosterItem) account.  This method
+      # blocks until the the vcard is returned.
+      #
+      # return:: [Jabber::VCard] The VCard object for this account
+      #
+      def get_vcard
+        ct = Thread.current
+        queryID = @roster.session.id
+        result = nil
+        @roster.session.connection.send(Jabber::Protocol::Iq.gen_vcard(self, queryID, jid)) { |je|
+            if je.element_tag == "iq" and je.attr_type=="result" and je.attr_id == queryID
+              je.consume_element
+              result = Jabber::VCard.from_element(je.VCARD)
+              ct.wakeup
+            else
+            end
+        }
+        Thread.stop
+        return result
+      end
+      
+      ##
+      # Adds a new resource to the Roster item and notifies listeners
+      #
+      # resourceName:: [String] The name of the resource
+      # show:: [String] How the resource is to be viewed
+      # status:: [String] The status message
+      # return:: [Jabber::Roster:RosterItem::Resource] The new Resource instance
+      #
+      def add(resourceName, show, status)
+        resource = Resource.new(self, resourceName, show, status)
+        @resources[resourceName] = resource
+        @roster.notify_listeners(RESOURCE_ADDED, resource)
+        resource
+      end
+      
+      ##
+      # Deletes a resource from this roster item and notifies listeners
+      #
+      # resourceName:: [String] The name of the resource
+      # return:: [Jabber::Roster:RosterItem::Resource] The deleted Resource
+      #
+      def delete(resourceName)
+        resource = @resources.delete(resourceName)
+        @roster.notify_listeners(RESOURCE_DELETED, resource) if resource
+        resource
+      end
+      
+      ##
+      # Retrieves a resource object
+      #
+      # resourceName:: [String] The name of the resource
+      # return:: [Jabber::Roster:RosterItem::Resource] The Resource instance
+      #
+      def [](resourceName)
+        return @resources[resourceName]
+      end
+      
+      ##
+      # Iterates over the list of available resources
+      #
+      # yield:: |Jabber::Roster:RosterItem::Resource| The resource instance
+      #
+      def each_resource
+        @resources.each_value {|resource| yield resource}
+      end
+      
+      ##
+      # Dumps the roster item
+      #
+      # return:: [String] The roster item dumped as a String
+      def to_s
+        "ITEM:#{@jid.to_s} SUBSCRIPTION:#{@subscription} NAME:#{@name} GROUP:#{@group}"
+      end
+    end
+    
+    ##
+    # Adds a listener to the roster to process roster changes
+    #
+    # &block:: [Block |event, rosteritem|] The block to process roster changes
+    # return:: [String] The listener id to use to deregister
+    #
+    def add_listener(&block)
+      id = Jabber.gen_random_id("", 10)
+      @listeners[id]=block if block
+      return id
+    end
+    
+    ##
+    # Deletes a listener for processing roster messages
+    #
+    # id:: [String] A listener id (given by add_listener)
+    #
+    def delete_listener(id)
+      @listeners.delete(id)
+    end
+    
+    ##
+    # Adds a subscription to be tracked in the Roster
+    #
+    # jid:: [JID | String] The Jabber ID
+    # subscription:: [String] The subscription type (both)
+    # name:: [String] The nickname
+    # group:: [String = nil] The name of the group of the roster item.
+    #
+    def add(jid, subscription, name, group=nil)
+      if jid.kind_of? String
+        jid = JID.new(jid) 
+        jid.strip_resource
+      elsif jid.kind_of? JID
+        jid = JID.new(jid.node+"@"+jid.host)
+      else
+        return
+      end
+      begin
+        item = RosterItem.new(self, jid, subscription, name, group)
+        @map[jid.to_s] = item
+        notify_listeners(ITEM_ADDED, item)
+      rescue => ex
+        puts ex.backtrace.join("\n")
+      end
+    end
+    
+    ##
+    # Returns a Jabber::Roster::RosterItem based on the JID
+    #
+    # jid:: [Jabber::JID | String] The Jabber ID
+    # return:: [Jabber::Roster::RosterItem] The roster item
+    #
+    def [](jid)
+      if jid.kind_of? String
+        jid = JID.new(jid) 
+        jid.strip_resource
+      elsif jid.kind_of? JID
+        jid = JID.new(jid.node+"@"+jid.host)
+      else
+        return
+      end
+      return @map[jid.to_s]
+    end
+    
+    ##
+    # Deletes a roster item based on the supplied Jabber ID
+    #
+    # jid:: [Jabber::JID | String]
+    #
+    def delete(jid)
+      if jid.kind_of? String
+        jid = JID.new(jid) 
+        jid.strip_resource
+      elsif jid.kind_of? JID
+        jid = JID.new(jid.node+"@"+jid.host)
+      else
+        return
+      end
+      item = @map.delete(jid.to_s)
+      notify_listeners(ITEM_DELETED, item) if item
+      item
+    end
+    
+    ##
+    # Iterates over each RosterItem
+    #
+    # yield:: [Jabber::Roster::RosterItem] The roster item.
+    #
+    def each_item
+      @map.each_value {|item| yield item}
+    end
+    
+    ##
+    # Dumps the Roster state as a string
+    #
+    # return:: [String] The roster state
+    #
+    def to_s
+      result = "ROSTER DUMP\n"
+      each_item do |item|
+        result += (item.to_s+"\n")
+        item.each_resource {|resource| result+= "    #{resource.to_s}\n"}
+      end
+      return result
+    end
+
+    ##
+    # Notifies listeners of a roster change event
+    # 
+    # event:: [Integer] The roster event
+    # object:: [RosterItem] The modified item
+    #
+    def notify_listeners(event, object)
+      @listeners.each_value {|listener| listener.call(event, object)}
+    end
+    
+  end
+  
+end
+

data/lib/jabber4r/session.rb

@@ -0,0 +1,615 @@
+# License: see LICENSE.txt
+#  Jabber4R - Jabber Instant Messaging Library for Ruby
+#  Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# 
+
+
+module Jabber
+  HEX = "0123456789abcdef"
+  
+  ##
+  # Generates a random hex string in the following format:
+  #   JRR_01234567
+  #
+  # return:: [String] The resource id
+  #
+  def Jabber.gen_random_resource
+    return Jabber.gen_random_id("JRR_", 8)
+  end
+  
+  ##
+  # Generates a random thread as a hex string in the following format:
+  #   JRT_01234567890123456789
+  #
+  # return:: [String] The thread id
+  #
+  def Jabber.gen_random_thread
+    return Jabber.gen_random_id("JRT_", 20)
+  end
+  
+  ##
+  # Generates a random id as a hex string
+  #
+  # prefix:: [String="Jabber4R_] The prefix for the random hex data
+  # length:: [Integer=16] The number of hex characters
+  # return:: [String] The random id
+  #
+  def Jabber.gen_random_id(prefix="Jabber4R_", length=16)
+    length.times {prefix += HEX[rand(16),1]}
+    prefix
+  end
+  
+  class Subscription
+    attr_accessor :type, :from, :id, :session
+    def initialize(session, type, from, id)
+      @session = session
+      @type = type
+      @from = from
+      @id = id
+    end
+    def accept
+      case type
+      when :subscribe
+        @session.connection.send(Jabber::Protocol::Presence.gen_accept_subscription(@id, @from))
+      when :unsubscribe
+        @session.connection.send(Jabber::Protocol::Presence.gen_accept_unsubscription(@id, @from))
+      else
+        raise "Cannot accept a subscription of type #{type.to_s}"
+      end
+    end
+  end
+  
+  ##
+  # This is a base class for subscription handlers
+  
+  class SubscriptionHandler
+    def subscribe(subscription)
+    end
+    
+    def subscribed(subscription)
+    end
+    
+    def unsubscribe(subscription)
+    end
+    
+    def unsubscribed(subscription)
+    end
+  end
+  
+  class AutoSubscriptionHandler < SubscriptionHandler
+  
+    def subscribe(subscription)
+      subscription.accept
+    end
+    
+    def unsubscribe(subscription)
+      subscription.accept
+    end
+  end
+    
+
+  ##
+  # The Jabber Session is the main class for dealing with a Jabber service.
+  #
+  class Session
+  
+    # The host this session is connected to
+    attr_reader :host
+    
+    # The port (defaults to 5222) that this session is connected to
+    attr_reader :port
+    
+    # The Jabber::Protocol::Connection instance
+    attr_reader :connection
+
+    # The Jabber::Roster instance
+    attr_reader :roster
+
+    # The session id sent from the Jabber service upon connection
+    attr_reader :session_id
+
+    # The Jabber::JID of the current session
+    attr_reader :jid
+    
+    # The username to use for authenticating this session
+    attr_accessor :username
+    
+    # The password to use for authenticating this session
+    attr_accessor :password
+    
+    # The resource id for this session
+    attr_accessor :resource
+    
+    # The iq handlers for this session
+    attr_accessor :iqHandlers
+    
+    ##
+    # Session creation factory that creates a session, logs in, 
+    # requests the roster, registers message and presence filters
+    # and announces initial presence.  Login is done via plaintext
+    # password authentication.
+    #
+    # jid:: [String | JID] The account information ("account@host/resouce")
+    # password:: [String] The account password
+    # port:: [Integer = 5222] The host port
+    # digest:: [Boolean = false] Use digest authentication?
+    # return:: [Jabber::Session] The new session
+    #
+    def Session.bind(jid, password, port=5222, digest=false)
+      jid = Jabber::JID.new(jid) if jid.kind_of? String
+      session = Session.new(jid.host, port)
+      raise "Authentication failed" unless session.authenticate(jid.node, password, jid.resource, digest)
+      session.request_roster
+      session.register_message_filter
+      session.register_presence_filter
+      session.register_iq_filter
+      session.announce_initial_presence
+      session
+    end
+    
+    ##
+    # Account registration method
+    #
+    def Session.register(jid, password, email="", name="", port=5222)
+      jid = Jabber::JID.new(jid) if jid.kind_of? String
+      session = Session.new(jid.host, port)
+      msg_id = session.id
+      registered = false
+      current = Thread.current
+      session.connection.send(Jabber::Protocol::Iq.gen_registration(session, msg_id, jid.node, password, email, name)) do |element|
+        if element.element_tag=="iq" and element.attr_id==msg_id
+          element.consume_element
+          if element.attr_type=="result"
+            registered = true
+          elsif element.attr_type=="error"
+            registered = false
+          end
+          current.wakeup
+        end
+      end
+      Thread.stop
+      session.release      
+      return registered
+    end
+    
+    ##
+    # Session creation factory that creates a session, logs in, 
+    # requests the roster, registers message and presence filters
+    # and announces initial presence.  Login is done via digest (SHA)
+    # password authentication.
+    #
+    # jid:: [String | JID] The account information ("account@host/resouce")
+    # password:: [String] The account password
+    # port:: [Integer = 5222] The host port
+    # return:: [Jabber::Session] The new session
+    #
+    def Session.bind_digest(jid, password, port=5222)
+      Session.bind(jid, password, port, true)
+    end
+    
+    # Creates a new session connected to the supplied host and port.
+    # The method attempts to build a Jabber::Protocol::Connection
+    # object and send the open_stream XML message.  It then blocks
+    # to recieve the coorisponding reply open_stream and sets the
+    # session_id from that xml element.
+    #
+    # host:: [String] The hostname of the Jabber service
+    # port:: [Integer=5222] The port of the Jabber service
+    # raise:: [RuntimeException] If connection fails
+    #
+    def initialize(host, port=5222)
+      @id = 1
+      @host = host
+      @port = port
+      @roster = Roster.new(self)
+      @messageListeners = Hash.new
+      @iqHandlers=Hash.new
+      @subscriptionHandler = nil
+      @connection = Jabber::Protocol::Connection.new(host, port)
+      @connection.connect
+      unless @connection.is_connected?
+        raise "Session Error: Could not connected to #{host}:#{port}"
+      else
+        @connection.send(Jabber::Protocol.gen_open_stream(host)) do |element| 
+          if element.element_tag=="stream:stream"
+            element.consume_element 
+            @session_id = element.attr_id
+          end
+        end
+        @connection.on_connection_exception do
+          if @session_failure_block
+            self.release
+            @session_failure_block.call
+          end
+        end
+        Thread.stop
+      end
+    end
+    
+    ##
+    # Set a handler for session exceptions that get caught in 
+    # communicating with the Jabber server.
+    #
+    def on_session_failure(&block)
+      @session_failure_block = block
+    end
+    
+    ##
+    # Counter for message IDs
+    #
+    # return:: [String] A unique message id for this session
+    #
+    def id
+      @id = @id + 1
+      return @id.to_s
+    end
+    
+    ##
+    # Authenticate (logs into) this session with the supplied credentials.
+    # The method blocks waiting for a reply to the login message.  Sets the
+    # authenticated attribute based on result.
+    #
+    # username:: [String] The username to use for authentication
+    # password:: [String] The password to use for authentication
+    # resource:: [String] The resource ID for this session
+    # digest:: [Boolean=false] True to use digest authentication (not sending password in the clear)
+    # return:: [Boolean] Whether the authentication succeeded or failed
+    #
+    def authenticate(username, password, resource, digest=false)
+      @username = username
+      @password = password
+      @resource = resource
+      @jid = JID.new("#{username}@#{@host}/#{resource}")
+      @roster.add(@jid, "both", "Me", "My Resources")
+      
+      msg_id = self.id
+      authHandler = Proc.new  do |element| 
+        if element.element_tag=="iq" and element.attr_id==msg_id
+          element.consume_element
+          if element.attr_type=="result"
+            @authenticated = true
+          elsif element.attr_type=="error"
+            @authenticated = false
+          end
+        end
+      end
+      if digest
+        require 'digest/sha1'
+        authRequest = Jabber::Protocol::Iq.gen_auth_digest(self, msg_id, username, Digest::SHA1.new(@session_id + password).hexdigest, resource)
+      else
+        authRequest = Jabber::Protocol::Iq.gen_auth(self, msg_id, username, password, resource)
+      end
+      @connection.send(authRequest, &authHandler)
+      Thread.stop
+      return @authenticated
+    end
+    
+    ##
+    # Is this an authenticated session?
+    #
+    # return:: [Boolean] True if the session is authenticated
+    #
+    def is_authenticated?
+      return @authenticated
+    end
+      
+    ##
+    # Sends the initial presence message to the Jabber service
+    #
+    def announce_initial_presence
+      @connection.send(Jabber::Protocol::Presence.gen_initial(id))
+    end
+    
+    ##
+    # Sends an extended away presence message
+    #
+    # status:: [String] The status message
+    #
+    def announce_extended_away(status=nil)
+      @connection.send(Jabber::Protocol::Presence.gen_xa(id, status))
+    end
+    
+    ##
+    # Sends a free for chat presence message
+    #
+    # status:: [String] The status message
+    #
+    def announce_free_for_chat(status=nil)
+      @connection.send(Jabber::Protocol::Presence.gen_chat(id, status))
+    end
+    
+    ##
+    # Sends a 'normal' presence message
+    #
+    # status:: [String] The status message
+    #
+    def announce_normal(status=nil)
+      @connection.send(Jabber::Protocol::Presence.gen_normal(id, status))
+    end
+    
+    ##
+    # Sends an away from computer presence message
+    #
+    # status:: [String] The status message
+    #
+    def announce_away_from_computer(status=nil)
+      @connection.send(Jabber::Protocol::Presence.gen_away(id, status))
+    end
+    
+    ##
+    # Sends a do not disturb presence message
+    #
+    # status:: [String] The status message
+    #
+    def announce_do_not_disturb(status=nil)
+      @connection.send(Jabber::Protocol::Presence.gen_dnd(id, status))
+    end
+    
+    ##
+    # Sets the handler for subscription requests, notifications, etc.
+    #
+    def set_subscription_handler(handler=nil, &block)
+      @subscriptionHandler = handler.new(self) if handler
+      @subscriptionHandler = block if block_given? and !handler
+    end
+    
+    def enable_autosubscription
+      set_subscription_handler AutoSubscriptionHandler
+    end
+    
+    def subscribe(to, name="") 
+      to = JID.to_jid(to)
+      roster_item = @roster[to]
+      
+      if roster_item #if you already have a roster item just send the subscribe request
+        if roster_item.subscription=="to" or roster_item.subscription=="both"
+          return
+        end
+        @connection.send(Jabber::Protocol::Presence.gen_new_subscription(to))
+        return
+      end
+      myid = self.id
+      @connection.send(Jabber::Protocol::Iq.gen_add_rosteritem(self, myid, to, name)) do |element|
+        if element.attr_id==myid
+          element.consume_element
+          if element.attr_type=="result"
+            @connection.send(Jabber::Protocol::Presence.gen_new_subscription(to))
+          end
+        end
+      end
+    end
+    
+    ##
+    # Adds a filter to the Connection to manage tracking resources that come online/offline
+    #
+    def register_presence_filter
+      @connection.add_filter("presenceAvailableFilter") do |element|
+        if element.element_tag=="presence"
+          type = element.attr_type
+          type = nil if type.nil?
+          case type
+          when nil, "available"
+            element.consume_element
+            from = JID.new(element.attr_from)
+            rItem = @roster[from]
+            show = element.show.element_data
+            show = "chat" unless show
+            status = element.status.element_data
+            status = "" unless status
+            if rItem
+              resource = rItem[from.resource]
+              if resource
+                resource.update(show, status)
+              else
+                rItem.add(from.resource, show, status)
+              end
+            end
+          when "unavailable"
+            element.consume_element
+            from = JID.new(element.attr_from)
+            rItem = @roster[from]
+            resource = rItem.delete(from.resource) if rItem
+          when "subscribe", "unsubscribe", "subscribed", "unsubscribed"
+            element.consume_element
+            from = JID.new(element.attr_from)
+            break unless @subscriptionHandler
+            if @subscriptionHandler.kind_of? Proc
+              @subscriptionHandler.call(Subscription.new(self, type.intern, from, id))
+            else
+              @subscriptionHandler.send(Subscription.new(self, type.intern, from, id))
+            end
+          end
+        end #if presence 
+      end #do
+    end
+    
+    ##
+    # Creates a new message to the supplied JID of type NORMAL
+    # 
+    # to:: [Jabber::JID] Who to send the message to
+    # type:: [String = Jabber::Protocol::Message::NORMAL] The type of message to send (see Jabber::Protocol::Message)
+    # return:: [Jabber::Protocol::Message] The new message
+    #
+    def new_message(to, type=Jabber::Protocol::Message::NORMAL)
+      msg = Jabber::Protocol::Message.new(to, type)
+      msg.session=self
+      return msg
+    end
+    
+    ##
+    # Creates a new message addressed to the supplied JID of type CHAT
+    #
+    # to:: [JID] Who to send the message to
+    # return:: [Jabber::Protocol::Message] The new (chat) message
+    #
+    def new_chat_message(to)
+      self.new_message(to, Jabber::Protocol::Message::CHAT)
+    end
+    
+    ##
+    # Creates a new message addressed to the supplied JID of type GROUPCHAT
+    #
+    # to:: [JID] Who to send the message to
+    # return:: [Jabber::Protocol::Message] The new (group chat) message
+    #
+    def new_group_chat_message(to)
+      self.new_message(to, Jabber::Protocol::Message::GROUPCHAT)
+    end
+    
+    ##
+    # Adds a filter to the Connection to manage tracking messages to forward
+    # to registered message listeners.
+    #
+    def register_message_filter
+      @connection.add_filter("messageFilter") do |element|
+        if element.element_tag=="message" and @messageListeners.size > 0
+          element.consume_element
+          message = Jabber::Protocol::Message.from_element(self, element)
+          notify_message_listeners(message)
+        end #if message 
+      end #do
+    end
+    
+    ##
+    # Add a listener for new messages
+    #
+    # Usage::
+    #    id = session.add_message_listener do |message|
+    #      puts message
+    #    end
+    # 
+    # &block [Block] The block to process a message
+    # return:: [String] The listener ID...used to remove the listener
+    #
+    def add_message_listener(&block)
+      id = Jabber.gen_random_id("", 10)
+      @messageListeners[id]=block if block
+      return id
+    end
+    
+    ##
+    # Deletes a message listener
+    #
+    # id:: [String] A messanger ID returned from add_message_listener
+    #
+    def delete_message_listener(lid)
+      @messageListeners.delete(lid)
+    end
+    
+    #Cleanup methods
+    
+    ##
+    # Releases the connection and resets the session.  The Session instance
+    # is no longer usable after this method is called
+    #
+    def release
+      begin
+        @connection.on_connection_exception do
+          #Do nothing...we are shutting down
+        end
+        @connection.send(Jabber::Protocol::Presence.gen_unavailable(id))
+        @connection.send(Jabber::Protocol.gen_close_stream)
+      rescue
+        #ignore error
+      end
+      begin
+        @connection.close
+      rescue
+        #ignore error
+      end
+    end
+    
+    ##
+    # Same as _release
+    #
+    def close
+      release
+    end
+    
+    ##
+    # Requests the Roster for the (authenticated) account.  This method blocks
+    # until a reply to the roster request is received.
+    #
+    def request_roster
+      if @authenticated
+        msg_id = id
+        @connection.send(Jabber::Protocol::Iq.gen_roster(self, msg_id)) do |element|
+          if element.attr_id == msg_id
+            element.consume_element
+            element.query.item.count.times do |i|
+              item = element.query.item[i]
+              @roster.add(item.attr_jid, item.attr_subscription, item.attr_name, item.group.element_data)
+            end
+          end
+        end
+        Thread.stop
+        register_roster_filter
+      end
+    end
+    
+    ##
+    # Registers the roster filter with the Connection to forward IQ requests
+    # to the IQ listeners(they register by namespace)
+    #
+    def register_iq_filter() 
+      @connection.add_filter("iqFilter") do |element|
+        if element.element_tag=="iq" then
+          element.consume_element
+          query=element.query
+          h=@iqHandlers[query.attr_xmlns]
+          h.call(Jabber::Protocol::Iq.from_element(self,element)) if h
+        end
+      end
+    end
+    
+    
+    ##
+    # Registers the roster filter with the Connection to forward roster changes to
+    # the roster listeners.
+    #
+    def register_roster_filter
+      @connection.add_filter("rosterFilter") do |element|
+        if element.element_tag=="iq" and element.query.attr_xmlns=="jabber:iq:roster" and element.attr_type=="set"
+          element.consume_element
+          item = element.query.item
+          if item.attr_subscription=="remove" then
+            @roster.remove(item.attr_jid)
+          else
+            @roster.add(item.attr_jid, item.attr_subscription, item.attr_name, item.group.element_data)
+          end
+        end
+      end
+    end
+    
+    ##
+    # Registers a listener for roster events
+    #
+    # &block:: [Block] The listener block to process roster changes
+    # return:: [String] A roster ID to use when removing this listener
+    #
+    def add_roster_listener(&block)
+      roster.add_listener(&block)
+    end
+    
+    ##
+    # Deletes the roster listener
+    #
+    # id:: [String] A roster ID received from the add_roster_listener method
+    #
+    def delete_roster_listener(id)
+      roster.delete_listener(id)
+    end
+    
+    ##
+    # Notifies message listeners of the received message
+    #
+    # message:: [Jabber::Protocol::Message] The received message
+    #
+    def notify_message_listeners(message)
+      @messageListeners.each_value {|listener| listener.call(message)}
+    end
+
+  end  
+  
+end
+