ruby-dbus 0.5.0

data/examples/no-introspect/tracker-test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# Trivial network interface lister using NetworkManager.
+# NetworkManager does not support introspection, so the api is not that sexy.
+
+require 'dbus'
+
+bus = DBus::SessionBus.instance
+
+tracker_service = bus.service("org.freedesktop.Tracker")
+tracker_manager = tracker_service.object("/org/freedesktop/tracker")
+poi = DBus::ProxyObjectInterface.new(tracker_manager, "org.freedesktop.Tracker.Files")
+poi.define_method("GetMetadataForFilesInFolder", "in live_query_id:i, in uri:s, in fields:as, out values:aas")
+p poi.GetMetadataForFilesInFolder(-1, ENV['HOME'] + "/Desktop", ["File:Name", "File:Size"])
+
+

data/examples/rhythmbox/playpause.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+bus = DBus::SessionBus.instance
+# get a rb object
+proxy = bus.introspect("org.gnome.Rhythmbox", "/org/gnome/Rhythmbox/Player")
+proxyi = proxy["org.gnome.Rhythmbox.Player"]
+
+# register for signals
+
+mr = DBus::MatchRule.new
+mr.type = "signal"
+mr.interface = "org.gnome.Rhythmbox.Player"
+mr.path = "/org/gnome/Rhythmbox/Player"
+bus.add_match(mr) do |msg, first_param|
+  print msg.member + " "
+  puts first_param
+end
+
+proxyi.playPause(true)
+
+main = DBus::Main.new
+main << bus
+main.run
+

data/examples/service/call_service.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "dbus"
+
+session_bus = DBus::SessionBus.instance
+
+ruby_srv = session_bus.service("org.ruby.service")
+
+# Get the object from this service
+player = ruby_srv.object("/org/ruby/MyInstance")
+
+# Introspect it
+puts player.introspect
+player.default_iface = "org.ruby.SampleInterface"
+player.test_variant(["s", "coucou"])
+player.on_signal("SomethingJustHappened") do |u, v|
+  puts "SomethingJustHappened: #{u} #{v}"
+end
+player.hello("8=======D", "(_._)")
+p player["org.ruby.AnotherInterface"].Reverse("Hello world!")
+
+main = DBus::Main.new
+main << session_bus
+main.run
+

data/examples/service/service_newapi.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+require 'thread'
+Thread.abort_on_exception = true
+
+class Test < DBus::Object
+  # Create an interface aggregating all upcoming dbus_method defines.
+  dbus_interface "org.ruby.SampleInterface" do
+    dbus_method :hello, "in name:s, in name2:s" do |name, name2|
+      puts "hello(#{name}, #{name2})"
+    end
+
+    dbus_method :test_variant, "in stuff:v" do |variant|
+      p variant
+    end
+
+    dbus_signal :SomethingJustHappened, "toto:s, tutu:u"
+  end
+
+  dbus_interface "org.ruby.AnotherInterface" do
+    dbus_method :ThatsALongMethodNameIThink do
+      puts "ThatsALongMethodNameIThink"
+    end
+    dbus_method :Reverse, "in instr:s, out outstr:s" do |instr|
+      outstr = instr.split(//).reverse.join
+      puts "got: #{instr}, replying: #{outstr}"
+      [outstr]
+    end
+  end
+end
+
+bus = DBus::SessionBus.instance
+service = bus.request_service("org.ruby.service")
+myobj = Test.new("/org/ruby/MyInstance")
+service.export(myobj)
+
+Thread.new do
+  i = 0
+  loop do 
+    # Signal emission
+    myobj.SomethingJustHappened("hey", i += 1)
+    sleep(0.5)
+  end
+end
+
+puts "listening"
+main = DBus::Main.new
+main << bus
+main.run
+

data/examples/simple/call_introspect.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require "dbus"
+
+session_bus = DBus::SessionBus.instance
+
+# Get the Rhythmbox service
+rhythmbox = session_bus.service("org.gnome.Rhythmbox")
+
+# Get the object from this service
+player = rhythmbox.object("/org/gnome/Rhythmbox/Player")
+
+# Introspect it
+player.introspect
+if player.has_iface? "org.gnome.Rhythmbox.Player"
+  puts "We have Rhythmbox Player interface"
+end
+
+player_with_iface = player["org.gnome.Rhythmbox.Player"]
+p player_with_iface.getPlayingUri
+
+# Maybe support default_iface=(iface_str) on an ProxyObject, so
+# that this is possible?
+player.default_iface = "org.gnome.Rhythmbox.Player"
+puts "default_iface test:"
+p player.getPlayingUri
+player.on_signal("elapsedChanged") do |u|
+  puts "elapsedChanged: #{u}"
+end
+
+main = DBus::Main.new
+main << session_bus
+main.run
+

data/examples/utils/listnames.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+
+d = if ARGV.member?("--system")
+  DBus::SystemBus.instance
+else
+  DBus::SessionBus.instance
+end
+d.proxy.ListNames[0].each{ |n| puts "\t#{n}" }
+

data/examples/utils/notify.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'dbus'
+
+if ARGV.size < 2
+  puts "Usage:"
+  puts "notify.rb \"title\" \"body\""
+  exit
+end
+
+d = DBus::SessionBus.instance
+o = d.service("org.freedesktop.Notifications").object("/org/freedesktop/Notifications")
+o.introspect
+
+i = o["org.freedesktop.Notifications"]
+
+i.Notify('notify.rb', 0, 'info', ARGV[0], ARGV[1], [], {}, 2000) do |ret, param|
+end
+

data/lib/dbus.rb

@@ -0,0 +1,91 @@
+# dbus.rb - Module containing the low-level D-Bus implementation
+#
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+require 'dbus/core_ext/class/attribute'
+require 'dbus/type'
+require 'dbus/introspect'
+require 'dbus/error'
+require 'dbus/export'
+require 'dbus/bus.rb'
+require 'dbus/marshall'
+require 'dbus/message'
+require 'dbus/matchrule'
+require 'dbus/auth'
+
+require 'socket'
+require 'thread'
+
+unless 0.respond_to?(:ord)
+  # Backward compatibility with Ruby 1.8.6, see http://www.pubbs.net/ruby/200907/65871/
+  class Integer
+    def ord; self; end
+  end
+end
+
+# = D-Bus main module
+#
+# Module containing all the D-Bus modules and classes.
+module DBus
+  # Default socket name for the system bus.
+  SystemSocketName = "unix:path=/var/run/dbus/system_bus_socket"
+
+  # Byte signifying big endianness.
+  BIG_END = ?B
+  # Byte signifying little endianness.
+  LIL_END = ?l
+
+  # Byte signifying the host's endianness.
+  HOST_END = if [0x01020304].pack("L").unpack("V")[0] == 0x01020304
+    LIL_END
+  else
+    BIG_END
+  end
+
+  # General exceptions.
+
+  # Exception raised when an invalid packet is encountered.
+  class InvalidPacketException < Exception
+  end
+
+  # Exception raised when there is a problem with a type (may be unknown or
+  # mismatch).
+  class TypeException < Exception
+  end
+
+  # Exception raised when an unmarshalled buffer is truncated and
+  # incomplete.
+  class IncompleteBufferException < Exception
+  end
+
+  # Exception raised when an interface is not implemented.
+  class InterfaceNotImplemented < Exception
+  end
+
+  # Exception raised when an method is not found in the interface.
+  class MethodNotInInterface < Exception
+  end
+
+  # Exception raised when a method has not been implemented (yet).
+  class MethodNotImplemented < Exception
+  end
+
+  # Exception raised when a method is invoked with invalid
+  # parameters (wrong number or type).
+  class InvalidParameters < Exception
+  end
+
+  # Exception raised when an invalid method name is used.
+  class InvalidMethodName < Exception
+  end
+
+  # Exception raised when invalid introspection data is parsed/used.
+  class InvalidIntrospectionData < Exception
+  end
+end # module DBus

data/lib/dbus/auth.rb

@@ -0,0 +1,258 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+$debug = $DEBUG #it's all over the state machine
+
+module DBus
+  # Exception raised when authentication fails somehow.
+  class AuthenticationFailed < Exception
+  end
+
+  # = General class for authentication.
+  class Authenticator
+    # Returns the name of the authenticator.
+    def name
+      self.class.to_s.upcase.sub(/.*::/, "")
+    end
+  end
+
+  # = External authentication class 
+  #
+  # Class for 'external' type authentication.
+  class External < Authenticator
+    # Performs the authentication.
+    def authenticate
+      # Take the user id (eg integer 1000) make a string out of it "1000", take
+      # each character and determin hex value "1" => 0x31, "0" => 0x30. You
+      # obtain for "1000" => 31303030 This is what the server is expecting.
+      # Why? I dunno. How did I come to that conclusion? by looking at rbus
+      # code. I have no idea how he found that out.
+      return Process.uid.to_s.split(//).collect { |a| "%x" % a[0].ord }.join
+    end
+  end
+  
+  # = Authentication class using SHA1 crypto algorithm 
+  #
+  # Class for 'CookieSHA1' type authentication.
+  # Implements the AUTH DBUS_COOKIE_SHA1 mechanism.
+  class DBusCookieSHA1 < Authenticator
+        
+    #the autenticate method (called in stage one of authentification)    
+    def authenticate
+      require 'etc'
+      #number of retries we have for auth
+      @retries = 1
+      return "#{hex_encode(Etc.getlogin)}" #server expects it to be binary
+    end
+
+    #returns the modules name
+    def name
+      return 'DBUS_COOKIE_SHA1'
+    end
+    
+    #handles the interesting crypto stuff, check the rbus-project for more info: http://rbus.rubyforge.org/
+    def data(hexdata)
+      require 'digest/sha1'
+      data = hex_decode(hexdata)
+      # name of cookie file, id of cookie in file, servers random challenge  
+      context, id, s_challenge = data.split(' ')
+      # Random client challenge        
+      c_challenge = Array.new(s_challenge.length/2).map{|obj|obj=rand(255).to_s}.join
+      # Search cookie file for id
+      path = File.join(ENV['HOME'], '.dbus-keyrings', context)
+      puts "DEBUG: path: #{path.inspect}" if $debug
+      File.foreach(path) do |line|
+        if line.index(id) == 0
+          # Right line of file, read cookie
+          cookie = line.split(' ')[2].chomp
+          puts "DEBUG: cookie: #{cookie.inspect}" if $debug
+          # Concatenate and encrypt
+          to_encrypt = [s_challenge, c_challenge, cookie].join(':')
+          sha = Digest::SHA1.hexdigest(to_encrypt)
+          #the almighty tcp server wants everything hex encoded
+          hex_response = hex_encode("#{c_challenge} #{sha}")
+          # Return response
+          response = [:AuthOk, hex_response]
+          return response
+        end
+      end
+      #a little rescue magic
+      unless @retries <= 0
+        puts "ERROR: Could not auth, will now exit." 
+        puts "ERROR: Unable to locate cookie, retry in 1 second."
+        @retries -= 1
+        sleep 1
+        data(hexdata)
+      end
+    end  
+    
+    # encode plain to hex
+    def hex_encode(plain)
+      return nil if plain.nil?
+      plain.to_s.unpack('H*')[0]
+    end
+    
+    # decode hex to plain
+    def hex_decode(encoded)
+      encoded.scan(/[[:xdigit:]]{2}/).map{|h|h.hex.chr}.join
+    end  
+  end #DBusCookieSHA1 class ends here
+
+  # Note: this following stuff is tested with External authenticator only!
+
+  # = Authentication client class.
+  #
+  # Class tha performs the actional authentication.
+  class Client
+    # Create a new authentication client.
+    def initialize(socket)
+      @socket = socket
+      @state = nil
+      @auth_list = [External,DBusCookieSHA1]
+    end
+
+    # Start the authentication process.
+    def authenticate
+      @socket.write(0.chr)
+      next_authenticator
+      @state = :Starting
+      while @state != :Authenticated
+        r = next_state
+        return r if not r
+      end
+      true
+    end
+
+    ##########
+    private
+    ##########
+
+    # Send an authentication method _meth_ with arguments _args_ to the
+    # server.
+    def send(meth, *args)
+      o = ([meth] + args).join(" ")
+      @socket.write(o + "\r\n")
+    end
+
+    # Try authentication using the next authenticator.
+    def next_authenticator
+      begin
+        raise AuthException if @auth_list.size == 0
+        @authenticator = @auth_list.shift.new
+        auth_msg = ["AUTH", @authenticator.name, @authenticator.authenticate]
+        puts "DEBUG: auth_msg: #{auth_msg.inspect}" if $debug
+        send(auth_msg)
+      rescue AuthException
+        @socket.close
+        raise
+      end
+    end
+
+    # Read data (a buffer) from the bus until CR LF is encountered.
+    # Return the buffer without the CR LF characters.
+    def next_msg
+      data,crlf = "","\r\n"
+      left = 1024 #1024 byte, no idea if it's ever getting bigger
+      while left > 0
+        buf = @socket.read( left > 1 ? 1 : left )
+        break if buf.nil?
+        left -= buf.size
+        data += buf
+        break if data.include? crlf #crlf means line finished, the TCP socket keeps on listening, so we break 
+      end
+      readline = data.chomp.split(" ")
+      puts "DEBUG: readline: #{readline.inspect}" if $debug
+      return readline
+    end
+
+=begin
+    # Read data (a buffer) from the bus until CR LF is encountered.
+    # Return the buffer without the CR LF characters.
+    def next_msg
+      @socket.readline.chomp.split(" ")
+    end
+=end
+
+    # Try to reach the next state based on the current state.
+    def next_state
+      msg = next_msg
+      if @state == :Starting
+        puts "DEBUG: :Starting msg: #{msg[0].inspect}" if $debug
+        case msg[0]
+        when "OK"
+          @state = :WaitingForOk    
+        when "CONTINUE"
+          @state = :WaitingForData
+        when "REJECTED" #needed by tcp, unix-path/abstract doesn't get here
+          @state = :WaitingForData
+        end
+      end
+      puts "DEBUG: state: #{@state}" if $debug
+      case @state
+      when :WaitingForData
+        puts "DEBUG: :WaitingForData msg: #{msg[0].inspect}" if $debug
+        case msg[0]
+        when "DATA"
+          chall = msg[1]
+          resp, chall = @authenticator.data(chall)
+          puts "DEBUG: :WaitingForData/DATA resp: #{resp.inspect}" if $debug
+          case resp
+          when :AuthContinue
+            send("DATA", chall)
+            @state = :WaitingForData
+          when :AuthOk
+            send("DATA", chall)
+            @state = :WaitingForOk
+          when :AuthError
+            send("ERROR")
+            @state = :WaitingForData
+          end
+        when "REJECTED"
+          next_authenticator
+          @state = :WaitingForData
+        when "ERROR"
+          send("CANCEL")
+          @state = :WaitingForReject
+        when "OK"
+          send("BEGIN")
+          @state = :Authenticated
+        else
+          send("ERROR")
+          @state = :WaitingForData
+        end
+      when :WaitingForOk
+        puts "DEBUG: :WaitingForOk msg: #{msg[0].inspect}" if $debug
+        case msg[0]
+        when "OK"
+          send("BEGIN")
+          @state = :Authenticated
+        when "REJECT"
+          next_authenticator
+          @state = :WaitingForData
+        when "DATA", "ERROR"
+          send("CANCEL")
+          @state = :WaitingForReject
+        else
+          send("ERROR")
+          @state = :WaitingForOk
+        end
+      when :WaitingForReject
+        puts "DEBUG: :WaitingForReject msg: #{msg[0].inspect}" if $debug
+        case msg[0]
+        when "REJECT"
+          next_authenticator
+          @state = :WaitingForOk
+        else
+          @socket.close
+          return false
+        end
+      end
+      return true
+    end # def next_state
+  end # class Client
+end # module D-Bus