ruby-dbus 0.16.0 → 0.25.0

data/lib/dbus/xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # dbus/xml.rb - introspection parser, rexml/nokogiri abstraction
 #
 # This file is part of the ruby-dbus project
@@ -9,11 +11,17 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
-# TODO: check if it is slow, make replaceable
-require "rexml/document"
+# Our gemspec says rexml is needed and nokogiri is optional
+# but in fact either will do
+
 begin
   require "nokogiri"
 rescue LoadError
+  begin
+    require "rexml/document"
+  rescue LoadError
+    raise LoadError, "cannot load nokogiri OR rexml/document"
+  end
 end
 
 module DBus
@@ -26,14 +34,23 @@ module DBus
       attr_accessor :backend
     end
     # Creates a new parser for XML data in string _xml_.
+    # @param xml [String]
     def initialize(xml)
       @xml = xml
     end
 
     class AbstractXML
+      # @!method initialize(xml)
+      # @abstract
+
+      # @!method each(xpath)
+      # @abstract
+      # yields nodes which match xpath of type AbstractXML::Node
+
       def self.have_nokogiri?
         Object.const_defined?("Nokogiri")
       end
+
       class Node
         def initialize(node)
           @node = node
@@ -46,12 +63,6 @@ module DBus
         # yields child nodes which match xpath of type AbstractXML::Node
         def each(xpath); end
       end
-      # required methods
-      # initialize parser with xml string
-      def initialize(xml); end
-
-      # yields nodes which match xpath of type AbstractXML::Node
-      def each(xpath); end
     end
 
     class NokogiriParser < AbstractXML
@@ -64,7 +75,9 @@ module DBus
           @node.search(path).each { |node| block.call NokogiriNode.new(node) }
         end
       end
+
       def initialize(xml)
+        super()
         @doc = Nokogiri.XML(xml)
       end
 
@@ -83,7 +96,9 @@ module DBus
           @node.elements.each(path) { |node| block.call REXMLNode.new(node) }
         end
       end
+
       def initialize(xml)
+        super()
         @doc = REXML::Document.new(xml)
       end
 
@@ -125,6 +140,10 @@ module DBus
           parse_methsig(se, s)
           i << s
         end
+        e.each("property") do |pe|
+          p = Property.from_xml(pe)
+          i << p
+        end
       end
       d = Time.now - t
       if d > 2
@@ -136,28 +155,30 @@ module DBus
     ######################################################################
     private
 
-    # Parses a method signature XML element _e_ and initialises
-    # method/signal _m_.
-    def parse_methsig(e, m)
-      e.each("arg") do |ae|
+    # Parses a method signature XML element *elem* and initialises
+    # method/signal *methsig*.
+    # @param elem [AbstractXML::Node]
+    def parse_methsig(elem, methsig)
+      elem.each("arg") do |ae|
         name = ae["name"]
         dir = ae["direction"]
         sig = ae["type"]
-        if m.is_a?(DBus::Signal)
+        case methsig
+        when DBus::Signal
           # Direction can only be "out", ignore it
-          m.add_fparam(name, sig)
-        elsif m.is_a?(DBus::Method)
+          methsig.add_fparam(name, sig)
+        when DBus::Method
           case dir
           # This is a method, so dir defaults to "in"
           when "in", nil
-            m.add_fparam(name, sig)
+            methsig.add_fparam(name, sig)
           when "out"
-            m.add_return(name, sig)
+            methsig.add_return(name, sig)
           end
         else
           raise NotImplementedError, dir
         end
       end
     end
-  end # class IntrospectXMLParser
-end # module DBus
+  end
+end

data/lib/dbus.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,46 +10,55 @@
 # License, version 2.1 as published by the Free Software Foundation.
 # See the file "COPYING" for the exact licensing terms.
 
+module DBus
+  # Protocol character signifying big endianness.
+  BIG_END = "B"
+  # Protocol character signifying little endianness.
+  LIL_END = "l"
+
+  # Protocol character signifying the host's endianness.
+  # "S": unpack as uint16, native endian
+  HOST_END = { 1 => BIG_END, 256 => LIL_END }.fetch("\x00\x01".unpack1("S"))
+end
+# ^ That's because dbus/message needs HOST_END early
+
 require_relative "dbus/api_options"
 require_relative "dbus/auth"
 require_relative "dbus/bus"
 require_relative "dbus/bus_name"
+require_relative "dbus/connection"
+require_relative "dbus/data"
+require_relative "dbus/emits_changed_signal"
 require_relative "dbus/error"
 require_relative "dbus/introspect"
 require_relative "dbus/logger"
+require_relative "dbus/main"
 require_relative "dbus/marshall"
 require_relative "dbus/matchrule"
 require_relative "dbus/message"
 require_relative "dbus/message_queue"
+require_relative "dbus/node_tree"
 require_relative "dbus/object"
+require_relative "dbus/object_manager"
 require_relative "dbus/object_path"
+require_relative "dbus/object_server"
+require_relative "dbus/platform"
 require_relative "dbus/proxy_object"
 require_relative "dbus/proxy_object_factory"
 require_relative "dbus/proxy_object_interface"
+require_relative "dbus/proxy_service"
+require_relative "dbus/raw_message"
 require_relative "dbus/type"
 require_relative "dbus/xml"
 
 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".freeze
-
-  # Byte signifying big endianness.
-  BIG_END = "B".freeze
-  # Byte signifying little endianness.
-  LIL_END = "l".freeze
-
-  # Byte signifying the host's endianness.
-  HOST_END = if [0x01020304].pack("L").unpack("V")[0] == 0x01020304
-               LIL_END
-             else
-               BIG_END
-             end
+  # Comparing symbols is faster than strings
+  # @return [:little,:big]
+  HOST_ENDIANNESS = RawMessage.endianness(HOST_END)
 
   # General exceptions.
 
@@ -69,4 +80,4 @@ module DBus
   # Exception raised when invalid introspection data is parsed/used.
   class InvalidIntrospectionData < Exception
   end
-end # module DBus
+end

data/ruby-dbus.gemspec

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 # -*- ruby -*-
-require "rubygems"
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "ruby-dbus"
@@ -7,7 +8,7 @@ GEMSPEC = Gem::Specification.new do |s|
   s.summary = "Ruby module for interaction with D-Bus"
   s.description = "Pure Ruby module for interaction with D-Bus IPC system"
   s.version = File.read("VERSION").strip
-  s.license = "LGPL-2.1"
+  s.license = "LGPL-2.1-or-later"
   s.author = "Ruby DBus Team"
   s.email = "martin.github@vidner.net"
   s.homepage = "https://github.com/mvidner/ruby-dbus"
@@ -18,15 +19,21 @@ GEMSPEC = Gem::Specification.new do |s|
   ]
   s.require_path = "lib"
 
-  s.required_ruby_version = ">= 2.0.0"
+  s.required_ruby_version = ">= 2.4.0"
 
-  # This is optional
+  s.add_runtime_dependency "logger"
+  # Either of rexml and nokogiri is required
+  # but AFAIK gemspec cannot express that.
+  # Nokogiri is recommended as rexml is dead slow.
+  s.add_runtime_dependency "rexml"
   # s.add_runtime_dependency "nokogiri"
 
-  s.add_development_dependency "coveralls"
+  # workaround: rubocop-1.0 needs base64 which is no longer in stdlib in newer rubies
+  s.add_development_dependency "base64"
+  s.add_development_dependency "ostruct"
   s.add_development_dependency "packaging_rake_tasks"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 3"
-  s.add_development_dependency "rubocop", "= 0.41.2"
   s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-lcov"
 end

data/spec/async_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test the binding of dbus concepts to ruby concepts
 require_relative "spec_helper"
 require "dbus"

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/binding_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test the binding of dbus concepts to ruby concepts
 require_relative "spec_helper"
 

data/spec/bus_and_xml_backend_spec.rb

@@ -1,9 +1,13 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test the bus class
 require_relative "spec_helper"
 
 require "rubygems"
-require "nokogiri"
+# If we have nokogiri, rexml is normally omitted
+# but here we include it for test coverage
+require "rexml"
 require "dbus"
 
 describe "BusAndXmlBackendTest" do

data/spec/bus_connection_spec.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::BusConnection do
+  let(:bus) { DBus::ASessionBus.new }
+
+  # deprecated method
+  describe "#request_service", tag_bus: true, tag_deprecated: true do
+    context "when the name request succeeds" do
+      # Formerly it returned Service, now ObjectServer takes its role.
+      # Replacement: server = bus.object_server; bus.request_name(name)
+      it "returns something which can export objects" do
+        name = "org.rubygems.ruby_dbus.RequestServiceTest"
+        server = bus.request_service(name)
+        expect(server).to respond_to(:export)
+        bus.proxy.ReleaseName(name)
+      end
+    end
+
+    context "when the name is taken already", tag_service: true do
+      it "raises NameRequestError... too late" do
+        name = "org.ruby.service"
+        expect do
+          bus.request_service(name)
+          _unrelated_call = bus.proxy.GetId.first
+        end.to raise_error(DBus::Connection::NameRequestError)
+        # The call fails but it means we did not get the name RIGHT AWAY
+        # but we are still queued to get it as soon as the current owner
+        # gives it up.
+        # So even now we have to the bus to remove us from the queue
+        bus.proxy.ReleaseName(name)
+      end
+    end
+
+    # This only works with our special bus setup
+    context "when we're not allowed to own the name", tag_limited_bus: true do
+      it "raises an error... too late" do
+        name = "org.rubygems.ruby_dbus.NobodyCanOwnThisName"
+        expect do
+          bus.request_service(name)
+          _unrelated_call = bus.proxy.GetId.first
+        end.to raise_error(DBus::Error, /not allowed to own the service/)
+      end
+    end
+  end
+
+  describe "#request_name", tag_bus: true do
+    context "when the name request succeeds" do
+      it "returns a success code" do
+        name = "org.rubygems.ruby_dbus.RequestNameTest"
+        expect(bus.request_name(name)).to eq DBus::Connection::REQUEST_NAME_REPLY_PRIMARY_OWNER
+        # second time, considered also a success
+        expect(bus.request_name(name)).to eq DBus::Connection::REQUEST_NAME_REPLY_ALREADY_OWNER
+        bus.release_name(name)
+      end
+    end
+
+    context "when the name is taken already", tag_service: true do
+      it "raises NameRequestError" do
+        name = "org.ruby.service"
+        expect do
+          bus.request_name(name)
+        end.to raise_error(DBus::Connection::NameRequestError)
+      end
+    end
+
+    context "when the name is taken already but we request queuing", tag_service: true do
+      it "raises NameRequestError but we are queued" do
+        name = "org.ruby.service"
+        owning = nil
+        # TODO: we do not expect the handlers to run
+        bus.on_name_acquired { owning = true }
+        bus.on_name_lost { owning = false }
+        expect do
+          bus.request_name(name, queue: true)
+        end.to raise_error(DBus::Connection::NameRequestError)
+        expect(bus.release_name(name)).to eq DBus::BusConnection::RELEASE_NAME_REPLY_RELEASED
+      end
+    end
+
+    context "when we're not allowed to own the name", tag_limited_bus: true do
+      it "raises an error" do
+        name = "org.rubygems.ruby_dbus.NobodyCanOwnThisName"
+        expect do
+          bus.request_name(name)
+        end.to raise_error(DBus::Error, /not allowed to own the service/)
+      end
+    end
+  end
+end

data/spec/bus_name_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 require "dbus"
 
@@ -17,7 +19,7 @@ describe DBus::BusName do
       expect(described_class.valid?("Empty.Last.Component.")).to be_falsey
       expect(described_class.valid?("Invalid.Ch@r@cter")).to be_falsey
       expect(described_class.valid?("/Invalid-Character")).to be_falsey
-      long_name = "a." + ("long." * 100) + "name"
+      long_name = "a.#{"long." * 100}name"
       expect(described_class.valid?(long_name)).to be_falsey
       expect(described_class.valid?("org.7_zip.Archiver")).to be_falsey
     end

data/spec/bus_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test the bus class
 require_relative "spec_helper"
 

data/spec/byte_array_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 require_relative "spec_helper"
 
 require "dbus"

data/spec/client_robustness_spec.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env rspec
+# frozen_string_literal: true
+
 # Test that a client survives various error cases
 require_relative "spec_helper"
 require "dbus"
@@ -12,14 +14,14 @@ describe "ClientRobustnessTest" do
   context "when the bus name is invalid" do
     it "tells the user the bus name is invalid" do
       # user mistake, should be "org.ruby.service"
-      expect { @bus.service(".org.ruby.service") }.to raise_error(DBus::Error)
+      expect { @bus.service(".org.ruby.service") }.to raise_error(DBus::Error, /Invalid bus name/)
     end
   end
 
   context "when the object path is invalid" do
     it "tells the user the path is invalid" do
       # user mistake, should be "/org/ruby/MyInstance"
-      expect { @svc.object("org.ruby.MyInstance") }.to raise_error(DBus::Error)
+      expect { @svc.object("org.ruby.MyInstance") }.to raise_error(DBus::Error, /Invalid object path/)
     end
   end
 end