xmpp4r 0.5 → 0.5.5

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

@@ -43,7 +43,7 @@ module Jabber
           begin
             # Actually this should be Time.xmlschema,
             # but "unfortunately, the 'jabber:x:delay' namespace predates" JEP 0082
-            Time.parse(attributes['stamp'])
+            Time.parse("#{attributes['stamp']}Z")
           rescue ArgumentError
             nil
           end

data/lib/xmpp4r/entity_time.rb

@@ -0,0 +1,6 @@
+# =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/entity_time/iq'
+require 'xmpp4r/entity_time/responder'

data/lib/xmpp4r/entity_time/iq.rb

@@ -0,0 +1,45 @@
+# =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 'time'
+
+module Jabber::EntityTime
+  NS_TIME = 'urn:xmpp:time'
+
+  class IqTime < Jabber::IqQuery
+    name_xmlns 'time', NS_TIME
+
+    def initialize(time=nil)
+      super()
+      set_time(time)
+    end
+
+    def set_time(time=nil)
+      time ||= Time.now
+
+      tzo = self.add_element('tzo')
+      tzo.add_text(time_zone_offset(time))
+
+      utc = self.add_element('utc')
+      utc.add_text(utc_time(time))
+    end
+
+    private
+    def utc_time(time)
+      raise ArgumentError, 'invalid time object' unless time.respond_to?(:utc)
+      time.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+    end
+
+    def time_zone_offset(time)
+      raise ArgumentError, 'invalid time object' unless time.respond_to?(:utc_offset)
+
+      sec_offset = time.utc_offset
+      h_offset = sec_offset.to_i / 3600
+      m_offset = sec_offset.abs % 60
+
+      "%+03d:%02d"%[h_offset, m_offset]
+    end
+
+  end # /IqTime
+end # /Jabber::EntityTime

data/lib/xmpp4r/entity_time/responder.rb

@@ -0,0 +1,57 @@
+# =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/entity_time/iq'
+
+module Jabber::EntityTime
+  ##
+  # XEP 202 Entity Time implementation
+  #
+  # @see http://xmpp.org/extensions/xep-0202.html
+  #
+  # @example
+  # <iq type='get'
+  #     from='romeo@montague.net/orchard'
+  #     to='juliet@capulet.com/balcony'
+  #     id='time_1'>
+  #   <time xmlns='urn:xmpp:time'/>
+  # </iq>
+  #
+  class Responder
+
+    CALLBACK_PRIORITY = 180
+
+    ##
+    # +to_s+ allows the responder to be added to another responder as a feature
+    def to_s
+      NS_TIME
+    end
+
+    def initialize(stream)
+      @stream = stream
+
+      stream.add_iq_callback(CALLBACK_PRIORITY, self) do |iq|
+        iq_callback(iq)
+      end
+    end # /initialize
+
+    def iq_callback(iq)
+      if iq.type == :get &&
+          iq.first_element('time') &&
+          iq.first_element('time').namespace === NS_TIME
+
+        answer = iq.answer(false)
+        answer.type = :result
+        answer.add(IqTime.new(Time.now))
+
+        @stream.send(answer)
+
+        return true
+      end
+
+      false
+    end
+
+  end # /Responder
+end # /Jabber::EntityTime

data/lib/xmpp4r/httpbinding/client.rb

@@ -7,6 +7,8 @@
 require 'xmpp4r/client'
 require 'xmpp4r/semaphore'
 require 'net/http'
+require 'uri'
+require 'cgi' # for escaping
 
 module Jabber
   module HTTPBinding
@@ -40,6 +42,8 @@ module Jabber
       # The server may hold this amount of stanzas
       # to reduce number of HTTP requests
       attr_accessor :http_hold
+      # Hook to initialize SSL parameters on Net::HTTP
+      attr_accessor :http_ssl_setup
 
       ##
       # Initialize
@@ -56,6 +60,50 @@ module Jabber
         @http_wait = 20
         @http_hold = 1
         @http_content_type = 'text/xml; charset=utf-8'
+
+        @no_proxy = []
+        @proxy_args = []
+      end
+
+      ##
+      # Set up proxy from the given url
+
+      # url:: [URI::Generic or String] of the form:
+      # when without proxy authentication
+      #   http://proxy_host:proxy_port/
+      # when with proxy authentication
+      #   http://proxy_user:proxy_password@proxy_host:proxy_port/
+      def http_proxy_uri=(uri)
+        uri = URI.parse(uri) unless uri.respond_to?(:host)
+        @proxy_args = [
+                       uri.host,
+                       uri.port,
+                       uri.user,
+                       uri.password,
+                      ]
+      end
+
+      ##
+      # Set up proxy from the environment variables
+      #
+      # Following environment variables are considered
+      # HTTP_PROXY, http_proxy
+      # NO_PROXY, no_proxy
+      # HTTP_PROXY_USER, HTTP_PROXY_PASSWORD
+      def http_proxy_env
+        @proxy_args = []
+        env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+        return if env_proxy.nil? or env_proxy.empty?
+
+        uri = URI.parse env_proxy
+        unless uri.user or uri.password then
+          uri.user     = CGI.escape (ENV['http_proxy_user'] || ENV['HTTP_PROXY_USER']) rescue nil
+          uri.password = CGI.escape (ENV['http_proxy_pass'] || ENV['HTTP_PROXY_PASS']) rescue nil
+        end
+
+        self.http_proxy_uri = uri
+
+        @no_proxy = (ENV['NO_PROXY'] || ENV['no_proxy'] || 'localhost, 127.0.0.1').split(/\s*,\s*/)
       end
 
       ##
@@ -76,7 +124,8 @@ module Jabber
         @stream_features = {}
         @http_rid = IdGenerator.generate_id.to_i
         @pending_rid = @http_rid
-        @pending_rid_lock = Semaphore.new
+        @pending_rid_lock = Mutex.new
+        @pending_rid_cv = [] # [ [rid, cv], [rid, cv], ... ]
 
         req_body = REXML::Element.new('body')
         req_body.attributes['rid'] = @http_rid
@@ -89,7 +138,7 @@ module Jabber
         end
         req_body.attributes['secure'] = 'true'
         req_body.attributes['xmlns'] = 'http://jabber.org/protocol/httpbind'
-        res_body = post(req_body)
+        res_body = post(req_body, "sid=new rid=#{@http_rid}")
         unless res_body.name == 'body'
           raise 'Response body is no <body/> element'
         end
@@ -125,10 +174,26 @@ module Jabber
 
       ##
       # Close the session by sending
-      # <presence type='unavailable'/>
+      # <body type='terminate'/>
       def close
         @status = DISCONNECTED
-        send(Jabber::Presence.new.set_type(:unavailable))
+        req_body = nil
+        @lock.synchronize {
+          req_body = "<body"
+          req_body += " rid='#{@http_rid += 1}'"
+          req_body += " sid='#{@http_sid}'"
+          req_body += " type='terminate'"
+          req_body += " xmlns='http://jabber.org/protocol/httpbind'"
+          req_body += ">"
+          req_body += "<presence type='unavailable' xmlns='jabber:client'/>"
+          req_body += "</body>"
+          current_rid = @http_rid
+          @pending_requests += 1
+          @last_send = Time.now
+        }
+        res_body = post(req_body, "terminate sid=#{@http_sid} rid=#{@http_rid}")
+        sleep(3)
+        Jabber::debuglog("Connection closed")
       end
 
       private
@@ -137,32 +202,60 @@ module Jabber
       # Receive stanzas ensuring that the 'rid' order is kept
       # result:: [REXML::Element]
       def receive_elements_with_rid(rid, elements)
-        while rid > @pending_rid
-          @pending_rid_lock.wait
+        @pending_rid_lock.synchronize do
+          # Wait until rid == @pending_rid
+          if rid > @pending_rid
+            cv = ConditionVariable.new
+            @pending_rid_cv << [rid, cv]
+            @pending_rid_cv.sort!
+            while rid > @pending_rid
+              cv.wait(@pending_rid_lock)
+            end
+          end
         end
-        @pending_rid = rid + 1
 
         elements.each { |e|
           receive(e)
         }
 
-        @pending_rid_lock.run
+        # Signal waiting elements
+        @pending_rid_lock.synchronize do
+          @pending_rid = rid + 1 # Ensure @pending_rid is modified atomically
+          if @pending_rid_cv.size > 0 && @pending_rid_cv.first.first == @pending_rid
+            next_rid, cv = @pending_rid_cv.shift
+            cv.signal
+          end
+        end
       end
 
       ##
       # Do a POST request
-      def post(body)
+      def post(body, debug_info)
         body = body.to_s
         request = Net::HTTP::Post.new(@uri.path)
         request.content_length = body.size
         request.body = body
         request['Content-Type'] = @http_content_type
-        Jabber::debuglog("HTTP REQUEST (#{@pending_requests + 1}/#{@http_requests}):\n#{request.body}")
-        response = Net::HTTP.start(@uri.host, @uri.port) { |http|
-          http.use_ssl = true if @uri.kind_of? URI::HTTPS
+        Jabber::debuglog("HTTP REQUEST (#{@pending_requests}/#{@http_requests}) #{debug_info}:\n#{request.body}")
+
+        net_http_args = [@uri.host, @uri.port]
+        unless @proxy_args.empty?
+          unless no_proxy?(@uri)
+            net_http_args.concat @proxy_args
+          end
+        end
+
+        http = Net::HTTP.new(*net_http_args)
+        if @uri.kind_of? URI::HTTPS
+          http.use_ssl = true
+          @http_ssl_setup and @http_ssl_setup.call(http)
+        end
+        http.read_timeout = @http_wait * 1.1
+
+        response = http.start { |http|
           http.request(request)
         }
-        Jabber::debuglog("HTTP RESPONSE (#{@pending_requests + 1}/#{@http_requests}): #{response.class}\n#{response.body}")
+        Jabber::debuglog("HTTP RESPONSE (#{@pending_requests}/#{@http_requests}) #{debug_info}: #{response.class}\n#{response.body}")
 
         unless response.kind_of? Net::HTTPSuccess
           # Unfortunately, HTTPResponses aren't exceptions
@@ -177,18 +270,30 @@ module Jabber
         body
       end
 
+      ##
+      # Check whether uri should be accessed without proxy
+      def no_proxy?(uri)
+        @no_proxy.each do |host_addr|
+          return true if uri.host.match(Regexp.quote(host_addr) + '$')
+        end
+        return false
+      end
+
       ##
       # Prepare data to POST and
       # handle the result
-      def post_data(data)
+      def post_data(data, restart = false)
         req_body = nil
         current_rid = nil
+        debug_info = ''
 
         begin
           begin
             @lock.synchronize {
               # Do not send unneeded requests
-              if data.size < 1 and @pending_requests > 0
+              if data.size < 1 and @pending_requests > 0 and !restart
+		@pending_requests += 1 # compensate for decrement in ensure clause
+                Jabber::debuglog "post_data: not sending excessive poll"
                 return
               end
 
@@ -196,23 +301,27 @@ module Jabber
               req_body += " rid='#{@http_rid += 1}'"
               req_body += " sid='#{@http_sid}'"
               req_body += " xmlns='http://jabber.org/protocol/httpbind'"
+              req_body += " xml:lang='en' xmpp:restart='true' xmlns:xmpp='urn:xmpp:xbosh'" if restart
               req_body += ">"
-              req_body += data
+              req_body += data unless restart
               req_body += "</body>"
               current_rid = @http_rid
+              debug_info = "sid=#{@http_sid} rid=#{current_rid}"
 
               @pending_requests += 1
               @last_send = Time.now
             }
 
-            res_body = post(req_body)
+            res_body = post(req_body, debug_info)
 
           ensure
-            @lock.synchronize { @pending_requests -= 1 }
+            @lock.synchronize {
+              @pending_requests -= 1
+            }
           end
 
           receive_elements_with_rid(current_rid, res_body.children)
-          ensure_one_pending_request
+          ensure_one_pending_request if @authenticated
 
         rescue REXML::ParseException
           if @exception_block
@@ -221,53 +330,78 @@ module Jabber
               close; @exception_block.call(e, self, :parser)
             end
           else
-            Jabber::debuglog "Exception caught when parsing HTTP response!"
+            Jabber::debuglog "Exception caught when parsing HTTP response! (#{debug_info})"
             close
             raise
           end
 
         rescue StandardError => e
-          Jabber::debuglog("POST error (will retry): #{e.class}: #{e}")
+          Jabber::debuglog("POST error (will retry) #{debug_info}: #{e.class}: #{e}, #{e.backtrace}")
           receive_elements_with_rid(current_rid, [])
           # It's not good to resend on *any* exception,
           # but there are too many cases (Timeout, 404, 502)
           # where resending is appropriate
           # TODO: recognize these conditions and act appropriate
+          # FIXME: resending the same data with a new rid is wrong.  should resend with the same rid
           send_data(data)
         end
       end
 
+      ##
+      # Restart stream after SASL authentication
+      def restart
+        Jabber::debuglog("Restarting after SASL")
+        @stream_mechanisms = []
+        @stream_features = {}
+        @features_sem = Semaphore.new
+        send_data('', true) # restart
+      end
+
       ##
       # Send data,
       # buffered and obeying 'polling' and 'requests' limits
-      def send_data(data)
-        @lock.synchronize do
-
-          @send_buffer += data
-          limited_by_polling = (@last_send + @http_polling >= Time.now)
-          limited_by_requests = (@pending_requests + 1 > @http_requests)
-
-          # Can we send?
-          if !limited_by_polling and !limited_by_requests
-            data = @send_buffer
-            @send_buffer = ''
+      def send_data(data, restart = false)
+        Jabber::debuglog("send_data")
+
+        while true do # exit by return
+          @lock.synchronize do
+            if @last_send + 0.05 >= Time.now
+              Jabber::debuglog("send_data too fast: waiting 0.05sec")
+              next
+            end
 
-            Thread.new do
-              Thread.current.abort_on_exception = true
-              post_data(data)
+            @send_buffer += data
+            limited_by_polling = false
+            if @pending_requests + 1 == @http_requests && @send_buffer.size == 0
+              limited_by_polling = (@last_send + @http_polling >= Time.now)
             end
+            limited_by_requests = (@pending_requests + 1 > @http_requests)
 
-          elsif !limited_by_requests
-            Thread.new do
-              Thread.current.abort_on_exception = true
-              # Defer until @http_polling has expired
-              wait = @last_send + @http_polling - Time.now
-              sleep(wait) if wait > 0
-              # Ignore locking, it's already threaded ;-)
-              send_data('')
+            # Can we send?
+            if !limited_by_polling and !limited_by_requests or !@authenticated
+              Jabber::debuglog("send_data non_limited")
+              data = @send_buffer
+              @send_buffer = ''
+
+              Thread.new do
+                Thread.current.abort_on_exception = true
+                post_data(data, restart)
+              end
+              return
+            elsif limited_by_requests
+              Jabber::debuglog("send_data limited by requests")
+              # Do nothing.
+              # When a pending request gets an response, it calls send_data('')
+              return
+            elsif # limited_by_polling && @authenticated
+              # Wait until we get some data to send, or @http_polling expires
+              Jabber::debuglog("send_data limited by polling: #{@http_polling}")
+            else
+              Jabber::errorlog("send_data: can't happen: pending_requests=#{@pending_requests} http_requests=#{@http_requests} send_buffer.size=#{@send_buffer.size} limited_by_polling=#{limited_by_polling} limited_by_requests=#{limited_by_requests}")
+              return
             end
           end
-
+          sleep(0.1)
         end
       end
     end