dbus.el 67.4 KB
Newer Older
Michael Albinus's avatar
Michael Albinus committed
1 2
;;; dbus.el --- Elisp bindings for D-Bus.

Paul Eggert's avatar
Paul Eggert committed
3
;; Copyright (C) 2007-2015 Free Software Foundation, Inc.
Michael Albinus's avatar
Michael Albinus committed
4 5 6 7 8 9

;; Author: Michael Albinus <michael.albinus@gmx.de>
;; Keywords: comm, hardware

;; This file is part of GNU Emacs.

10
;; GNU Emacs is free software: you can redistribute it and/or modify
Michael Albinus's avatar
Michael Albinus committed
11
;; it under the terms of the GNU General Public License as published by
12 13
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Michael Albinus's avatar
Michael Albinus committed
14 15 16 17 18 19 20

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
21
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
Michael Albinus's avatar
Michael Albinus committed
22 23 24 25 26 27 28 29 30

;;; Commentary:

;; This package provides language bindings for the D-Bus API.  D-Bus
;; is a message bus system, a simple way for applications to talk to
;; one another.  See <http://dbus.freedesktop.org/> for details.

;; Low-level language bindings are implemented in src/dbusbind.c.

31 32 33
;; D-Bus support in the Emacs core can be disabled with configuration
;; option "--without-dbus".

Michael Albinus's avatar
Michael Albinus committed
34 35
;;; Code:

36 37
;; Declare used subroutines and variables.
(declare-function dbus-message-internal "dbusbind.c")
38
(declare-function dbus--init-bus "dbusbind.c")
39 40 41 42 43
(defvar dbus-message-type-invalid)
(defvar dbus-message-type-method-call)
(defvar dbus-message-type-method-return)
(defvar dbus-message-type-error)
(defvar dbus-message-type-signal)
44
(defvar dbus-debug)
45
(defvar dbus-registered-objects-table)
46 47

;; Pacify byte compiler.
Stefan Monnier's avatar
Stefan Monnier committed
48
(eval-when-compile (require 'cl-lib))
49

Michael Albinus's avatar
Michael Albinus committed
50 51 52 53 54 55 56 57
(require 'xml)

(defconst dbus-service-dbus "org.freedesktop.DBus"
  "The bus name used to talk to the bus itself.")

(defconst dbus-path-dbus "/org/freedesktop/DBus"
  "The object path used to talk to the bus itself.")

58 59 60
(defconst dbus-path-local (concat dbus-path-dbus "/Local")
  "The object path used in local/in-process-generated messages.")

61 62
;; Default D-Bus interfaces.

Michael Albinus's avatar
Michael Albinus committed
63
(defconst dbus-interface-dbus "org.freedesktop.DBus"
64
  "The interface exported by the service `dbus-service-dbus'.")
Michael Albinus's avatar
Michael Albinus committed
65

66
(defconst dbus-interface-peer (concat dbus-interface-dbus ".Peer")
67 68 69 70 71 72 73 74 75 76
  "The interface for peer objects.
See URL `http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-peer'.")

;; <interface name="org.freedesktop.DBus.Peer">
;;   <method name="Ping">
;;   </method>
;;   <method name="GetMachineId">
;;     <arg name="machine_uuid" type="s" direction="out"/>
;;   </method>
;; </interface>
77 78 79

(defconst dbus-interface-introspectable
  (concat dbus-interface-dbus ".Introspectable")
80 81
  "The interface supported by introspectable objects.
See URL `http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-introspectable'.")
Michael Albinus's avatar
Michael Albinus committed
82

83 84 85 86 87
;; <interface name="org.freedesktop.DBus.Introspectable">
;;   <method name="Introspect">
;;     <arg name="data" type="s" direction="out"/>
;;   </method>
;; </interface>
88

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
(defconst dbus-interface-properties (concat dbus-interface-dbus ".Properties")
  "The interface for property objects.
See URL `http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties'.")

;; <interface name="org.freedesktop.DBus.Properties">
;;   <method name="Get">
;;     <arg name="interface" type="s" direction="in"/>
;;     <arg name="propname"  type="s" direction="in"/>
;;     <arg name="value"     type="v" direction="out"/>
;;   </method>
;;   <method name="Set">
;;     <arg name="interface" type="s" direction="in"/>
;;     <arg name="propname"  type="s" direction="in"/>
;;     <arg name="value"     type="v" direction="in"/>
;;   </method>
;;   <method name="GetAll">
;;     <arg name="interface" type="s" direction="in"/>
;;     <arg name="props"     type="a{sv}" direction="out"/>
;;   </method>
;;   <signal name="PropertiesChanged">
;;     <arg name="interface" type="s"/>
;;     <arg name="changed_properties"     type="a{sv}"/>
;;     <arg name="invalidated_properties" type="as"/>
;;   </signal>
;; </interface>

(defconst dbus-interface-objectmanager
  (concat dbus-interface-dbus ".ObjectManager")
  "The object manager interface.
See URL `http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager'.")

;; <interface name="org.freedesktop.DBus.ObjectManager">
;;   <method name="GetManagedObjects">
;;     <arg name="object_paths_interfaces_and_properties"
;;          type="a{oa{sa{sv}}}" direction="out"/>
;;   </method>
;;   <signal name="InterfacesAdded">
;;     <arg name="object_path"               type="o"/>
;;     <arg name="interfaces_and_properties" type="a{sa{sv}}"/>
;;   </signal>
;;   <signal name="InterfacesRemoved">
;;     <arg name="object_path"               type="o"/>
;;     <arg name="interfaces"                type="as"/>
;;   </signal>
;; </interface>

135 136 137 138 139 140 141 142 143
(defconst dbus-interface-local (concat dbus-interface-dbus ".Local")
  "An interface whose methods can only be invoked by the local implementation.")

;; <interface name="org.freedesktop.DBus.Local">
;;   <signal name="Disconnected">
;;     <arg name="object_path"               type="o"/>
;;   </signal>
;; </interface>

144
;; Emacs defaults.
145 146 147 148
(defconst dbus-service-emacs "org.gnu.Emacs"
  "The well known service name of Emacs.")

(defconst dbus-path-emacs "/org/gnu/Emacs"
149 150 151
  "The object path namespace used by Emacs.
All object paths provided by the service `dbus-service-emacs'
shall be subdirectories of this path.")
152

153 154
(defconst dbus-interface-emacs "org.gnu.Emacs"
  "The interface namespace used by Emacs.")
155

156
;; D-Bus constants.
157

158 159 160
(defmacro dbus-ignore-errors (&rest body)
  "Execute BODY; signal D-Bus error when `dbus-debug' is non-nil.
Otherwise, return result of last form in BODY, or all other errors."
Stefan Monnier's avatar
Stefan Monnier committed
161
  (declare (indent 0) (debug t))
162 163 164 165 166
  `(condition-case err
       (progn ,@body)
     (dbus-error (when dbus-debug (signal (car err) (cdr err))))))
(font-lock-add-keywords 'emacs-lisp-mode '("\\<dbus-ignore-errors\\>"))

Stefan Monnier's avatar
Stefan Monnier committed
167 168
(define-obsolete-variable-alias 'dbus-event-error-hooks
  'dbus-event-error-functions "24.3")
169
(defvar dbus-event-error-functions '(dbus-notice-synchronous-call-errors)
170
  "Functions to be called when a D-Bus error happens in the event handler.
171
Every function must accept two arguments, the event and the error variable
Paul Eggert's avatar
Paul Eggert committed
172
caught in `condition-case' by `dbus-error'.")
173

174

175
;;; Basic D-Bus message functions.
176

177 178
(defvar dbus-return-values-table (make-hash-table :test 'equal)
  "Hash table for temporary storing arguments of reply messages.
179 180 181
A key in this hash table is a list (:serial BUS SERIAL), like in
`dbus-registered-objects-table'.  BUS is either a Lisp symbol,
`:system' or `:session', or a string denoting the bus address.
182 183 184 185 186 187
SERIAL is the serial number of the reply message.

The value of an entry is a cons (STATE . RESULT).  STATE can be
either `:pending' (we are still waiting for the result),
`:complete' (the result is available) or `:error' (the reply
message was an error message).")
188 189 190 191 192

(defun dbus-call-method-handler (&rest args)
  "Handler for reply messages of asynchronous D-Bus message calls.
It calls the function stored in `dbus-registered-objects-table'.
The result will be made available in `dbus-return-values-table'."
193 194 195
  (let* ((key (list :serial
		    (dbus-event-bus-name last-input-event)
		    (dbus-event-serial-number last-input-event)))
196 197 198 199 200 201 202
         (result (gethash key dbus-return-values-table)))
    (when (consp result)
      (setcar result :complete)
      (setcdr result (if (= (length args) 1) (car args) args)))))

(defun dbus-notice-synchronous-call-errors (ev er)
  "Detect errors resulting from pending synchronous calls."
203 204 205
  (let* ((key (list :serial
		    (dbus-event-bus-name ev)
		    (dbus-event-serial-number ev)))
206 207 208 209
         (result (gethash key dbus-return-values-table)))
    (when (consp result)
      (setcar result :error)
      (setcdr result er))))
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

(defun dbus-call-method (bus service path interface method &rest args)
  "Call METHOD on the D-Bus BUS.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.

SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
object path SERVICE is registered at.  INTERFACE is an interface
offered by SERVICE.  It must provide METHOD.

If the parameter `:timeout' is given, the following integer TIMEOUT
specifies the maximum number of milliseconds the method call must
return.  The default value is 25,000.  If the method call doesn't
return in time, a D-Bus error is raised.

All other arguments ARGS are passed to METHOD as arguments.  They are
converted into D-Bus types via the following rules:

  t and nil => DBUS_TYPE_BOOLEAN
  number    => DBUS_TYPE_UINT32
  integer   => DBUS_TYPE_INT32
  float     => DBUS_TYPE_DOUBLE
  string    => DBUS_TYPE_STRING
  list      => DBUS_TYPE_ARRAY

All arguments can be preceded by a type symbol.  For details about
type symbols, see Info node `(dbus)Type Conversion'.

`dbus-call-method' returns the resulting values of METHOD as a list of
Lisp objects.  The type conversion happens the other direction as for
input arguments.  It follows the mapping rules:

  DBUS_TYPE_BOOLEAN     => t or nil
  DBUS_TYPE_BYTE        => number
  DBUS_TYPE_UINT16      => number
  DBUS_TYPE_INT16       => integer
  DBUS_TYPE_UINT32      => number or float
  DBUS_TYPE_UNIX_FD     => number or float
  DBUS_TYPE_INT32       => integer or float
  DBUS_TYPE_UINT64      => number or float
  DBUS_TYPE_INT64       => integer or float
  DBUS_TYPE_DOUBLE      => float
  DBUS_TYPE_STRING      => string
  DBUS_TYPE_OBJECT_PATH => string
  DBUS_TYPE_SIGNATURE   => string
  DBUS_TYPE_ARRAY       => list
  DBUS_TYPE_VARIANT     => list
  DBUS_TYPE_STRUCT      => list
  DBUS_TYPE_DICT_ENTRY  => list

Example:

\(dbus-call-method
  :session \"org.gnome.seahorse\" \"/org/gnome/seahorse/keys/openpgp\"
  \"org.gnome.seahorse.Keys\" \"GetKeyField\"
  \"openpgp:657984B8C7A966DD\" \"simple-name\")

  => (t (\"Philip R. Zimmermann\"))

If the result of the METHOD call is just one value, the converted Lisp
object is returned instead of a list containing this single Lisp object.

\(dbus-call-method
  :system \"org.freedesktop.Hal\" \"/org/freedesktop/Hal/devices/computer\"
  \"org.freedesktop.Hal.Device\" \"GetPropertyString\"
  \"system.kernel.machine\")

  => \"i686\""

280 281
  (or (featurep 'dbusbind)
      (signal 'dbus-error (list "Emacs not compiled with dbus support")))
282 283 284 285 286 287 288 289 290 291 292 293
  (or (memq bus '(:system :session)) (stringp bus)
      (signal 'wrong-type-argument (list 'keywordp bus)))
  (or (stringp service)
      (signal 'wrong-type-argument (list 'stringp service)))
  (or (stringp path)
      (signal 'wrong-type-argument (list 'stringp path)))
  (or (stringp interface)
      (signal 'wrong-type-argument (list 'stringp interface)))
  (or (stringp method)
      (signal 'wrong-type-argument (list 'stringp method)))

  (let ((timeout (plist-get args :timeout))
294
        (check-interval 0.001)
295 296 297
	(key
	 (apply
	  'dbus-message-internal dbus-message-type-method-call
298 299
	  bus service path interface method 'dbus-call-method-handler args))
        (result (cons :pending nil)))
300

301 302
    ;; Wait until `dbus-call-method-handler' has put the result into
    ;; `dbus-return-values-table'.  If no timeout is given, use the
303
    ;; default 25".  Events which are not from D-Bus must be restored.
Michael Albinus's avatar
Michael Albinus committed
304 305
    ;; `read-event' performs a redisplay.  This must be suppressed; it
    ;; hurts when reading D-Bus events asynchronously.
306 307

    ;; Work around bug#16775 by busy-waiting with gradual backoff for
Paul Eggert's avatar
Paul Eggert committed
308
    ;; dbus calls to complete.  A better approach would involve either
309 310 311 312
    ;; adding arbitrary wait condition support to read-event or
    ;; restructuring dbus as a kind of process object.  Poll at most
    ;; about once per second for completion.

313 314 315 316 317 318 319 320
    (puthash key result dbus-return-values-table)
    (unwind-protect
         (progn
           (with-timeout ((if timeout (/ timeout 1000.0) 25)
                          (signal 'dbus-error (list "call timed out")))
             (while (eq (car result) :pending)
               (let ((event (let ((inhibit-redisplay t) unread-command-events)
                              (read-event nil nil check-interval))))
321 322 323 324 325 326
		 (when event
		   (if (ignore-errors (dbus-check-event event))
		       (setf result (gethash key dbus-return-values-table))
		     (setf unread-command-events
			   (nconc unread-command-events
				  (cons event nil)))))
327 328 329 330 331
                 (when (< check-interval 1)
                   (setf check-interval (* check-interval 1.05))))))
           (when (eq (car result) :error)
             (signal (cadr result) (cddr result)))
           (cdr result))
332 333 334 335
      (remhash key dbus-return-values-table))))

;; `dbus-call-method' works non-blocking now.
(defalias 'dbus-call-method-non-blocking 'dbus-call-method)
336
(make-obsolete 'dbus-call-method-non-blocking 'dbus-call-method "24.3")
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386

(defun dbus-call-method-asynchronously
 (bus service path interface method handler &rest args)
 "Call METHOD on the D-Bus BUS asynchronously.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.

SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
object path SERVICE is registered at.  INTERFACE is an interface
offered by SERVICE.  It must provide METHOD.

HANDLER is a Lisp function, which is called when the corresponding
return message has arrived.  If HANDLER is nil, no return message
will be expected.

If the parameter `:timeout' is given, the following integer TIMEOUT
specifies the maximum number of milliseconds the method call must
return.  The default value is 25,000.  If the method call doesn't
return in time, a D-Bus error is raised.

All other arguments ARGS are passed to METHOD as arguments.  They are
converted into D-Bus types via the following rules:

  t and nil => DBUS_TYPE_BOOLEAN
  number    => DBUS_TYPE_UINT32
  integer   => DBUS_TYPE_INT32
  float     => DBUS_TYPE_DOUBLE
  string    => DBUS_TYPE_STRING
  list      => DBUS_TYPE_ARRAY

All arguments can be preceded by a type symbol.  For details about
type symbols, see Info node `(dbus)Type Conversion'.

If HANDLER is a Lisp function, the function returns a key into the
hash table `dbus-registered-objects-table'.  The corresponding entry
in the hash table is removed, when the return message has been arrived,
and HANDLER is called.

Example:

\(dbus-call-method-asynchronously
  :system \"org.freedesktop.Hal\" \"/org/freedesktop/Hal/devices/computer\"
  \"org.freedesktop.Hal.Device\" \"GetPropertyString\" 'message
  \"system.kernel.machine\")

  => \(:serial :system 2)

  -| i686"

387 388
  (or (featurep 'dbusbind)
      (signal 'dbus-error (list "Emacs not compiled with dbus support")))
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
  (or (memq bus '(:system :session)) (stringp bus)
      (signal 'wrong-type-argument (list 'keywordp bus)))
  (or (stringp service)
      (signal 'wrong-type-argument (list 'stringp service)))
  (or (stringp path)
      (signal 'wrong-type-argument (list 'stringp path)))
  (or (stringp interface)
      (signal 'wrong-type-argument (list 'stringp interface)))
  (or (stringp method)
      (signal 'wrong-type-argument (list 'stringp method)))
  (or (null handler) (functionp handler)
      (signal 'wrong-type-argument (list 'functionp handler)))

  (apply 'dbus-message-internal dbus-message-type-method-call
	 bus service path interface method handler args))

(defun dbus-send-signal (bus service path interface signal &rest args)
  "Send signal SIGNAL on the D-Bus BUS.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.  The signal is sent from the D-Bus object
Emacs is registered at BUS.

SERVICE is the D-Bus name SIGNAL is sent to.  It can be either a known
name or a unique name.  If SERVICE is nil, the signal is sent as
broadcast message.  PATH is the D-Bus object path SIGNAL is sent from.
INTERFACE is an interface available at PATH.  It must provide signal
SIGNAL.

All other arguments ARGS are passed to SIGNAL as arguments.  They are
converted into D-Bus types via the following rules:

  t and nil => DBUS_TYPE_BOOLEAN
  number    => DBUS_TYPE_UINT32
  integer   => DBUS_TYPE_INT32
  float     => DBUS_TYPE_DOUBLE
  string    => DBUS_TYPE_STRING
  list      => DBUS_TYPE_ARRAY

All arguments can be preceded by a type symbol.  For details about
type symbols, see Info node `(dbus)Type Conversion'.

Example:

\(dbus-send-signal
  :session nil \"/org/gnu/Emacs\" \"org.gnu.Emacs.FileManager\"
  \"FileModified\" \"/home/albinus/.emacs\")"

437 438
  (or (featurep 'dbusbind)
      (signal 'dbus-error (list "Emacs not compiled with dbus support")))
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
  (or (memq bus '(:system :session)) (stringp bus)
      (signal 'wrong-type-argument (list 'keywordp bus)))
  (or (null service) (stringp service)
      (signal 'wrong-type-argument (list 'stringp service)))
  (or (stringp path)
      (signal 'wrong-type-argument (list 'stringp path)))
  (or (stringp interface)
      (signal 'wrong-type-argument (list 'stringp interface)))
  (or (stringp signal)
      (signal 'wrong-type-argument (list 'stringp signal)))

  (apply 'dbus-message-internal dbus-message-type-signal
	 bus service path interface signal args))

(defun dbus-method-return-internal (bus service serial &rest args)
  "Return for message SERIAL on the D-Bus BUS.
This is an internal function, it shall not be used outside dbus.el."

457 458
  (or (featurep 'dbusbind)
      (signal 'dbus-error (list "Emacs not compiled with dbus support")))
459 460 461 462 463 464 465 466 467 468 469 470 471 472
  (or (memq bus '(:system :session)) (stringp bus)
      (signal 'wrong-type-argument (list 'keywordp bus)))
  (or (stringp service)
      (signal 'wrong-type-argument (list 'stringp service)))
  (or (natnump serial)
      (signal 'wrong-type-argument (list 'natnump serial)))

  (apply 'dbus-message-internal dbus-message-type-method-return
	 bus service serial args))

(defun dbus-method-error-internal (bus service serial &rest args)
  "Return error message for message SERIAL on the D-Bus BUS.
This is an internal function, it shall not be used outside dbus.el."

473 474
  (or (featurep 'dbusbind)
      (signal 'dbus-error (list "Emacs not compiled with dbus support")))
475 476 477 478 479 480 481 482 483 484 485 486
  (or (memq bus '(:system :session)) (stringp bus)
      (signal 'wrong-type-argument (list 'keywordp bus)))
  (or (stringp service)
      (signal 'wrong-type-argument (list 'stringp service)))
  (or (natnump serial)
      (signal 'wrong-type-argument (list 'natnump serial)))

  (apply 'dbus-message-internal dbus-message-type-error
	 bus service serial args))


;;; Hash table of registered functions.
487

488
(defun dbus-list-hash-table ()
489
  "Returns all registered member registrations to D-Bus.
490
The return value is a list, with elements of kind (KEY . VALUE).
491
See `dbus-registered-objects-table' for a description of the
492 493 494
hash table."
  (let (result)
    (maphash
495
     (lambda (key value) (add-to-list 'result (cons key value) 'append))
496
     dbus-registered-objects-table)
497 498
    result))

499 500
(defun dbus-setenv (bus variable value)
  "Set the value of the BUS environment variable named VARIABLE to VALUE.
501

502 503
BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.  Both VARIABLE and VALUE should be strings.
504

505 506
Normally, services inherit the environment of the BUS daemon.  This
function adds to or modifies that environment when activating services.
507

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
Some bus instances, such as `:system', may disable setting the environment."
  (dbus-call-method
   bus dbus-service-dbus dbus-path-dbus
   dbus-interface-dbus "UpdateActivationEnvironment"
   `(:array (:dict-entry ,variable ,value))))

(defun dbus-register-service (bus service &rest flags)
  "Register known name SERVICE on the D-Bus BUS.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.

SERVICE is the D-Bus service name that should be registered.  It must
be a known name.

FLAGS are keywords, which control how the service name is registered.
The following keywords are recognized:

`:allow-replacement': Allow another service to become the primary
owner if requested.

`:replace-existing': Request to replace the current primary owner.

`:do-not-queue': If we can not become the primary owner do not place
us in the queue.

The function returns a keyword, indicating the result of the
operation.  One of the following keywords is returned:

`:primary-owner': Service has become the primary owner of the
requested name.

`:in-queue': Service could not become the primary owner and has been
placed in the queue.

`:exists': Service is already in the queue.

`:already-owner': Service is already the primary owner."

Michael Albinus's avatar
Michael Albinus committed
547 548 549 550
  ;; Add Peer handler.
  (dbus-register-method
   bus service nil dbus-interface-peer "Ping" 'dbus-peer-handler 'dont-register)

551 552 553 554 555 556 557 558 559 560
  ;; Add ObjectManager handler.
  (dbus-register-method
   bus service nil dbus-interface-objectmanager "GetManagedObjects"
   'dbus-managed-objects-handler 'dont-register)

  (let ((arg 0)
	reply)
    (dolist (flag flags)
      (setq arg
	    (+ arg
Stefan Monnier's avatar
Stefan Monnier committed
561
	       (pcase flag
562 563 564
		 (:allow-replacement 1)
		 (:replace-existing 2)
		 (:do-not-queue 4)
Stefan Monnier's avatar
Stefan Monnier committed
565
		 (_ (signal 'wrong-type-argument (list flag)))))))
566 567 568
    (setq reply (dbus-call-method
		 bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus
		 "RequestName" service arg))
Stefan Monnier's avatar
Stefan Monnier committed
569
    (pcase reply
570 571 572 573
      (1 :primary-owner)
      (2 :in-queue)
      (3 :exists)
      (4 :already-owner)
Stefan Monnier's avatar
Stefan Monnier committed
574
      (_ (signal 'dbus-error (list "Could not register service" service))))))
575

576 577
(defun dbus-unregister-service (bus service)
  "Unregister all objects related to SERVICE from D-Bus BUS.
578
BUS is either a Lisp symbol, `:system' or `:session', or a string
579 580 581 582 583
denoting the bus address.  SERVICE must be a known service name.

The function returns a keyword, indicating the result of the
operation.  One of the following keywords is returned:

584
`:released': We successfully released the service.
585 586 587 588 589 590

`:non-existent': Service name does not exist on this bus.

`:not-owner': We are neither the primary owner nor waiting in the
queue of this service."

591 592
  (maphash
   (lambda (key value)
593 594 595 596 597 598 599
     (unless (equal :serial (car key))
       (dolist (elt value)
	 (ignore-errors
	   (when (and (equal bus (cadr key)) (string-equal service (cadr elt)))
	     (unless
		 (puthash key (delete elt value) dbus-registered-objects-table)
	       (remhash key dbus-registered-objects-table)))))))
600
   dbus-registered-objects-table)
601 602 603
  (let ((reply (dbus-call-method
		bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus
		"ReleaseName" service)))
Stefan Monnier's avatar
Stefan Monnier committed
604
    (pcase reply
605 606 607
      (1 :released)
      (2 :non-existent)
      (3 :not-owner)
Stefan Monnier's avatar
Stefan Monnier committed
608
      (_ (signal 'dbus-error (list "Could not unregister service" service))))))
609

610 611 612
(defun dbus-register-signal
  (bus service path interface signal handler &rest args)
  "Register for a signal on the D-Bus BUS.
613

614 615
BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.
616

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
SERVICE is the D-Bus service name used by the sending D-Bus object.
It can be either a known name or the unique name of the D-Bus object
sending the signal.

PATH is the D-Bus object path SERVICE is registered.  INTERFACE
is an interface offered by SERVICE.  It must provide SIGNAL.
HANDLER is a Lisp function to be called when the signal is
received.  It must accept as arguments the values SIGNAL is
sending.

SERVICE, PATH, INTERFACE and SIGNAL can be nil.  This is
interpreted as a wildcard for the respective argument.

The remaining arguments ARGS can be keywords or keyword string pairs.
The meaning is as follows:

`:argN' STRING:
`:pathN' STRING: This stands for the Nth argument of the
signal.  `:pathN' arguments can be used for object path wildcard
Paul Eggert's avatar
Paul Eggert committed
636
matches as specified by D-Bus, while an `:argN' argument
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
requires an exact match.

`:arg-namespace' STRING: Register for the signals, which first
argument defines the service or interface namespace STRING.

`:path-namespace' STRING: Register for the object path namespace
STRING.  All signals sent from an object path, which has STRING as
the preceding string, are matched.  This requires PATH to be nil.

`:eavesdrop': Register for unicast signals which are not directed
to the D-Bus object Emacs is registered at D-Bus BUS, if the
security policy of BUS allows this.

Example:

\(defun my-signal-handler (device)
  (message \"Device %s added\" device))

\(dbus-register-signal
  :system \"org.freedesktop.Hal\" \"/org/freedesktop/Hal/Manager\"
  \"org.freedesktop.Hal.Manager\" \"DeviceAdded\" 'my-signal-handler)

  => \(\(:signal :system \"org.freedesktop.Hal.Manager\" \"DeviceAdded\")
      \(\"org.freedesktop.Hal\" \"/org/freedesktop/Hal/Manager\" my-signal-handler))

`dbus-register-signal' returns an object, which can be used in
`dbus-unregister-object' for removing the registration."

  (let ((counter 0)
	(rule "type='signal'")
	uname key key1 value)

    ;; Retrieve unique name of service.  If service is a known name,
    ;; we will register for the corresponding unique name, if any.
    ;; Signals are sent always with the unique name as sender.  Note:
    ;; the unique name of `dbus-service-dbus' is that string itself.
    (if (and (stringp service)
	     (not (zerop (length service)))
	     (not (string-equal service dbus-service-dbus))
	     (not (string-match "^:" service)))
	(setq uname (dbus-get-name-owner bus service))
      (setq uname service))

    (setq rule (concat rule
		       (when uname (format ",sender='%s'" uname))
		       (when interface (format ",interface='%s'" interface))
		       (when signal (format ",member='%s'" signal))
		       (when path (format ",path='%s'" path))))

    ;; Add arguments to the rule.
    (if (or (stringp (car args)) (null (car args)))
	;; As backward compatibility option, we allow just strings.
	(dolist (arg args)
	  (if (stringp arg)
	      (setq rule (concat rule (format ",arg%d='%s'" counter arg)))
	    (if arg (signal 'wrong-type-argument (list "Wrong argument" arg))))
	  (setq counter (1+ counter)))

      ;; Parse keywords.
      (while args
	(setq
	 key (car args)
	 rule (concat
	       rule
	       (cond
		;; `:arg0' .. `:arg63', `:path0' .. `:path63'.
		((and (keywordp key)
		      (string-match
		       "^:\\(arg\\|path\\)\\([[:digit:]]+\\)$"
		       (symbol-name key)))
		 (setq counter (match-string 2 (symbol-name key))
		       args (cdr args)
		       value (car args))
710 711
		 (unless (and (<= (string-to-number counter) 63)
			      (stringp value))
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
		   (signal 'wrong-type-argument
			   (list "Wrong argument" key value)))
		 (format
		  ",arg%s%s='%s'"
		  counter
		  (if (string-equal (match-string 1 (symbol-name key)) "path")
		      "path" "")
		  value))
		;; `:arg-namespace', `:path-namespace'.
		((and (keywordp key)
		      (string-match
		       "^:\\(arg\\|path\\)-namespace$" (symbol-name key)))
		 (setq args (cdr args)
		       value (car args))
		 (unless (stringp value)
		   (signal 'wrong-type-argument
			   (list "Wrong argument" key value)))
		 (format
		  ",%s='%s'"
		  (if (string-equal (match-string 1 (symbol-name key)) "path")
		      "path_namespace" "arg0namespace")
		  value))
		;; `:eavesdrop'.
		((eq key :eavesdrop)
		 ",eavesdrop='true'")
		(t (signal 'wrong-type-argument (list "Wrong argument" key)))))
	 args (cdr args))))

    ;; Add the rule to the bus.
    (condition-case err
	(dbus-call-method
	 bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus
	 "AddMatch" rule)
      (dbus-error
       (if (not (string-match "eavesdrop" rule))
	   (signal (car err) (cdr err))
	 ;; The D-Bus spec says we shall fall back to a rule without eavesdrop.
	 (when dbus-debug (message "Removing eavesdrop from rule %s" rule))
	 (setq rule (replace-regexp-in-string ",eavesdrop='true'" "" rule))
	 (dbus-call-method
	  bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus
	  "AddMatch" rule))))
754

755
    (when dbus-debug (message "Matching rule \"%s\" created" rule))
756

757 758 759 760 761 762
    ;; Create a hash table entry.
    (setq key (list :signal bus interface signal)
	  key1 (list uname service path handler rule)
	  value (gethash key dbus-registered-objects-table))
    (unless  (member key1 value)
      (puthash key (cons key1 value) dbus-registered-objects-table))
763

764 765
    ;; Return the object.
    (list key (list service path handler))))
766

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
(defun dbus-register-method
  (bus service path interface method handler &optional dont-register-service)
  "Register for method METHOD on the D-Bus BUS.

BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.

SERVICE is the D-Bus service name of the D-Bus object METHOD is
registered for.  It must be a known name (See discussion of
DONT-REGISTER-SERVICE below).

PATH is the D-Bus object path SERVICE is registered (See discussion of
DONT-REGISTER-SERVICE below).  INTERFACE is the interface offered by
SERVICE.  It must provide METHOD.

HANDLER is a Lisp function to be called when a method call is
received.  It must accept the input arguments of METHOD.  The return
value of HANDLER is used for composing the returning D-Bus message.
In case HANDLER shall return a reply message with an empty argument
list, HANDLER must return the symbol `:ignore'.

When DONT-REGISTER-SERVICE is non-nil, the known name SERVICE is not
registered.  This means that other D-Bus clients have no way of
noticing the newly registered method.  When interfaces are constructed
incrementally by adding single methods or properties at a time,
DONT-REGISTER-SERVICE can be used to prevent other clients from
discovering the still incomplete interface."

  ;; Register SERVICE.
  (unless (or dont-register-service
	      (member service (dbus-list-names bus)))
    (dbus-register-service bus service))

  ;; Create a hash table entry.  We use nil for the unique name,
  ;; because the method might be called from anybody.
  (let* ((key (list :method bus interface method))
	 (key1 (list nil service path handler))
	 (value (gethash key dbus-registered-objects-table)))

    (unless  (member key1 value)
      (puthash key (cons key1 value) dbus-registered-objects-table))

    ;; Return the object.
    (list key (list service path handler))))

(defun dbus-unregister-object (object)
  "Unregister OBJECT from D-Bus.
OBJECT must be the result of a preceding `dbus-register-method',
`dbus-register-property' or `dbus-register-signal' call.  It
returns `t' if OBJECT has been unregistered, `nil' otherwise.

When OBJECT identifies the last method or property, which is
registered for the respective service, Emacs releases its
association to the service from D-Bus."
  ;; Check parameter.
  (unless (and (consp object) (not (null (car object))) (consp (cdr object)))
    (signal 'wrong-type-argument (list 'D-Bus object)))

  ;; Find the corresponding entry in the hash table.
  (let* ((key (car object))
	 (type (car key))
	 (bus (cadr key))
	 (value (cadr object))
	 (service (car value))
	 (entry (gethash key dbus-registered-objects-table))
	 ret)
    ;; key has the structure (TYPE BUS INTERFACE MEMBER).
    ;; value has the structure (SERVICE PATH [HANDLER]).
    ;; entry has the structure ((UNAME SERVICE PATH MEMBER [RULE]) ...).
    ;; MEMBER is either a string (the handler), or a cons cell (a
    ;; property value).  UNAME and property values are not taken into
    ;; account for comparison.

    ;; Loop over the registered functions.
    (dolist (elt entry)
      (when (equal
	     value
	     (butlast (cdr elt) (- (length (cdr elt)) (length value))))
	(setq ret t)
	;; Compute new hash value.  If it is empty, remove it from the
	;; hash table.
	(unless (puthash key (delete elt entry) dbus-registered-objects-table)
	  (remhash key dbus-registered-objects-table))
	;; Remove match rule of signals.
	(when (eq type :signal)
	  (dbus-call-method
	   bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus
	   "RemoveMatch" (nth 4 elt)))))

    ;; Check, whether there is still a registered function or property
    ;; for the given service.  If not, unregister the service from the
    ;; bus.
    (when (and service (memq type '(:method :property))
	       (not (catch :found
		      (progn
			(maphash
			 (lambda (k v)
			   (dolist (e v)
			     (ignore-errors
			       (and
				;; Bus.
				(equal bus (cadr k))
				;; Service.
				(string-equal service (cadr e))
				;; Non-empty object path.
872
				(caddr e)
873 874 875 876 877 878
				(throw :found t)))))
			 dbus-registered-objects-table)
			nil))))
      (dbus-unregister-service bus service))
    ;; Return.
    ret))
879

880 881 882 883 884 885

;;; D-Bus type conversion.

(defun dbus-string-to-byte-array (string)
  "Transforms STRING to list (:array :byte c1 :byte c2 ...).
STRING shall be UTF8 coded."
886 887 888 889 890
  (if (zerop (length string))
      '(:array :signature "y")
    (let (result)
      (dolist (elt (string-to-list string) (append '(:array) result))
	(setq result (append result (list :byte elt)))))))
891

892
(defun dbus-byte-array-to-string (byte-array &optional multibyte)
893
  "Transforms BYTE-ARRAY into UTF8 coded string.
894
BYTE-ARRAY must be a list of structure (c1 c2 ...), or a byte
895 896
array as produced by `dbus-string-to-byte-array'.  The resulting
string is unibyte encoded, unless MULTIBYTE is non-nil."
897
  (apply
898
   (if multibyte 'string 'unibyte-string)
899 900 901 902 903
   (if (equal byte-array '(:array :signature "y"))
       nil
     (let (result)
       (dolist (elt byte-array result)
	 (when (characterp elt) (setq result (append result `(,elt)))))))))
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920

(defun dbus-escape-as-identifier (string)
  "Escape an arbitrary STRING so it follows the rules for a C identifier.
The escaped string can be used as object path component, interface element
component, bus name component or member name in D-Bus.

The escaping consists of replacing all non-alphanumerics, and the
first character if it's a digit, with an underscore and two
lower-case hex digits:

   \"0123abc_xyz\\x01\\xff\" -> \"_30123abc_5fxyz_01_ff\"

i.e. similar to URI encoding, but with \"_\" taking the role of \"%\",
and a smaller allowed set. As a special case, \"\" is escaped to
\"_\".

Returns the escaped string.  Algorithm taken from
921
telepathy-glib's `tp_escape_as_identifier'."
922 923 924 925 926 927 928 929
  (if (zerop (length string))
      "_"
    (replace-regexp-in-string
     "^[0-9]\\|[^A-Za-z0-9]"
     (lambda (x) (format "_%2x" (aref x 0)))
     string)))

(defun dbus-unescape-from-identifier (string)
930 931
  "Retrieve the original string from the encoded STRING as unibyte string.
STRING must have been encoded with `dbus-escape-as-identifier'."
932 933 934 935
  (if (string-equal string "_")
      ""
    (replace-regexp-in-string
     "_.."
936
     (lambda (x) (byte-to-string (string-to-number (substring x 1) 16)))
937 938
     string)))

939 940 941

;;; D-Bus events.

Michael Albinus's avatar
Michael Albinus committed
942 943 944 945
(defun dbus-check-event (event)
  "Checks whether EVENT is a well formed D-Bus event.
EVENT is a list which starts with symbol `dbus-event':

946
  (dbus-event BUS TYPE SERIAL SERVICE PATH INTERFACE MEMBER HANDLER &rest ARGS)
Michael Albinus's avatar
Michael Albinus committed
947

948
BUS identifies the D-Bus the message is coming from.  It is
949 950 951 952 953 954 955 956 957
either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.  TYPE is the D-Bus message type which
has caused the event, SERIAL is the serial number of the received
D-Bus message.  SERVICE and PATH are the unique name and the
object path of the D-Bus object emitting the message.  INTERFACE
and MEMBER denote the message which has been sent.  HANDLER is
the function which has been registered for this message.  ARGS
are the arguments passed to HANDLER, when it is called during
event handling in `dbus-handle-event'.
Michael Albinus's avatar
Michael Albinus committed
958 959 960 961 962 963

This function raises a `dbus-error' signal in case the event is
not well formed."
  (when dbus-debug (message "DBus-Event %s" event))
  (unless (and (listp event)
	       (eq (car event) 'dbus-event)
964
	       ;; Bus symbol.
965 966
	       (or (symbolp (nth 1 event))
		   (stringp (nth 1 event)))
967 968 969
	       ;; Type.
	       (and (natnump (nth 2 event))
		    (< dbus-message-type-invalid (nth 2 event)))
970
	       ;; Serial.
971
	       (natnump (nth 3 event))
972
	       ;; Service.
973
	       (or (= dbus-message-type-method-return (nth 2 event))
974
		   (= dbus-message-type-error (nth 2 event))
975 976
                   (or (stringp (nth 4 event))
                       (null (nth 4 event))))
977
	       ;; Object path.
978
	       (or (= dbus-message-type-method-return (nth 2 event))
979
		   (= dbus-message-type-error (nth 2 event))
980
		   (stringp (nth 5 event)))
981
	       ;; Interface.
982
	       (or (= dbus-message-type-method-return (nth 2 event))
983
		   (= dbus-message-type-error (nth 2 event))
984
		   (stringp (nth 6 event)))
985
	       ;; Member.
986
	       (or (= dbus-message-type-method-return (nth 2 event))
987
		   (= dbus-message-type-error (nth 2 event))
988
		   (stringp (nth 7 event)))
989
	       ;; Handler.
990
	       (functionp (nth 8 event)))
Michael Albinus's avatar
Michael Albinus committed
991 992 993 994 995
    (signal 'dbus-error (list "Not a valid D-Bus event" event))))

;;;###autoload
(defun dbus-handle-event (event)
  "Handle events from the D-Bus.
996
EVENT is a D-Bus event, see `dbus-check-event'.  HANDLER, being
997
part of the event, is called with arguments ARGS.
998
If the HANDLER returns a `dbus-error', it is propagated as return message."
Michael Albinus's avatar
Michael Albinus committed
999
  (interactive "e")
1000 1001
  (condition-case err
      (let (result)
1002
	;; We ignore not well-formed events.
1003
	(dbus-check-event event)
1004 1005 1006 1007
	;; Error messages must be propagated.
	(when (= dbus-message-type-error (nth 2 event))
	  (signal 'dbus-error (nthcdr 9 event)))
	;; Apply the handler.
1008 1009 1010 1011
	(setq result (apply (nth 8 event) (nthcdr 9 event)))
	;; Return a message when it is a message call.
	(when (= dbus-message-type-method-call (nth 2 event))
	  (dbus-ignore-errors
1012 1013
	    (if (eq result :ignore)
		(dbus-method-return-internal
1014
		 (nth 1 event) (nth 4 event) (nth 3 event))
1015
	      (apply 'dbus-method-return-internal
1016
		     (nth 1 event) (nth 4 event) (nth 3 event)
1017
		     (if (consp result) result (list result)))))))
1018 1019 1020 1021 1022 1023
    ;; Error handling.
    (dbus-error
     ;; Return an error message when it is a message call.
     (when (= dbus-message-type-method-call (nth 2 event))
       (dbus-ignore-errors
	 (dbus-method-error-internal
1024
	  (nth 1 event) (nth 4 event) (nth 3 event) (cadr err))))
1025
     ;; Propagate D-Bus error messages.
Stefan Monnier's avatar
Stefan Monnier committed
1026
     (run-hook-with-args 'dbus-event-error-functions event err)
1027
     (when dbus-debug
1028
       (signal (car err) (cdr err))))))
Michael Albinus's avatar
Michael Albinus committed
1029 1030 1031

(defun dbus-event-bus-name (event)
  "Return the bus name the event is coming from.
1032 1033 1034 1035
The result is either a Lisp symbol, `:system' or `:session', or a
string denoting the bus address.  EVENT is a D-Bus event, see
`dbus-check-event'.  This function raises a `dbus-error' signal
in case the event is not well formed."
Michael Albinus's avatar
Michael Albinus committed
1036
  (dbus-check-event event)
1037
  (nth 1 event))
Michael Albinus's avatar
Michael Albinus committed
1038

1039 1040 1041 1042 1043 1044 1045 1046
(defun dbus-event-message-type (event)
  "Return the message type of the corresponding D-Bus message.
The result is a number.  EVENT is a D-Bus event, see
`dbus-check-event'.  This function raises a `dbus-error' signal
in case the event is not well formed."
  (dbus-check-event event)
  (nth 2 event))

1047 1048
(defun dbus-event-serial-number (event)
  "Return the serial number of the corresponding D-Bus message.
1049 1050 1051 1052
The result is a number.  The serial number is needed for
generating a reply message.  EVENT is a D-Bus event, see
`dbus-check-event'.  This function raises a `dbus-error' signal
in case the event is not well formed."
1053
  (dbus-check-event event)
1054
  (nth 3 event))
1055

Michael Albinus's avatar
Michael Albinus committed
1056
(defun dbus-event-service-name (event)
1057
  "Return the name of the D-Bus object the event is coming from.
Michael Albinus's avatar
Michael Albinus committed
1058 1059 1060 1061
The result is a string.  EVENT is a D-Bus event, see `dbus-check-event'.
This function raises a `dbus-error' signal in case the event is
not well formed."
  (dbus-check-event event)
1062
  (nth 4 event))
Michael Albinus's avatar
Michael Albinus committed
1063 1064 1065 1066 1067 1068 1069

(defun dbus-event-path-name (event)
  "Return the object path of the D-Bus object the event is coming from.
The result is a string.  EVENT is a D-Bus event, see `dbus-check-event'.
This function raises a `dbus-error' signal in case the event is
not well formed."
  (dbus-check-event event)
1070
  (nth 5 event))
Michael Albinus's avatar
Michael Albinus committed
1071 1072 1073 1074 1075 1076 1077

(defun dbus-event-interface-name (event)
  "Return the interface name of the D-Bus object the event is coming from.
The result is a string.  EVENT is a D-Bus event, see `dbus-check-event'.
This function raises a `dbus-error' signal in case the event is
not well formed."
  (dbus-check-event event)
1078
  (nth 6 event))
Michael Albinus's avatar
Michael Albinus committed
1079 1080 1081

(defun dbus-event-member-name (event)
  "Return the member name the event is coming from.
Juanma Barranquero's avatar
Juanma Barranquero committed
1082
It is either a signal name or a method name. The result is a
Michael Albinus's avatar
Michael Albinus committed
1083 1084 1085 1086
string.  EVENT is a D-Bus event, see `dbus-check-event'.  This
function raises a `dbus-error' signal in case the event is not
well formed."
  (dbus-check-event event)
1087
  (nth 7 event))
1088 1089 1090


;;; D-Bus registered names.
Michael Albinus's avatar
Michael Albinus committed
1091

1092
(defun dbus-list-activatable-names (&optional bus)
Michael Albinus's avatar
Michael Albinus committed
1093
  "Return the D-Bus service names which can be activated as list.
1094 1095 1096
If BUS is left nil, `:system' is assumed.  The result is a list
of strings, which is `nil' when there are no activatable service
names at all."
1097 1098
  (dbus-ignore-errors
    (dbus-call-method
1099
     (or bus :system) dbus-service-dbus
1100
     dbus-path-dbus dbus-interface-dbus "ListActivatableNames")))
Michael Albinus's avatar
Michael Albinus committed
1101 1102 1103

(defun dbus-list-names (bus)
  "Return the service names registered at D-Bus BUS.
1104 1105 1106 1107
The result is a list of strings, which is `nil' when there are no
registered service names at all.  Well known names are strings
like \"org.freedesktop.DBus\".  Names starting with \":\" are
unique names for services."
1108 1109 1110
  (dbus-ignore-errors
    (dbus-call-method
     bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus "ListNames")))
Michael Albinus's avatar
Michael Albinus committed
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120

(defun dbus-list-known-names (bus)
  "Retrieve all services which correspond to a known name in BUS.
A service has a known name if it doesn't start with \":\"."
  (let (result)
    (dolist (name (dbus-list-names bus) result)
      (unless (string-equal ":" (substring name 0 1))
	(add-to-list 'result name 'append)))))

(defun dbus-list-queued-owners (bus service)
1121 1122 1123
  "Return the unique names registered at D-Bus BUS and queued for SERVICE.
The result is a list of strings, or `nil' when there are no
queued name owners service names at all."
1124 1125 1126 1127
  (dbus-ignore-errors
    (dbus-call-method
     bus dbus-service-dbus dbus-path-dbus
     dbus-interface-dbus "ListQueuedOwners" service)))
Michael Albinus's avatar
Michael Albinus committed
1128 1129 1130

(defun dbus-get-name-owner (bus service)
  "Return the name owner of SERVICE registered at D-Bus BUS.
1131
The result is either a string, or `nil' if there is no name owner."
1132 1133 1134 1135
  (dbus-ignore-errors
    (dbus-call-method
     bus dbus-service-dbus dbus-path-dbus
     dbus-interface-dbus "GetNameOwner" service)))
Michael Albinus's avatar
Michael Albinus committed
1136

1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
(defun dbus-ping (bus service &optional timeout)
  "Check whether SERVICE is registered for D-Bus BUS.
TIMEOUT, a nonnegative integer, specifies the maximum number of
milliseconds `dbus-ping' must return.  The default value is 25,000.

Note, that this autoloads SERVICE if it is not running yet.  If
it shall be checked whether SERVICE is already running, one shall
apply

  \(member service \(dbus-list-known-names bus))"
1147 1148 1149 1150
  ;; "Ping" raises a D-Bus error if SERVICE does not exist.
  ;; Otherwise, it returns silently with `nil'.
  (condition-case nil
      (not
1151 1152 1153 1154 1155 1156
       (if (natnump timeout)
	   (dbus-call-method
	    bus service dbus-path-dbus dbus-interface-peer
	    "Ping" :timeout timeout)
	 (dbus-call-method
	  bus service dbus-path-dbus dbus-interface-peer "Ping")))
1157 1158
    (dbus-error nil)))

Michael Albinus's avatar
Michael Albinus committed
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
(defun dbus-peer-handler ()
  "Default handler for the \"org.freedesktop.DBus.Peer\" interface.
It will be registered for all objects created by `dbus-register-service'."
  (let* ((last-input-event last-input-event)
	 (method (dbus-event-member-name last-input-event)))
    (cond
     ;; "Ping" does not return an output parameter.
     ((string-equal method "Ping")
      :ignore)
     ;; "GetMachineId" returns "s".
     ((string-equal method "GetMachineId")
      (signal
       'dbus-error
       (list
	(format "%s.GetMachineId not implemented" dbus-interface-peer)))))))

1175 1176

;;; D-Bus introspection.
Michael Albinus's avatar
Michael Albinus committed
1177

1178
(defun dbus-introspect (bus service path)
1179
  "Return all interfaces and sub-nodes of SERVICE,
1180 1181
registered at object path PATH at bus BUS.

1182 1183 1184 1185 1186
BUS is either a Lisp symbol, `:system' or `:session', or a string
denoting the bus address.  SERVICE must be a known service name,
and PATH must be a valid object path.  The last two parameters
are strings.  The result, the introspection data, is a string in
XML format."
1187
  ;; We don't want to raise errors.
1188
  (dbus-ignore-errors
1189 1190 1191
    (dbus-call-method
     bus service path dbus-interface-introspectable "Introspect"
     :timeout 1000)))
Michael Albinus's avatar
Michael Albinus committed
1192

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
(defun dbus-introspect-xml (bus service path)
  "Return the introspection data of SERVICE in D-Bus BUS at object path PATH.
The data are a parsed list.  The root object is a \"node\",
representing the object path PATH.  The root object can contain
\"interface\" and further \"node\" objects."
  ;; We don't want to raise errors.
  (xml-node-name
   (ignore-errors
     (with-temp-buffer
       (insert (dbus-introspect bus service path))
       (xml-parse-region (point-min) (point-max))))))

(defun dbus-introspect-get-attribute (object attribute)
  "Return the ATTRIBUTE value of D-Bus introspection OBJECT.
ATTRIBUTE must be a string according to the attribute names in
the D-Bus specification."
  (xml-get-attribute-or-nil object (intern attribute)))

(defun dbus-introspect-get-node-names (bus service path)
  "Return all node names of SERVICE in D-Bus BUS at object path PATH.
It returns a list of strings.  The node names stand for further
object paths of the D-Bus service."
  (let ((object (dbus-introspect-xml bus service path))
	result)
    (dolist (elt (xml-get-children object 'node) result)
      (add-to-list
       'result (dbus-introspect-get-attribute elt "name") 'append))))

(defun dbus-introspect-get-all-nodes (bus service path)
  "Return all node names of SERVICE in D-Bus BUS at object path PATH.
It returns a list of strings, which are further object paths of SERVICE."
  (let ((result (list path)))
    (dolist (elt
             (dbus-introspect-get-node-names bus service path)
             result)
      (setq elt (expand-file-name elt path))
      (setq result
            (append result (dbus-introspect-get-all-nodes bus service elt))))))

(defun dbus-introspect-get-interface-names (bus service path)
  "Return all interface names of SERVICE in D-Bus BUS at object path PATH.
It returns a list of strings.

There will be always the default interface
\"org.freedesktop.DBus.Introspectable\".  Another default
interface is \"org.freedesktop.DBus.Properties\".  If present,
\"interface\" objects can also have \"property\" objects as
children, beside \"method\" and \"signal\" objects."
  (let ((object (dbus-introspect-xml bus service path))
	result)
    (dolist (elt (xml-get-children object 'interface) result)
      (add-to-list
       'result (dbus-introspect-get-attribute elt "name") 'append))))

(defun dbus-introspect-get-interface (bus service path interface)
  "Return the INTERFACE of SERVICE in D-Bus BUS at object path PATH.
The return value is an XML object.  INTERFACE must be a string,
1250 1251
element of the list returned by `dbus-introspect-get-interface-names'.
The resulting \"interface\" object can contain \"method\", \"signal\",
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293