mad-p-xmpp4r 0.6.0

data/lib/xmpp4r/framework/bot.rb

@@ -0,0 +1,148 @@
+require 'xmpp4r/framework/base'
+
+require 'xmpp4r'
+require 'xmpp4r/roster'
+require 'xmpp4r/caps/c'
+require 'xmpp4r/discovery'
+require 'xmpp4r/xhtml'
+
+module Jabber
+  module Framework
+    ##
+    # Abstract handler methods that *may* be implemented by a deriving class:
+    # * on_message(text)
+    # * on_message_xhtml(html_body, text)
+    class Bot < Base
+      helper :roster, Roster::Helper
+      helper(:disco_default) { |cl|
+        Discovery::Responder.new(cl,
+                                 nil,
+                                 [Jabber::Discovery::Identity.new('client', 'XMPP4R Bot', 'bot')]
+                                 )
+      }
+      helper(:disco_caps) { |cl|
+        Discovery::Responder.new(cl,
+                                 "http://home.gna.org/xmpp4r/#{Jabber::XMPP4R_VERSION}",
+                                 [Jabber::Discovery::Identity.new('client', 'XMPP4R Bot', 'bot')]
+                                 )
+      }
+
+      def initialize(jid, password)
+        cl = Jabber::Client.new(jid)
+        cl.connect
+        cl.auth(password)
+
+        super(cl)
+
+        roster.add_subscription_request_callback do |item,presence|
+          if accept_subscription_from?(presence.from.strip)
+            roster.accept_subscription(presence.from.strip)
+          else
+            roster.decline_subscription(presence.from.strip)
+          end
+        end
+
+        @pep_notifications = []
+        cl.add_message_callback do |msg|
+          if msg.type != :error and msg.body
+            if (html = msg.first_element('html')) and respond_to? :on_message_xhtml
+              on_message_xhtml(html.body, msg.body)
+            elsif respond_to? :on_message
+              on_message(msg.body)
+            end
+          elsif msg.type != :error and (event = msg.first_element('event'))
+            event.each_element('items') do |items|
+              node = items.attributes['node']
+              items.each_element('item') do |item|
+                @pep_notifications.each { |notification_node,callback|
+                  if node == notification_node
+                    callback.call(msg.from, item)
+                  end
+                }
+              end
+            end
+          else
+            false
+          end
+        end
+
+        add_cap('presence')
+        add_cap(Caps::NS_CAPS)
+        add_cap('message') if respond_to? :on_message
+        add_cap(XHTML::NS_XHTML_IM) if respond_to? :on_message_xhtml
+
+        @presence_show = nil
+        @presence_status = nil
+      end
+
+      ##
+      # Add feature namespace to Capabilities Discovery
+      def add_cap(capability)
+        disco_default.add_feature(capability)
+        disco_caps.add_feature(capability)
+      end
+
+      ##
+      # Front-end for Roster::Helper#add_subscription_request_callback
+      #
+      # Can be overwritten, must return true or false
+      def accept_subscription_from?(jid)
+        true
+      end
+
+      ##
+      # Send a simple text chat message
+      def send_message(to, text)
+        msg = Message.new
+        msg.type = :chat
+        msg.to = to
+        msg.body = text
+        @stream.send(msg)
+      end
+
+      ##
+      # Send an XHTML chat message
+      # text:: [String] alternate plain text body, generated from xhtml_contents if nil
+      def send_message_xhtml(to, xhtml_contents, text=nil)
+        msg = Message.new
+        msg.type = :chat
+        msg.to = to
+        html = msg.add(XHTML::HTML.new(xhtml_contents))
+        msg.body = text ? text : html.to_text
+        @stream.send(msg)
+      end
+
+      ##
+      # Set and send a Presence
+      def set_presence(show=nil, status=nil)
+        @presence_show = show
+        @presence_status = status
+        send_presence
+      end
+
+      private
+
+      def send_presence
+        roster.wait_for_roster
+
+        # TODO: vcard photo hash
+        if @presence_show == :unavailable
+          presence = Presence.new(nil, @presence_status)
+          presence.type = :unavailable
+        else
+          presence = Presence.new(@presence_show, @presence_status)
+        end
+        presence.add(disco_caps.generate_caps)
+        @stream.send(presence)
+      end
+
+      public
+
+      def add_pep_notification(node, &callback)
+        add_cap("#{node}+notify")
+        @pep_notifications << [node, callback]
+      end
+    end
+
+  end
+end

data/lib/xmpp4r/httpbinding.rb

@@ -0,0 +1,5 @@
+# =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/httpbinding/client'

data/lib/xmpp4r/httpbinding/client.rb

@@ -0,0 +1,384 @@
+# =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/
+
+# TODO: eval  <body type='terminate' condition=
+
+require 'xmpp4r/client'
+require 'xmpp4r/semaphore'
+require 'net/http'
+require 'uri'
+require 'cgi' # for escaping
+require 'pry'
+
+module Jabber
+  module HTTPBinding
+    ##
+    # This class implements an alternative Client
+    # using HTTP Binding (JEP0124).
+    #
+    # This class is designed to be a drop-in replacement
+    # for Jabber::Client, except for the
+    # Jabber::HTTP::Client#connect method which takes an URI
+    # as argument.
+    #
+    # HTTP requests are buffered to not exceed the negotiated
+    # 'polling' and 'requests' parameters.
+    #
+    # Stanzas in HTTP resonses may be delayed to arrive in the
+    # order defined by 'rid' parameters.
+    #
+    # =Debugging
+    # Turning Jabber::debug to true will make debug output
+    # not only spit out stanzas but HTTP request/response
+    # bodies, too.
+    class Client < Jabber::Client
+
+      # Content-Type to be used for communication
+      # (you can set this to "text/html")
+      attr_accessor :http_content_type
+      # The server should wait this value seconds if
+      # there is no stanza to be received
+      attr_accessor :http_wait
+      # 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
+      # jid:: [JID or String]
+      def initialize(jid)
+        super
+
+        @lock = Mutex.new
+        @pending_requests = 0
+        @last_send = Time.at(0)
+        @send_buffer = ''
+
+        @http_requests = 1
+        @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
+
+      ##
+      # Set up the stream using uri as the HTTP Binding URI
+      #
+      # You may optionally pass host and port parameters
+      # to make use of the JEP0124 'route' feature.
+      #
+      # uri:: [URI::Generic or String]
+      # host:: [String] Optional host to route to
+      # port:: [Fixnum] Port for route feature
+      def connect(uri, host=nil, port=5222)
+        uri = URI::parse(uri) unless uri.kind_of? URI::Generic
+        @uri = uri
+
+        @allow_tls = false  # Shall be done at HTTP level
+        @stream_mechanisms = []
+        @stream_features = {}
+        @http_rid = IdGenerator.generate_id.to_i
+        @pending_rid = @http_rid
+        @pending_rid_lock = Semaphore.new
+
+        req_body = REXML::Element.new('body')
+        req_body.attributes['rid'] = @http_rid
+        req_body.attributes['content'] = @http_content_type
+        req_body.attributes['hold'] = @http_hold.to_s
+        req_body.attributes['wait'] = @http_wait.to_s
+        req_body.attributes['to'] = @jid.domain
+        if host
+          req_body.attributes['route'] = "xmpp:#{host}:#{port}"
+        end
+        req_body.attributes['secure'] = 'true'
+        req_body.attributes['xmlns'] = 'http://jabber.org/protocol/httpbind'
+        res_body = post(req_body)
+        unless res_body.name == 'body'
+          raise 'Response body is no <body/> element'
+        end
+
+        @streamid = res_body.attributes['authid']
+        @status = CONNECTED
+        @http_sid = res_body.attributes['sid']
+        @http_wait = res_body.attributes['wait'].to_i if res_body.attributes['wait']
+        @http_hold = res_body.attributes['hold'].to_i if res_body.attributes['hold']
+        @http_inactivity = res_body.attributes['inactivity'].to_i
+        @http_polling = res_body.attributes['polling'].to_i
+        @http_polling = 5 if @http_polling == 0
+        @http_requests = res_body.attributes['requests'].to_i
+        @http_requests = 1 if @http_requests == 0
+
+        receive_elements_with_rid(@http_rid, res_body.children)
+
+        @features_sem.run
+      end
+
+      ##
+      # Ensure that there is one pending request
+      #
+      # Will be automatically called if you've sent
+      # a stanza.
+      def ensure_one_pending_request
+        return if is_disconnected?
+
+        if @lock.synchronize { @pending_requests } < 1
+          send_data('')
+        end
+      end
+
+      ##
+      # Close the session by sending
+      # <body type='terminate'/>
+      def close
+        @status = DISCONNECTED
+        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)
+        sleep(3)
+        Jabber::debuglog("Connection closed")
+      end
+
+      private
+
+      ##
+      # 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
+        end
+        @pending_rid = rid + 1
+
+        elements.each { |e|
+          receive(e)
+        }
+
+        @pending_rid_lock.run
+      end
+
+      ##
+      # Do a POST request
+      def post(body)
+        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}/#{@http_requests}):\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}/#{@http_requests}): #{response.class}\n#{response.body}")
+
+        unless response.kind_of? Net::HTTPSuccess
+          # Unfortunately, HTTPResponses aren't exceptions
+          # TODO: rescue'ing code should be able to distinguish
+          raise Net::HTTPBadResponse, "#{response.class}"
+        end
+
+        body = REXML::Document.new(response.body).root
+        if body.name != 'body' and body.namespace != 'http://jabber.org/protocol/httpbind'
+          raise REXML::ParseException.new('Malformed body')
+        end
+        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, restart = false)
+        req_body = nil
+        current_rid = nil
+
+        begin
+          begin
+            @lock.synchronize {
+              # Do not send unneeded requests
+              if data.size < 1 and @pending_requests > 0 and !restart
+		@pending_requests += 1 # compensate for decrement in ensure clause
+                return
+              end
+
+              req_body = "<body"
+              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 unless restart
+              req_body += "</body>"
+              current_rid = @http_rid
+
+              @pending_requests += 1
+              @last_send = Time.now
+            }
+
+            res_body = post(req_body)
+
+          ensure
+            @lock.synchronize {
+              @pending_requests -= 1
+            }
+          end
+
+          receive_elements_with_rid(current_rid, res_body.children)
+          ensure_one_pending_request if @authenticated
+
+        rescue REXML::ParseException
+          if @exception_block
+            Thread.new do
+              Thread.current.abort_on_exception = true
+              close; @exception_block.call(e, self, :parser)
+            end
+          else
+            Jabber::debuglog "Exception caught when parsing HTTP response!"
+            close
+            raise
+          end
+
+        rescue StandardError => e
+          Jabber::debuglog("POST error (will retry): #{e.class}: #{e}")
+          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
+          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, restart = false)
+        @lock.synchronize do
+          Jabber::debuglog("send_data")
+
+          @send_buffer += data
+          limited_by_polling = false
+          if @pending_requests + 1 == @http_requests
+            limited_by_polling = (@last_send + @http_polling >= Time.now)
+          end
+          limited_by_requests = (@pending_requests + 1 > @http_requests)
+
+          # 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
+              sleep(0.05)
+              post_data(data, restart)
+            end
+
+          elsif !limited_by_requests
+            Jabber::debuglog("send_data limited")
+            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('', restart)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end