jabber4r-revive 0.9.0

data/lib/jabber4r/connection.rb

@@ -0,0 +1,258 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+module Jabber
+  # The connection class encapsulates the connection to the Jabber
+  # service including managing the socket and controlling the parsing
+  # of the Jabber XML stream.
+  class Connection
+    DISCONNECTED = 1
+    CONNECTED = 2
+
+    # Public
+    attr_reader :host, :port, :status, :input, :output
+
+    # Internal
+    attr_reader :poll_thread, :parser_thread
+
+    # Internal
+    attr_reader :filters, :handlers
+
+    # Internal
+    attr_reader :socket, :parser
+
+    def initialize(host, port = 5222)
+      @host, @port = host, port
+
+      @handlers, @filters = {}, {}
+
+      @poll_counter = 10
+      @mutex = Mutex.new
+
+      @status = DISCONNECTED
+    end
+
+    # Public: Connects to the Jabber server through a TCP Socket and
+    # starts the Jabber parser.
+    #
+    # Returns nothing
+    def connect
+      @socket = TCPSocket.new(@host, @port)
+      @parser = Jabber::Protocol.Parser.new(socket, self)
+
+      register_parsing_thread
+      register_polling_thread
+
+      @status = CONNECTED
+    end
+
+    # Internal: Register new parser thread
+    #
+    # Returns nothing
+    def register_parsing_thread
+      @parser_thread = Thread.new { parser.parse }
+    end
+
+    # Internal: Register new polling thread
+    #
+    # Returns nothing
+    def register_polling_thread
+      @poll_thread = Thread.new { poll }
+    end
+
+    # Public: Closes the connection to the Jabber service
+    #
+    # Returns nothing
+    def close
+      parser_thread.kill if parser_thread # why if?
+      poll_thread.kill
+      socket.close if socket
+
+      @status = DISCONNECTED
+    end
+    alias :disconnect :close
+
+    # Public: Returns if this connection is connected to a Jabber service
+    #
+    # Returns boolean
+    def connected?
+      status == CONNECTED
+    end
+
+    # Public: Returns if this connection is NOT connected to a Jabber service
+    #
+    # Returns boolean
+    def disconnected?
+      status == DISCONNECTED
+    end
+
+    # Public: Adds a filter block to process received XML messages
+    #
+    # name - String the name of filter
+    # block - Block of code
+    #
+    # Returns nothing
+    def add_filter(name, &block)
+      raise ArgumentError, "Expected block to be given" if block.nil?
+
+      @filters[name] = block
+    end
+
+    # Public: Removes a filter block
+    #
+    # name - String the name of filter
+    #
+    # Returns Block of code
+    def remove_filter(name)
+      filters.delete(name)
+    end
+
+    # Public: Receiving xml element, and processing it
+    # NOTE: Synchonized by Mutex
+    #
+    # xml         - String the string containing xml
+    # proc_object - Proc the proc object to call (default: nil)
+    # block       - Block of ruby code
+    #
+    # Returns nothing
+    def send(xml, proc_object = nil, &block)
+      @mutex.synchronize { write_to_socket(xml, proc_object, &block) }
+    end
+
+    # Public: Receiving xml element, and processing it
+    # NOTE: Synchonized by Mutex
+    #
+    # xml_element - ParsedXMLElement the received from socket xml element
+    #
+    # Returns nothing
+    def receive(xml)
+      @mutex.synchronize { process_xml_from_socket(xml) }
+    end
+
+    # Internal: Sends XML data to the socket and (optionally) waits
+    # to process received data.
+    # NOTE: If both habdler and block are given, handler has higher proirity
+    #
+    # xml     - String the xml data to send
+    # handler - [Proc|Lambda|#call] the proc object or labda to handle response data (optional)
+    # block   - Block the block of ruby code (optional)
+    #
+    # Returns nothing
+    def write_to_socket(xml, handler = nil, &block)
+      Jabber.debug("SENDING:\n#{xml}")
+
+      handler = block if handler.nil?
+      handlers[Thread.current] = handler unless handler.nil?
+
+      socket.write(xml)
+
+      @poll_counter = 10
+    end
+
+    # Internal: Processes a received ParsedXMLElement and executes
+    # registered handlers and filters against it
+    #
+    # xml - ParsedXMLElement The received element
+    #
+    # Returns nothing
+    def process_xml_from_socket(xml)
+      sleep 0.1 while wait_for_consume?
+
+      Jabber.debug("RECEIVED:\n#{xml}")
+
+      consume_xml_by_handlers(xml) || consume_xml_by_filters(xml)
+    end
+
+    # Internal: Processes a received ParsedXMLElement by handlers
+    #
+    # xml - ParsedXMLElement The received element
+    #
+    # Returns boolean
+    def consume_xml_by_handlers(xml)
+      handlers.each do |thread, block|
+        begin
+          block.call(xml)
+
+          if xml.element_consumed?
+            handlers.delete(thread)
+            thread.wakeup if thread.alive?
+
+            return true
+          end
+        rescue Exception => error
+          puts error.to_s
+          puts error.backtrace.join("\n")
+        end
+      end
+
+      false
+    end
+
+    # Internal: Processes a received ParsedXMLElement by filters
+    #
+    # xml - ParsedXMLElement The received element
+    #
+    # Returns boolean
+    def consume_xml_by_filters(xml)
+      filters.each_value do |block|
+        begin
+          block.call(xml)
+
+          return true if xml.element_consumed?
+        rescue Exception => error
+          puts error.to_s
+          puts error.backtrace.join("\n")
+        end
+      end
+
+      false
+    end
+
+    # Internal: Should we wait for next part of socket data
+    #
+    # Returns boolean
+    def wait_for_consume?
+      handlers.size.zero? && filters.size.zero?
+    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.
+    #
+    def on_connection_exception(&block)
+      @exception_block = block
+    end
+
+    def parse_failure(exception = nil)
+      Thread.new { @exception_block.call(exception) if @exception_block }
+    end
+
+    ############################################################################
+    #                 All that under needs to be REFACTORED                    #
+    ############################################################################
+
+    ##
+    # Starts a polling thread to send "keep alive" data to prevent
+    # the Jabber connection from closing for inactivity.
+    #
+    def poll
+      sleep 10
+      while true
+        sleep 2
+        @poll_counter = @poll_counter - 1
+        if @poll_counter < 0
+          begin
+            send("  \t  ")
+          rescue
+            Thread.new {@exception_block.call if @exception_block}
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jabber4r/debugger.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# Copyright (C) 2013  Sergey Fedorov <strech_ftf@mail.ru>
+
+require "singleton"
+require "logger"
+
+module Jabber
+  # Produces debug methods
+  #
+  # Example
+  #
+  # def warn(message)
+  #   Debug.instance.send(:warn, message)
+  # end
+  # module_function m
+  [:warn, :debug, :info].each do |m|
+    define_method(m) do |message|
+      Debugger.send(m, message)
+    end
+    module_function m
+  end
+
+  class Debugger
+    include Singleton
+
+    attr_accessor :enabled, :logger
+
+    def initialize
+      @logger  = Logger.new(STDOUT)
+      @enabled = false
+    end
+
+    class << self
+      def logger=(logger)
+        instance.logger = logger
+      end
+
+      def enable!
+        instance.enabled = true
+      end
+
+      def disable!
+        instance.enabled = false
+      end
+
+      def enabled?
+        instance.enabled
+      end
+
+      [:warn, :debug, :info].each do |m|
+        define_method(m) do |message|
+          enabled? && instance.logger.send(m, message)
+        end
+      end
+    end # class << self
+  end
+end

data/lib/jabber4r/jid.rb

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+module Jabber
+  # The Jabber ID class is used to hold a parsed jabber identifier (account+host+resource)
+  class JID
+    PATTERN = /^(?:(?<node>[^@]*)@)??(?<host>[^@\/]*)(?:\/(?<resource>.*?))?$/.freeze
+
+    # The node (account)
+    attr_accessor :node
+
+    # The resource id
+    attr_accessor :resource
+
+    # The host name (or IP address)
+    attr_accessor :host
+
+    # Public: Convert something to Jabber::JID
+    #
+    # jid - [String|Jabber::JID] the jid of future Jabber::JID
+    #
+    # Returns Jabber::JID
+    def self.to_jid(jid)
+      return jid if jid.kind_of? self
+
+      new jid
+    end
+
+    # Constructs a JID from the supplied string of the format:
+    # node@host[/resource] (e.g. "rich_kilmer@jabber.com/laptop")
+    #
+    # jid      - String the jabber id string to parse
+    # host     - String the host of jabber server (optional)
+    # resource - String the resource of jabber id (optional)
+    #
+    # Examples
+    #
+    # jid = Jabber::JID.new("strech@localhost/attach")
+    # jid.node # => "strech"
+    # jid.host # => "localhost"
+    # jid.resource # => "attach"
+    #
+    # Raises ArgumentError
+    # Returns nothing
+    def initialize(jid, host = nil, resource = nil)
+      raise ArgumentError, "Node can't be empty" if jid.to_s.empty?
+
+      @node, @host, @resource = self.class.parse(jid)
+      @node, @host = @host, nil if @node.nil? && @host
+
+      @host = host unless host.nil?
+      @resource = resource unless resource.nil?
+
+      raise ArgumentError, "Couldn't create JID without host" if @host.to_s.empty?
+    end
+
+    # Public: Evalutes whether the node, resource and host are the same
+    #
+    # jid - Jabber::JID the other jabber id
+    #
+    # Returns boolean
+    def ==(jid)
+      jid.to_s == self.to_s
+    end
+
+    # Public: Compare accounts without resources
+    #
+    # jid - Jabber::JID the other jabber id
+    #
+    # Returns boolean
+    def same?(jid)
+      other_jid = self.class.to_jid(jid)
+
+      other_jid.node == node && other_jid.host == host
+    end
+
+    # Public: Strip resource from jid and return new object
+    #
+    # Returns Jabber::JID
+    def strip
+      self.class.new(node, host)
+    end
+
+    # Public: Strip resource from jid and return the same object
+    #
+    # Returns Jabber::JID
+    def strip!
+      @resource = nil
+
+      self
+    end
+
+    # Public: String representation of JID
+    #
+    # Returns String
+    def to_s
+      ["#{node}@#{host}", resource].compact.join "/"
+    end
+
+    # Public: Override #hash to hash based on the to_s method
+    #
+    # Returns Fixnum
+    def hash
+      to_s.hash
+    end
+
+    private
+    # Internal: Parse jid string for node, host, resource
+    #
+    # jid - String jabber id
+    #
+    # Examples
+    #
+    # result = Jabber::JID.parse("strech@localhost/pewsource")
+    # result # => ["strech", "localhost", "pewsource"]
+    #
+    # Rerturns Array
+    def self.parse(jid)
+      jid.match(PATTERN).captures
+    end
+  end
+end

data/lib/jabber4r/protocol/iq.rb

@@ -0,0 +1,260 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+module Jabber::Protocol
+  ##
+  # A class used to build/parse IQ requests/responses
+  #
+  class Iq
+    attr_accessor :session,:to, :from, :id, :type, :xmlns, :data,:error,:errorcode
+    ERROR="error"
+    GET="get"
+    SET="set"
+    RESULT="result"
+
+    ##
+    # Factory to build an IQ object from xml element
+    #
+    # session:: [Jabber::Session] The Jabber session instance
+    # element:: [Jabber::Protocol::ParsedXMLElement] The received XML object
+    # return:: [Jabber::Protocol::Iq] The newly created Iq object
+    #
+    def self.from_element(session, element)
+      iq = new(session)
+
+      iq.from = Jabber::JID.new(element.attr_from) if element.attr_from
+      iq.to   = Jabber::JID.new(element.attr_to) if element.attr_to
+
+      iq.id = element.attr_id
+      iq.type = element.attr_type
+      iq.xmlns = element.query.attr_xmlns
+      iq.data  = element.query
+      iq.session = session
+
+      if element.attr_type = "error"
+        iq.error = element.error
+        iq.errorcode = element.error.attr_code
+      end
+
+      return iq
+    end
+
+    ##
+    # Default constructor to build an Iq object
+    # session:: [Jabber::Session] The Jabber session instance
+    # id:: [String=nil] The (optional) id of the Iq object
+    def initialize(session,id=nil)
+      @session=session
+      @id=id
+    end
+
+    ##
+    # Return an IQ object that uses the jabber:iq:private namespace
+    #
+    def self.get_private(session,id,ename,ns)
+      iq=Iq.new(session,id)
+      iq.type="get"
+      iq.xmlns="jabber:iq:private"
+      iq.data=XMLElement.new(ename,{'xmlns' => ns});
+      return iq
+    end
+
+
+    ##
+    # Generates an IQ roster request XML element
+    #
+    # id:: [String] The message id
+    # return:: [String] The XML data to send
+    #
+    def self.gen_roster(session, id)
+      iq = Iq.new(session, id)
+      iq.type = "get"
+      iq.xmlns = "jabber:iq:roster"
+      return iq
+      #return XMLElement.new("iq", {"type"=>"get", "id"=>id}).add_child("query", {"xmlns"=>"jabber:iq:roster"}).to_s
+    end
+
+    ##
+    # Generates an IQ authortization request XML element
+    #
+    # id:: [String] The message id
+    # username:: [String] The username
+    # password:: [String] The password
+    # email:: [String] The email address of the account
+    # name:: [String] The full name
+    # return:: [String] The XML data to send
+    #
+    def self.gen_registration(session, id, username, password, email, name)
+      iq = Iq.new(session, id)
+      iq.type = "set"
+      iq.xmlns = "jabber:iq:register"
+      iq.data = XMLElement.new("username").add_data(username).to_s
+      iq.data << XMLElement.new("password").add_data(password).to_s
+      iq.data << XMLElement.new("email").add_data(email).to_s
+      iq.data << XMLElement.new("name").add_data(name).to_s
+      return iq
+    end
+
+    ##
+    # Generates an IQ Roster Item add request XML element
+    #
+    # session:: [Session] The session
+    # id:: [String] The message id
+    # jid:: [JID] The Jabber ID to add to the roster
+    # name:: [String] The full name
+    # return:: [String] The XML data to send
+    #
+    def self.gen_add_rosteritem(session, id, jid, name)
+      iq = Iq.new(session, id)
+      iq.type = "set"
+      iq.xmlns = "jabber:iq:roster"
+      iq.data = XMLElement.new("item").add_attribute("jid", jid).add_attribute("name", name).to_s
+      return iq
+    end
+
+    ##
+    # Generates an IQ authortization request XML element
+    #
+    # id:: [String] The message id
+    # username:: [String] The username
+    # password:: [String] The password
+    # resource:: [String] The resource to bind this session to
+    # return:: [String] The XML data to send
+    #
+    def self.gen_auth(session, id, username, password, resource)
+      iq = Iq.new(session, id)
+      iq.type = "set"
+      iq.xmlns = "jabber:iq:auth"
+      iq.data = XMLElement.new("username").add_data(username).to_s
+      iq.data << XMLElement.new("password").add_data(password).to_s
+      iq.data << XMLElement.new("resource").add_data(resource).to_s
+      return iq
+      #element = XMLElement.new("iq", {"type"=>"set", "id"=>id}).add_child("query", {"xmlns"=>"jabber:iq:auth"}).add_child("username").add_data(username).to_parent.add_child("password").add_data(password).to_parent.add_child("resource").add_data(resource).to_parent.to_s
+    end
+
+    ##
+    # Generates an IQ digest authortization request XML element
+    #
+    # id:: [String] The message id
+    # username:: [String] The username
+    # digest:: [String] The SHA-1 hash of the sessionid and the password
+    # resource:: [String] The resource to bind this session to
+    # return:: [String] The XML data to send
+    #
+    def self.gen_auth_digest(session, id, username, digest, resource)
+      iq = Iq.new(session, id)
+      iq.type = "set"
+      iq.xmlns = "jabber:iq:auth"
+      iq.data = XMLElement.new("username").add_data(username).to_s
+      iq.data << XMLElement.new("digest").add_data(digest).to_s
+      iq.data << XMLElement.new("resource").add_data(resource).to_s
+      return iq
+      #return XMLElement.new("iq", {"type"=>"set", "id"=>id}).add_child("query", {"xmlns"=>"jabber:iq:auth"}).add_child("username").add_data(username).to_parent.add_child("digest").add_data(digest).to_parent.add_child("resource").add_data(resource).to_parent.to_s
+    end
+
+    ##
+    # Generates an IQ out of bounds XML element
+    #
+    # to:: [JID] The Jabber ID to send to
+    # url:: [String] The data to send
+    # desc:: [String=""] The description of the data
+    # return:: [String] The XML data to send
+    #
+    def self.gen_oob(session, to, url, desc="")
+      iq = Iq.new(session, nil)
+      iq.type = "set"
+      iq.xmlns = "jabber:iq:oob"
+      iq.data = XMLElement.new("url").add_data(url).to_s
+      iq.data << XMLElement.new("desc").add_data(desc).to_s
+      return iq
+      #return XMLElement.new("iq", {"type"=>"set"}).add_child("query", {"xmlns"=>"jabber:iq:oob"}).add_child("url").add_data(url).to_parent.add_child("desc").add_data(data).to_parent.to_s
+    end
+
+    ##
+    # Generates an VCard request XML element
+    #
+    # id:: [String] The message ID
+    # to:: [JID] The jabber id of the account to get the VCard for
+    # return:: [String] The XML data to send
+    #
+    def self.gen_vcard(session, id, to)
+      iq = Iq.new(session, id)
+      iq.xmlns = "vcard-temp"
+      iq.type = "get"
+      iq.to = to
+      return iq
+      #return XMLElement.new("iq", {"type"=>"get", "id"=>id, "to"=>to}).add_child("query", {"xmlns"=>"vcard-temp"}).to_s
+    end
+
+
+
+
+    ##
+    # Sends the IQ to the Jabber service for delivery
+    #
+    # wait:: [Boolean = false] Wait for reply before return?
+    # &block:: [Block] A block to process the message replies
+    #
+    def send(wait=false, &block)
+      if wait
+        iq = nil
+        blockedThread = Thread.current
+        @session.connection.send(self.to_s, block) do |je|
+          if je.element_tag == "iq" and je.attr_id == @id
+            je.consume_element
+            iq = self.class.from_element(@session, je)
+            blockedThread.wakeup
+          end
+        end
+        Thread.stop
+        return iq
+      else
+        @session.connection.send(self.to_s, block) if @session
+      end
+    end
+
+    ##
+    # Builds a reply to an existing Iq
+    #
+    # return:: [Jabber::Protocol::Iq] The result Iq
+    #
+    def reply
+      iq = Iq.new(@session,@id)
+      iq.to = @from
+      iq.id = @id
+      iq.type = 'result'
+      @is_reply = true
+      return iq
+    end
+
+    ##
+    # Generates XML that complies with the Jabber protocol for
+    # sending the Iq through the Jabber service.
+    #
+    # return:: [String] The XML string.
+    #
+    def to_xml
+      elem = XMLElement.new("iq", { "type"=>@type})
+      elem.add_attribute("to" ,@to) if @to
+      elem.add_attribute("id", @id) if @id
+      elem.add_child("query").add_attribute("xmlns",@xmlns).add_data(@data.to_s)
+      if @type=="error" then
+        e=elem.add_child("error");
+        e.add_attribute("code",@errorcode) if @errorcode
+        e.add_data(@error) if @error
+      end
+      return elem.to_s
+    end
+
+    ##
+    # see to_xml
+    #
+    def to_s
+      to_xml
+    end
+
+  end
+end