demirten-ruby-dbus 0.2.4.6

data/README.rdoc

@@ -0,0 +1,127 @@
+= Ruby D-Bus -> ffwd
+
+Ruby D-Bus provides an implementation of the D-Bus protocol such that the
+D-Bus system can be used in the Ruby programming language.
+
+You can switch between REXML and Hpricot as XML parsers!
+
+Still a little bumpy with multiple threads, but getting there.
+
+
+This is my personal dev-fork of mvidners upstream.
+
+If you'd like to contrib to this fork, let me know.
+
+Most of my work here is actually for another project: http://github.com/pangdudu/robots/tree/master
+
+Peace.
+
+== Requirements
+
+ * Ruby 1.8 (>= 1.8.6?)
+
+== Installation
+
+  sudo gem install pangdudu-ruby-dbus --source=http://gems.github.com
+
+== Features
+
+Ruby D-Bus currently supports the following features:
+
+ * Connecting to local buses.
+ * Accessing remote services, objects and interfaces.
+ * Invoking methods on remote objects synchronously and asynchronously.
+ * Catch signals on remote objects and handle them via callbacks.
+ * Remote object introspection.
+ * Walking object trees.
+ * Creating services and registering them on the bus.
+ * Exporting objects with interfaces on a bus for remote use.
+ * Rubyish D-Bus object and interface syntax support that automatically
+   allows for introspection.
+ * Emitting signals on exported objects.
+ 
+ * Connection to a local or remote bus over TCP/IP using 'Dbus::RemoteBus.new(socket_name)'
+ * Authentification mechanisms working now: External,CookieSHA1
+
+== Usage
+
+=== Basics:
+
+View a tutorial online on http://trac.luon.net/data/ruby-dbus/tutorial/.
+
+
+=== TCP/Remote stuff:
+
+Take a look at 'config/remote.session.dbus.conf' and start 'config/start_dbus_session.sh'.
+
+You can now try and run one of the tests e.g. 'test/simple_socket_test.rb'.
+
+
+=== Problems you'll have with 'CookieSHA1' when using it remotely: 
+
+Unless we [including you :)] write a funkier SASL authentification mechanism that
+makes sense when using it over-wire, we're stuck with the cookie auth.
+
+Works like this: 
+
+There is a file in '~/.dbus-keyrings' named 'org_freedesktop_general'. 
+It is '-rw-------' so that only you can read it (if you change the permissions, 
+dbus-daemon will most likely ignore the file leaving you with 'External', which is
+even worse remotely). It's kind of a secret key you use to auth against yourself 
+later on.
+
+If you take a look at 'dbus/auth.rb line 40+' you'll see the problem:
+
+  # Search cookie file for id
+  path = File.join(ENV['HOME'], '.dbus-keyrings', context)
+  
+So if you're starting 'config/start_dbus_session.sh' on one host and 'config/start_dbus_session.sh'
+on another one, you'll need to make sure that the content in '~/.dbus-keyrings/org_freedesktop_general'
+is the same on both machines, in order for the 'CookieSHA1' auth to work.
+
+Not cool. I can think of hacks with nfs,smb or fuse:sshfs making it less
+painful to use. 
+
+The file content also get's updated every 5 minutes (when a client fails to auth etc.). 
+Making copy and paste from one shell to another very frolic.
+
+=== Hackish solution from pangdudu/robots/lib/robots_agent.rb
+
+  #because dbus remote auth still betrays us, we need to hack it
+  def get_remote_cookie
+    if @config[:robots_socket_name].include? "tcp:"
+      af, port, daemon_name, daemon_addr = (Socket::getaddrinfo(@config[:daemonhost],@config[:daemonhost].to_i)).first
+      ilog "Trying to get/hack remote cookie from: #{daemon_name}."
+      begin
+        cookiepath = "#{ENV['HOME']}/.dbus-keyrings/org_freedesktop_general"
+        #oki, the scp magic only works, if you use sshkeys
+        `scp #{daemon_addr}:.dbus-keyrings/org_freedesktop_general #{cookiepath}`
+        if File.exist? cookiepath
+          cookie = File.open(cookiepath) 
+          dlog "Got cookie: #{cookie.gets}"
+        end
+      rescue
+        elog "Oops, something is wrong."
+      end
+    else
+      dlog "Nothing to hack, boring."
+    end
+  end
+
+in principle, this is ok. we can now do what we want and it is save to exchange cookies over 
+a ssh session. However I'm still not feeling comfortable doing this. I guess everything else 
+would mean touching the reference C dbus-daemon implementation. 
+
+
+more infos:
+  http://dbus.freedesktop.org/doc/dbus-specification.html#auth-mechanisms
+  http://lists.freedesktop.org/archives/dbus/2007-June/008067.html
+
+Booyaa.
+
+== License
+
+Ruby D-Bus is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 2.1 of the License, or (at
+your option) any later version.

data/config/remote.session.dbus.conf

@@ -0,0 +1,39 @@
+<!-- This configuration file controls the per-user-login-session message bus.
+     Add a session-local.conf and edit that rather than changing this 
+     file directly. -->
+
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <!-- Our well-known bus type, don't change this -->
+  <type>session</type>
+
+  <!-- If we fork, keep the user's original umask to avoid affecting
+       the behavior of child processes. -->
+  <keep_umask/>
+
+<!--  <allow_anonymous/> -->
+  
+  <!-- Listen to everything on tcp! -->
+  <listen>tcp:host=0.0.0.0,port=2687,family=ipv4</listen>
+  <!-- Listen on socket at this file location -->
+  <!-- <listen>unix:path=/tmp/socket_test_session_bus_socket</listen> -->
+  
+  <standard_session_servicedirs /> 
+
+  <policy context="default">
+    <!-- Allow everything to be sent -->
+    <allow send_destination="*" eavesdrop="true"/>
+    <!-- Allow everything to be received -->
+    <allow eavesdrop="true"/>
+    <!-- Allow anyone to own anything -->
+    <allow own="*"/>
+  </policy>
+
+  <!-- raise the service start timeout to 40 seconds as it can timeout
+       on the live cd on slow machines -->
+  <limit name="service_start_timeout">60000</limit>
+
+  <include if_selinux_enabled="yes" selinux_root_relative="yes">contexts/dbus_contexts</include>
+
+</busconfig>

data/config/start_dbus_session.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+dbus-daemon --print-address --config-file=remote.session.dbus.conf

data/lib/dbus.rb

@@ -0,0 +1,86 @@
+# 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 'rubygems'
+require 'rofl' #http://github.com/pangdudu/rofl/tree/master makes the debug/tracing easy
+require 'hpricot' #hope this will speed stuff up a little
+require 'dbus/type'
+require 'dbus/introspect'
+require 'dbus/export'
+require 'dbus/bus'
+require 'dbus/marshall'
+require 'dbus/message'
+require 'dbus/matchrule'
+require 'dbus/auth'
+require 'socket'
+require 'thread'
+
+# = 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"
+
+  # Socket name for the session bus, not pretty.
+  SessionSocketName = ENV["DBUS_SESSION_BUS_ADDRESS"]
+
+  # 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,251 @@
+# 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 = true #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] }.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)
+      dlog "context, id, s_challenge: #{data.inspect}"
+      # 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)
+      dlog "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
+          dlog "cookie: #{cookie.inspect}" if $debug
+          # Concatenate and encrypt
+          to_encrypt = [s_challenge, c_challenge, cookie].join(':')
+          dlog "s_challenge, c_challenge, cookie: #{to_encrypt.inspect}"
+          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
+      elog "Could not auth, will now exit." unless @retries <= 0
+      elog "Unable to locate cookie, retry in 1 second."
+      @retries -= 1
+      sleep 1
+      data(hexdata)
+    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
+
+  # = 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(" ")
+      dlog "#{o.inspect}"
+      @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]
+        dlog "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(" ")
+      dlog "readline: #{readline.inspect}" if $debug
+      return readline
+    end
+
+    # Try to reach the next state based on the current state.
+    def next_state
+      msg = next_msg
+      if @state == :Starting
+        dlog ":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
+      dlog "state: #{@state}" if $debug
+      case @state
+      when :WaitingForData
+        dlog ":WaitingForData msg: #{msg[0].inspect}" if $debug
+        case msg[0]
+        when "DATA"
+          chall = msg[1]
+          resp, chall = @authenticator.data(chall)
+          dlog ":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
+        dlog ":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
+        dlog ":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