ruby-dbus 0.16.0 → 0.25.0

data/lib/dbus/matchrule.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file is part of the ruby-dbus project
 # Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
 #
@@ -27,7 +29,7 @@ module DBus
     attr_accessor :path
     # The destination filter.
     attr_accessor :destination
-    # The type type that is matched.
+    # @return [String] The type type that is matched.
     attr_reader :type
 
     # Create a new match rule
@@ -35,13 +37,14 @@ module DBus
       @sender = @interface = @member = @path = @destination = @type = nil
     end
 
-    # Set the message types to filter to type _t_.
+    # Set the message types to filter to type _typ_.
     # Possible message types are: signal, method_call, method_return, and error.
-    def type=(t)
-      if !["signal", "method_call", "method_return", "error"].member?(t)
-        raise MatchRuleException, t
+    def type=(typ)
+      if !["signal", "method_call", "method_return", "error"].member?(typ)
+        raise MatchRuleException, typ
       end
-      @type = t
+
+      @type = typ
     end
 
     # Returns a match rule string version of the object. E.g.:
@@ -58,11 +61,13 @@ module DBus
     def from_s(str)
       str.split(",").each do |eq|
         next unless eq =~ /^(.*)='([^']*)'$/
+
         # "
         name = Regexp.last_match(1)
         val = Regexp.last_match(2)
         raise MatchRuleException, name unless FILTERS.member?(name.to_sym)
-        method(name + "=").call(val)
+
+        method("#{name}=").call(val)
       end
       self
     end
@@ -80,18 +85,13 @@ module DBus
 
     # 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 @type && @type != msg.message_type_s
       return false if @interface && @interface != msg.interface
       return false if @member && @member != msg.member
       return false if @path && @path != msg.path
+
       # FIXME: sender and destination are ignored
       true
     end
-  end # class MatchRule
-end # module D-Bus
+  end
+end

data/lib/dbus/message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # dbus.rb - Module containing the low-level D-Bus implementation
 #
 # This file is part of the ruby-dbus project
@@ -8,16 +10,12 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
+require_relative "raw_message"
+
 # = 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.
@@ -27,7 +25,7 @@ module DBus
     # Mutex that protects updates on the serial number.
     @@serial_mutex = Mutex.new
     # Type of a message (by specification).
-    MESSAGE_SIGNATURE = "yyyyuua(yv)".freeze
+    MESSAGE_SIGNATURE = "yyyyuua(yv)"
 
     # FIXME: following message type constants should be under Message::Type IMO
     # well, yeah sure
@@ -43,6 +41,9 @@ module DBus
     # Signal message type.
     SIGNAL = 4
 
+    # Names used by signal match rules
+    TYPE_NAMES = ["invalid", "method_call", "method_return", "error", "signal"].freeze
+
     # Message flag signyfing that no reply is expected.
     NO_REPLY_EXPECTED = 0x1
     # Message flag signifying that no automatic start is required/must be
@@ -66,11 +67,13 @@ module DBus
     attr_accessor :sender
     # The signature of the message contents.
     attr_accessor :signature
-    # The serial number of the message this message is a reply for.
+    # @return [Integer] (u32)
+    #   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.
+    # @return [Integer] (u32)
+    #   The serial of the message.
     attr_reader :serial
     # The parameters of the message.
     attr_reader :params
@@ -100,27 +103,33 @@ module DBus
 
     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}"
+        "serial=#{serial} reply_serial=#{reply_serial} " \
+        "path=#{path}; interface=#{interface}; member=#{member} " \
+        "error_name=#{error_name}"
+    end
+
+    # @return [String] name of message type, as used in match rules:
+    #    "method_call", "method_return", "signal", "error"
+    def message_type_s
+      TYPE_NAMES[message_type] || "unknown_type_#{message_type}"
     end
 
-    # Create a regular reply to a message _m_.
-    def self.method_return(m)
-      MethodReturnMessage.new.reply_to(m)
+    # Create a regular reply to a message _msg_.
+    def self.method_return(msg)
+      MethodReturnMessage.new.reply_to(msg)
     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)
+    # Create an error reply to a message _msg_.
+    def self.error(msg, error_name, description = nil)
+      ErrorMessage.new(error_name, description).reply_to(msg)
     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
+    # Mark this message as a reply to a another message _msg_, taking
+    # the serial number of _msg_ as reply serial and the sender of _msg_ as
     # destination.
-    def reply_to(m)
-      @reply_serial = m.serial
-      @destination = m.sender
+    def reply_to(msg)
+      @reply_serial = msg.serial
+      @destination = msg.sender
       self
     end
 
@@ -131,6 +140,10 @@ module DBus
       @params << [type, val]
     end
 
+    # "l" or "B"
+    ENDIANNESS_CHAR = ENV.fetch("RUBY_DBUS_ENDIANNESS", HOST_END)
+    ENDIANNESS = RawMessage.endianness(ENDIANNESS_CHAR)
+
     # 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
@@ -145,21 +158,25 @@ module DBus
     SENDER = 7
     SIGNATURE = 8
 
+    RESERVED_PATH = "/org/freedesktop/DBus/Local"
+
     # Marshall the message with its current set parameters and return
     # it in a packet form.
+    # @return [String]
     def marshall
-      if @path == "/org/freedesktop/DBus/Local"
-        raise InvalidDestinationName
+      if @path == RESERVED_PATH
+        # the bus would disconnect us, better explain why
+        raise "Cannot send a message with the reserved path #{RESERVED_PATH}: #{inspect}"
       end
 
-      params = PacketMarshaller.new
-      @params.each do |param|
-        params.append(param[0], param[1])
+      params_marshaller = PacketMarshaller.new(endianness: ENDIANNESS)
+      @params.each do |type, value|
+        params_marshaller.append(type, value)
       end
-      @body_length = params.packet.bytesize
+      @body_length = params_marshaller.packet.bytesize
 
-      marshaller = PacketMarshaller.new
-      marshaller.append(Type::BYTE, HOST_END)
+      marshaller = PacketMarshaller.new(endianness: ENDIANNESS)
+      marshaller.append(Type::BYTE, ENDIANNESS_CHAR.ord)
       marshaller.append(Type::BYTE, @message_type)
       marshaller.append(Type::BYTE, @flags)
       marshaller.append(Type::BYTE, @protocol)
@@ -178,10 +195,8 @@ module DBus
       marshaller.append("a(yv)", headers)
 
       marshaller.align(8)
-      @params.each do |param|
-        marshaller.append(param[0], param[1])
-      end
-      marshaller.packet
+
+      marshaller.packet + params_marshaller.packet
     end
 
     # Unmarshall a packet contained in the buffer _buf_ and set the
@@ -191,13 +206,7 @@ module DBus
     #   the detected message (self) and
     #   the index pointer of the buffer where the message data ended.
     def unmarshall_buffer(buf)
-      buf = buf.dup
-      endianness = if buf[0] == "l"
-                     LIL_END
-                   else
-                     BIG_END
-                   end
-      pu = PacketUnmarshaller.new(buf, endianness)
+      pu = PacketUnmarshaller.new(buf, RawMessage.endianness(buf[0]))
       mdata = pu.unmarshall(MESSAGE_SIGNATURE)
       _, @message_type, @flags, @protocol, @body_length, @serial,
         headers = mdata
@@ -222,21 +231,21 @@ module DBus
           @signature = struct[1]
         end
       end
-      pu.align(8)
-      if @body_length > 0 && @signature
+      pu.align_body
+      if @body_length.positive? && @signature
         @params = pu.unmarshall(@signature, @body_length)
       end
-      [self, pu.idx]
+      [self, pu.consumed_size]
     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
+    def annotate_exception(exc)
+      new_exc = exc.exception("#{exc}; caused by #{self}")
+      new_exc.set_backtrace(exc.backtrace)
+      new_exc
     end
-  end # class Message
+  end
 
   class MethodReturnMessage < Message
     def initialize
@@ -251,17 +260,17 @@ module DBus
       add_param(Type::STRING, description) unless description.nil?
     end
 
-    def self.from_exception(ex)
-      name = if ex.is_a? DBus::Error
-               ex.name
+    def self.from_exception(exc)
+      name = if exc.is_a? DBus::Error
+               exc.name
              else
                "org.freedesktop.DBus.Error.Failed"
-               # ex.class.to_s # RuntimeError is not a valid name, has no dot
+               # exc.class.to_s # RuntimeError is not a valid name, has no dot
              end
-      description = ex.message
+      description = exc.message
       msg = new(name, description)
-      msg.add_param(DBus.type("as"), ex.backtrace)
+      msg.add_param(DBus.type("as"), exc.backtrace)
       msg
     end
   end
-end # module DBus
+end

data/lib/dbus/message_queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This file is part of the ruby-dbus project
 # Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
 # Copyright (C) 2009-2014 Martin Vidner
@@ -16,35 +18,49 @@ module DBus
     # The socket that is used to connect with the bus.
     attr_reader :socket
 
+    # The buffer size for messages.
+    MSG_BUF_SIZE = 4096
+
     def initialize(address)
+      DBus.logger.debug "MessageQueue: #{address}"
       @address = address
       @buffer = ""
+      # Reduce allocations by using a single buffer for our socket
+      @read_buffer = String.new(capacity: MSG_BUF_SIZE)
       @is_tcp = false
+      @mutex = Mutex.new
       connect
     end
 
-    # @param non_block [Boolean] if true, return nil instead of waiting
+    # @param blocking [Boolean]
+    #   true:  wait to return a {Message};
+    #   false: may return `nil`
     # @return [Message,nil] one message or nil if unavailable
     # @raise EOFError
     # @todo failure modes
-    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 && r[0] == @socket
-            buffer_from_socket_nonblock
-            message = message_from_buffer_nonblock
+    def pop(blocking: true)
+      # FIXME: this is not enough, the R/W test deadlocks on shared connections
+      @mutex.synchronize do
+        buffer_from_socket_nonblock
+        message = message_from_buffer_nonblock
+        if blocking
+          # we can block
+          while message.nil?
+            r, _d, _d = IO.select([@socket])
+            if r && r[0] == @socket
+              buffer_from_socket_nonblock
+              message = message_from_buffer_nonblock
+            end
           end
         end
+        message
       end
-      message
     end
 
     def push(message)
-      @socket.write(message.marshall)
+      @mutex.synchronize do
+        @socket.write(message.marshall)
+      end
     end
     alias << push
 
@@ -54,7 +70,7 @@ module DBus
     def connect
       addresses = @address.split ";"
       # connect to first one that succeeds
-      worked = addresses.find do |a|
+      addresses.find do |a|
         transport, keyvaluestring = a.split ":"
         kv_list = keyvaluestring.split ","
         kv_hash = {}
@@ -74,29 +90,29 @@ module DBus
           # 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") && params.key?("port")
+      host = params["host"]
+      port = params["port"]
+      if host && port
         begin
           # initialize the tcp socket
-          @socket = TCPSocket.new(params["host"], params["port"].to_i)
+          @socket = TCPSocket.new(host, 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."
+          puts "Error: Could not establish connection to: #{host}:#{port}, 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."
+        puts "Error: supplied params: #{@params}, unusable! sorry."
       end
     end
 
@@ -125,7 +141,7 @@ module DBus
 
     # Initialize the connection to the bus.
     def init_connection
-      client = Client.new(@socket)
+      client = Authentication::Client.new(@socket)
       client.authenticate
     end
 
@@ -135,6 +151,7 @@ module DBus
     # @return [Message,nil] the message or nil if unavailable
     def message_from_buffer_nonblock
       return nil if @buffer.empty?
+
       ret = nil
       begin
         ret, size = Message.new.unmarshall_buffer(@buffer)
@@ -145,15 +162,12 @@ module DBus
       ret
     end
 
-    # The buffer size for messages.
-    MSG_BUF_SIZE = 4096
-
     # Fill (append) the buffer from data that might be available on the
     # socket.
     # @return [void]
     # @raise EOFError
     def buffer_from_socket_nonblock
-      @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
+      @buffer += @socket.read_nonblock(MSG_BUF_SIZE, @read_buffer)
     rescue EOFError
       raise # the caller expects it
     rescue Errno::EAGAIN
@@ -161,6 +175,7 @@ module DBus
     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

data/lib/dbus/node_tree.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2023 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.
+
+module DBus
+  # Has a tree of {Node}s, refering to {Object}s or to {ProxyObject}s.
+  class NodeTree
+    # @return [Node]
+    attr_reader :root
+
+    def initialize
+      @root = Node.new("/")
+    end
+
+    # Get the object node corresponding to the given *path*.
+    # @param path [ObjectPath]
+    # @param create [Boolean] if true, the the {Node}s in the path are created
+    #   if they do not already exist.
+    # @return [Node,nil]
+    def get_node(path, create: false)
+      n = @root
+      path.sub(%r{^/}, "").split("/").each do |elem|
+        if !(n[elem])
+          return nil if !create
+
+          n[elem] = Node.new(elem)
+        end
+        n = n[elem]
+      end
+      n
+    end
+  end
+
+  # = Object path node class
+  #
+  # Class representing a node on an object path.
+  class Node < Hash
+    # @return [DBus::Object,DBus::ProxyObject,nil]
+    #   The D-Bus object contained by the node.
+    attr_accessor :object
+
+    # The name of the node.
+    # @return [String] the last component of its object path, or "/"
+    attr_reader :name
+
+    # Create a new node with a given _name_.
+    def initialize(name)
+      super()
+      @name = name
+      @object = nil
+    end
+
+    # Return an XML string representation of the node.
+    # It is shallow, not recursing into subnodes
+    # @param node_opath [String]
+    def to_xml(node_opath)
+      xml = '<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+'
+      xml += "<node name=\"#{node_opath}\">\n"
+      each_key do |k|
+        xml += "  <node name=\"#{k}\" />\n"
+      end
+      @object&.intfs&.each_value do |v|
+        xml += v.to_xml
+      end
+      xml += "</node>"
+      xml
+    end
+
+    # Return inspect information of the node.
+    def inspect
+      # Need something here
+      "<DBus::Node #{sub_inspect}>"
+    end
+
+    # Return instance inspect information, used by Node#inspect.
+    def sub_inspect
+      s = ""
+      if !@object.nil?
+        s += format("%x ", @object.object_id)
+      end
+      contents_sub_inspect = keys
+                             .map { |k| "#{k} => #{self[k].sub_inspect}" }
+                             .join(",")
+      "#{s}{#{contents_sub_inspect}}"
+    end
+
+    # All objects (not paths) under this path (except itself).
+    # @return [Array<DBus::Object>]
+    def descendant_objects
+      children_objects = values.map(&:object).compact
+      descendants = values.map(&:descendant_objects)
+      flat_descendants = descendants.reduce([], &:+)
+      children_objects + flat_descendants
+    end
+  end
+end