ruby-dbus 0.18.1 → 0.20.0

data/lib/dbus/bus.rb

@@ -76,6 +76,7 @@ module DBus
     def export(obj)
       obj.service = self
       get_node(obj.path, create: true).object = obj
+      object_manager_for(obj)&.object_added(obj)
     end
 
     # Undo exporting an object _obj_.
@@ -93,6 +94,7 @@ module DBus
       parent_node = get_node(parent_path, create: false)
       return false unless parent_node
 
+      object_manager_for(obj)&.object_removed(obj)
       obj.service = nil
       parent_node.delete(node_name).object
     end
@@ -112,18 +114,51 @@ module DBus
         end
         n = n[elem]
       end
-      if n.nil?
-        DBus.logger.debug "Warning, unknown object #{path}"
-      end
       n
     end
 
+    # Find the (closest) parent of *object*
+    # implementing the ObjectManager interface, or nil
+    # @return [DBus::Object,nil]
+    def object_manager_for(object)
+      path = object.path
+      node_chain = get_node_chain(path)
+      om_node = node_chain.reverse_each.find do |node|
+        node.object&.is_a? DBus::ObjectManager
+      end
+      om_node&.object
+    end
+
+    # All objects (not paths) under this path (except itself).
+    # @param path [ObjectPath]
+    # @return [Array<DBus::Object>]
+    # @raise ArgumentError if the *path* does not exist
+    def descendants_for(path)
+      node = get_node(path, create: false)
+      raise ArgumentError, "Object path #{path} doesn't exist" if node.nil?
+
+      node.descendant_objects
+    end
+
     #########
 
     private
 
     #########
 
+    # @raise ArgumentError if the *path* does not exist
+    def get_node_chain(path)
+      n = @root
+      result = [n]
+      path.sub(%r{^/}, "").split("/").each do |elem|
+        n = n[elem]
+        raise ArgumentError, "Object path #{path} doesn't exist" if n.nil?
+
+        result.push(n)
+      end
+      result
+    end
+
     # Perform a recursive retrospection on the given current _node_
     # on the given _path_.
     def rec_introspect(node, path)
@@ -198,6 +233,15 @@ module DBus
                              .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
 
   # FIXME: rename Connection to Bus?
@@ -233,7 +277,6 @@ module DBus
       @method_call_msgs = {}
       @signal_matchrules = {}
       @proxy = nil
-      @object_root = Node.new("/")
     end
 
     # Dispatch all messages that are available in the queue,
@@ -561,23 +604,22 @@ module DBus
           DBus.logger.debug "Got method call on /org/freedesktop/DBus"
         end
         node = @service.get_node(msg.path, create: false)
-        if !node
-          reply = Message.error(msg, "org.freedesktop.DBus.Error.UnknownObject",
-                                "Object #{msg.path} doesn't exist")
-          @message_queue.push(reply)
-        # handle introspectable as an exception:
-        elsif msg.interface == "org.freedesktop.DBus.Introspectable" &&
-              msg.member == "Introspect"
+        # introspect a known path even if there is no object on it
+        if node &&
+           msg.interface == "org.freedesktop.DBus.Introspectable" &&
+           msg.member == "Introspect"
           reply = Message.new(Message::METHOD_RETURN).reply_to(msg)
           reply.sender = @unique_name
           xml = node.to_xml(msg.path)
           reply.add_param(Type::STRING, xml)
           @message_queue.push(reply)
+        # dispatch for an object
+        elsif node&.object
+          node.object.dispatch(msg)
         else
-          obj = node.object
-          return if obj.nil? # FIXME, pushes no reply
-
-          obj&.dispatch(msg)
+          reply = Message.error(msg, "org.freedesktop.DBus.Error.UnknownObject",
+                                "Object #{msg.path} doesn't exist")
+          @message_queue.push(reply)
         end
       when DBus::Message::SIGNAL
         # the signal can match multiple different rules

data/lib/dbus/introspect.rb

@@ -270,7 +270,7 @@ module DBus
   class Property
     # @return [Symbol] The name of the property, for example FooBar.
     attr_reader :name
-    # @return [SingleCompleteType]
+    # @return [Type]
     attr_reader :type
     # @return [Symbol] :read :write or :readwrite
     attr_reader :access
@@ -282,6 +282,7 @@ module DBus
 
     def initialize(name, type, access, ruby_name:)
       @name = name.to_sym
+      type = DBus.type(type) unless type.is_a?(Type)
       @type = type
       @access = access
       @ruby_name = ruby_name

data/lib/dbus/marshall.rb

@@ -327,7 +327,7 @@ module DBus
         # Damn ruby rocks here
         val = val.to_a
       end
-      # If string is recieved and ay is expected, explode the string
+      # If string is received and ay is expected, explode the string
       if val.is_a?(String) && child_type.sigtype == Type::BYTE
         val = val.bytes
       end

data/lib/dbus/message_queue.rb

@@ -19,9 +19,11 @@ module DBus
     attr_reader :socket
 
     def initialize(address)
+      DBus.logger.debug "MessageQueue: #{address}"
       @address = address
       @buffer = ""
       @is_tcp = false
+      @mutex = Mutex.new
       connect
     end
 
@@ -32,23 +34,28 @@ module DBus
     # @raise EOFError
     # @todo failure modes
     def pop(blocking: true)
-      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
+      # 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
 
@@ -129,7 +136,7 @@ module DBus
 
     # Initialize the connection to the bus.
     def init_connection
-      client = Client.new(@socket)
+      client = Authentication::Client.new(@socket)
       client.authenticate
     end
 

data/lib/dbus/object.rb

@@ -89,8 +89,11 @@ module DBus
           # while the superclass keeps the old one.
           self.intfs = intfs.merge(name => @@cur_intf)
         end
-        yield
-        @@cur_intf = nil
+        begin
+          yield
+        ensure
+          @@cur_intf = nil
+        end
       end
     end
 
@@ -122,7 +125,8 @@ module DBus
     #
     # @param ruby_name [Symbol] :foo_bar is exposed as FooBar;
     #   use dbus_name to override
-    # @param type a signature like "s" or "a(uus)" or Type::STRING
+    # @param type [Type,SingleCompleteType]
+    #   a signature like "s" or "a(uus)" or Type::STRING
     # @param dbus_name [String] if not given it is made
     #   by CamelCasing the ruby_name. foo_bar becomes FooBar
     #   to convert the Ruby convention to the DBus convention.
@@ -387,6 +391,23 @@ module DBus
       property
     end
 
+    # Generates information about interfaces and properties of the object
+    #
+    # Returns a hash containing interfaces names as keys. Each value is the
+    # same hash that would be returned by the
+    # org.freedesktop.DBus.Properties.GetAll() method for that combination of
+    # object path and interface. If an interface has no properties, the empty
+    # hash is returned.
+    #
+    # @return [Hash{String => Hash{String => Data::Base}}] interface -> property -> value
+    def interfaces_and_properties
+      get_all_method = self.class.make_method_name("org.freedesktop.DBus.Properties", :GetAll)
+
+      intfs.keys.each_with_object({}) do |interface, hash|
+        hash[interface] = public_send(get_all_method, interface).first
+      end
+    end
+
     ####################################################################
 
     # use the above defined methods to declare the property-handling
@@ -459,5 +480,12 @@ module DBus
 
       dbus_signal :PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
     end
+
+    dbus_interface "org.freedesktop.DBus.Introspectable" do
+      dbus_method :Introspect, "out xml_data:s" do
+        # The body is not used, Connection#process handles it instead
+        # which is more efficient and handles paths without objects.
+      end
+    end
   end
 end

data/lib/dbus/object_manager.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# This file is part of the ruby-dbus project
+# Copyright (C) 2022 José Iván López González
+# Copyright (C) 2022 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
+  # A mixin for {DBus::Object} implementing
+  # {https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager
+  # org.freedesktop.DBus.ObjectManager}.
+  #
+  # {Service#export} and {Service#unexport} will look for an ObjectManager
+  # parent in the path hierarchy. If found, it will emit InterfacesAdded
+  # or InterfacesRemoved, as appropriate.
+  module ObjectManager
+    OBJECT_MANAGER_INTERFACE = "org.freedesktop.DBus.ObjectManager"
+
+    # @return [Hash{ObjectPath => Hash{String => Hash{String => Data::Base}}}]
+    #   object -> interface -> property -> value
+    def managed_objects
+      # FIXME: also fix the "service" concept
+      descendant_objects = @service.descendants_for(path)
+      descendant_objects.each_with_object({}) do |obj, hash|
+        hash[obj.path] = obj.interfaces_and_properties
+      end
+    end
+
+    # @param object [DBus::Object]
+    # @return [void]
+    def object_added(object)
+      InterfacesAdded(object.path, object.interfaces_and_properties)
+    end
+
+    # @param object [DBus::Object]
+    # @return [void]
+    def object_removed(object)
+      InterfacesRemoved(object.path, object.intfs.keys)
+    end
+
+    def self.included(base)
+      base.class_eval do
+        dbus_interface OBJECT_MANAGER_INTERFACE do
+          dbus_method :GetManagedObjects, "out res:a{oa{sa{sv}}}" do
+            [managed_objects]
+          end
+
+          dbus_signal :InterfacesAdded, "object:o, interfaces_and_properties:a{sa{sv}}"
+          dbus_signal :InterfacesRemoved, "object:o, interfaces:as"
+        end
+      end
+    end
+  end
+end

data/lib/dbus.rb

@@ -24,6 +24,7 @@ require_relative "dbus/matchrule"
 require_relative "dbus/message"
 require_relative "dbus/message_queue"
 require_relative "dbus/object"
+require_relative "dbus/object_manager"
 require_relative "dbus/object_path"
 require_relative "dbus/proxy_object"
 require_relative "dbus/proxy_object_factory"

data/spec/auth_spec.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::Authentication::Client do
+  let(:socket) { instance_double("Socket") }
+  let(:subject) { described_class.new(socket) }
+
+  before(:each) do
+    allow(Process).to receive(:uid).and_return(999)
+    allow(subject).to receive(:send_nul_byte)
+  end
+
+  describe "#next_state" do
+    it "raises when I forget to handle a state" do
+      subject.instance_variable_set(:@state, :Denmark)
+      expect { subject.__send__(:next_state, []) }.to raise_error(RuntimeError, /unhandled state :Denmark/)
+    end
+  end
+
+  def expect_protocol(pairs)
+    pairs.each do |we_say, server_says|
+      expect(subject).to receive(:write_line).with(we_say)
+      next if server_says.nil?
+
+      expect(subject).to receive(:read_line).and_return(server_says)
+    end
+  end
+
+  context "with ANONYMOUS" do
+    let(:subject) { described_class.new(socket, [DBus::Authentication::Anonymous]) }
+
+    it "authentication passes" do
+      expect_protocol [
+        ["AUTH ANONYMOUS 527562792044427573\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "ERROR not for anonymous\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+    end
+  end
+
+  context "with EXTERNAL" do
+    let(:subject) { described_class.new(socket, [DBus::Authentication::External]) }
+
+    it "authentication passes, and address_uuid is set" do
+      expect_protocol [
+        ["AUTH EXTERNAL 393939\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+      expect(subject.address_uuid).to eq "ffffffffffffffffffffffffffffffff"
+    end
+
+    context "when the server says superfluous things before an OK" do
+      it "authentication passes" do
+        expect_protocol [
+          ["AUTH EXTERNAL 393939\r\n", "WOULD_YOU_LIKE_SOME_TEA\r\n"],
+          ["ERROR\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+          ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+          ["BEGIN\r\n"]
+        ]
+
+        expect { subject.authenticate }.to_not raise_error
+      end
+    end
+
+    context "when the server messes up NEGOTIATE_UNIX_FD" do
+      it "authentication fails orderly" do
+        expect_protocol [
+          ["AUTH EXTERNAL 393939\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+          ["NEGOTIATE_UNIX_FD\r\n", "I_DONT_NEGOTIATE_WITH_TENORISTS\r\n"]
+        ]
+
+        allow(socket).to receive(:close) # want to get rid of this
+        # TODO: quote the server error message?
+        expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /Unknown server reply/)
+      end
+    end
+
+    context "when the server replies with ERROR" do
+      it "authentication fails orderly" do
+        expect_protocol [
+          ["AUTH EXTERNAL 393939\r\n", "ERROR something failed\r\n"],
+          ["CANCEL\r\n", "REJECTED DBUS_COOKIE_SHA1\r\n"]
+        ]
+
+        allow(socket).to receive(:close) # want to get rid of this
+        # TODO: quote the server error message?
+        expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /exhausted/)
+      end
+    end
+  end
+
+  context "with EXTERNAL without uid" do
+    let(:subject) do
+      described_class.new(socket, [DBus::Authentication::External, DBus::Authentication::ExternalWithoutUid])
+    end
+
+    it "authentication passes" do
+      expect_protocol [
+        ["AUTH EXTERNAL 393939\r\n", "REJECTED EXTERNAL\r\n"],
+        # this succeeds when we connect to a privileged container,
+        # where outside-non-root becomes inside-root
+        ["AUTH EXTERNAL\r\n", "DATA\r\n"],
+        ["DATA\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+    end
+  end
+
+  context "with a rejected mechanism and then EXTERNAL" do
+    let(:rejected_mechanism) do
+      double("Mechanism", name: "WIMP", call: [:MechContinue, "I expect to be rejected"])
+    end
+
+    let(:subject) { described_class.new(socket, [rejected_mechanism, DBus::Authentication::External]) }
+
+    it "authentication eventually passes" do
+      expect_protocol [
+        [/^AUTH WIMP .*\r\n/, "REJECTED EXTERNAL\r\n"],
+        ["AUTH EXTERNAL 393939\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+    end
+  end
+
+  context "with a DATA-using mechanism" do
+    let(:mechanism) do
+      double("Mechanism", name: "CHALLENGE_ME", call: [:MechContinue, "1"])
+    end
+
+    # try it twice to test calling #use_next_mechanism
+    let(:subject) { described_class.new(socket, [mechanism, mechanism]) }
+
+    it "authentication fails orderly when the server says ERROR" do
+      expect_protocol [
+        ["AUTH CHALLENGE_ME 31\r\n", "ERROR something failed\r\n"],
+        ["CANCEL\r\n", "REJECTED DBUS_COOKIE_SHA1\r\n"],
+        ["AUTH CHALLENGE_ME 31\r\n", "ERROR something failed\r\n"],
+        ["CANCEL\r\n", "REJECTED DBUS_COOKIE_SHA1\r\n"]
+      ]
+
+      allow(socket).to receive(:close) # want to get rid of this
+      # TODO: quote the server error message?
+      expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /exhausted/)
+    end
+
+    it "authentication fails orderly when the server says ERROR and then changes its mind" do
+      expect_protocol [
+        ["AUTH CHALLENGE_ME 31\r\n", "ERROR something failed\r\n"],
+        ["CANCEL\r\n", "I_CHANGED_MY_MIND please come back\r\n"]
+      ]
+
+      allow(socket).to receive(:close) # want to get rid of this
+      # TODO: quote the server error message?
+      expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /Unknown.*MIND.*REJECTED/)
+    end
+
+    it "authentication passes when the server says superfluous things before DATA" do
+      expect_protocol [
+        ["AUTH CHALLENGE_ME 31\r\n", "WOULD_YOU_LIKE_SOME_TEA\r\n"],
+        ["ERROR\r\n", "DATA\r\n"],
+        ["DATA 31\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+    end
+
+    it "authentication passes when the server decides not to need the DATA" do
+      expect_protocol [
+        ["AUTH CHALLENGE_ME 31\r\n", "OK ffffffffffffffffffffffffffffffff\r\n"],
+        ["NEGOTIATE_UNIX_FD\r\n", "AGREE_UNIX_FD\r\n"],
+        ["BEGIN\r\n"]
+      ]
+
+      expect { subject.authenticate }.to_not raise_error
+    end
+  end
+
+  context "with a mechanism returning :MechError" do
+    let(:fallible_mechanism) do
+      double(name: "FALLIBLE", call: [:MechError, "not my best day"])
+    end
+
+    let(:subject) { described_class.new(socket, [fallible_mechanism]) }
+
+    it "authentication fails orderly" do
+      expect_protocol [
+        ["ERROR not my best day\r\n", "REJECTED DBUS_COOKIE_SHA1\r\n"]
+      ]
+
+      allow(socket).to receive(:close) # want to get rid of thise
+      expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /exhausted/)
+    end
+  end
+
+  context "with a badly implemented mechanism" do
+    let(:buggy_mechanism) do
+      double(name: "buggy", call: [:smurf, nil])
+    end
+
+    let(:subject) { described_class.new(socket, [buggy_mechanism]) }
+
+    it "authentication fails before protoxol is exchanged" do
+      expect(subject).to_not receive(:write_line)
+      expect(subject).to_not receive(:read_line)
+
+      expect { subject.authenticate }.to raise_error(DBus::AuthenticationFailed, /smurf/)
+    end
+  end
+end

data/spec/node_spec.rb

@@ -20,4 +20,50 @@ describe DBus::Node do
       expect(parent.inspect).to match(/<DBus::Node [0-9a-f]+ {child0 => {},child1 => {},child2 => {}}>/)
     end
   end
+
+  describe "#descendant_objects" do
+    let(:manager_path) { "/org/example/FooManager" }
+    let(:child_paths) do
+      [
+        # note that "/org/example/FooManager/good"
+        # is a path under a managed object but there is no object there
+        "/org/example/FooManager/good/1",
+        "/org/example/FooManager/good/2",
+        "/org/example/FooManager/good/3",
+        "/org/example/FooManager/bad/1",
+        "/org/example/FooManager/bad/2"
+      ]
+    end
+
+    let(:non_child_paths) do
+      [
+        "/org/example/BarManager/good/1",
+        "/org/example/BarManager/good/2"
+      ]
+    end
+
+    context "on the bus" do
+      let(:bus) { DBus::ASessionBus.new }
+      let(:service) do
+        # if we used org.ruby.service it would be a name collision
+        # ... which would not break the test for lucky reasons
+        bus.request_service("org.ruby.service.scratch")
+      end
+
+      before do
+        service.export(DBus::Object.new(manager_path))
+        non_child_paths.each do |p|
+          service.export(DBus::Object.new(p))
+        end
+      end
+
+      it "returns just the descendants of the specified objects" do
+        child_exported_objects = child_paths.map { |p| DBus::Object.new(p) }
+        child_exported_objects.each { |obj| service.export(obj) }
+
+        node = service.get_node(manager_path, create: false)
+        expect(node.descendant_objects).to eq child_exported_objects
+      end
+    end
+  end
 end

data/spec/object_manager_spec.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::ObjectManager do
+  describe "GetManagedObjects" do
+    let(:bus) { DBus::ASessionBus.new }
+    let(:service) { bus["org.ruby.service"] }
+    let(:obj) { service["/org/ruby/MyInstance"] }
+    let(:parent_iface) { obj["org.ruby.TestParent"] }
+    let(:om_iface) { obj["org.freedesktop.DBus.ObjectManager"] }
+
+    it "returns the interfaces and properties of currently managed objects" do
+      c1_opath = parent_iface.New("child1")
+      c2_opath = parent_iface.New("child2")
+
+      parent_iface.Delete(c1_opath)
+      expected_gmo = {
+        "/org/ruby/MyInstance/child2" => {
+          "org.freedesktop.DBus.Introspectable" => {},
+          "org.freedesktop.DBus.Properties" => {},
+          "org.ruby.TestChild" => { "Name" => "Child2" }
+        }
+      }
+      expect(om_iface.GetManagedObjects).to eq(expected_gmo)
+
+      parent_iface.Delete(c2_opath)
+      expect(om_iface.GetManagedObjects).to eq({})
+    end
+  end
+end

data/spec/object_spec.rb

@@ -61,6 +61,16 @@ describe DBus::Object do
         end
       end.to raise_error(DBus::Object::UndefinedInterface)
     end
+
+    it "fails when the signature is invalid" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_interface "org.ruby.ServerTest" do
+            dbus_reader :foo2, "!"
+          end
+        end
+      end.to raise_error(DBus::Type::SignatureException)
+    end
   end
 
   describe ".dbus_reader, when paired with attr_accessor" do