rbus 0.1.0

data/lib/rbus/auth/external.rb

@@ -0,0 +1,34 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+module RBus
+  module Auth
+  
+    # Implements the AUTH EXTERNAL mechanism.
+    class External
+      def auth
+        ['EXTERNAL', Process.uid, :OK]
+      end      
+    end
+  end
+end

data/lib/rbus/auth/state_machine.rb

@@ -0,0 +1,168 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+module RBus
+  module Auth
+    
+    # Implements a statemachine for Authorization like the one described in
+    # the D-Bus specification.
+    class StateMachine
+      def initialize(transport)
+        @transport = transport
+        @mechanism = FIRST_MECHANISM.new
+      end
+      
+      # Main entry point, returns guid if succesful, or raises otherwise.
+      def authorize        
+        state = :AUTH
+        
+        loop do
+          case state
+            when :AUTH
+              command, data, state = @mechanism.auth
+              send_auth(command, data)
+              
+            when :REJECTED
+              response = Command.new(@transport.readline)
+              case response.command
+                when 'REJECTED'
+                  next_mechanism(response.data)
+                  state = :AUTH
+                else
+                  raise AuthException
+              end 
+      
+            when :OK
+              response = Command.new(@transport.readline)
+              case response.command
+                when 'OK'
+                  send_begin
+                  return response.data
+                when 'REJECT'
+                  next_mechanism(response.data)
+                  state = :AUTH
+                when 'DATA'
+                  send_cancel
+                  state = :REJECT
+                when 'ERROR'
+                  send_cancel
+                  state = :REJECT
+                else
+                  send_error
+                  state = :OK
+              end
+      
+            when :DATA
+              response = Command.new(@transport.readline)
+              case response.command
+                when 'DATA'
+                  begin
+                    message, state = @mechanism.data(response.data)
+                  rescue AuthException => e
+                    send_cancel
+                    state = :REJECT
+                  else
+                    send_data(message)
+                  end
+                when 'REJECT'
+                  next_mechanism(response.data)
+                  state = :AUTH
+                when 'ERROR'
+                  send_cancel
+                  state = :REJECT
+                when 'OK'
+                  send_begin
+                  return response.data
+                else
+                  send_error
+                  state = :DATA
+              end
+            else
+              raise
+          end
+        end
+      end
+        
+      # Move to next mechanism
+      def next_mechanism(data)
+        if @mechanisms.nil?
+          populate_mechanisms(data)
+        end
+        if @mechanisms.empty?
+          raise AuthException
+        else
+          @mechanism = @mechanisms.shift.new
+        end
+      end
+
+      # Build initial mechanism list
+      def populate_mechanisms(data)
+        server_mechanisms = data.split(' ')
+        
+        # Find common mechanisms, or try them all if server didn't tell us
+        if server_mechanisms.empty?
+          mechanisms = MECHANISMS.keys
+        else
+          mechanisms = (server_mechanisms & MECHANISMS.keys)
+        end
+        
+        @mechanisms = mechanisms.map{|name| MECHANISMS[name]}
+      end
+            
+      # Send AUTH ...
+      def send_auth(command, data)
+        line = ['AUTH', command, hex_encode(data)].compact.join(' ')
+        @transport.sendline(line)
+      end
+      
+      # send_begin => BEGIN, etc
+      def method_missing(symbol, *args)
+        command = symbol.to_s
+        if command.sub!('send_', '')
+          line = [command.upcase, hex_encode(args[0])].compact.join(' ')
+          @transport.sendline(line)          
+        end
+      end
+        
+      # Server expects all data to be encoded in hex
+      def hex_encode(plain)
+        return nil if plain.nil?
+        plain.to_s.unpack('H*')[0]
+      end   
+    end
+
+    # Parses server response and splits it into component parts
+    # Decodes where appropriate (only DATA)
+    class Command
+      attr_reader :command, :data
+      def initialize(string)
+        @command, data = string.split(/ /, 2)
+        @data = (@command == 'DATA') ? hex_decode(data) : data
+      end
+      
+      def hex_decode(encoded)
+        encoded.scan(/[[:xdigit:]]{2}/).map{|h|h.hex.chr}.join
+      end
+    end    
+  end
+end

data/lib/rbus/bus/bus.rb

@@ -0,0 +1,101 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+
+require File.dirname(__FILE__) + '/proxy'
+require 'singleton'
+
+module RBus
+
+  # Get the session bus
+  def self.session_bus
+    SessionBus.instance
+  end
+  
+  # Get the system bus
+  def self.system_bus
+    SystemBus.instance
+  end
+  
+  # Get Bus with specific address
+  def self.get_bus(address)
+    Bus.new(address)
+  end
+  
+
+  # Represents a connection to a Bus. It is also a Proxy object for
+  # sending messages to the bus itself.
+  class Bus < Proxy
+    NAMES = []
+    
+    attr_reader :message_loop
+    
+    # Connect to Bus with +server_address+, which can contain multiple
+    # addresses to try, separated by semicolons.
+    def initialize(server_address)
+      raise InvalidAddressException, 'Empty address' if server_address.empty?
+
+      # Can be several addresses, separated by ;
+      server_address.split(';').each do |address|
+        @transport = Transport.connect(address)
+      end
+
+      # Not used for anything, save at all?
+      @guid = Auth.authorize(@transport)
+
+      # Start main message loop.
+      #@message_loop = Message::Loop.new(@transport).run
+      @message_loop = Mainloop.new(@transport)
+      
+      @well_known_name = 'org.freedesktop.DBus'
+      @object_path = '/org/freedesktop/DBus'
+      @interface = 'org.freedesktop.DBus'
+      NAMES << Hello()
+      Introspect()
+
+      Log.debug('Bus names:', NAMES)
+
+    end
+    
+    # Returns a remote object for well-known name and object path.
+    def get_object(well_known_name, object_path)
+      Proxy.new(self, well_known_name, object_path)
+    end
+  end
+
+  # Represents the connection to the Session Bus.
+  class SessionBus < Bus
+    include Singleton
+    def initialize
+      super(ENV['DBUS_SESSION_BUS_ADDRESS'])
+    end
+  end
+
+  # Represents the connection to the System Bus.
+  class SystemBus < Bus
+    include Singleton
+    def initialize
+      super(ENV['DBUS_SYSTEM_BUS_ADDRESS'] || 'unix:path=/var/run/dbus/system_bus_socket')
+    end
+  end
+end

data/lib/rbus/bus/proxy.rb

@@ -0,0 +1,137 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+require 'rexml/document'
+
+module RBus
+
+  VALID_METHOD_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,254}$/
+
+  # BlankSlate is a superclass that empties (almost) all instance methods
+  # from it's subclasses.
+  # See: http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__|[!\?]$/ }
+  end
+
+  # The object that represents the remote bus object.
+  class Proxy < BlankSlate
+  
+    # Parses Introspect() XML into a hash with
+    # {method => signature}
+    def self.parse_introspect(xml)
+      methods = {}
+      doc = REXML::Document.new(xml)
+      doc.elements.each("//method") do |method|
+        name = method.attribute('name').to_s
+        signature = ''
+        method.elements.each("*[@direction!='out']") do |arg|
+          signature << arg.attribute('type').to_s
+        end
+        methods[name] = signature
+      end
+      methods
+    end
+     
+    def initialize(bus, well_known_name, object_path)
+      @bus = bus
+      @message_loop = @bus.message_loop
+      @well_known_name = well_known_name
+      @object_path = object_path
+      Introspect()
+    end
+    
+    def Introspect # :nodoc:
+      # TODO: store interfaces as well, if ever needed
+      interface = @interface
+      @interface = 'org.freedesktop.DBus.Introspectable'
+      @methods = Proxy.parse_introspect(method_missing(:Introspect))
+      Log.debug("Methods from introspect: " + @methods.inspect)
+      @interface = interface
+    end
+
+    # Set interface and return or yield self.
+    # If a block is given, a copy of the object will be 
+    # the new interface will only be set for that block, and reset
+    # afterwards.
+    def interface!(interface)
+      old_i = @interface
+      @interface = interface
+      if block_given?
+        yield self
+        @interface = old_i
+      end
+      self
+    end
+
+    # Connect block to a signal
+    def connect!(signal, options = {}, &block)
+      raise MessageException, "connect! needs a block" unless block_given?
+      
+      rules = {
+        :type => 'signal',
+        :member => signal.to_s,
+        :path => @object_path,
+        #:sender => @well_known_name
+      }
+      rules['interface'] = @interface if @interface
+      
+      rules.merge!(options)
+      
+      Log.debug(rules)
+      @bus.AddMatch(rules, &block)
+    end
+    
+    # Define a method with signature.
+    # +name+ can be a string or a symbol.
+    def method!(name, signature)
+      @methods[name.to_s] = signature
+    end
+    
+    # Routes all method calls to remote object
+    def method_missing(name, *args, &block) # :nodoc:
+      
+      method = name.to_s
+      
+      Log.debug('Proxy method called: ' + method)
+      
+      unless method.match(VALID_METHOD_NAME)
+        raise InvalidNameException, "Invalid method name '#{name}'"
+      end
+      
+      call = MethodCall.new do |m|
+        m.destination = @well_known_name
+        m.object_path = @object_path
+        m.interface = @interface if @interface
+        m.member = method
+        m.arguments = args
+        if !args.empty? && @methods.has_key?(method)
+          Log.debug('Signature: ' + @methods[method])
+          m.signature = @methods[method]
+        end
+      end
+      Log.debug(block_given? ? 'Block given' : 'Block NOT given')
+      @message_loop.send_message(call, block_given? ? block : nil)
+    end
+  end
+end

data/lib/rbus/bus/transport.rb

@@ -0,0 +1,125 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+require 'socket'
+
+module RBus
+
+  # Transport represents the connection to the bus,
+  # and supports sending and recieving messages
+  # The class itself is a factory that returns the
+  # appropriate transport for an address
+  class Transport
+
+    # Abstract base implementation of a transport.
+    class AbstractTransport
+      # Newline
+      CRLF = "\015\012"
+      attr_reader :socket
+      
+      def initialize(connection_info)
+        @connection_info = connection_info
+        create_socket
+      end
+      
+      def send(message)
+        @socket.write(message)
+      end
+      
+      def read(len = 2**27)
+        @socket.read(len)
+        #@socket.recv(len)
+      end
+      
+      def sendline(message)
+        @socket.write(message + CRLF)        
+      end
+      
+      def readline
+        @socket.readline.chomp
+      end
+      
+      def close
+        @socket.close
+      end
+      
+    end
+    
+    # Represents a connection to a UNIX Socket, abstract or regular.
+    class UNIXTransport < AbstractTransport
+      def create_socket
+        if @connection_info.has_key?('abstract')
+          @socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+          @socket.connect("\1\0\0#{@connection_info['abstract']}")
+        elsif @connection_info.has_key?('path')
+          @socket = UNIXSocket.open(@connection_info['path'])
+        end
+      end
+    end
+    
+    # Represents a connection to a TCP Socket.
+    class TCPTransport < AbstractTransport
+      def create_socket
+        @socket = TCPSocket.new(@connection_info['host'], @connection_info['port'])        
+      end
+    end
+
+    # Unescape simple hex encoding (%XX) for values
+    def self.unescape(value)
+      value.gsub(/%([[:xdigit:]]{2})/) {$1.hex.chr}
+    end
+
+    # Parse a valid connection address
+    def self.parse_address(address)
+      connection_info = {}
+      connection_info['transport'], info = address.split(':', 2)
+      
+      raise InvalidAddressException if info.nil? || info.empty?
+      
+      info.split(',').each do |pair|
+        key, value = pair.split('=')
+        connection_info[key] = unescape(value)
+      end
+      connection_info
+    end
+
+    # Define factory method connect
+    class << self
+      def connect(address)    
+        connection_info = parse_address(address)
+        
+        klass =
+          case connection_info['transport']
+            when 'unix'
+              UNIXTransport
+            when 'tcp'
+              TCPTransport
+            else
+              raise InvalidTransportException, "Unknown transport #{connection_info['transport']}"
+          end
+        klass::new(connection_info)
+      end
+    end
+  end
+end
+