em-ruby-dbus 0.11.0

data/lib/dbus/matchrule.rb

@@ -0,0 +1,101 @@
+# 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.
+
+module DBus
+  # Exception raised when an erroneous match rule type is encountered.
+  class MatchRuleException < Exception
+  end
+
+  # = D-Bus match rule class
+  #
+  # FIXME
+  class MatchRule
+    # The list of possible match filters. TODO argN, argNpath
+    FILTERS = [:sender, :interface, :member, :path, :destination, :type]
+    # The sender filter.
+    attr_accessor :sender
+    # The interface filter.
+    attr_accessor :interface
+    # The member filter.
+    attr_accessor :member
+    # The path filter.
+    attr_accessor :path
+    # The destination filter.
+    attr_accessor :destination
+    # The type type that is matched.
+    attr_reader :type
+
+    # Create a new match rule
+    def initialize
+      @sender = @interface = @member = @path = @destination = @type = nil
+    end
+
+    # Set the message types to filter to type _t_.
+    # Possible message types are: signal, method_call, method_return, and error.
+    def type=(t)
+      if not ['signal', 'method_call', 'method_return', 'error'].member?(t)
+        raise MatchRuleException, t
+      end
+      @type = t
+    end
+
+    # Returns a match rule string version of the object.
+    # E.g.:  "type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',path='/bar/foo',destination=':452345.34',arg2='bar'"
+    def to_s
+      FILTERS.select do |sym|
+        not method(sym).call.nil?
+      end.collect do |sym|
+        "#{sym.to_s}='#{method(sym).call}'"
+      end.join(",")
+    end
+
+    # Parses a match rule string _s_ and sets the filters on the object.
+    def from_s(str)
+      str.split(",").each do |eq|
+        if eq =~ /^(.*)='([^']*)'$/
+# "
+          name = $1
+          val = $2
+          if FILTERS.member?(name.to_sym)
+            method(name + "=").call(val)
+          else
+            raise MatchRuleException, name
+          end
+        end
+      end
+      self
+    end
+
+    # Sets the match rule to filter for the given _signal_ and the
+    # given interface _intf_.
+    def from_signal(intf, signal)
+      signal = signal.name unless signal.is_a?(String)
+      self.type = "signal"
+      self.interface = intf.name
+      self.member = signal
+      self.path = intf.object.path
+      self
+    end
+
+    # Determines whether a message _msg_ matches the match rule.
+    def match(msg)
+      if @type
+        if {Message::SIGNAL => "signal", Message::METHOD_CALL => "method_call",
+          Message::METHOD_RETURN => "method_return",
+          Message::ERROR => "error"}[msg.message_type] != @type
+          return false
+        end
+      end
+      return false if @interface and @interface != msg.interface
+      return false if @member and @member != msg.member
+      return false if @path and @path != msg.path
+      # FIXME sender and destination are ignored
+      true
+    end
+  end # class MatchRule
+end # module D-Bus

data/lib/dbus/message.rb

@@ -0,0 +1,276 @@
+# 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.
+
+# = D-Bus main module
+#
+# Module containing all the D-Bus modules and classes.
+module DBus
+  # = InvalidDestinationName class
+  # Thrown when you try to send a message to /org/freedesktop/DBus/Local, that
+  # is reserved.
+  class InvalidDestinationName < Exception
+  end
+
+  # = D-Bus message class
+  #
+  # Class that holds any type of message that travels over the bus.
+  class Message
+    # The serial number of the message.
+    @@serial = 1
+    # Mutex that protects updates on the serial number.
+    @@serial_mutex = Mutex.new
+    # Type of a message (by specification).
+    MESSAGE_SIGNATURE = "yyyyuua(yv)"
+
+    # FIXME: following message type constants should be under Message::Type IMO
+    # well, yeah sure
+    #
+    # Invalid message type.
+    INVALID = 0
+    # Method call message type.
+    METHOD_CALL = 1
+    # Method call return value message type.
+    METHOD_RETURN = 2
+    # Error message type.
+    ERROR = 3
+    # Signal message type.
+    SIGNAL = 4
+
+    # Message flag signyfing that no reply is expected.
+    NO_REPLY_EXPECTED = 0x1
+    # Message flag signifying that no automatic start is required/must be 
+    # performed.
+    NO_AUTO_START = 0x2
+
+    # The type of the message.
+    attr_reader :message_type
+    # The path of the object instance the message must be sent to/is sent from.
+    attr_accessor :path
+    # The interface of the object that must be used/was used.
+    attr_accessor :interface
+    # The interface member (method/signal name) of the object that must be
+    # used/was used.
+    attr_accessor :member
+    # The name of the error (in case of an error message type).
+    attr_accessor :error_name
+    # The destination connection of the object that must be used/was used.
+    attr_accessor :destination
+    # The sender of the message.
+    attr_accessor :sender
+    # The signature of the message contents.
+    attr_accessor :signature
+    # The serial number of the message this message is a reply for.
+    attr_accessor :reply_serial
+    # The protocol.
+    attr_reader :protocol
+    # The serial of the message.
+    attr_reader :serial
+    # The parameters of the message.
+    attr_reader :params
+
+    # Create a message with message type _mtype_ with default values and a
+    # unique serial number.
+    def initialize(mtype = INVALID)
+      @message_type = mtype
+
+      @flags = 0
+      @protocol = 1
+      @body_length = 0
+      @signature = String.new
+      @@serial_mutex.synchronize do
+        @serial = @@serial
+        @@serial += 1
+      end
+      @params = Array.new
+      @destination = nil
+      @interface = nil
+      @error_name = nil
+      @member = nil
+      @path = nil
+      @reply_serial = nil
+
+      if mtype == METHOD_RETURN
+        @flags = NO_REPLY_EXPECTED
+      end
+    end
+
+    def to_s
+      "#{message_type} sender=#{sender} -> dest=#{destination} serial=#{serial} reply_serial=#{reply_serial} path=#{path}; interface=#{interface}; member=#{member} error_name=#{error_name}"
+    end
+
+    # Create a regular reply to a message _m_.
+    def self.method_return(m)
+      MethodReturnMessage.new.reply_to(m)
+    end
+
+    # Create an error reply to a message _m_.
+    def self.error(m, error_name, description=nil)
+      ErrorMessage.new(error_name, description).reply_to(m)
+    end
+
+    # Mark this message as a reply to a another message _m_, taking
+    # the serial number of _m_ as reply serial and the sender of _m_ as
+    # destination.
+    def reply_to(m)
+      @reply_serial = m.serial
+      @destination = m.sender
+      self
+    end
+
+    # Add a parameter _val_ of type _type_ to the message.
+    def add_param(type, val)
+      type = type.chr if type.kind_of?(Fixnum)
+      @signature += type.to_s
+      @params << [type, val]
+    end
+
+    # FIXME: what are these? a message element constant enumeration?
+    # See method below, in a message, you have and array of optional parameters
+    # that come with an index, to determine their meaning. The values are in
+    # spec, more a definition than an enumeration.
+
+    PATH = 1
+    INTERFACE = 2
+    MEMBER = 3
+    ERROR_NAME = 4
+    REPLY_SERIAL = 5
+    DESTINATION = 6
+    SENDER = 7
+    SIGNATURE = 8
+
+    # Marshall the message with its current set parameters and return
+    # it in a packet form.
+    def marshall
+      if @path == "/org/freedesktop/DBus/Local"
+        raise InvalidDestinationName
+      end
+
+      params = PacketMarshaller.new
+      @params.each do |param|
+        params.append(param[0], param[1])
+      end
+      @body_length = params.packet.bytesize
+
+      marshaller = PacketMarshaller.new
+      marshaller.append(Type::BYTE, HOST_END)
+      marshaller.append(Type::BYTE, @message_type)
+      marshaller.append(Type::BYTE, @flags)
+      marshaller.append(Type::BYTE, @protocol)
+      marshaller.append(Type::UINT32, @body_length)
+      marshaller.append(Type::UINT32, @serial)
+
+      headers = []
+      headers << [PATH,         ["o", @path]]         if @path
+      headers << [INTERFACE,    ["s", @interface]]    if @interface
+      headers << [MEMBER,       ["s", @member]]       if @member
+      headers << [ERROR_NAME,   ["s", @error_name]]   if @error_name
+      headers << [REPLY_SERIAL, ["u", @reply_serial]] if @reply_serial
+      headers << [DESTINATION,  ["s", @destination]]  if @destination
+      #           SENDER is not sent, the message bus fills it in instead
+      headers << [SIGNATURE,    ["g", @signature]]    if @signature != ""
+      marshaller.append("a(yv)", headers)
+
+      marshaller.align(8)
+      @params.each do |param|
+        marshaller.append(param[0], param[1])
+      end
+      marshaller.packet
+    end
+
+    # Unmarshall a packet contained in the buffer _buf_ and set the
+    # parameters of the message object according the data found in the
+    # buffer.
+    # Return the detected message and the index pointer of the buffer where
+    # the message data ended.
+    def unmarshall_buffer(buf)
+      buf = buf.dup
+      if buf[0] == ?l
+        endianness = LIL_END
+      else
+        endianness = BIG_END
+      end
+      pu = PacketUnmarshaller.new(buf, endianness)
+      mdata = pu.unmarshall(MESSAGE_SIGNATURE)
+      _, @message_type, @flags, @protocol, @body_length, @serial, 
+        headers = mdata
+
+      headers.each do |struct|
+        case struct[0]
+        when PATH
+          @path = struct[1]
+        when INTERFACE
+          @interface = struct[1]
+        when MEMBER
+          @member = struct[1]
+        when ERROR_NAME
+          @error_name = struct[1]
+        when REPLY_SERIAL
+          @reply_serial = struct[1]
+        when DESTINATION
+          @destination = struct[1]
+        when SENDER
+          @sender = struct[1]
+        when SIGNATURE
+          @signature = struct[1]
+        end
+      end
+      pu.align(8)
+      if @body_length > 0 and @signature
+        @params = pu.unmarshall(@signature, @body_length)
+      end
+      [self, pu.idx]
+    end # def unmarshall_buf
+
+    # Unmarshall the data of a message found in the buffer _buf_ using
+    # Message#unmarshall_buf.
+    # Return the message.
+    def unmarshall(buf)
+      ret, _ = unmarshall_buffer(buf)
+      ret
+    end
+
+    # Make a new exception from ex, mark it as being caused by this message
+    # @api private
+    def annotate_exception(ex)
+      new_ex = ex.exception("#{ex}; caused by #{self}")
+      new_ex.set_backtrace(ex.backtrace)
+      new_ex
+    end
+  end # class Message
+
+  class MethodReturnMessage < Message
+    def initialize
+      super(METHOD_RETURN)
+    end
+  end
+
+  class ErrorMessage < Message
+    def initialize(error_name, description=nil)
+      super(ERROR)
+      @error_name = error_name
+      unless description.nil?
+        add_param(Type::STRING, description)
+      end
+    end
+
+    def self.from_exception(ex)
+      name = if ex.is_a? DBus::Error
+               ex.name
+             else
+               "org.freedesktop.DBus.Error.Failed"
+               # ex.class.to_s # RuntimeError is not a valid name, has no dot
+             end
+      description = ex.message
+      msg = self.new(name, description)
+      msg.add_param(DBus.type("as"), ex.backtrace)
+      msg
+    end
+  end
+end # module DBus

data/lib/dbus/message_queue.rb

@@ -0,0 +1,166 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# 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 "fcntl"
+require "socket"
+
+module DBus
+  class MessageQueue
+    # The socket that is used to connect with the bus.
+    attr_reader :socket
+
+    def initialize(address)
+      @address = address
+      @buffer = ""
+      @is_tcp = false
+      connect
+    end
+
+    # TODO failure modes
+    #
+    # If _non_block_ is true, return nil instead of waiting
+    # EOFError may be raised
+    def pop(non_block = false)
+      buffer_from_socket_nonblock
+      message = message_from_buffer_nonblock
+      unless non_block
+        # we can block
+        while message.nil?
+          r, d, d = IO.select([@socket])
+          if r and r[0] == @socket
+            buffer_from_socket_nonblock
+            message = message_from_buffer_nonblock
+          end
+        end
+      end
+      message
+    end
+
+    def push(message)
+      @socket.write(message.marshall)
+    end
+    alias :<< :push
+
+    private
+
+    # Connect to the bus and initialize the connection.
+    def connect
+      addresses = @address.split ";"
+      # connect to first one that succeeds
+      worked = addresses.find do |a|
+        transport, keyvaluestring = a.split ":"
+        kv_list = keyvaluestring.split ","
+        kv_hash = Hash.new
+        kv_list.each do |kv|
+          key, escaped_value = kv.split "="
+          value = escaped_value.gsub(/%(..)/) {|m| [$1].pack "H2" }
+          kv_hash[key] = value
+        end
+        case transport
+          when "unix"
+          connect_to_unix kv_hash
+          when "tcp"
+          connect_to_tcp kv_hash
+          when "launchd"
+          connect_to_launchd kv_hash
+          else
+          # ignore, report?
+        end
+      end
+      worked
+      # returns the address that worked or nil.
+      # how to report failure?
+    end
+
+    # Connect to a bus over tcp and initialize the connection.
+    def connect_to_tcp(params)
+      #check if the path is sufficient
+      if params.key?("host") and params.key?("port")
+        begin
+          #initialize the tcp socket
+          @socket = TCPSocket.new(params["host"],params["port"].to_i)
+          @socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+          init_connection
+          @is_tcp = true
+        rescue Exception => e
+          puts "Oops:", e
+          puts "Error: Could not establish connection to: #{@path}, will now exit."
+          exit(1) #a little harsh
+        end
+      else
+        #Danger, Will Robinson: the specified "path" is not usable
+        puts "Error: supplied path: #{@path}, unusable! sorry."
+      end
+    end
+
+    # Connect to an abstract unix bus and initialize the connection.
+    def connect_to_unix(params)
+      @socket = Socket.new(Socket::Constants::PF_UNIX,Socket::Constants::SOCK_STREAM, 0)
+      @socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      if ! params['abstract'].nil?
+        if HOST_END == LIL_END
+          sockaddr = "\1\0\0#{params['abstract']}"
+        else
+          sockaddr = "\0\1\0#{params['abstract']}"
+        end
+      elsif ! params['path'].nil?
+        sockaddr = Socket.pack_sockaddr_un(params['path'])
+      end
+      @socket.connect(sockaddr)
+      init_connection
+    end
+
+    def connect_to_launchd(params)
+      socket_var = params['env']
+      socket = `launchctl getenv #{socket_var}`.chomp
+      connect_to_unix 'path' => socket
+    end
+
+    # Initialize the connection to the bus.
+    def init_connection
+      @client = Client.new(@socket)
+      @client.authenticate
+    end
+
+    public                      # FIXME: fix Main loop instead
+
+    # Get and remove one message from the buffer.
+    # Return the message or nil.
+    def message_from_buffer_nonblock
+      return nil if @buffer.empty?
+      ret = nil
+      begin
+        ret, size = Message.new.unmarshall_buffer(@buffer)
+        @buffer.slice!(0, size)
+      rescue IncompleteBufferException
+        # fall through, let ret be null
+      end
+      ret
+    end
+
+    # The buffer size for messages.
+    MSG_BUF_SIZE = 4096
+
+    # Fill (append) the buffer from data that might be available on the
+    # socket.
+    # EOFError may be raised
+    def buffer_from_socket_nonblock
+      @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
+    rescue EOFError
+      raise                     # the caller expects it
+    rescue Errno::EAGAIN
+      # fine, would block
+    rescue Exception => e
+      puts "Oops:", e
+      raise if @is_tcp          # why?
+      puts "WARNING: read_nonblock failed, falling back to .recv"
+      @buffer += @socket.recv(MSG_BUF_SIZE)
+    end
+  end
+end