xmpp4r 0.3

data/lib/xmpp4r/connection.rb

@@ -0,0 +1,166 @@
+# =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 'openssl'
+require 'xmpp4r/stream'
+require 'xmpp4r/errorexception'
+
+module Jabber
+  ##
+  # The connection class manages the TCP connection to the Jabber server
+  #
+  class Connection  < Stream
+    attr_reader :host, :port
+
+    # Allow TLS negotiation? Defaults to true
+    attr_accessor :allow_tls
+
+    # How many seconds to wait for <stream:features/>
+    # before proceeding
+    attr_accessor :features_timeout
+
+    # Optional CA-Path for TLS-handshake
+    attr_accessor :ssl_capath
+
+    # Optional callback for verification of SSL peer
+    attr_accessor :ssl_verifycb
+
+    ##
+    # Create a new connection to the given host and port, using threaded mode
+    # or not.
+    def initialize(threaded = true)
+      super(threaded)
+      @host = nil
+      @port = nil
+      @allow_tls = true
+      @tls = false
+      @ssl_capath = nil
+      @ssl_verifycb = nil
+      @features_timeout = 10
+    end
+
+    ##
+    # Connects to the Jabber server through a TCP Socket and
+    # starts the Jabber parser.
+    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)
+      start
+
+      accept_features
+    end
+
+    def accept_features
+      begin
+        Timeout::timeout(@features_timeout) {
+          Jabber::debuglog("FEATURES: waiting...")
+          @features_lock.lock
+          @features_lock.unlock
+          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
+      @features_lock.lock
+
+      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 ErrorException(reply.first_element('error'))
+      end
+      # Don't be interrupted
+      stop
+
+      begin
+        error = nil
+
+        # Context/user set-able stuff
+        ctx = OpenSSL::SSL::SSLContext.new('TLSv1')
+        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
+    
+  end  
+end

data/lib/xmpp4r/dataforms/x/data.rb

@@ -0,0 +1,248 @@
+# =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/x'
+require 'xmpp4r/jid'
+
+module Jabber
+  module Dataforms
+    ##
+    # Data Forms (JEP-0004) implementation
+    class XData < X
+      def initialize(type=nil)
+        super()
+        add_namespace('jabber:x:data')
+        self.type = type
+      end
+
+      def typed_add(xe)
+        if xe.kind_of?(REXML::Element)
+          case xe.name
+            when 'instructions' then super XDataInstructions.new.import(xe)
+            when 'title' then super XDataTitle.new.import(xe)
+            when 'field' then super XDataField.new.import(xe)
+            when 'reported' then super XDataReported.new.import(xe)
+            #when 'item' then super XDataItem.new.import(xe)
+            else super xe
+          end
+        else
+          super xe
+        end
+      end
+
+      ##
+      # Search a field by it's var-name
+      # var:: [String]
+      # result:: [XDataField] or [nil]
+      def field(var)
+        each_element { |xe|
+          return xe if xe.kind_of?(XDataField) and xe.var == var
+        }
+        nil
+      end
+
+      ##
+      # Type of this Data Form
+      # result:: * :cancel
+      #          * :form
+      #          * :result
+      #          * :submit
+      #          * nil
+      def type
+        case attributes['type']
+          when 'cancel' then :cancel
+          when 'form' then :form
+          when 'result' then :result
+          when 'submit' then :submit
+          else nil
+        end
+      end
+
+      ##
+      # Set the type (see type)
+      def type=(t)
+        case t
+          when :cancel then attributes['type'] = 'cancel'
+          when :form then attributes['type'] = 'form'
+          when :result then attributes['type'] = 'result'
+          when :submit then attributes['type'] = 'submit'
+          else attributes['type'] = nil
+        end
+      end
+    end
+
+    X.add_namespaceclass('jabber:x:data', XData)
+
+    ##
+    # Child of XData, contains the title of this Data Form
+    class XDataTitle < REXML::Element
+      def initialize
+        super('title')
+      end
+      def to_s
+        text.to_s
+      end
+      def title
+        text
+      end
+    end
+
+    ##
+    # Child of XData, contains the instructions of this Data Form
+    class XDataInstructions < REXML::Element
+      def initialize
+        super('instructions')
+      end
+      def to_s
+        text.to_s
+      end
+      def instructions
+        text
+      end
+    end
+
+    ##
+    # Child of XData, contains configurable/configured options of this Data Form
+    class XDataField < REXML::Element
+      def initialize(var=nil, type=nil)
+        super('field')
+        self.var = var
+        self.type = type
+      end
+
+      def label
+        attributes['label']
+      end
+
+      def label=(s)
+        attributes['label'] = s
+      end
+
+      def var
+        attributes['var']
+      end
+
+      def var=(s)
+        attributes['var'] = s
+      end
+
+      ##
+      # Type of this field
+      # result::
+      #          * :boolean
+      #          * :fixed
+      #          * :hidden
+      #          * :jid_multi
+      #          * :jid_single
+      #          * :list_multi
+      #          * :list_single
+      #          * :text_multi
+      #          * :text_private
+      #          * :text_single
+      #          * nil
+      def type
+        case attributes['type']
+          when 'boolean' then :boolean
+          when 'fixed' then :fixed
+          when 'hidden' then :hidden
+          when 'jid-multi' then :jid_multi
+          when 'jid-single' then :jid_single
+          when 'list-multi' then :list_multi
+          when 'list-single' then :list_single
+          when 'text-multi' then :text_multi
+          when 'text-private' then :text_private
+          when 'text-single' then :text_single
+          else nil
+        end
+      end
+
+      ##
+      # Set the type of this field (see type)
+      def type=(t)
+        case t
+          when :boolean then attributes['type'] = 'boolean'
+          when :fixed then attributes['type'] = 'fixed'
+          when :hidden then attributes['type'] = 'hidden'
+          when :jid_multi then attributes['type'] = 'jid-multi'
+          when :jid_single then attributes['type'] = 'jid-single'
+          when :list_multi then attributes['type'] = 'list-multi'
+          when :list_single then attributes['type'] = 'list-single'
+          when :text_multi then attributes['type'] = 'text-multi'
+          when :text_private then attributes['type'] = 'text-private'
+          when :text_single then attributes['type'] = 'text-single'
+          else attributes['type'] = nil
+        end
+      end
+
+      ##
+      # Is this field required (has the <required/> child)?
+      def required?
+        res = false
+        each_element('required') { res = true }
+        res
+      end
+
+      ##
+      # Set if this field is required
+      # r:: [true] or [false]
+      def required=(r)
+        delete_elements('required')
+        if r
+          add REXML::Element.new('required')
+        end
+      end
+
+      ##
+      # Get the values (in a Data Form with type='submit')
+      def values
+        res = []
+        each_element('value') { |e|
+          res << e.text
+        }
+        res
+      end
+
+      ##
+      # Set the values
+      def values=(ary)
+        delete_elements('value')
+        ary.each { |v|
+          add(REXML::Element.new('value')).text = v
+        }
+      end
+
+      ##
+      # Get the options (in a Data Form with type='form')
+      def options
+        res = {}
+        each_element('option') { |e|
+          value = nil
+          e.each_element('value') { |ve| value = ve.text }
+          res[value] = e.attributes['label']
+        }
+        res
+      end
+
+      ##
+      # Set the options
+      def options=(hsh)
+        delete_elements('option')
+        hsh.each { |value,label|
+          o = add(REXML::Element.new('option'))
+          o.attributes['label'] = label
+          o.add(REXML::Element.new('value')).text = value
+        }
+      end
+    end
+
+    ##
+    # The <reported/> element, can contain XDataField elements
+    class XDataReported < REXML::Element
+      def initialize
+        super('reported')
+      end
+    end
+  end
+end
+

data/lib/xmpp4r/dataforms.rb

@@ -0,0 +1 @@
+require 'xmpp4r/dataforms/x/data.rb'

data/lib/xmpp4r/debuglog.rb

@@ -0,0 +1,34 @@
+# =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
+  # Is debugging mode enabled ?
+  @@debug = false
+
+  # Enable/disable debugging mode. When debug mode is enabled, information
+  # can be logged using Jabber::debuglog. When debug mode is disabled, calls
+  # to Jabber::debuglog are just ignored.
+  def Jabber::debug=(debug)
+    @@debug = debug
+    if @@debug
+      debuglog('Debugging mode enabled.')
+    end
+  end
+
+  # returns true if debugging mode is enabled. If you just want to log
+  # something if debugging is enabled, use Jabber::debuglog instead.
+  def Jabber::debug
+    @@debug
+  end
+    
+  # Outputs a string only if debugging mode is enabled. If the string includes
+  # several lines, 4 spaces are added at the begginning of each line but the
+  # first one. Time is prepended to the string.
+  def Jabber::debuglog(string)
+    return if not @@debug
+    s = string.chomp.gsub("\n", "\n    ")
+    t = Time::new.strftime('%H:%M:%S')
+    puts "#{t} #{s}"
+  end
+end

data/lib/xmpp4r/delay/x/delay.rb

@@ -0,0 +1,100 @@
+# =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/x'
+require 'xmpp4r/jid'
+require 'time'
+
+module Jabber
+  module Delay
+    ##
+    # Implementation of JEP 0091
+    # for <x xmlns='jabber:x:delay' stamp='...' .../>
+    # applied on <message/> and <presence/> stanzas
+    #
+    # One may also use XDelay#text for a descriptive reason
+    # for the delay.
+    #
+    # Please note that you must require 'xmpp4r/xdelay' to use
+    # this class as it's not required by a basic XMPP implementation.
+    # <x/> elements with the specific namespace will then be
+    # converted to XDelay automatically.
+    class XDelay < X
+      ##
+      # Initialize a new XDelay element
+      #
+      # insertnow:: [Boolean] Set the stamp to [Time::now]
+      def initialize(insertnow=true)
+        super()
+        add_namespace('jabber:x:delay')
+
+        if insertnow
+          set_stamp(Time.now)
+        end
+      end
+
+      ##
+      # Get the timestamp
+      # result:: [Time] or nil
+      def stamp
+        if attributes['stamp']
+          begin
+            # Actually this should be Time.xmlschema,
+            # but "unfortunately, the 'jabber:x:delay' namespace predates" JEP 0082
+            Time.parse(attributes['stamp'])
+          rescue ArgumentError
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      ##
+      # Set the timestamp
+      # t:: [Time] or nil
+      def stamp=(t)
+        if t.nil?
+          attributes['stamp'] = nil
+        else
+          attributes['stamp'] = t.strftime("%Y%m%dT%H:%M:%S")
+        end
+      end
+
+      ##
+      # Set the timestamp (chaining-friendly)
+      def set_stamp(t)
+        self.stamp = t
+        self
+      end
+
+      ##
+      # Get the timestamp's origin
+      # result:: [JID]
+      def from
+        if attributes['from']
+          JID::new(attributes['from'])
+        else
+          nil
+        end
+      end
+
+      ##
+      # Set the timestamp's origin
+      # jid:: [JID]
+      def from=(jid)
+        attributes['from'] = jid.nil? ? nil : jid.to_s
+      end
+
+      ##
+      # Set the timestamp's origin (chaining-friendly)
+      def set_from(jid)
+        self.from = jid
+        self
+      end
+    end
+
+    X.add_namespaceclass('jabber:x:delay', XDelay)
+  end
+end

data/lib/xmpp4r/delay.rb

@@ -0,0 +1 @@
+require 'xmpp4r/delay/x/delay.rb'