tp-blather 0.8.2

data/lib/blather/errors/stream_error.rb

@@ -0,0 +1,84 @@
+module Blather
+
+# Stream Errors
+# [RFC3920 Section 9.3](http://xmpp.org/rfcs/rfc3920.html#streams-error-rules)
+#
+# @handler :stream_error
+class StreamError < BlatherError
+  # @private
+  STREAM_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-streams'
+
+  register :stream_error
+
+  attr_reader :text, :extras
+
+  # Factory method for instantiating the proper class for the error
+  #
+  # @param [Blather::XMPPNode] node the importable node
+  def self.import(node)
+    name = node.find_first('descendant::*[name()!="text"]', STREAM_ERR_NS).element_name
+
+    text = node.find_first 'descendant::*[name()="text"]', STREAM_ERR_NS
+    text = text.content if text
+
+    extras = node.find("descendant::*[namespace-uri()!='#{STREAM_ERR_NS}']").map { |n| n }
+
+    self.new name, text, extras
+  end
+
+  # Create a new Stream Error
+  # [RFC3920 Section 4.7.2](http://xmpp.org/rfcs/rfc3920.html#rfc.section.4.7.2)
+  #
+  # @param [String] name the error name
+  # @param [String, nil] text optional error text
+  # @param [Array<Blather::XMPPNode>] extras an array of extras to attach to the
+  # error
+  def initialize(name, text = nil, extras = [])
+    @name = name
+    @text = text
+    @extras = extras
+  end
+
+  # The error name
+  #
+  # @return [Symbol]
+  def name
+    @name.gsub('-','_').to_sym
+  end
+
+  # Creates an XML node from the error
+  #
+  # @return [Blather::XMPPNode]
+  def to_node
+    node = XMPPNode.new('error')
+    node.namespace = {'stream' => Blather::Stream::STREAM_NS}
+
+    node << (err = XMPPNode.new(@name, node.document))
+    err.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+
+    if self.text
+      node << (text = XMPPNode.new('text', node.document))
+      text.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+      text.content = self.text
+    end
+
+    self.extras.each { |extra| node << extra.dup }
+    node
+  end
+
+  # Convert the object to a proper node then convert it to a string
+  #
+  # @return [String]
+  def to_xml
+    to_node.to_s
+  end
+
+  # @private
+  def inspect
+    "Stream Error (#{@name}): #{self.text}" + (self.extras.empty? ? '' : " [#{self.extras}]")
+  end
+  # @private
+  alias_method :to_s, :inspect
+end  # StreamError
+
+end  # Blather

data/lib/blather/file_transfer.rb

@@ -0,0 +1,107 @@
+module Blather
+  # File Transfer helper
+  # Takes care of accepting, declining and offering file transfers through the stream
+  class FileTransfer
+
+    # Set this to false if you don't want to use In-Band Bytestreams
+    attr_accessor :allow_ibb
+
+    # Set this to false if you don't want to use SOCKS5 Bytestreams
+    attr_accessor :allow_s5b
+
+    # Set this to true if you want SOCKS5 Bytestreams to attempt to use private network addresses
+    attr_accessor :allow_private_ips
+    
+    # Create a new FileTransfer
+    #
+    # @param [Blather::Stream] stream the stream the file transfer should use
+    # @param [Blather::Stanza::Iq::Si] iq a si iq used to stream-initiation
+    def initialize(stream, iq = nil)
+      @stream = stream
+      @allow_s5b = true
+      @allow_ibb = true
+
+      @iq = iq
+    end
+
+    # Accept an incoming file-transfer
+    #
+    # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+    # @param [Array] params the params to be passed into the handler
+    def accept(handler, *params)
+      answer = @iq.reply
+
+      answer.si.feature.x.type = :submit
+
+      supported_methods = @iq.si.feature.x.field("stream-method").options.map(&:value)
+      if supported_methods.include?(Stanza::Iq::S5b::NS_S5B) and @allow_s5b
+        answer.si.feature.x.fields = {:var => 'stream-method', :value => Stanza::Iq::S5b::NS_S5B}
+
+        @stream.register_handler :s5b_open, :from => @iq.from do |iq|
+          transfer = Blather::FileTransfer::S5b.new(@stream, iq)
+          transfer.allow_ibb_fallback = true if @allow_ibb
+          transfer.allow_private_ips = true if @allow_private_ips
+          transfer.accept(handler, *params)
+          true
+        end
+
+        @stream.write answer
+      elsif supported_methods.include?(Stanza::Iq::Ibb::NS_IBB) and @allow_ibb
+        answer.si.feature.x.fields = {:var => 'stream-method', :value => Stanza::Iq::Ibb::NS_IBB}
+
+        @stream.register_handler :ibb_open, :from => @iq.from do |iq|
+          transfer = Blather::FileTransfer::Ibb.new(@stream, iq)
+          transfer.accept(handler, *params)
+          true
+        end
+
+        @stream.write answer
+      else
+        reason = XMPPNode.new('no-valid-streams')
+        reason.namespace = Blather::Stanza::Iq::Si::NS_SI
+
+        @stream.write StanzaError.new(@iq, 'bad-request', 'cancel', nil, [reason]).to_node
+      end
+    end
+
+    # Decline an incoming file-transfer
+    def decline
+      answer = StanzaError.new(@iq, 'forbidden', 'cancel', 'Offer declined').to_node
+
+      @stream.write answer
+    end
+
+    # Offer a file to somebody, not implemented yet
+    def offer
+      # TODO: implement
+    end
+
+    # Simple handler for incoming file transfers
+    #
+    # You can define your own handler and pass it to the accept method.
+    module SimpleFileReceiver
+      def initialize(path, size)
+        @path = path
+        @size = size
+        @transferred = 0
+      end
+
+      # @private
+      def post_init
+        @file = File.open(@path, "w")
+      end
+
+      # @private
+      def receive_data(data)
+        @transferred += data.size
+        @file.write data
+      end
+
+      # @private
+      def unbind
+        @file.close
+        File.delete(@path) unless @transferred == @size
+      end
+    end
+  end
+end

data/lib/blather/file_transfer/ibb.rb

@@ -0,0 +1,68 @@
+require "base64"
+
+module Blather
+  class FileTransfer
+    # In-Band Bytestreams Transfer helper
+    # Takes care of accepting, declining and offering file transfers through the stream
+    class Ibb
+      def initialize(stream, iq)
+        @stream = stream
+        @iq = iq
+        @seq = 0
+      end
+
+      # Accept an incoming file-transfer
+      #
+      # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+      # @param [Array] params the params to be passed into the handler
+      def accept(handler, *params)
+        @io_read, @io_write = IO.pipe
+        EM::attach @io_read, handler, *params
+
+        @stream.register_handler :ibb_data, :from => @iq.from, :sid => @iq.sid do |iq|
+          if iq.data['seq'] == @seq.to_s
+            begin
+              @io_write << Base64.decode64(iq.data.content)
+
+              @stream.write iq.reply
+
+              @seq += 1
+              @seq = 0 if @seq > 65535
+            rescue Errno::EPIPE => e
+              @stream.write StanzaError.new(iq, 'not-acceptable', :cancel).to_node
+            end
+          else
+            @stream.write StanzaError.new(iq, 'unexpected-request', :wait).to_node
+          end
+          true
+        end
+
+        @stream.register_handler :ibb_close, :from => @iq.from, :sid => @iq.sid do |iq|
+          @stream.write iq.reply
+          @stream.clear_handlers :ibb_data, :from => @iq.from, :sid => @iq.sid
+          @stream.clear_handlers :ibb_close, :from => @iq.from, :sid => @iq.sid
+
+          @io_write.close
+          true
+        end
+
+        @stream.clear_handlers :ibb_open, :from => @iq.from
+        @stream.clear_handlers :ibb_open, :from => @iq.from, :sid => @iq.sid
+        @stream.write @iq.reply
+      end
+
+      # Decline an incoming file-transfer
+      def decline
+        @stream.clear_handlers :ibb_open, :from => @iq.from
+        @stream.clear_handlers :ibb_data, :from => @iq.from, :sid => @iq.sid
+        @stream.clear_handlers :ibb_close, :from => @iq.from, :sid => @iq.sid
+        @stream.write StanzaError.new(@iq, 'not-acceptable', :cancel).to_node
+      end
+
+      # Offer a file to somebody, not implemented yet
+      def offer
+        # TODO: implement
+      end
+    end
+  end
+end

data/lib/blather/file_transfer/s5b.rb

@@ -0,0 +1,114 @@
+module Blather
+  class FileTransfer
+    # SOCKS5 Bytestreams Transfer helper
+    # Takes care of accepting, declining and offering file transfers through the stream
+    class S5b
+
+      # Set this to false if you don't want to fallback to In-Band Bytestreams
+      attr_accessor :allow_ibb_fallback
+
+      # Set this to true if the buddies of your bot will be in the same local network
+      #
+      # Usually IM clients advertise all network addresses which they can determine.
+      # Skipping the local ones can save time if your bot is not in the same local network as it's buddies
+      attr_accessor :allow_private_ips
+
+      def initialize(stream, iq)
+        @stream = stream
+        @iq = iq
+        @allow_ibb_fallback = true
+        @allow_private_ips = false
+      end
+
+      # Accept an incoming file-transfer
+      #
+      # @param [module] handler the handler for incoming data, see Blather::FileTransfer::SimpleFileReceiver for an example
+      # @param [Array] params the params to be passed into the handler
+      def accept(handler, *params)
+        @streamhosts = @iq.streamhosts
+        @streamhosts.delete_if {|s| begin IPAddr.new(s.host).private? rescue false end } unless @allow_private_ips
+        @socket_address = Digest::SHA1.hexdigest("#{@iq.sid}#{@iq.from}#{@iq.to}")
+
+        @handler = handler
+        @params = params
+
+        connect_next_streamhost
+        @stream.clear_handlers :s5b_open, :from => @iq.from
+      end
+
+      # Decline an incoming file-transfer
+      def decline
+        @stream.clear_handlers :s5b_open, :from => @iq.from
+        @stream.write StanzaError.new(@iq, 'not-acceptable', :auth).to_node
+      end
+
+      # Offer a file to somebody, not implemented yet
+      def offer
+        # TODO: implement
+      end
+
+      private
+
+      def connect_next_streamhost
+        if streamhost = @streamhosts.shift
+          connect(streamhost)
+        else
+          if @allow_ibb_fallback
+            @stream.register_handler :ibb_open, :from => @iq.from, :sid => @iq.sid do |iq|
+              transfer = Blather::FileTransfer::Ibb.new(@stream, iq)
+              transfer.accept(@handler, *@params)
+              true
+            end
+          end
+
+          @stream.write StanzaError.new(@iq, 'item-not-found', :cancel).to_node
+        end
+      end
+
+      def connect(streamhost)
+        begin
+          socket = EM.connect streamhost.host, streamhost.port, SocketConnection, @socket_address, 0, @handler, *@params
+
+          socket.callback do
+            answer = @iq.reply
+            answer.streamhosts = nil
+            answer.streamhost_used = streamhost.jid
+
+            @stream.write answer
+          end
+
+          socket.errback do
+            connect_next_streamhost
+          end
+        rescue EventMachine::ConnectionError => e
+          connect_next_streamhost
+        end
+      end
+
+      # @private
+      class SocketConnection < EM::P::Socks5
+        include EM::Deferrable
+
+        def initialize(host, port, handler, *params)
+          super(host, port)
+          @@handler = handler
+          @params = params
+        end
+
+        def post_init
+          self.succeed
+          
+          class << self
+            include @@handler
+          end
+          send(:initialize, *@params)
+          post_init
+        end
+
+        def unbind
+          self.fail if @socks_state != :connected
+        end
+      end
+    end
+  end
+end

data/lib/blather/jid.rb

@@ -0,0 +1,141 @@
+module Blather
+
+  # Jabber ID or JID
+  #
+  # See [RFC 3920 Section 3 - Addressing](http://xmpp.org/rfcs/rfc3920.html#addressing)
+  #
+  # An entity is anything that can be considered a network endpoint (i.e., an
+  # ID on the network) and that can communicate using XMPP. All such entities
+  # are uniquely addressable in a form that is consistent with RFC 2396 [URI].
+  # For historical reasons, the address of an XMPP entity is called a Jabber
+  # Identifier or JID. A valid JID contains a set of ordered elements formed
+  # of a domain identifier, node identifier, and resource identifier.
+  #
+  # The syntax for a JID is defined below using the Augmented Backus-Naur Form
+  # as defined in [ABNF]. (The IPv4address and IPv6address rules are defined
+  # in Appendix B of [IPv6]; the allowable character sequences that conform to
+  # the node rule are defined by the Nodeprep profile of [STRINGPREP] as
+  # documented in Appendix A of this memo; the allowable character sequences
+  # that conform to the resource rule are defined by the Resourceprep profile
+  # of [STRINGPREP] as documented in Appendix B of this memo; and the
+  # sub-domain rule makes reference to the concept of an internationalized
+  # domain label as described in [IDNA].)
+  #
+  #     jid             = [ node "@" ] domain [ "/" resource ]
+  #     domain          = fqdn / address-literal
+  #     fqdn            = (sub-domain 1*("." sub-domain))
+  #     sub-domain      = (internationalized domain label)
+  #     address-literal = IPv4address / IPv6address
+  #
+  # All JIDs are based on the foregoing structure. The most common use of this
+  # structure is to identify an instant messaging user, the server to which
+  # the user connects, and the user's connected resource (e.g., a specific
+  # client) in the form of <user@host/resource>. However, node types other
+  # than clients are possible; for example, a specific chat room offered by a
+  # multi-user chat service could be addressed as <room@service> (where "room"
+  # is the name of the chat room and "service" is the hostname of the
+  # multi-user chat service) and a specific occupant of such a room could be
+  # addressed as <room@service/nick> (where "nick" is the occupant's room
+  # nickname). Many other JID types are possible (e.g., <domain/resource>
+  # could be a server-side script or service).
+  #
+  # Each allowable portion of a JID (node identifier, domain identifier, and
+  # resource identifier) MUST NOT be more than 1023 bytes in length, resulting
+  # in a maximum total size (including the '@' and '/' separators) of 3071
+  # bytes.
+  class JID
+    include Comparable
+
+    # Validating pattern for JID string
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/.freeze
+
+    attr_reader :node,
+                :domain,
+                :resource
+
+    # @private
+    def self.new(node, domain = nil, resource = nil)
+      node.is_a?(JID) ? node : super
+    end
+
+    # Create a new JID object
+    #
+    # @overload initialize(jid)
+    #   Passes the jid object right back out
+    #   @param [Blather::JID] jid a jid object
+    # @overload initialize(jid)
+    #   Creates a new JID parsed out of the provided jid
+    #   @param [String] jid a jid in the standard format
+    #   ("node@domain/resource")
+    # @overload initialize(node, domain = nil, resource = nil)
+    #   Creates a new JID
+    #   @param [String] node the node of the JID
+    #   @param [String, nil] domian the domain of the JID
+    #   @param [String, nil] resource the resource of the JID
+    # @raise [ArgumentError] if the parts of the JID are too large (1023 bytes)
+    # @return [Blather::JID] a new jid object
+    def initialize(node, domain = nil, resource = nil)
+      @resource = resource
+      @domain = domain
+      @node = node
+
+      if @domain.nil? && @resource.nil?
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+
+      raise ArgumentError, 'Node too long' if (@node || '').length > 1023
+      raise ArgumentError, 'Domain too long' if (@domain || '').length > 1023
+      raise ArgumentError, 'Resource too long' if (@resource || '').length > 1023
+    end
+
+    # Turn the JID into a string
+    #
+    # * ""
+    # * "domain"
+    # * "node@domain"
+    # * "domain/resource"
+    # * "node@domain/resource"
+    #
+    # @return [String] the JID as a string
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s = "#{s}/#{@resource}" if @resource
+      s
+    end
+
+    # Returns a new JID with resource removed.
+    #
+    # @return [Blather::JID] a new JID without a resource
+    def stripped
+      dup.strip!
+    end
+
+    # Removes the resource (sets it to nil)
+    #
+    # @return [Blather::JID] the JID without a resource
+    def strip!
+      @resource = nil
+      self
+    end
+
+    # Compare two JIDs, helpful for sorting etc.
+    #
+    # String representations are compared, see JID#to_s
+    #
+    # @param [#to_s] other a JID to comare against
+    # @return [Fixnum<-1, 0, 1>]
+    def <=>(other)
+      to_s.downcase <=> other.to_s.downcase
+    end
+    alias_method :eql?, :==
+
+    # Test if JID is stripped
+    #
+    # @return [true, false]
+    def stripped?
+      @resource.nil?
+    end
+  end  # JID
+
+end  # Blather