tp-blather 0.8.2

data/lib/blather/client/dsl/pubsub.rb

@@ -0,0 +1,174 @@
+module Blather
+module DSL
+
+  # A helper class for providing a simplified PubSub interface to the
+  # DSL
+  class PubSub
+    attr_accessor :host
+
+    # Create a new pubsub DSL
+    #
+    # @param [Blather::Client] client the client who's connection will be used
+    # @param [#to_s] host the PubSub host
+    def initialize(client, host)
+      @client = client
+      @host = host
+    end
+
+    # Retrieve Affiliations
+    #
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Hash] affiliations See {Blather::Stanza::PubSub::Affiliations#list}
+    def affiliations(host = nil, &callback)
+      request Stanza::PubSub::Affiliations.new(:get, send_to(host)), :list, callback
+    end
+
+    # Retrieve Subscriptions
+    #
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Hash] affiliations See {Blather::Stanza::PubSub::Subscriptions#list}
+    def subscriptions(host = nil, &callback)
+      request Stanza::PubSub::Subscriptions.new(:get, send_to(host)), :list, callback
+    end
+
+    # Discover Nodes
+    #
+    # @param [#to_s] path the node path
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Array<Blather::Stanza::DiscoItems::Item>] items
+    def nodes(path = nil, host = nil, &callback)
+      path ||= '/'
+      stanza = Stanza::DiscoItems.new(:get, path)
+      stanza.to = send_to(host)
+      request stanza, :items, callback
+    end
+
+    # Discover node information
+    #
+    # @param [#to_s] path the node path
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza::DiscoInfo>] info
+    def node(path, host = nil, &callback)
+      stanza = Stanza::DiscoInfo.new(:get, path)
+      stanza.to = send_to(host)
+      request stanza, nil, callback
+    end
+
+    # Retrieve items for a node
+    #
+    # @param [#to_s] path the node path
+    # @param [Array<#to_s>] list a list of IDs to retrieve
+    # @param [Fixnum, #to_s] max the maximum number of items to return
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Array<Blather::Stanza::PubSub::PubSubItem>] items see {Blather::Stanza::PubSub::Items#items}
+    def items(path, list = [], max = nil, host = nil, &callback)
+      request(
+        Stanza::PubSub::Items.request(send_to(host), path, list, max),
+        :items,
+        callback
+      )
+    end
+
+    # Subscribe to a node
+    #
+    # @param [#to_s] node the node to subscribe to
+    # @param [Blather::JID, #to_s] jid is the jid that should be used.
+    # Defaults to the stripped current JID
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def subscribe(node, jid = nil, host = nil)
+      jid ||= client.jid.stripped
+      stanza = Stanza::PubSub::Subscribe.new(:set, send_to(host), node, jid)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Unsubscribe from a node
+    #
+    # @param [#to_s] node the node to unsubscribe from
+    # @param [Blather::JID, #to_s] jid is the jid that should be used.
+    # Defaults to the stripped current JID
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def unsubscribe(node, jid = nil, subid = nil, host = nil)
+      jid ||= client.jid.stripped
+      stanza = Stanza::PubSub::Unsubscribe.new(:set, send_to(host), node, jid, subid)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Publish an item to a node
+    #
+    # @param [#to_s] node the node to publish to
+    # @param [#to_s] payload the payload to send see {Blather::Stanza::PubSub::Publish}
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def publish(node, payload, host = nil)
+      stanza = Stanza::PubSub::Publish.new(send_to(host), node, :set, payload)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Delete items from a node
+    #
+    # @param [#to_s] node the node to delete from
+    # @param [Array<#to_s>] ids a list of ids to delete
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def retract(node, ids = [], host = nil)
+      stanza = Stanza::PubSub::Retract.new(send_to(host), node, :set, ids)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Create a node
+    #
+    # @param [#to_s] node the node to create
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @param [optional, Blather::Stanza::X] configuration the additional configuration to be set to created node
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def create(node, host = nil, configuration = nil)
+      stanza = Stanza::PubSub::Create.new(:set, send_to(host), node)
+      stanza.configure_node << configuration if configuration
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Purge all node items
+    #
+    # @param [#to_s] node the node to purge
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def purge(node, host = nil)
+      stanza = Stanza::PubSubOwner::Purge.new(:set, send_to(host), node)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+    # Delete a node
+    #
+    # @param [#to_s] node the node to delete
+    # @param [#to_s] host the PubSub host (defaults to the initialized host)
+    # @yield [Blather::Stanza] stanza the reply stanza
+    def delete(node, host = nil)
+      stanza = Stanza::PubSubOwner::Delete.new(:set, send_to(host), node)
+      request(stanza) { |n| yield n if block_given? }
+    end
+
+  private
+    def request(node, method = nil, callback = nil, &block)
+      unless block_given?
+        block = lambda do |node|
+          callback.call(method ? node.__send__(method) : node)
+        end
+      end
+
+      client.write_with_handler(node, &block)
+    end
+
+    def send_to(host = nil)
+      raise 'You must provide a host' unless (host ||= @host)
+      host
+    end
+
+    def client
+      @client
+    end
+  end  # PubSub
+
+end  # DSL
+end  # Blather

data/lib/blather/core_ext/eventmachine.rb

@@ -0,0 +1,125 @@
+# @private
+module EventMachine
+  # @private
+  module Protocols
+    # Basic SOCKS v5 client implementation
+    #
+    # Use as you would any regular connection:
+    #
+    # class MyConn < EM::P::Socks5
+    #   def post_init
+    #     send_data("sup")
+    #   end
+    #
+    #   def receive_data(data)
+    #     send_data("you said: #{data}")
+    #   end
+    # end
+    #
+    # EM.connect socks_host, socks_port, MyConn, host, port
+    #
+    # @private
+    class Socks5 < Connection
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @socks_error_code = nil
+        @buffer = ''
+        @socks_state = :method_negotiation
+        @socks_methods = [0] # TODO: other authentication methods
+        setup_methods
+      end
+
+      def setup_methods
+        class << self
+          def post_init; socks_post_init; end
+          def receive_data(*a); socks_receive_data(*a); end
+        end
+      end
+
+      def restore_methods
+        class << self
+          remove_method :post_init
+          remove_method :receive_data
+        end
+      end
+
+      def socks_post_init
+        packet = [5, @socks_methods.size].pack('CC') + @socks_methods.pack('C*')
+        send_data(packet)
+      end
+
+      def socks_receive_data(data)
+        @buffer << data
+
+        if @socks_state == :method_negotiation
+          return if @buffer.size < 2
+
+          header_resp = @buffer.slice! 0, 2
+          _, method_code = header_resp.unpack("cc")
+
+          if @socks_methods.include?(method_code)
+            @socks_state = :connecting
+            packet = [5, 1, 0].pack("C*")
+
+            if @host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/ # IPv4
+              packet << [1, $1.to_i, $2.to_i, $3.to_i, $4.to_i].pack("C*")
+            elsif @host.include?(":") # IPv6
+              l, r = if @host =~ /^(.*)::(.*)$/
+                [$1,$2].map {|i| i.split ":"}
+              else
+                [@host.split(":"),[]]
+              end
+              dec_groups = (l + Array.new(8-l.size-r.size, '0') + r).map {|i| i.hex}
+              packet << ([4] + dec_groups).pack("Cn8")
+            else # Domain
+              packet << [3, @host.length, @host].pack("CCA*")
+            end
+            packet << [@port].pack("n")
+
+            send_data packet
+          else
+            @socks_state = :invalid
+            @socks_error_code = method_code
+            close_connection
+            return
+          end
+        elsif @socks_state == :connecting
+          return if @buffer.size < 4
+
+          header_resp = @buffer.slice! 0, 4
+          _, response_code, _, address_type = header_resp.unpack("C*")
+
+          if response_code == 0
+            case address_type
+            when 1
+              @buffer.slice! 0, 4
+            when 3
+              len = @buffer.slice! 0, 1
+              @buffer.slice! 0, len.unpack("C").first
+            when 4
+              @buffer.slice! 0, 16
+            else
+              @socks_state = :invalid
+              @socks_error_code = address_type
+              close_connection
+              return
+            end
+            @buffer.slice! 0, 2
+
+            @socks_state = :connected
+            restore_methods
+
+            post_init
+            receive_data(@buffer) unless @buffer.empty?
+          else
+            @socks_state = :invalid
+            @socks_error_code = response_code
+            close_connection
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/blather/core_ext/ipaddr.rb

@@ -0,0 +1,20 @@
+# @private
+class IPAddr
+  PrivateRanges = [
+    IPAddr.new("10.0.0.0/8"),
+    IPAddr.new("172.16.0.0/12"),
+    IPAddr.new("192.168.0.0/16")
+  ]
+
+  def private?
+    return false unless self.ipv4?
+    PrivateRanges.each do |ipr|
+      return true if ipr.include?(self)
+    end
+    return false
+  end
+
+  def public?
+    !private?
+  end
+end

data/lib/blather/errors.rb

@@ -0,0 +1,69 @@
+module Blather
+  # Main error class
+  # This starts the error hierarchy
+  #
+  # @handler :error
+  class BlatherError < StandardError
+    class_attribute :handler_hierarchy
+    self.handler_hierarchy ||= []
+
+    # @private
+    @@handler_list = []
+
+    # Register the class's handler
+    #
+    # @param [Symbol] handler the handler name
+    def self.register(handler)
+      @@handler_list << handler
+      self.handler_hierarchy = [handler] + self.handler_hierarchy
+    end
+
+    # The list of registered handlers
+    #
+    # @return [Array<Symbol>] a list of currently registered handlers
+    def self.handler_list
+      @@handler_list
+    end
+
+    register :error
+
+    # @private
+    # HACK!! until I can refactor the entire Error object model
+    def id
+      nil
+    end
+  end  # BlatherError
+
+  # Used in cases where a stanza only allows specific values for its attributes
+  # and an invalid value is attempted.
+  #
+  # @handler :argument_error
+  class ArgumentError < BlatherError
+    register :argument_error
+  end  # ArgumentError
+
+  # The stream handler received a response it didn't know how to handle
+  #
+  # @handler :unknown_response_error
+  class UnknownResponse < BlatherError
+    register :unknown_response_error
+    attr_reader :node
+
+    def initialize(node)
+      @node = node
+    end
+  end  # UnknownResponse
+
+  # Something bad happened while parsing the incoming stream
+  #
+  # @handler :parse_error
+  class ParseError < BlatherError
+    register :parse_error
+    attr_reader :message
+
+    def initialize(msg)
+      @message = msg.to_s
+    end
+  end  # ParseError
+
+end  # Blather

data/lib/blather/errors/sasl_error.rb

@@ -0,0 +1,44 @@
+module Blather
+
+# General SASL Errors
+# Check #name for the error name
+#
+# @handler :sasl_error
+class SASLError < BlatherError
+  # @private
+  SASL_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
+  class_attribute :err_name
+  # @private
+  @@registrations = {}
+
+  register :sasl_error
+
+  # Import the stanza
+  #
+  # @param [Blather::XMPPNode] node the error node
+  # @return [Blather::SASLError]
+  def self.import(node)
+    self.new node
+  end
+
+  # Create a new SASLError
+  #
+  # @param [Blather::XMPPNode] node the error node
+  def initialize(node)
+    super()
+    @node = node
+  end
+
+  # The actual error name
+  #
+  # @return [Symbol] a symbol representing the error name
+  def name
+    if @node
+      name = @node.find_first('ns:*', :ns => SASL_ERR_NS).element_name
+      name.gsub('-', '_').to_sym
+    end
+  end
+end  # SASLError
+
+end  # Blather

data/lib/blather/errors/stanza_error.rb

@@ -0,0 +1,110 @@
+module Blather
+
+# Stanza errors
+# RFC3920 Section 9.3 (http://xmpp.org/rfcs/rfc3920.html#stanzas-error)
+#
+# @handler :stanza_error
+class StanzaError < BlatherError
+  # @private
+  STANZA_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+  # @private
+  VALID_TYPES = [:cancel, :continue, :modify, :auth, :wait].freeze
+
+  register :stanza_error
+
+  attr_reader :original, :name, :type, :text, :extras
+
+  # Factory method for instantiating the proper class for the error
+  #
+  # @param [Blather::XMPPNode] node the error node to import
+  # @return [Blather::StanzaError]
+  def self.import(node)
+    original = node.copy
+    original.remove_child 'error'
+
+    error_node = node.find_first '//*[local-name()="error"]'
+
+    name = error_node.find_first('child::*[name()!="text"]', STANZA_ERR_NS).element_name
+    type = error_node['type']
+    text = node.find_first 'descendant::*[name()="text"]', STANZA_ERR_NS
+    text = text.content if text
+
+    extras = error_node.find("descendant::*[name()!='text' and name()!='#{name}']").map { |n| n }
+
+    self.new original, name, type, text, extras
+  end
+
+  # Create a new StanzaError
+  #
+  # @param [Blather::XMPPNode] original the original stanza
+  # @param [String] name the error name
+  # @param [#to_s] type the error type as specified in
+  # [RFC3920](http://xmpp.org/rfcs/rfc3920.html#rfc.section.9.3.2)
+  # @param [String, nil] text additional text for the error
+  # @param [Array<Blather::XMPPNode>] extras an array of extra nodes to add
+  def initialize(original, name, type, text = nil, extras = [])
+    @original = original
+    @name = name
+    self.type = type
+    @text = text
+    @extras = extras
+  end
+
+  # Set the error type
+  #
+  # @param [#to_sym] type the new error type. Must be on of
+  # Blather::StanzaError::VALID_TYPES
+  # @see [RFC3920 Section 9.3.2](http://xmpp.org/rfcs/rfc3920.html#rfc.section.9.3.2)
+  def type=(type)
+    type = type.to_sym
+    if !VALID_TYPES.include?(type)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+    end
+    @type = type
+  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 = self.original.reply
+    node.type = 'error'
+    node << (error_node = XMPPNode.new('error'))
+
+    error_node << (err = XMPPNode.new(@name, error_node.document))
+    error_node['type'] = self.type
+    err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+
+    if self.text
+      error_node << (text = XMPPNode.new('text', error_node.document))
+      text.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+      text.content = self.text
+    end
+
+    self.extras.each { |extra| error_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
+    "Stanza Error (#{@name}): #{self.text} [#{self.extras}]"
+  end
+  # @private
+  alias_method :to_s, :inspect
+end  # StanzaError
+
+end  # Blather