cancer 0.1.0.a1

data/lib/cancer/xeps/xep_0050_commands.rb

@@ -0,0 +1,256 @@
+
+module Cancer
+  # Ad-Hoc Commands
+  # http://xmpp.org/extensions/xep-0050.html
+  module XEP_0050
+    include Cancer::XEP
+    
+    NS  = "http://jabber.org/protocol/commands"
+    NAMESPACES = { 'c' => CLIENT_NS, 'cmd' => NS, 'x' => Cancer::XEP_0004::NS }
+    
+    dependency 'core'
+    dependency 'xep-0004'
+    dependency 'xep-0030'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0050::StreamHelpers
+      end
+      stream.install_controller   Cancer::XEP_0050::Controller
+      stream.install_event_helper Cancer::XEP_0050::EventDSL
+      stream.disco.feature(NS)
+    end
+    
+    module StreamHelpers
+      
+      def commands_provided_by(peer)
+        disco_items_for(peer, NS).inject({}) { |commands, item| commands[item['node'].to_s] = item['name'].to_s ; commands }
+      end
+      
+      def command(to, node)
+        session = RemoteSession.new(self, to, node)
+        yield(session) if block_given?
+        session
+      end
+      
+      def register_command(uri, name=nil)
+        @disco_commands ||= disco.item(:node => NS, :jid => self.options[:jid])
+        @disco_commands.item(:node => uri, :name => name, :jid => self.options[:jid])
+      end
+      
+    end
+    
+    class RemoteSession
+      attr_reader :peer, :node, :id, :status, :allowed_actions, :execute_action
+      
+      def initialize(stream, peer, node)
+        @stream, @peer, @node = stream, peer, node
+        @status = @id = nil
+        @allowed_actions = [:execute]
+        @execute_action  = :execute
+        @stages = []
+      end
+      
+      def send(action, form=nil)
+        unless @allowed_actions.include?(action.to_sym)
+          raise "Action #{action} is not allowed (#{@allowed_actions.join(', ')})"
+        end
+        
+        attributes = {:xmlns => NS, :node => @node, :action => action}
+        attributes[:sessionid] = @id if @id
+        result = @stream.send_iq(@peer, :set) do |x|
+          x.command(attributes) do
+            x.x(form) if form
+          end
+        end
+        
+        command_node = result.first('/c:iq/cmd:command', NAMESPACES)
+        actions_node = command_node.all('./cmd:actions', NAMESPACES)
+        form_node    = command_node.all('./x:x',         NAMESPACES)
+        
+        @id              = command_node[:sessionid].to_s if command_node[:sessionid]
+        @status          = (command_node[:status] || :completed).to_sym
+        @allowed_actions = actions_node.children.collect { |n| n.name.to_sym }
+        @execute_action  = (actions_node[:execute] || :next).to_sym
+        
+        form = Cancer::XEP_0004::Form.load(form_node)
+        @stages << form
+        
+        form
+      end
+      
+      def execute!(form=nil)
+        send(@execute_action, form)
+      end
+      
+      def next!(form=nil)
+        send(:next, form)
+      end
+      
+      def complete!(form=nil)
+        send(:complete, form)
+      end
+      
+      def prev!
+        send(:prev)
+      end
+      
+      def cancel!
+        send(:cancel)
+      end
+    end
+    
+    class LocalSession
+      attr_reader :peer, :node, :id, :current_stage, :stages
+      attr_accessor :next_stage, :iq_id
+      
+      def initialize(controller, peer, node, id, initial_stage=:initial)
+        @controller       = controller
+        @peer, @node, @id = peer, node, id
+        @current_stage    = nil
+        @next_stage       = initial_stage.to_sym
+        @stages           = {}
+        @iq_id            = nil
+      end
+      
+      def complete!
+        @controller.send_iq(@peer, :result, @iq_id) do |x|
+          x.command(:xmlns => NS, :node => @node, :sessionid => @id, :status => 'completed') do
+            yield x
+          end
+        end
+      end
+      
+      def next!(next_stage, form=nil, options={})
+        options, form = form, nil if Hash === form
+        
+        @next_stage = next_stage.to_sym
+        @controller.send_iq(@peer, :result, @iq_id) do |x|
+          x.command(:xmlns => NS, :node => @node, :sessionid => @id, :status => 'executing') do
+            
+            x.actions(options[:execute] ? {:execute => options[:execute]} : {}) do
+              (options[:actions] || []).each do |action|
+                x.send(action)
+              end
+            end
+            
+            if form
+              form = case form
+              when Cancer::XEP_0004::Form           then form
+              when Cancer::XEP_0004::FormDefinition then form
+              else @controller.form(form)
+              end
+              
+              x.x(form, options.merge(:verbose => true))
+            end
+            
+          end
+        end
+      end
+      
+      def form
+        @stages[@current_stage]
+      end
+      
+      def push_stage!(iq_id, form_data)
+        @iq_id               = iq_id
+        @stages[@next_stage] = (form_data ? Cancer::XEP_0004::Form.load(form_data) : nil)
+        @current_stage       = @next_stage
+        @next_stage          = nil
+      end
+    end
+    
+    class Controller < Cancer::Controller
+      
+      on { |e| e.xpath('/c:iq[@type="set"]/cmd:command', NAMESPACES) }
+      def handle_command(e)
+        command_node = e.xml.first('/c:iq/cmd:command', NAMESPACES)
+        session_id   = (command_node[:sessionid] || rand(1<<100)).to_s
+        session      = command_sessions[session_id]
+        
+        unless session
+          session = LocalSession.new(self, e.sender, command_node[:node].to_s, session_id)
+          command_sessions[session_id] = session
+        end
+        
+        session.push_stage!(e.id, e.xml.first('/c:iq/cmd:command/x:x', NAMESPACES))
+        
+        fire! Cancer::XEP_0050::Event, self, session, command_node[:action]
+      end
+      
+      def command_sessions
+        @command_sessions ||= {}
+      end
+      
+    end
+    
+    class Event < Cancer::Events::AbstractEvent
+      attr_reader :session, :action
+      def initialize(controller, session, action)
+        @controller, @session, @action = controller, session, action
+        @action = @action.to_sym if @action
+      end
+    end
+    
+    class EventMatcher < Cancer::Events::Matcher
+      
+      def initialize(node, options={})
+        @node           = node.to_s
+        @stage          = (options.delete(:stage)          || :initial).to_sym
+        @action         = (options.delete(:action)         || :execute).to_sym
+        @default_action = (options.delete(:default_action) || :execute).to_sym
+      end
+      
+      def match?(event)
+        (
+          Cancer::XEP_0050::Event === event and
+          matching_node?(event)             and
+          matching_stage?(event)            and
+          matching_action?(event)
+        )
+      end
+      
+      def matching_node?(event)
+        @node ? (@node == event.session.node) : true
+      end
+      
+      def matching_stage?(event)
+        @stage ? (@stage == event.session.current_stage) : true
+      end
+      
+      def matching_action?(event)
+        @action ? (@action == (event.action || @default_action)) : true
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def command(node, options={})
+        Cancer::XEP_0050::EventMatcher.new(node, options)
+      end
+      
+    end
+    
+  end
+end
+
+=begin
+class Controller
+  
+  on { |e| e.command(:config) }
+  def config_initial_stage(e)
+    if ok? current_stage
+      e.session.next!(:ask_details, 'my_form', default_values)
+    else
+      # error
+    end
+  end
+  
+  on { |e| e.command(:config, :stage => :ask_details) }
+  def config_ask_details_stage(e)
+    
+  end
+  
+end
+=end

data/lib/cancer/xeps/xep_0065_bytestreams.rb

@@ -0,0 +1,306 @@
+
+require 'ipaddr'
+require 'digest/sha1'
+
+module Cancer
+  # SOCKS5 Bytestreams
+  # http://xmpp.org/extensions/xep-0065.html
+  module XEP_0065
+    include Cancer::XEP
+    
+    dependency 'core'
+    dependency 'xep-0030'
+    dependency 'xep-0095', :weak => true
+    
+    NS = 'http://jabber.org/protocol/bytestreams'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::XEP_0065::StreamHelpers
+      end
+      stream.install_controller   Cancer::XEP_0065::Controller
+      stream.install_event_helper Cancer::XEP_0065::EventDSL
+      if stream.respond_to?(:register_stream_method)
+        stream.register_stream_method(Cancer::XEP_0065::StreamMethod, Cancer::XEP_0065::NS)
+        stream.install_controller Cancer::XEP_0065::SOCKS5Controller
+      end
+      stream.disco.feature NS
+    end
+    
+    module StreamHelpers
+      
+      def open_socks5_bytestream(to, sid=nil)
+        sid ||= rand(1<<100).to_s
+        
+        streamhosts = discover_streamhosts
+        
+        result = send_iq(to, :set) do |x|
+          x.query(:xmlns => Cancer::XEP_0065::NS, :sid => sid, :mode => 'tcp') do
+            
+            streamhosts.each do |jid, options|
+              x.streamhost(options.merge(:jid => jid))
+            end
+            
+          end
+        end
+        
+        namespaces = { 'c' => CLIENT_NS, 's' => Cancer::XEP_0065::NS }
+        streamhost = result.first("/c:iq/s:query/s:streamhost-used", namespaces)
+        if streamhost
+          streamhost_jid = streamhost[:jid].to_s
+          streamhost = streamhosts[streamhost_jid]
+          
+          address_base = "#{sid}#{result[:to]}#{result[:from]}"
+          address = Digest::SHA1.hexdigest(address_base)
+          
+          socket = TCPSocket.new(streamhost[:host], streamhost[:port])
+          socket.extend Cancer::XEP_0065::TCPSocketHelper
+          socket.extend Cancer::XEP_0065::SOCKS_5
+          socket.auth
+          socket.connect_domain(address, 0)
+          
+          send_iq(streamhost_jid, :set) do |x|
+            x.query(:xmlns => Cancer::XEP_0065::NS, :sid => sid) do
+              x.activate(result[:from].to_s)
+            end
+          end
+          
+          socket.peer       = result[:from].to_s
+          socket.stream_id  = sid
+          socket.streamhost = streamhost_jid
+          
+          if block_given?
+            yield(socket)
+            socket.close
+          else
+            socket
+          end
+        else
+          return false
+        end
+      end
+      
+      def discover_streamhosts(server_jid=nil)
+        @streamhosts ||= {}
+        server_jid ||= options[:jid].server_jid
+        @streamhosts[server_jid.to_s] ||= begin
+          discover_socks5_proxies(server_jid).inject({}) do |streamhosts, proxy|
+            streamhosts.merge discover_address_for_socks5_proxy(proxy)
+          end
+        end
+      end
+      
+    private
+      
+      def discover_socks5_proxies(server_jid)
+        proxies = []
+        
+        disco_items_for(server_jid).each do |item|
+          info = disco_info_for(item['jid'].to_s)
+          has_identity = info.identities.any? { |identity| identity[:category] == 'proxy' }
+          has_feature  = info.features.include?(Cancer::XEP_0065::NS)
+          proxies.push(item['jid'].to_s) if has_identity and has_feature
+        end
+        
+        proxies
+      end
+      
+      def discover_address_for_socks5_proxy(jid, sid=nil)
+        attributes = { :xmlns => Cancer::XEP_0065::NS }
+        attributes[:sid] = sid if sid
+        result = send_iq(jid) do |x|
+          x.query(attributes)
+        end
+        
+        streamhosts = {}
+        
+        namespaces = { 'c' => CLIENT_NS, 's' => Cancer::XEP_0065::NS }
+        result.all('/c:iq/s:query/s:streamhost', namespaces) do |streamhost|
+          streamhosts[streamhost[:jid].to_s] = {
+            :host => streamhost[:host],
+            :port => (streamhost[:port].to_i rescue 1080),
+            :zeroconf => streamhost[:zeroconf],
+          }.clean
+        end
+        
+        streamhosts
+      end
+      
+    end
+    
+    class Controller < Cancer::Controller
+      
+      NAMESPACES = { 'c' => CLIENT_NS, 'bs' => NS }
+      
+      on { |e| e.xpath('/c:iq/bs:query/bs:streamhost', NAMESPACES) }
+      def open_bytestream(e)
+        query       = e.xml.first('/c:iq/bs:query', NAMESPACES)
+        
+        streamhosts = {}
+        e.xml.all('/c:iq/bs:query/bs:streamhost', NAMESPACES) do |streamhost|
+          streamhosts[streamhost[:jid].to_s] = {
+            :host => streamhost[:host],
+            :port => (streamhost[:port].to_i rescue 1080),
+            :zeroconf => streamhost[:zeroconf],
+          }.clean
+        end
+        
+        fire!(Event, self,
+          :streamhosts => streamhosts,
+          :iq_id       => e.id,
+          :peer        => e.sender,
+          :self        => e.receiver,
+          :mode        => query[:mode],
+          :sid         => query[:sid]
+        )
+      end
+      
+    end
+    
+    class Event < Cancer::Events::AbstractEvent
+      attr_reader :bytestream, :options
+      def initialize(controller, options)
+        @controller, @bytestream, @options = controller, nil, options
+      end
+      
+      def accept!(&proc)
+        if block_given?
+          @controller.enqueue(self, proc) do |e, proc|
+            bs = e.connect_with_socks5_proxy_and_handle
+            proc.call(bs) if bs
+          end
+        else
+          bs = self.connect_with_socks5_proxy_and_handle
+          proc.call(bs) if bs
+        end
+      end
+      
+      def reject!
+        @controller.send_iq(@options[:peer], :error, @options[:iq_id]) do |x|
+          x.error(:code => 406, :type => 'auth') do
+            x.send('not-acceptable', :xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas')
+          end
+        end
+      end
+      
+      def connect_with_socks5_proxy_and_handle
+        @bytestream = connect_with_socks5_proxy
+        
+        if @bytestream
+          @controller.send_iq(@options[:peer], :result, @options[:iq_id]) do |x|
+            x.query(:xmlns => Cancer::XEP_0065::NS, :sid => @options[:sid]) do
+              x.send('streamhost-used', :jid => @bytestream.streamhost)
+            end
+          end
+        else
+          @controller.send_iq(@options[:peer], :error, @options[:iq_id]) do |x|
+            x.error(:code => 404, :type => 'cancel') do
+              x.send('item-not-found', :xmlns => 'urn:ietf:params:xml:ns:xmpp-stanzas')
+            end
+          end
+          return false
+        end
+        
+        return @bytestream
+      end
+      
+    private
+      
+      def connect_with_socks5_proxy
+        @options[:streamhosts].each do |jid, streamhost|
+          
+          begin
+            
+            address_base = "#{@options[:sid]}#{@options[:peer]}#{@options[:self]}"
+            address = Digest::SHA1.hexdigest(address_base)
+            
+            socket = TCPSocket.new(streamhost[:host].to_s, streamhost[:port])
+            socket.extend Cancer::XEP_0065::TCPSocketHelper
+            socket.extend Cancer::XEP_0065::SOCKS_5
+            socket.auth
+            socket.connect_domain(address, 0)
+            
+            socket.peer       = @options[:from].to_s
+            socket.stream_id  = @options[:sid]
+            socket.streamhost = jid.to_s
+            
+            return socket
+          rescue IOError => e
+            Cancer.logger.debug e
+          end
+        end
+        return nil
+      end
+      
+    end
+    
+    class EventMatcher < Cancer::Events::Matcher
+      def match?(event)
+        Cancer::XEP_0065::Event === event
+      end
+    end
+    
+    module EventDSL
+      def socks5_bytestream
+        Cancer::XEP_0065::EventMatcher.new
+      end
+    end
+    
+    module TCPSocketHelper
+      attr_accessor :peer, :stream_id, :streamhost
+    end
+    
+    module SOCKS_5
+      class Error < IOError ; end
+      def auth
+        write("\x05\x01\x00")
+        buf = read(2)
+        if buf.nil? or buf != "\x05\x00"
+          close
+          raise SOCKS_5::Error.new("Invalid SOCKS5 authentication: #{buf.inspect}")
+        end
+        
+        self
+      end
+      
+      def connect_domain(domain, port)
+        buf_out = "\x05\x01\x00\x03#{domain.size.chr}#{domain}#{[port].pack("n")}"
+        write(buf_out)
+        buf = read(4)
+        if buf.nil? or buf[0..1] != "\005\000"
+          close
+          raise SOCKS_5::Error.new("Invalid SOCKS5 connect: #{buf_out.inspect} => #{buf.inspect}")
+        end
+        
+        case buf.respond_to?(:bytes) ? buf.bytes.to_a[3] : buf[3]
+          when 1 then read(6)  # IPv4 addr
+          when 3 then read(3 + domain.size) # Domain
+          when 4 then read(18) # IPv6 addr
+          else
+            close
+            raise SOCKS_5::Error.new("Invalid SOCKS5 address type #{buf[3].to_s}")
+        end
+        
+        self
+      end
+    end
+    
+    class StreamMethod < Cancer::XEP_0095::StreamMethod
+      def handle(to, id, &proc)
+        @stream.open_socks5_bytestream(to, id, &proc)
+      end
+    end
+    
+    class SOCKS5Controller < Cancer::Controller
+      on { |e| e.socks5_bytestream }
+      def catch_socks5(e)
+        controller = self.controllers_by_name['Cancer::XEP_0095::Controller']
+        si_event = controller.pending_streams[e.options[:sid].to_s]
+        if si_event
+          si_event.caught_stream!(e)
+        end
+      end
+    end
+    
+  end
+end