cerberus 0.6 → 0.7

data/lib/vendor/xmpp4r/lib/xmpp4r/command/helper/responder.rb

@@ -0,0 +1,53 @@
+module Jabber
+
+  module Command
+
+    ##
+    # The Responder Helper handles the low-level stuff of the
+    # Ad-hoc commands (JEP 0050).
+    class Responder
+
+      ##
+      # Initialize a Responder
+      def initialize(stream)
+        @stream = stream
+        @commandsdiscocbs = CallbackList.new
+        @commandexeccbs = CallbackList.new
+
+        stream.add_iq_callback(180, self) { |iq|
+          iq_callback(iq)
+        }
+      end
+
+      ##
+      # Add a callback for <query> stanzas asking for the list
+      # of ad-hoc commands
+      def add_commands_disco_callback(priority = 0, ref = nil, &block)
+        @commandsdiscocbs.add(priority, ref, block)
+      end
+
+      ##
+      # Add a callback for <command> stanzas asking for the execution
+      # of an ad-hoc command
+      def add_commands_exec_callback(priority = 0, ref = nil, &block)
+        @commandexeccbs.add(priority, ref, block)
+      end
+
+      ##
+      # Handles <iq> stanzas and execute callbacks
+      def iq_callback(iq)
+        if iq.type == :get
+          if iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoItems) &&
+             iq.query.node == "http://jabber.org/protocol/commands"
+            @commandsdiscocbs.process(iq)
+          end
+        elsif iq.type == :set && iq.command
+          @commandexeccbs.process(iq)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/command/iq/command.rb

@@ -0,0 +1,154 @@
+require 'xmpp4r/iq'
+
+module Jabber
+
+  module Command
+
+    ##
+    # Class for handling ad-hoc commands
+    # (JEP 0050)
+    #
+    # A command is uniquely identified by its node attribute.
+    class IqCommand < Iq
+      name_xmlns 'command', 'http://jabber.org/protocol/commands'
+
+      def initialize(node=nil, action=nil)
+        super()
+        set_node(node)
+        set_action(action)
+      end
+
+      ##
+      # Get the node of the Command stanza
+      # result:: [String] or nil
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Set the node of the Command stanza
+      # v:: [String] or nil
+      def node=(v)
+        attributes['node'] = v
+      end
+
+      ##
+      # Set the node of the Command stanza (chaining-friendly)
+      # v:: [String] or nil
+      def set_node(v)
+        self.node = v
+        self
+      end
+
+      ##
+      # Get the sessionid of the Command stanza
+      # result:: [String] or nil
+      def sessionid
+        attributes['sessionid']
+      end
+
+      ##
+      # Set the sessionid of the Command stanza
+      # v:: [String] or nil
+      def sessionid=(v)
+        attributes['sessionid'] = v
+      end
+
+      ##
+      # Set the sessionid of the Command stanza (chaining-friendly)
+      # v:: [String] or nil
+      def set_sessionid(v)
+        self.sessionid = v
+        self
+      end
+
+      ##
+      # Get the action of the Command stanza
+      #
+      # The following Symbols are allowed:
+      # * :execute
+      # * :cancel
+      # * :prev
+      # * :next
+      # * :complete
+      # return:: [Symbol] or nil
+      def action
+        case attributes['action']
+          when 'execute' then :execute
+          when 'cancel' then :cancel
+          when 'prev' then :prev
+          when 'next' then :next
+          when 'complete' then :complete
+          else nil
+        end
+      end
+
+      ##
+      # Set the action of the Command stanza (see IqCommand#action for details)
+      # v:: [Symbol] or nil
+      def action=(v)
+        attributes['action'] = case v
+          when :execute then 'execute'
+          when :cancel then 'cancel'
+          when :prev then 'prev'
+          when :next then 'next'
+          when :complete then 'complete'
+          else nil
+        end
+      end
+
+      ##
+      # Set the action of the Command stanza (chaining-friendly)
+      # v:: [Symbol] or nil
+      def set_action(v)
+        self.action = v
+        self
+      end
+
+      ##
+      # Get the status of the Command stanza
+      #
+      # The following Symbols are allowed:
+      # * :executing
+      # * :completed
+      # * :canceled
+      # return:: [Symbol] or nil
+      def status
+        case attributes['status']
+          when 'executing' then :executing
+          when 'completed' then :completed
+          when 'canceled' then :canceled
+          else nil
+        end
+      end
+
+      ##
+      # Set the status of the Command stanza (see IqCommand#status for details)
+      # v:: [Symbol] or nil
+      def status=(v)
+        attributes['status'] = case v
+          when :executing then 'executing'
+          when :completed then 'completed'
+          when :canceled then 'canceled'
+          else nil
+        end
+      end
+
+      ##
+      # Set the status of the Command stanza (chaining-friendly)
+      # v:: [Symbol] or nil
+      def set_status(v)
+        self.status = v
+        self
+      end
+
+      ##
+      # Get the actions allowed
+      # return:: [REXML::Element] or nil
+      def actions
+        first_element('actions')
+      end
+
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/component.rb

@@ -0,0 +1,103 @@
+# =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/connection'
+
+module Jabber
+  ##
+  # The component class provides everything needed to build a XMPP Component.
+  #
+  # Components are more flexible as they are only restricted in the use of a
+  # fixed domain. node and resource of JIDs are freely choosable for all stanzas.
+  class Component  < Connection
+
+    # The component's JID
+    attr_reader :jid
+
+    # The server's address
+    attr_reader :server_address
+
+    # The server's port
+    attr_reader :server_port
+
+    # Create a new Component
+    # jid:: [JID]
+    def initialize(jid, server_address=nil, server_port=5347)
+      super()
+      @jid = (jid.kind_of?(JID) ? jid : JID.new(jid.to_s))
+
+      if server_address
+        $stderr.puts "Passing server and port to Jabber::Component.new is " +
+                     "obsolete and will vanish in some later XMPP4R release. " +
+                     "Please use these arguments when calling " +
+                     "Jabber::Client#connect"
+        @server_address = server_address
+        @server_port = server_port
+      end
+    end
+
+    # Connect to the server
+    # (chaining-friendly)
+    # server:: [String] Hostname
+    # port:: [Integer] TCP port (5347)
+    # return:: self
+    def connect(server=nil, port=5347)
+      if server
+        super(server, port)
+      else
+        super(@server_address, @server_port)
+      end
+      self
+    end
+
+    ##
+    # Close the connection,
+    # sends <tt></stream:stream></tt> tag first
+    def close
+      send("</stream:stream>")
+      super
+    end
+
+    def generate_stream_start(to=nil, from=nil, id=nil, xml_lang="en", xmlns="jabber:component:accept", version="1.0")
+      super
+    end
+    private :generate_stream_start
+
+    ##
+    # Start the stream-parser and send the component-specific stream opening element
+    def start
+      super
+      send(generate_stream_start(@jid)) { |e|
+        if e.name == 'stream'
+          true
+        else
+          false
+        end
+      }
+    end
+
+    ##
+    # Send auth with given secret and wait for result
+    #
+    # Throws ComponentAuthenticationFailure
+    # secret:: [String] the shared secret
+    def auth(secret)
+      hash = Digest::SHA1::hexdigest(@streamid.to_s + secret)
+      authenticated = false
+      send("<handshake>#{hash}</handshake>") { |r|
+        if r.prefix == 'stream' and r.name == 'error'
+          true
+        elsif r.name == 'handshake'
+          authenticated = true
+          true
+        else
+          false
+        end
+      }
+      unless authenticated
+        raise ComponentAuthenticationFailure.new, "Component authentication failed"
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/connection.rb

@@ -0,0 +1,219 @@
+# =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/
+
+begin
+  require 'openssl'
+rescue LoadError
+end
+require 'xmpp4r/stream'
+
+module Jabber
+  ##
+  # The connection class manages the TCP connection to the Jabber server
+  #
+  class Connection  < Stream
+    attr_reader :host, :port
+
+    # How many seconds to wait for <stream:features/>
+    # before proceeding
+    attr_accessor :features_timeout
+
+    # Keep-alive interval in seconds, defaults to 60
+    # (see private method keepalive_loop for implementation details)
+    attr_accessor :keepalive_interval
+
+    # Allow TLS negotiation? Defaults to true
+    attr_accessor :allow_tls
+
+    # Optional CA-Path for TLS-handshake
+    attr_accessor :ssl_capath
+
+    # Optional callback for verification of SSL peer
+    attr_accessor :ssl_verifycb
+
+    #whether to use the old and deprecated SSL protocol
+    #Defaults to false
+    attr_accessor :use_ssl
+
+    ##
+    # Create a new connection to the given host and port
+    def initialize
+      super()
+      @host = nil
+      @port = nil
+      @allow_tls = defined? OpenSSL
+      @tls = false
+      @ssl_capath = nil
+      @ssl_verifycb = nil
+      @features_timeout = 10
+      @keepalive_interval = 60
+      @use_ssl = false
+    end
+
+    ##
+    # Connect to the Jabber server through a TCP Socket,
+    # start the Jabber parser,
+    # invoke to accept_features to wait for TLS,
+    # start the keep-alive thread
+    def connect(host, port)
+      @host = host
+      @port = port
+      # Reset is_tls?, so that it works when reconnecting
+      @tls = false
+
+      Jabber::debuglog("CONNECTING:\n#{@host}:#{@port}")
+      @socket = TCPSocket.new(@host, @port)
+
+      # We want to use the old and deprecated SSL protocol (usually on port 5223)
+      if @use_ssl
+        ssl = OpenSSL::SSL::SSLSocket.new(@socket)
+        ssl.connect # start SSL session
+        ssl.sync_close = true
+        Jabber::debuglog("SSL connection established.")
+        @socket = ssl
+      end
+
+      start
+
+      accept_features
+
+      @keepaliveThread = Thread.new do
+        Thread.current.abort_on_exception = true
+        keepalive_loop
+      end
+    end
+
+    ##
+    # Closing connection:
+    # first kill keepaliveThread, then call Stream#close!
+    def close!
+      @keepaliveThread.kill if @keepaliveThread and @keepaliveThread.alive?
+      super
+    end
+
+    def accept_features
+      begin
+        Timeout::timeout(@features_timeout) {
+          Jabber::debuglog("FEATURES: waiting...")
+          @features_sem.wait
+          Jabber::debuglog("FEATURES: waiting finished")
+        }
+      rescue Timeout::Error
+        Jabber::debuglog("FEATURES: timed out when waiting, stream peer seems not XMPP compliant")
+      end
+
+      if @allow_tls and not is_tls? and @stream_features['starttls'] == 'urn:ietf:params:xml:ns:xmpp-tls'
+        begin
+          starttls
+        rescue
+          Jabber::debuglog("STARTTLS:\nFailure: #{$!}")
+        end
+      end
+    end
+
+    ##
+    # Start the parser on the previously connected socket
+    def start
+      super(@socket)
+    end
+
+    ##
+    # Do a <starttls/>
+    # (will be automatically done by connect if stream peer supports this)
+    def starttls
+      stls = REXML::Element.new('starttls')
+      stls.add_namespace('urn:ietf:params:xml:ns:xmpp-tls')
+
+      reply = nil
+      send(stls) { |r|
+        reply = r
+        true
+      }
+      if reply.name != 'proceed'
+        raise ServerError(reply.first_element('error'))
+      end
+      # Don't be interrupted
+      stop
+
+      begin
+        error = nil
+
+        # Context/user set-able stuff
+        ctx = OpenSSL::SSL::SSLContext.new
+        if @ssl_capath
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          ctx.ca_path = @ssl_capath
+        else
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        ctx.verify_callback = @ssl_verifycb
+
+        # SSL connection establishing
+        sslsocket = OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+        sslsocket.sync_close = true
+        Jabber::debuglog("TLSv1: OpenSSL handshake in progress")
+        sslsocket.connect
+
+        # Make REXML believe it's a real socket
+        class << sslsocket
+          def kind_of?(o)
+            o == IO ? true : super
+          end
+        end
+
+        # We're done and will use it
+        @tls = true
+        @socket = sslsocket
+      rescue
+        error = $!
+      ensure
+        Jabber::debuglog("TLSv1: restarting parser")
+        start
+        accept_features
+        raise error if error
+      end
+    end
+
+    ##
+    # Have we gone to TLS mode?
+    # result:: [true] or [false]
+    def is_tls?
+      @tls
+    end
+
+    def generate_stream_start(to=nil, from=nil, id=nil, xml_lang="en", xmlns="jabber:client", version="1.0")
+      stream_start_string = "<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "
+      stream_start_string += "xmlns='#{xmlns}' " unless xmlns.nil?
+      stream_start_string += "to='#{to}' " unless to.nil?
+      stream_start_string += "from='#{from}' " unless from.nil?
+      stream_start_string += "id='#{id}' " unless id.nil?
+      stream_start_string += "xml:lang='#{xml_lang}' " unless xml_lang.nil?
+      stream_start_string += "version='#{version}' " unless version.nil?
+      stream_start_string += ">"
+      stream_start_string
+    end
+    private :generate_stream_start
+
+    ##
+    # A loop to send "keep alive" data to prevent
+    # the Jabber connection from closing for inactivity.
+    #
+    # This loop sends a single white-space character if
+    # no other data has been sent in the last @keepalive_interval
+    # seconds.
+    def keepalive_loop
+      loop do
+        difference = @last_send + @keepalive_interval - Time.now
+        if difference <= 0
+          send(' ')
+          sleep @keepalive_interval
+        else
+          sleep(difference)
+        end
+      end
+    end
+    private :keepalive_loop
+
+  end
+end