1 /* Elisp bindings for D-Bus.
2 Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <dbus/dbus.h>
28 #include "termhooks.h"
33 Lisp_Object Qdbus_init_bus
;
34 Lisp_Object Qdbus_get_unique_name
;
35 Lisp_Object Qdbus_call_method
;
36 Lisp_Object Qdbus_call_method_asynchronously
;
37 Lisp_Object Qdbus_method_return_internal
;
38 Lisp_Object Qdbus_method_error_internal
;
39 Lisp_Object Qdbus_send_signal
;
40 Lisp_Object Qdbus_register_signal
;
41 Lisp_Object Qdbus_register_method
;
43 /* D-Bus error symbol. */
44 Lisp_Object Qdbus_error
;
46 /* Lisp symbols of the system and session buses. */
47 Lisp_Object QCdbus_system_bus
, QCdbus_session_bus
;
49 /* Lisp symbol for method call timeout. */
50 Lisp_Object QCdbus_timeout
;
52 /* Lisp symbols of D-Bus types. */
53 Lisp_Object QCdbus_type_byte
, QCdbus_type_boolean
;
54 Lisp_Object QCdbus_type_int16
, QCdbus_type_uint16
;
55 Lisp_Object QCdbus_type_int32
, QCdbus_type_uint32
;
56 Lisp_Object QCdbus_type_int64
, QCdbus_type_uint64
;
57 Lisp_Object QCdbus_type_double
, QCdbus_type_string
;
58 Lisp_Object QCdbus_type_object_path
, QCdbus_type_signature
;
59 Lisp_Object QCdbus_type_array
, QCdbus_type_variant
;
60 Lisp_Object QCdbus_type_struct
, QCdbus_type_dict_entry
;
62 /* Hash table which keeps function definitions. */
63 Lisp_Object Vdbus_registered_objects_table
;
65 /* Whether to debug D-Bus. */
66 Lisp_Object Vdbus_debug
;
68 /* Whether we are reading a D-Bus event. */
69 int xd_in_read_queued_messages
= 0;
72 /* We use "xd_" and "XD_" as prefix for all internal symbols, because
73 we don't want to poison other namespaces with "dbus_". */
75 /* Raise a signal. If we are reading events, we cannot signal; we
76 throw to xd_read_queued_messages then. */
77 #define XD_SIGNAL1(arg) \
79 if (xd_in_read_queued_messages) \
80 Fthrow (Qdbus_error, Qnil); \
82 xsignal1 (Qdbus_error, arg); \
85 #define XD_SIGNAL2(arg1, arg2) \
87 if (xd_in_read_queued_messages) \
88 Fthrow (Qdbus_error, Qnil); \
90 xsignal2 (Qdbus_error, arg1, arg2); \
93 #define XD_SIGNAL3(arg1, arg2, arg3) \
95 if (xd_in_read_queued_messages) \
96 Fthrow (Qdbus_error, Qnil); \
98 xsignal3 (Qdbus_error, arg1, arg2, arg3); \
101 /* Raise a Lisp error from a D-Bus ERROR. */
102 #define XD_ERROR(error) \
105 strncpy (s, error.message, 1023); \
106 dbus_error_free (&error); \
107 /* Remove the trailing newline. */ \
108 if (strchr (s, '\n') != NULL) \
109 s[strlen (s) - 1] = '\0'; \
110 XD_SIGNAL1 (build_string (s)); \
113 /* Macros for debugging. In order to enable them, build with
114 "make MYCPPFLAGS='-DDBUS_DEBUG -Wall'". */
116 #define XD_DEBUG_MESSAGE(...) \
119 snprintf (s, 1023, __VA_ARGS__); \
120 printf ("%s: %s\n", __func__, s); \
121 message ("%s: %s", __func__, s); \
123 #define XD_DEBUG_VALID_LISP_OBJECT_P(object) \
125 if (!valid_lisp_object_p (object)) \
127 XD_DEBUG_MESSAGE ("%d Assertion failure", __LINE__); \
128 XD_SIGNAL1 (build_string ("Assertion failure")); \
132 #else /* !DBUS_DEBUG */
133 #define XD_DEBUG_MESSAGE(...) \
135 if (!NILP (Vdbus_debug)) \
138 snprintf (s, 1023, __VA_ARGS__); \
139 message ("%s: %s", __func__, s); \
142 #define XD_DEBUG_VALID_LISP_OBJECT_P(object)
145 /* Check whether TYPE is a basic DBusType. */
146 #define XD_BASIC_DBUS_TYPE(type) \
147 ((type == DBUS_TYPE_BYTE) \
148 || (type == DBUS_TYPE_BOOLEAN) \
149 || (type == DBUS_TYPE_INT16) \
150 || (type == DBUS_TYPE_UINT16) \
151 || (type == DBUS_TYPE_INT32) \
152 || (type == DBUS_TYPE_UINT32) \
153 || (type == DBUS_TYPE_INT64) \
154 || (type == DBUS_TYPE_UINT64) \
155 || (type == DBUS_TYPE_DOUBLE) \
156 || (type == DBUS_TYPE_STRING) \
157 || (type == DBUS_TYPE_OBJECT_PATH) \
158 || (type == DBUS_TYPE_SIGNATURE))
160 /* This was a macro. On Solaris 2.11 it was said to compile for
161 hours, when optimzation is enabled. So we have transferred it into
163 /* Determine the DBusType of a given Lisp symbol. OBJECT must be one
164 of the predefined D-Bus type symbols. */
166 xd_symbol_to_dbus_type (object
)
170 ((EQ (object
, QCdbus_type_byte
)) ? DBUS_TYPE_BYTE
171 : (EQ (object
, QCdbus_type_boolean
)) ? DBUS_TYPE_BOOLEAN
172 : (EQ (object
, QCdbus_type_int16
)) ? DBUS_TYPE_INT16
173 : (EQ (object
, QCdbus_type_uint16
)) ? DBUS_TYPE_UINT16
174 : (EQ (object
, QCdbus_type_int32
)) ? DBUS_TYPE_INT32
175 : (EQ (object
, QCdbus_type_uint32
)) ? DBUS_TYPE_UINT32
176 : (EQ (object
, QCdbus_type_int64
)) ? DBUS_TYPE_INT64
177 : (EQ (object
, QCdbus_type_uint64
)) ? DBUS_TYPE_UINT64
178 : (EQ (object
, QCdbus_type_double
)) ? DBUS_TYPE_DOUBLE
179 : (EQ (object
, QCdbus_type_string
)) ? DBUS_TYPE_STRING
180 : (EQ (object
, QCdbus_type_object_path
)) ? DBUS_TYPE_OBJECT_PATH
181 : (EQ (object
, QCdbus_type_signature
)) ? DBUS_TYPE_SIGNATURE
182 : (EQ (object
, QCdbus_type_array
)) ? DBUS_TYPE_ARRAY
183 : (EQ (object
, QCdbus_type_variant
)) ? DBUS_TYPE_VARIANT
184 : (EQ (object
, QCdbus_type_struct
)) ? DBUS_TYPE_STRUCT
185 : (EQ (object
, QCdbus_type_dict_entry
)) ? DBUS_TYPE_DICT_ENTRY
186 : DBUS_TYPE_INVALID
);
189 /* Check whether a Lisp symbol is a predefined D-Bus type symbol. */
190 #define XD_DBUS_TYPE_P(object) \
191 (SYMBOLP (object) && ((xd_symbol_to_dbus_type (object) != DBUS_TYPE_INVALID)))
193 /* Determine the DBusType of a given Lisp OBJECT. It is used to
194 convert Lisp objects, being arguments of `dbus-call-method' or
195 `dbus-send-signal', into corresponding C values appended as
196 arguments to a D-Bus message. */
197 #define XD_OBJECT_TO_DBUS_TYPE(object) \
198 ((EQ (object, Qt) || EQ (object, Qnil)) ? DBUS_TYPE_BOOLEAN \
199 : (NATNUMP (object)) ? DBUS_TYPE_UINT32 \
200 : (INTEGERP (object)) ? DBUS_TYPE_INT32 \
201 : (FLOATP (object)) ? DBUS_TYPE_DOUBLE \
202 : (STRINGP (object)) ? DBUS_TYPE_STRING \
203 : (XD_DBUS_TYPE_P (object)) ? xd_symbol_to_dbus_type (object) \
205 ? ((XD_DBUS_TYPE_P (CAR_SAFE (object))) \
206 ? ((XD_BASIC_DBUS_TYPE (xd_symbol_to_dbus_type (CAR_SAFE (object)))) \
208 : xd_symbol_to_dbus_type (CAR_SAFE (object))) \
212 /* Return a list pointer which does not have a Lisp symbol as car. */
213 #define XD_NEXT_VALUE(object) \
214 ((XD_DBUS_TYPE_P (CAR_SAFE (object))) ? CDR_SAFE (object) : object)
216 /* Compute SIGNATURE of OBJECT. It must have a form that it can be
217 used in dbus_message_iter_open_container. DTYPE is the DBusType
218 the object is related to. It is passed as argument, because it
219 cannot be detected in basic type objects, when they are preceded by
220 a type symbol. PARENT_TYPE is the DBusType of a container this
221 signature is embedded, or DBUS_TYPE_INVALID. It is needed for the
222 check that DBUS_TYPE_DICT_ENTRY occurs only as array element. */
224 xd_signature (signature
, dtype
, parent_type
, object
)
226 unsigned int dtype
, parent_type
;
229 unsigned int subtype
;
231 char x
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
238 case DBUS_TYPE_UINT16
:
239 case DBUS_TYPE_UINT32
:
240 case DBUS_TYPE_UINT64
:
241 CHECK_NATNUM (object
);
242 sprintf (signature
, "%c", dtype
);
245 case DBUS_TYPE_BOOLEAN
:
246 if (!EQ (object
, Qt
) && !EQ (object
, Qnil
))
247 wrong_type_argument (intern ("booleanp"), object
);
248 sprintf (signature
, "%c", dtype
);
251 case DBUS_TYPE_INT16
:
252 case DBUS_TYPE_INT32
:
253 case DBUS_TYPE_INT64
:
254 CHECK_NUMBER (object
);
255 sprintf (signature
, "%c", dtype
);
258 case DBUS_TYPE_DOUBLE
:
259 CHECK_FLOAT (object
);
260 sprintf (signature
, "%c", dtype
);
263 case DBUS_TYPE_STRING
:
264 case DBUS_TYPE_OBJECT_PATH
:
265 case DBUS_TYPE_SIGNATURE
:
266 CHECK_STRING (object
);
267 sprintf (signature
, "%c", dtype
);
270 case DBUS_TYPE_ARRAY
:
271 /* Check that all list elements have the same D-Bus type. For
272 complex element types, we just check the container type, not
273 the whole element's signature. */
276 /* Type symbol is optional. */
277 if (EQ (QCdbus_type_array
, CAR_SAFE (elt
)))
278 elt
= XD_NEXT_VALUE (elt
);
280 /* If the array is empty, DBUS_TYPE_STRING is the default
284 subtype
= DBUS_TYPE_STRING
;
285 strcpy (x
, DBUS_TYPE_STRING_AS_STRING
);
289 subtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
));
290 xd_signature (x
, subtype
, dtype
, CAR_SAFE (XD_NEXT_VALUE (elt
)));
293 /* If the element type is DBUS_TYPE_SIGNATURE, and this is the
294 only element, the value of this element is used as he array's
295 element signature. */
296 if ((subtype
== DBUS_TYPE_SIGNATURE
)
297 && STRINGP (CAR_SAFE (XD_NEXT_VALUE (elt
)))
298 && NILP (CDR_SAFE (XD_NEXT_VALUE (elt
))))
299 strcpy (x
, SDATA (CAR_SAFE (XD_NEXT_VALUE (elt
))));
303 if (subtype
!= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
)))
304 wrong_type_argument (intern ("D-Bus"), CAR_SAFE (elt
));
305 elt
= CDR_SAFE (XD_NEXT_VALUE (elt
));
308 sprintf (signature
, "%c%s", dtype
, x
);
311 case DBUS_TYPE_VARIANT
:
312 /* Check that there is exactly one list element. */
315 elt
= XD_NEXT_VALUE (elt
);
316 subtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
));
317 xd_signature (x
, subtype
, dtype
, CAR_SAFE (XD_NEXT_VALUE (elt
)));
319 if (!NILP (CDR_SAFE (XD_NEXT_VALUE (elt
))))
320 wrong_type_argument (intern ("D-Bus"),
321 CAR_SAFE (CDR_SAFE (XD_NEXT_VALUE (elt
))));
323 sprintf (signature
, "%c", dtype
);
326 case DBUS_TYPE_STRUCT
:
327 /* A struct list might contain any number of elements with
328 different types. No further check needed. */
331 elt
= XD_NEXT_VALUE (elt
);
333 /* Compose the signature from the elements. It is enclosed by
335 sprintf (signature
, "%c", DBUS_STRUCT_BEGIN_CHAR
);
338 subtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
));
339 xd_signature (x
, subtype
, dtype
, CAR_SAFE (XD_NEXT_VALUE (elt
)));
340 strcat (signature
, x
);
341 elt
= CDR_SAFE (XD_NEXT_VALUE (elt
));
343 strcat (signature
, DBUS_STRUCT_END_CHAR_AS_STRING
);
346 case DBUS_TYPE_DICT_ENTRY
:
347 /* Check that there are exactly two list elements, and the first
348 one is of basic type. The dictionary entry itself must be an
349 element of an array. */
352 /* Check the parent object type. */
353 if (parent_type
!= DBUS_TYPE_ARRAY
)
354 wrong_type_argument (intern ("D-Bus"), object
);
356 /* Compose the signature from the elements. It is enclosed by
358 sprintf (signature
, "%c", DBUS_DICT_ENTRY_BEGIN_CHAR
);
361 elt
= XD_NEXT_VALUE (elt
);
362 subtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
));
363 xd_signature (x
, subtype
, dtype
, CAR_SAFE (XD_NEXT_VALUE (elt
)));
364 strcat (signature
, x
);
366 if (!XD_BASIC_DBUS_TYPE (subtype
))
367 wrong_type_argument (intern ("D-Bus"), CAR_SAFE (XD_NEXT_VALUE (elt
)));
369 /* Second element. */
370 elt
= CDR_SAFE (XD_NEXT_VALUE (elt
));
371 subtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (elt
));
372 xd_signature (x
, subtype
, dtype
, CAR_SAFE (XD_NEXT_VALUE (elt
)));
373 strcat (signature
, x
);
375 if (!NILP (CDR_SAFE (XD_NEXT_VALUE (elt
))))
376 wrong_type_argument (intern ("D-Bus"),
377 CAR_SAFE (CDR_SAFE (XD_NEXT_VALUE (elt
))));
379 /* Closing signature. */
380 strcat (signature
, DBUS_DICT_ENTRY_END_CHAR_AS_STRING
);
384 wrong_type_argument (intern ("D-Bus"), object
);
387 XD_DEBUG_MESSAGE ("%s", signature
);
390 /* Append C value, extracted from Lisp OBJECT, to iteration ITER.
391 DTYPE must be a valid DBusType. It is used to convert Lisp
392 objects, being arguments of `dbus-call-method' or
393 `dbus-send-signal', into corresponding C values appended as
394 arguments to a D-Bus message. */
396 xd_append_arg (dtype
, object
, iter
)
399 DBusMessageIter
*iter
;
401 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
402 DBusMessageIter subiter
;
404 if (XD_BASIC_DBUS_TYPE (dtype
))
408 CHECK_NUMBER (object
);
410 unsigned char val
= XUINT (object
) & 0xFF;
411 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
412 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
413 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
417 case DBUS_TYPE_BOOLEAN
:
419 dbus_bool_t val
= (NILP (object
)) ? FALSE
: TRUE
;
420 XD_DEBUG_MESSAGE ("%c %s", dtype
, (val
== FALSE
) ? "false" : "true");
421 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
422 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
426 case DBUS_TYPE_INT16
:
427 CHECK_NUMBER (object
);
429 dbus_int16_t val
= XINT (object
);
430 XD_DEBUG_MESSAGE ("%c %d", dtype
, (int) val
);
431 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
432 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
436 case DBUS_TYPE_UINT16
:
437 CHECK_NUMBER (object
);
439 dbus_uint16_t val
= XUINT (object
);
440 XD_DEBUG_MESSAGE ("%c %u", dtype
, (unsigned int) val
);
441 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
442 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
446 case DBUS_TYPE_INT32
:
447 CHECK_NUMBER (object
);
449 dbus_int32_t val
= XINT (object
);
450 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
451 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
452 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
456 case DBUS_TYPE_UINT32
:
457 CHECK_NUMBER (object
);
459 dbus_uint32_t val
= XUINT (object
);
460 XD_DEBUG_MESSAGE ("%c %u", dtype
, val
);
461 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
462 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
466 case DBUS_TYPE_INT64
:
467 CHECK_NUMBER (object
);
469 dbus_int64_t val
= XINT (object
);
470 XD_DEBUG_MESSAGE ("%c %d", dtype
, (int) val
);
471 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
472 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
476 case DBUS_TYPE_UINT64
:
477 CHECK_NUMBER (object
);
479 dbus_uint64_t val
= XUINT (object
);
480 XD_DEBUG_MESSAGE ("%c %u", dtype
, (unsigned int) val
);
481 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
482 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
486 case DBUS_TYPE_DOUBLE
:
487 CHECK_FLOAT (object
);
489 double val
= XFLOAT_DATA (object
);
490 XD_DEBUG_MESSAGE ("%c %f", dtype
, val
);
491 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
492 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
496 case DBUS_TYPE_STRING
:
497 case DBUS_TYPE_OBJECT_PATH
:
498 case DBUS_TYPE_SIGNATURE
:
499 CHECK_STRING (object
);
501 /* We need to send a valid UTF-8 string. We could encode `object'
502 but by not encoding it, we guarantee it's valid utf-8, even if
503 it contains eight-bit-bytes. Of course, you can still send
504 manually-crafted junk by passing a unibyte string. */
505 char *val
= SDATA (object
);
506 XD_DEBUG_MESSAGE ("%c %s", dtype
, val
);
507 if (!dbus_message_iter_append_basic (iter
, dtype
, &val
))
508 XD_SIGNAL2 (build_string ("Unable to append argument"), object
);
513 else /* Compound types. */
516 /* All compound types except array have a type symbol. For
517 array, it is optional. Skip it. */
518 if (!XD_BASIC_DBUS_TYPE (XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (object
))))
519 object
= XD_NEXT_VALUE (object
);
521 /* Open new subiteration. */
524 case DBUS_TYPE_ARRAY
:
525 /* An array has only elements of the same type. So it is
526 sufficient to check the first element's signature
530 /* If the array is empty, DBUS_TYPE_STRING is the default
532 strcpy (signature
, DBUS_TYPE_STRING_AS_STRING
);
535 /* If the element type is DBUS_TYPE_SIGNATURE, and this is
536 the only element, the value of this element is used as
537 the array's element signature. */
538 if ((XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (object
))
539 == DBUS_TYPE_SIGNATURE
)
540 && STRINGP (CAR_SAFE (XD_NEXT_VALUE (object
)))
541 && NILP (CDR_SAFE (XD_NEXT_VALUE (object
))))
543 strcpy (signature
, SDATA (CAR_SAFE (XD_NEXT_VALUE (object
))));
544 object
= CDR_SAFE (XD_NEXT_VALUE (object
));
548 xd_signature (signature
,
549 XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (object
)),
550 dtype
, CAR_SAFE (XD_NEXT_VALUE (object
)));
552 XD_DEBUG_MESSAGE ("%c %s %s", dtype
, signature
,
553 SDATA (format2 ("%s", object
, Qnil
)));
554 if (!dbus_message_iter_open_container (iter
, dtype
,
555 signature
, &subiter
))
556 XD_SIGNAL3 (build_string ("Cannot open container"),
557 make_number (dtype
), build_string (signature
));
560 case DBUS_TYPE_VARIANT
:
561 /* A variant has just one element. */
562 xd_signature (signature
, XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (object
)),
563 dtype
, CAR_SAFE (XD_NEXT_VALUE (object
)));
565 XD_DEBUG_MESSAGE ("%c %s %s", dtype
, signature
,
566 SDATA (format2 ("%s", object
, Qnil
)));
567 if (!dbus_message_iter_open_container (iter
, dtype
,
568 signature
, &subiter
))
569 XD_SIGNAL3 (build_string ("Cannot open container"),
570 make_number (dtype
), build_string (signature
));
573 case DBUS_TYPE_STRUCT
:
574 case DBUS_TYPE_DICT_ENTRY
:
575 /* These containers do not require a signature. */
576 XD_DEBUG_MESSAGE ("%c %s", dtype
,
577 SDATA (format2 ("%s", object
, Qnil
)));
578 if (!dbus_message_iter_open_container (iter
, dtype
, NULL
, &subiter
))
579 XD_SIGNAL2 (build_string ("Cannot open container"),
580 make_number (dtype
));
584 /* Loop over list elements. */
585 while (!NILP (object
))
587 dtype
= XD_OBJECT_TO_DBUS_TYPE (CAR_SAFE (object
));
588 object
= XD_NEXT_VALUE (object
);
590 xd_append_arg (dtype
, CAR_SAFE (object
), &subiter
);
592 object
= CDR_SAFE (object
);
595 /* Close the subiteration. */
596 if (!dbus_message_iter_close_container (iter
, &subiter
))
597 XD_SIGNAL2 (build_string ("Cannot close container"),
598 make_number (dtype
));
602 /* Retrieve C value from a DBusMessageIter structure ITER, and return
603 a converted Lisp object. The type DTYPE of the argument of the
604 D-Bus message must be a valid DBusType. Compound D-Bus types
605 result always in a Lisp list. */
607 xd_retrieve_arg (dtype
, iter
)
609 DBusMessageIter
*iter
;
617 dbus_message_iter_get_basic (iter
, &val
);
619 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
620 return make_number (val
);
623 case DBUS_TYPE_BOOLEAN
:
626 dbus_message_iter_get_basic (iter
, &val
);
627 XD_DEBUG_MESSAGE ("%c %s", dtype
, (val
== FALSE
) ? "false" : "true");
628 return (val
== FALSE
) ? Qnil
: Qt
;
631 case DBUS_TYPE_INT16
:
634 dbus_message_iter_get_basic (iter
, &val
);
635 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
636 return make_number (val
);
639 case DBUS_TYPE_UINT16
:
642 dbus_message_iter_get_basic (iter
, &val
);
643 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
644 return make_number (val
);
647 case DBUS_TYPE_INT32
:
650 dbus_message_iter_get_basic (iter
, &val
);
651 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
652 return make_fixnum_or_float (val
);
655 case DBUS_TYPE_UINT32
:
658 dbus_message_iter_get_basic (iter
, &val
);
659 XD_DEBUG_MESSAGE ("%c %d", dtype
, val
);
660 return make_fixnum_or_float (val
);
663 case DBUS_TYPE_INT64
:
666 dbus_message_iter_get_basic (iter
, &val
);
667 XD_DEBUG_MESSAGE ("%c %d", dtype
, (int) val
);
668 return make_fixnum_or_float (val
);
671 case DBUS_TYPE_UINT64
:
674 dbus_message_iter_get_basic (iter
, &val
);
675 XD_DEBUG_MESSAGE ("%c %d", dtype
, (int) val
);
676 return make_fixnum_or_float (val
);
679 case DBUS_TYPE_DOUBLE
:
682 dbus_message_iter_get_basic (iter
, &val
);
683 XD_DEBUG_MESSAGE ("%c %f", dtype
, val
);
684 return make_float (val
);
687 case DBUS_TYPE_STRING
:
688 case DBUS_TYPE_OBJECT_PATH
:
689 case DBUS_TYPE_SIGNATURE
:
692 dbus_message_iter_get_basic (iter
, &val
);
693 XD_DEBUG_MESSAGE ("%c %s", dtype
, val
);
694 return build_string (val
);
697 case DBUS_TYPE_ARRAY
:
698 case DBUS_TYPE_VARIANT
:
699 case DBUS_TYPE_STRUCT
:
700 case DBUS_TYPE_DICT_ENTRY
:
704 DBusMessageIter subiter
;
708 dbus_message_iter_recurse (iter
, &subiter
);
709 while ((subtype
= dbus_message_iter_get_arg_type (&subiter
))
710 != DBUS_TYPE_INVALID
)
712 result
= Fcons (xd_retrieve_arg (subtype
, &subiter
), result
);
713 dbus_message_iter_next (&subiter
);
715 XD_DEBUG_MESSAGE ("%c %s", dtype
, SDATA (format2 ("%s", result
, Qnil
)));
716 RETURN_UNGCPRO (Fnreverse (result
));
720 XD_DEBUG_MESSAGE ("DBusType '%c' not supported", dtype
);
725 /* Initialize D-Bus connection. BUS is a Lisp symbol, either :system
726 or :session. It tells which D-Bus to be initialized. */
727 static DBusConnection
*
731 DBusConnection
*connection
;
734 /* Parameter check. */
736 if (!(EQ (bus
, QCdbus_system_bus
) || EQ (bus
, QCdbus_session_bus
)))
737 XD_SIGNAL2 (build_string ("Wrong bus name"), bus
);
739 /* We do not want to have an autolaunch for the session bus. */
740 if (EQ (bus
, QCdbus_session_bus
)
741 && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL
)
742 XD_SIGNAL2 (build_string ("No connection to bus"), bus
);
744 /* Open a connection to the bus. */
745 dbus_error_init (&derror
);
747 if (EQ (bus
, QCdbus_system_bus
))
748 connection
= dbus_bus_get (DBUS_BUS_SYSTEM
, &derror
);
750 connection
= dbus_bus_get (DBUS_BUS_SESSION
, &derror
);
752 if (dbus_error_is_set (&derror
))
755 if (connection
== NULL
)
756 XD_SIGNAL2 (build_string ("No connection to bus"), bus
);
759 dbus_error_free (&derror
);
761 /* Return the result. */
766 /* Add connection file descriptor to input_wait_mask, in order to
767 let select() detect, whether a new message has been arrived. */
769 xd_add_watch (watch
, data
)
773 /* We check only for incoming data. */
774 if (dbus_watch_get_flags (watch
) & DBUS_WATCH_READABLE
)
776 #if HAVE_DBUS_WATCH_GET_UNIX_FD
777 /* TODO: Reverse these on Win32, which prefers the opposite. */
778 int fd
= dbus_watch_get_unix_fd(watch
);
780 fd
= dbus_watch_get_socket(watch
);
782 int fd
= dbus_watch_get_fd(watch
);
784 XD_DEBUG_MESSAGE ("fd %d", fd
);
789 /* Add the file descriptor to input_wait_mask. */
790 add_keyboard_wait_descriptor (fd
);
797 /* Remove connection file descriptor from input_wait_mask. DATA is
798 the used bus, either QCdbus_system_bus or QCdbus_session_bus. */
800 xd_remove_watch (watch
, data
)
804 /* We check only for incoming data. */
805 if (dbus_watch_get_flags (watch
) & DBUS_WATCH_READABLE
)
807 #if HAVE_DBUS_WATCH_GET_UNIX_FD
808 /* TODO: Reverse these on Win32, which prefers the opposite. */
809 int fd
= dbus_watch_get_unix_fd(watch
);
811 fd
= dbus_watch_get_socket(watch
);
813 int fd
= dbus_watch_get_fd(watch
);
815 XD_DEBUG_MESSAGE ("fd %d", fd
);
820 /* Unset session environment. */
821 if ((data
!= NULL
) && (data
== (void*) XHASH (QCdbus_session_bus
)))
823 XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
824 unsetenv ("DBUS_SESSION_BUS_ADDRESS");
827 /* Remove the file descriptor from input_wait_mask. */
828 delete_keyboard_wait_descriptor (fd
);
835 DEFUN ("dbus-init-bus", Fdbus_init_bus
, Sdbus_init_bus
, 1, 1, 0,
836 doc
: /* Initialize connection to D-Bus BUS.
837 This is an internal function, it shall not be used outside dbus.el. */)
841 DBusConnection
*connection
;
843 /* Check parameters. */
846 /* Open a connection to the bus. */
847 connection
= xd_initialize (bus
);
849 /* Add the watch functions. We pass also the bus as data, in order
850 to distinguish between the busses in xd_remove_watch. */
851 if (!dbus_connection_set_watch_functions (connection
,
854 NULL
, (void*) XHASH (bus
), NULL
))
855 XD_SIGNAL1 (build_string ("Cannot add watch functions"));
857 /* We do not want to abort. */
858 putenv ("DBUS_FATAL_WARNINGS=0");
864 DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name
, Sdbus_get_unique_name
,
866 doc
: /* Return the unique name of Emacs registered at D-Bus BUS. */)
870 DBusConnection
*connection
;
873 /* Check parameters. */
876 /* Open a connection to the bus. */
877 connection
= xd_initialize (bus
);
879 /* Request the name. */
880 name
= dbus_bus_get_unique_name (connection
);
882 XD_SIGNAL1 (build_string ("No unique name available"));
885 return build_string (name
);
888 DEFUN ("dbus-call-method", Fdbus_call_method
, Sdbus_call_method
, 5, MANY
, 0,
889 doc
: /* Call METHOD on the D-Bus BUS.
891 BUS is either the symbol `:system' or the symbol `:session'.
893 SERVICE is the D-Bus service name to be used. PATH is the D-Bus
894 object path SERVICE is registered at. INTERFACE is an interface
895 offered by SERVICE. It must provide METHOD.
897 If the parameter `:timeout' is given, the following integer TIMEOUT
898 specifies the maximum number of milliseconds the method call must
899 return. The default value is 25,000. If the method call doesn't
900 return in time, a D-Bus error is raised.
902 All other arguments ARGS are passed to METHOD as arguments. They are
903 converted into D-Bus types via the following rules:
905 t and nil => DBUS_TYPE_BOOLEAN
906 number => DBUS_TYPE_UINT32
907 integer => DBUS_TYPE_INT32
908 float => DBUS_TYPE_DOUBLE
909 string => DBUS_TYPE_STRING
910 list => DBUS_TYPE_ARRAY
912 All arguments can be preceded by a type symbol. For details about
913 type symbols, see Info node `(dbus)Type Conversion'.
915 `dbus-call-method' returns the resulting values of METHOD as a list of
916 Lisp objects. The type conversion happens the other direction as for
917 input arguments. It follows the mapping rules:
919 DBUS_TYPE_BOOLEAN => t or nil
920 DBUS_TYPE_BYTE => number
921 DBUS_TYPE_UINT16 => number
922 DBUS_TYPE_INT16 => integer
923 DBUS_TYPE_UINT32 => number or float
924 DBUS_TYPE_INT32 => integer or float
925 DBUS_TYPE_UINT64 => number or float
926 DBUS_TYPE_INT64 => integer or float
927 DBUS_TYPE_DOUBLE => float
928 DBUS_TYPE_STRING => string
929 DBUS_TYPE_OBJECT_PATH => string
930 DBUS_TYPE_SIGNATURE => string
931 DBUS_TYPE_ARRAY => list
932 DBUS_TYPE_VARIANT => list
933 DBUS_TYPE_STRUCT => list
934 DBUS_TYPE_DICT_ENTRY => list
939 :session "org.gnome.seahorse" "/org/gnome/seahorse/keys/openpgp"
940 "org.gnome.seahorse.Keys" "GetKeyField"
941 "openpgp:657984B8C7A966DD" "simple-name")
943 => (t ("Philip R. Zimmermann"))
945 If the result of the METHOD call is just one value, the converted Lisp
946 object is returned instead of a list containing this single Lisp object.
949 :system "org.freedesktop.Hal" "/org/freedesktop/Hal/devices/computer"
950 "org.freedesktop.Hal.Device" "GetPropertyString"
951 "system.kernel.machine")
955 usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TIMEOUT &rest ARGS) */)
958 register Lisp_Object
*args
;
960 Lisp_Object bus
, service
, path
, interface
, method
;
962 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
963 DBusConnection
*connection
;
964 DBusMessage
*dmessage
;
966 DBusMessageIter iter
;
971 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
973 /* Check parameters. */
981 CHECK_STRING (service
);
983 CHECK_STRING (interface
);
984 CHECK_STRING (method
);
985 GCPRO5 (bus
, service
, path
, interface
, method
);
987 XD_DEBUG_MESSAGE ("%s %s %s %s",
993 /* Open a connection to the bus. */
994 connection
= xd_initialize (bus
);
996 /* Create the message. */
997 dmessage
= dbus_message_new_method_call (SDATA (service
),
1002 if (dmessage
== NULL
)
1003 XD_SIGNAL1 (build_string ("Unable to create a new message"));
1005 /* Check for timeout parameter. */
1006 if ((i
+2 <= nargs
) && (EQ ((args
[i
]), QCdbus_timeout
)))
1008 CHECK_NATNUM (args
[i
+1]);
1009 timeout
= XUINT (args
[i
+1]);
1013 /* Initialize parameter list of message. */
1014 dbus_message_iter_init_append (dmessage
, &iter
);
1016 /* Append parameters to the message. */
1017 for (; i
< nargs
; ++i
)
1019 dtype
= XD_OBJECT_TO_DBUS_TYPE (args
[i
]);
1020 if (XD_DBUS_TYPE_P (args
[i
]))
1022 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1023 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
+1]);
1024 XD_DEBUG_MESSAGE ("Parameter%d %s %s", i
-4,
1025 SDATA (format2 ("%s", args
[i
], Qnil
)),
1026 SDATA (format2 ("%s", args
[i
+1], Qnil
)));
1031 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1032 XD_DEBUG_MESSAGE ("Parameter%d %s", i
-4,
1033 SDATA (format2 ("%s", args
[i
], Qnil
)));
1036 /* Check for valid signature. We use DBUS_TYPE_INVALID as
1037 indication that there is no parent type. */
1038 xd_signature (signature
, dtype
, DBUS_TYPE_INVALID
, args
[i
]);
1040 xd_append_arg (dtype
, args
[i
], &iter
);
1043 /* Send the message. */
1044 dbus_error_init (&derror
);
1045 reply
= dbus_connection_send_with_reply_and_block (connection
,
1050 if (dbus_error_is_set (&derror
))
1054 XD_SIGNAL1 (build_string ("No reply"));
1056 XD_DEBUG_MESSAGE ("Message sent");
1058 /* Collect the results. */
1062 if (dbus_message_iter_init (reply
, &iter
))
1064 /* Loop over the parameters of the D-Bus reply message. Construct a
1065 Lisp list, which is returned by `dbus-call-method'. */
1066 while ((dtype
= dbus_message_iter_get_arg_type (&iter
))
1067 != DBUS_TYPE_INVALID
)
1069 result
= Fcons (xd_retrieve_arg (dtype
, &iter
), result
);
1070 dbus_message_iter_next (&iter
);
1075 /* No arguments: just return nil. */
1079 dbus_error_free (&derror
);
1080 dbus_message_unref (dmessage
);
1081 dbus_message_unref (reply
);
1083 /* Return the result. If there is only one single Lisp object,
1084 return it as-it-is, otherwise return the reversed list. */
1085 if (XUINT (Flength (result
)) == 1)
1086 RETURN_UNGCPRO (CAR_SAFE (result
));
1088 RETURN_UNGCPRO (Fnreverse (result
));
1091 DEFUN ("dbus-call-method-asynchronously", Fdbus_call_method_asynchronously
,
1092 Sdbus_call_method_asynchronously
, 6, MANY
, 0,
1093 doc
: /* Call METHOD on the D-Bus BUS asynchronously.
1095 BUS is either the symbol `:system' or the symbol `:session'.
1097 SERVICE is the D-Bus service name to be used. PATH is the D-Bus
1098 object path SERVICE is registered at. INTERFACE is an interface
1099 offered by SERVICE. It must provide METHOD.
1101 HANDLER is a Lisp function, which is called when the corresponding
1102 return message has arrived. If HANDLER is nil, no return message will
1105 If the parameter `:timeout' is given, the following integer TIMEOUT
1106 specifies the maximum number of milliseconds the method call must
1107 return. The default value is 25,000. If the method call doesn't
1108 return in time, a D-Bus error is raised.
1110 All other arguments ARGS are passed to METHOD as arguments. They are
1111 converted into D-Bus types via the following rules:
1113 t and nil => DBUS_TYPE_BOOLEAN
1114 number => DBUS_TYPE_UINT32
1115 integer => DBUS_TYPE_INT32
1116 float => DBUS_TYPE_DOUBLE
1117 string => DBUS_TYPE_STRING
1118 list => DBUS_TYPE_ARRAY
1120 All arguments can be preceded by a type symbol. For details about
1121 type symbols, see Info node `(dbus)Type Conversion'.
1123 Unless HANDLER is nil, the function returns a key into the hash table
1124 `dbus-registered-objects-table'. The corresponding entry in the hash
1125 table is removed, when the return message has been arrived, and
1130 \(dbus-call-method-asynchronously
1131 :system "org.freedesktop.Hal" "/org/freedesktop/Hal/devices/computer"
1132 "org.freedesktop.Hal.Device" "GetPropertyString" 'message
1133 "system.kernel.machine")
1139 usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLER &optional :timeout TIMEOUT &rest ARGS) */)
1142 register Lisp_Object
*args
;
1144 Lisp_Object bus
, service
, path
, interface
, method
, handler
;
1146 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
1147 DBusConnection
*connection
;
1148 DBusMessage
*dmessage
;
1149 DBusMessageIter iter
;
1153 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
1155 /* Check parameters. */
1159 interface
= args
[3];
1164 CHECK_STRING (service
);
1165 CHECK_STRING (path
);
1166 CHECK_STRING (interface
);
1167 CHECK_STRING (method
);
1168 if (!NILP (handler
) && !FUNCTIONP (handler
))
1169 wrong_type_argument (intern ("functionp"), handler
);
1170 GCPRO6 (bus
, service
, path
, interface
, method
, handler
);
1172 XD_DEBUG_MESSAGE ("%s %s %s %s",
1178 /* Open a connection to the bus. */
1179 connection
= xd_initialize (bus
);
1181 /* Create the message. */
1182 dmessage
= dbus_message_new_method_call (SDATA (service
),
1186 if (dmessage
== NULL
)
1187 XD_SIGNAL1 (build_string ("Unable to create a new message"));
1189 /* Check for timeout parameter. */
1190 if ((i
+2 <= nargs
) && (EQ ((args
[i
]), QCdbus_timeout
)))
1192 CHECK_NATNUM (args
[i
+1]);
1193 timeout
= XUINT (args
[i
+1]);
1197 /* Initialize parameter list of message. */
1198 dbus_message_iter_init_append (dmessage
, &iter
);
1200 /* Append parameters to the message. */
1201 for (; i
< nargs
; ++i
)
1203 dtype
= XD_OBJECT_TO_DBUS_TYPE (args
[i
]);
1204 if (XD_DBUS_TYPE_P (args
[i
]))
1206 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1207 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
+1]);
1208 XD_DEBUG_MESSAGE ("Parameter%d %s %s", i
-4,
1209 SDATA (format2 ("%s", args
[i
], Qnil
)),
1210 SDATA (format2 ("%s", args
[i
+1], Qnil
)));
1215 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1216 XD_DEBUG_MESSAGE ("Parameter%d %s", i
-4,
1217 SDATA (format2 ("%s", args
[i
], Qnil
)));
1220 /* Check for valid signature. We use DBUS_TYPE_INVALID as
1221 indication that there is no parent type. */
1222 xd_signature (signature
, dtype
, DBUS_TYPE_INVALID
, args
[i
]);
1224 xd_append_arg (dtype
, args
[i
], &iter
);
1227 if (!NILP (handler
))
1229 /* Send the message. The message is just added to the outgoing
1231 if (!dbus_connection_send_with_reply (connection
, dmessage
,
1233 XD_SIGNAL1 (build_string ("Cannot send message"));
1235 /* The result is the key in Vdbus_registered_objects_table. */
1236 result
= (list2 (bus
, make_number (dbus_message_get_serial (dmessage
))));
1238 /* Create a hash table entry. */
1239 Fputhash (result
, handler
, Vdbus_registered_objects_table
);
1243 /* Send the message. The message is just added to the outgoing
1245 if (!dbus_connection_send (connection
, dmessage
, NULL
))
1246 XD_SIGNAL1 (build_string ("Cannot send message"));
1251 /* Flush connection to ensure the message is handled. */
1252 dbus_connection_flush (connection
);
1254 XD_DEBUG_MESSAGE ("Message sent");
1257 dbus_message_unref (dmessage
);
1259 /* Return the result. */
1260 RETURN_UNGCPRO (result
);
1263 DEFUN ("dbus-method-return-internal", Fdbus_method_return_internal
,
1264 Sdbus_method_return_internal
,
1266 doc
: /* Return for message SERIAL on the D-Bus BUS.
1267 This is an internal function, it shall not be used outside dbus.el.
1269 usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS) */)
1272 register Lisp_Object
*args
;
1274 Lisp_Object bus
, serial
, service
;
1275 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1276 DBusConnection
*connection
;
1277 DBusMessage
*dmessage
;
1278 DBusMessageIter iter
;
1281 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
1283 /* Check parameters. */
1289 CHECK_NUMBER (serial
);
1290 CHECK_STRING (service
);
1291 GCPRO3 (bus
, serial
, service
);
1293 XD_DEBUG_MESSAGE ("%lu %s ", (unsigned long) XUINT (serial
), SDATA (service
));
1295 /* Open a connection to the bus. */
1296 connection
= xd_initialize (bus
);
1298 /* Create the message. */
1299 dmessage
= dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN
);
1300 if ((dmessage
== NULL
)
1301 || (!dbus_message_set_reply_serial (dmessage
, XUINT (serial
)))
1302 || (!dbus_message_set_destination (dmessage
, SDATA (service
))))
1305 XD_SIGNAL1 (build_string ("Unable to create a return message"));
1310 /* Initialize parameter list of message. */
1311 dbus_message_iter_init_append (dmessage
, &iter
);
1313 /* Append parameters to the message. */
1314 for (i
= 3; i
< nargs
; ++i
)
1316 dtype
= XD_OBJECT_TO_DBUS_TYPE (args
[i
]);
1317 if (XD_DBUS_TYPE_P (args
[i
]))
1319 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1320 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
+1]);
1321 XD_DEBUG_MESSAGE ("Parameter%d %s %s", i
-2,
1322 SDATA (format2 ("%s", args
[i
], Qnil
)),
1323 SDATA (format2 ("%s", args
[i
+1], Qnil
)));
1328 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1329 XD_DEBUG_MESSAGE ("Parameter%d %s", i
-2,
1330 SDATA (format2 ("%s", args
[i
], Qnil
)));
1333 /* Check for valid signature. We use DBUS_TYPE_INVALID as
1334 indication that there is no parent type. */
1335 xd_signature (signature
, dtype
, DBUS_TYPE_INVALID
, args
[i
]);
1337 xd_append_arg (dtype
, args
[i
], &iter
);
1340 /* Send the message. The message is just added to the outgoing
1342 if (!dbus_connection_send (connection
, dmessage
, NULL
))
1343 XD_SIGNAL1 (build_string ("Cannot send message"));
1345 /* Flush connection to ensure the message is handled. */
1346 dbus_connection_flush (connection
);
1348 XD_DEBUG_MESSAGE ("Message sent");
1351 dbus_message_unref (dmessage
);
1357 DEFUN ("dbus-method-error-internal", Fdbus_method_error_internal
,
1358 Sdbus_method_error_internal
,
1360 doc
: /* Return error message for message SERIAL on the D-Bus BUS.
1361 This is an internal function, it shall not be used outside dbus.el.
1363 usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS) */)
1366 register Lisp_Object
*args
;
1368 Lisp_Object bus
, serial
, service
;
1369 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1370 DBusConnection
*connection
;
1371 DBusMessage
*dmessage
;
1372 DBusMessageIter iter
;
1375 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
1377 /* Check parameters. */
1383 CHECK_NUMBER (serial
);
1384 CHECK_STRING (service
);
1385 GCPRO3 (bus
, serial
, service
);
1387 XD_DEBUG_MESSAGE ("%lu %s ", (unsigned long) XUINT (serial
), SDATA (service
));
1389 /* Open a connection to the bus. */
1390 connection
= xd_initialize (bus
);
1392 /* Create the message. */
1393 dmessage
= dbus_message_new (DBUS_MESSAGE_TYPE_ERROR
);
1394 if ((dmessage
== NULL
)
1395 || (!dbus_message_set_error_name (dmessage
, DBUS_ERROR_FAILED
))
1396 || (!dbus_message_set_reply_serial (dmessage
, XUINT (serial
)))
1397 || (!dbus_message_set_destination (dmessage
, SDATA (service
))))
1400 XD_SIGNAL1 (build_string ("Unable to create a error message"));
1405 /* Initialize parameter list of message. */
1406 dbus_message_iter_init_append (dmessage
, &iter
);
1408 /* Append parameters to the message. */
1409 for (i
= 3; i
< nargs
; ++i
)
1411 dtype
= XD_OBJECT_TO_DBUS_TYPE (args
[i
]);
1412 if (XD_DBUS_TYPE_P (args
[i
]))
1414 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1415 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
+1]);
1416 XD_DEBUG_MESSAGE ("Parameter%d %s %s", i
-2,
1417 SDATA (format2 ("%s", args
[i
], Qnil
)),
1418 SDATA (format2 ("%s", args
[i
+1], Qnil
)));
1423 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1424 XD_DEBUG_MESSAGE ("Parameter%d %s", i
-2,
1425 SDATA (format2 ("%s", args
[i
], Qnil
)));
1428 /* Check for valid signature. We use DBUS_TYPE_INVALID as
1429 indication that there is no parent type. */
1430 xd_signature (signature
, dtype
, DBUS_TYPE_INVALID
, args
[i
]);
1432 xd_append_arg (dtype
, args
[i
], &iter
);
1435 /* Send the message. The message is just added to the outgoing
1437 if (!dbus_connection_send (connection
, dmessage
, NULL
))
1438 XD_SIGNAL1 (build_string ("Cannot send message"));
1440 /* Flush connection to ensure the message is handled. */
1441 dbus_connection_flush (connection
);
1443 XD_DEBUG_MESSAGE ("Message sent");
1446 dbus_message_unref (dmessage
);
1452 DEFUN ("dbus-send-signal", Fdbus_send_signal
, Sdbus_send_signal
, 5, MANY
, 0,
1453 doc
: /* Send signal SIGNAL on the D-Bus BUS.
1455 BUS is either the symbol `:system' or the symbol `:session'.
1457 SERVICE is the D-Bus service name SIGNAL is sent from. PATH is the
1458 D-Bus object path SERVICE is registered at. INTERFACE is an interface
1459 offered by SERVICE. It must provide signal SIGNAL.
1461 All other arguments ARGS are passed to SIGNAL as arguments. They are
1462 converted into D-Bus types via the following rules:
1464 t and nil => DBUS_TYPE_BOOLEAN
1465 number => DBUS_TYPE_UINT32
1466 integer => DBUS_TYPE_INT32
1467 float => DBUS_TYPE_DOUBLE
1468 string => DBUS_TYPE_STRING
1469 list => DBUS_TYPE_ARRAY
1471 All arguments can be preceded by a type symbol. For details about
1472 type symbols, see Info node `(dbus)Type Conversion'.
1477 :session "org.gnu.Emacs" "/org/gnu/Emacs"
1478 "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
1480 usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS) */)
1483 register Lisp_Object
*args
;
1485 Lisp_Object bus
, service
, path
, interface
, signal
;
1486 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1487 DBusConnection
*connection
;
1488 DBusMessage
*dmessage
;
1489 DBusMessageIter iter
;
1492 char signature
[DBUS_MAXIMUM_SIGNATURE_LENGTH
];
1494 /* Check parameters. */
1498 interface
= args
[3];
1502 CHECK_STRING (service
);
1503 CHECK_STRING (path
);
1504 CHECK_STRING (interface
);
1505 CHECK_STRING (signal
);
1506 GCPRO5 (bus
, service
, path
, interface
, signal
);
1508 XD_DEBUG_MESSAGE ("%s %s %s %s",
1514 /* Open a connection to the bus. */
1515 connection
= xd_initialize (bus
);
1517 /* Create the message. */
1518 dmessage
= dbus_message_new_signal (SDATA (path
),
1522 if (dmessage
== NULL
)
1523 XD_SIGNAL1 (build_string ("Unable to create a new message"));
1525 /* Initialize parameter list of message. */
1526 dbus_message_iter_init_append (dmessage
, &iter
);
1528 /* Append parameters to the message. */
1529 for (i
= 5; i
< nargs
; ++i
)
1531 dtype
= XD_OBJECT_TO_DBUS_TYPE (args
[i
]);
1532 if (XD_DBUS_TYPE_P (args
[i
]))
1534 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1535 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
+1]);
1536 XD_DEBUG_MESSAGE ("Parameter%d %s %s", i
-4,
1537 SDATA (format2 ("%s", args
[i
], Qnil
)),
1538 SDATA (format2 ("%s", args
[i
+1], Qnil
)));
1543 XD_DEBUG_VALID_LISP_OBJECT_P (args
[i
]);
1544 XD_DEBUG_MESSAGE ("Parameter%d %s", i
-4,
1545 SDATA (format2 ("%s", args
[i
], Qnil
)));
1548 /* Check for valid signature. We use DBUS_TYPE_INVALID as
1549 indication that there is no parent type. */
1550 xd_signature (signature
, dtype
, DBUS_TYPE_INVALID
, args
[i
]);
1552 xd_append_arg (dtype
, args
[i
], &iter
);
1555 /* Send the message. The message is just added to the outgoing
1557 if (!dbus_connection_send (connection
, dmessage
, NULL
))
1558 XD_SIGNAL1 (build_string ("Cannot send message"));
1560 /* Flush connection to ensure the message is handled. */
1561 dbus_connection_flush (connection
);
1563 XD_DEBUG_MESSAGE ("Signal sent");
1566 dbus_message_unref (dmessage
);
1572 /* Check, whether there is pending input in the message queue of the
1573 D-Bus BUS. BUS is a Lisp symbol, either :system or :session. */
1575 xd_get_dispatch_status (bus
)
1578 DBusConnection
*connection
;
1580 /* Open a connection to the bus. */
1581 connection
= xd_initialize (bus
);
1583 /* Non blocking read of the next available message. */
1584 dbus_connection_read_write (connection
, 0);
1588 (dbus_connection_get_dispatch_status (connection
)
1589 == DBUS_DISPATCH_DATA_REMAINS
)
1593 /* Check for queued incoming messages from the system and session buses. */
1595 xd_pending_messages ()
1598 xd_in_read_queued_messages
= 1;
1600 /* Vdbus_registered_objects_table will be initialized as hash table
1601 in dbus.el. When this package isn't loaded yet, it doesn't make
1602 sense to handle D-Bus messages. */
1603 if (HASH_TABLE_P (Vdbus_registered_objects_table
))
1605 ret
= (!NILP (internal_catch (Qdbus_error
, xd_get_dispatch_status
,
1606 QCdbus_system_bus
)));
1607 if (ret
) goto theend
;
1609 ret
= ((getenv ("DBUS_SESSION_BUS_ADDRESS") != NULL
) &&
1610 (!NILP (internal_catch (Qdbus_error
, xd_get_dispatch_status
,
1611 QCdbus_session_bus
))));
1616 xd_in_read_queued_messages
= 0;
1620 /* Read queued incoming message of the D-Bus BUS. BUS is a Lisp
1621 symbol, either :system or :session. */
1623 xd_read_message (bus
)
1626 Lisp_Object args
, key
, value
;
1627 struct gcpro gcpro1
;
1628 struct input_event event
;
1629 DBusConnection
*connection
;
1630 DBusMessage
*dmessage
;
1631 DBusMessageIter iter
;
1634 const char *uname
, *path
, *interface
, *member
;
1636 /* Open a connection to the bus. */
1637 connection
= xd_initialize (bus
);
1639 /* Non blocking read of the next available message. */
1640 dbus_connection_read_write (connection
, 0);
1641 dmessage
= dbus_connection_pop_message (connection
);
1643 /* Return if there is no queued message. */
1644 if (dmessage
== NULL
)
1647 /* Collect the parameters. */
1651 /* Loop over the resulting parameters. Construct a list. */
1652 if (dbus_message_iter_init (dmessage
, &iter
))
1654 while ((dtype
= dbus_message_iter_get_arg_type (&iter
))
1655 != DBUS_TYPE_INVALID
)
1657 args
= Fcons (xd_retrieve_arg (dtype
, &iter
), args
);
1658 dbus_message_iter_next (&iter
);
1660 /* The arguments are stored in reverse order. Reorder them. */
1661 args
= Fnreverse (args
);
1664 /* Read message type, message serial, unique name, object path,
1665 interface and member from the message. */
1666 mtype
= dbus_message_get_type (dmessage
);
1668 ((mtype
== DBUS_MESSAGE_TYPE_METHOD_RETURN
)
1669 || (mtype
== DBUS_MESSAGE_TYPE_ERROR
))
1670 ? dbus_message_get_reply_serial (dmessage
)
1671 : dbus_message_get_serial (dmessage
);
1672 uname
= dbus_message_get_sender (dmessage
);
1673 path
= dbus_message_get_path (dmessage
);
1674 interface
= dbus_message_get_interface (dmessage
);
1675 member
= dbus_message_get_member (dmessage
);
1677 XD_DEBUG_MESSAGE ("Event received: %s %d %s %s %s %s %s",
1678 (mtype
== DBUS_MESSAGE_TYPE_INVALID
)
1679 ? "DBUS_MESSAGE_TYPE_INVALID"
1680 : (mtype
== DBUS_MESSAGE_TYPE_METHOD_CALL
)
1681 ? "DBUS_MESSAGE_TYPE_METHOD_CALL"
1682 : (mtype
== DBUS_MESSAGE_TYPE_METHOD_RETURN
)
1683 ? "DBUS_MESSAGE_TYPE_METHOD_RETURN"
1684 : (mtype
== DBUS_MESSAGE_TYPE_ERROR
)
1685 ? "DBUS_MESSAGE_TYPE_ERROR"
1686 : "DBUS_MESSAGE_TYPE_SIGNAL",
1687 serial
, uname
, path
, interface
, member
,
1688 SDATA (format2 ("%s", args
, Qnil
)));
1690 if ((mtype
== DBUS_MESSAGE_TYPE_METHOD_RETURN
)
1691 || (mtype
== DBUS_MESSAGE_TYPE_ERROR
))
1693 /* Search for a registered function of the message. */
1694 key
= list2 (bus
, make_number (serial
));
1695 value
= Fgethash (key
, Vdbus_registered_objects_table
, Qnil
);
1697 /* There shall be exactly one entry. Construct an event. */
1701 /* Remove the entry. */
1702 Fremhash (key
, Vdbus_registered_objects_table
);
1704 /* Construct an event. */
1706 event
.kind
= DBUS_EVENT
;
1707 event
.frame_or_window
= Qnil
;
1708 event
.arg
= Fcons (value
, args
);
1711 else /* (mtype != DBUS_MESSAGE_TYPE_METHOD_RETURN) */
1713 /* Vdbus_registered_objects_table requires non-nil interface and
1715 if ((interface
== NULL
) || (member
== NULL
))
1718 /* Search for a registered function of the message. */
1719 key
= list3 (bus
, build_string (interface
), build_string (member
));
1720 value
= Fgethash (key
, Vdbus_registered_objects_table
, Qnil
);
1722 /* Loop over the registered functions. Construct an event. */
1723 while (!NILP (value
))
1725 key
= CAR_SAFE (value
);
1726 /* key has the structure (UNAME SERVICE PATH HANDLER). */
1727 if (((uname
== NULL
)
1728 || (NILP (CAR_SAFE (key
)))
1729 || (strcmp (uname
, SDATA (CAR_SAFE (key
))) == 0))
1731 || (NILP (CAR_SAFE (CDR_SAFE (CDR_SAFE (key
)))))
1733 SDATA (CAR_SAFE (CDR_SAFE (CDR_SAFE (key
)))))
1735 && (!NILP (CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (key
)))))))
1738 event
.kind
= DBUS_EVENT
;
1739 event
.frame_or_window
= Qnil
;
1740 event
.arg
= Fcons (CAR_SAFE (CDR_SAFE (CDR_SAFE (CDR_SAFE (key
)))),
1744 value
= CDR_SAFE (value
);
1751 /* Add type, serial, uname, path, interface and member to the event. */
1752 event
.arg
= Fcons ((member
== NULL
? Qnil
: build_string (member
)),
1754 event
.arg
= Fcons ((interface
== NULL
? Qnil
: build_string (interface
)),
1756 event
.arg
= Fcons ((path
== NULL
? Qnil
: build_string (path
)),
1758 event
.arg
= Fcons ((uname
== NULL
? Qnil
: build_string (uname
)),
1760 event
.arg
= Fcons (make_number (serial
), event
.arg
);
1761 event
.arg
= Fcons (make_number (mtype
), event
.arg
);
1763 /* Add the bus symbol to the event. */
1764 event
.arg
= Fcons (bus
, event
.arg
);
1766 /* Store it into the input event queue. */
1767 kbd_buffer_store_event (&event
);
1769 XD_DEBUG_MESSAGE ("Event stored: %s",
1770 SDATA (format2 ("%s", event
.arg
, Qnil
)));
1774 dbus_message_unref (dmessage
);
1776 RETURN_UNGCPRO (Qnil
);
1779 /* Read queued incoming messages from the system and session buses. */
1781 xd_read_queued_messages ()
1784 /* Vdbus_registered_objects_table will be initialized as hash table
1785 in dbus.el. When this package isn't loaded yet, it doesn't make
1786 sense to handle D-Bus messages. Furthermore, we ignore all Lisp
1787 errors during the call. */
1788 if (HASH_TABLE_P (Vdbus_registered_objects_table
))
1790 xd_in_read_queued_messages
= 1;
1791 internal_catch (Qdbus_error
, xd_read_message
, QCdbus_system_bus
);
1792 internal_catch (Qdbus_error
, xd_read_message
, QCdbus_session_bus
);
1793 xd_in_read_queued_messages
= 0;
1797 DEFUN ("dbus-register-signal", Fdbus_register_signal
, Sdbus_register_signal
,
1799 doc
: /* Register for signal SIGNAL on the D-Bus BUS.
1801 BUS is either the symbol `:system' or the symbol `:session'.
1803 SERVICE is the D-Bus service name used by the sending D-Bus object.
1804 It can be either a known name or the unique name of the D-Bus object
1805 sending the signal. When SERVICE is nil, related signals from all
1806 D-Bus objects shall be accepted.
1808 PATH is the D-Bus object path SERVICE is registered. It can also be
1809 nil if the path name of incoming signals shall not be checked.
1811 INTERFACE is an interface offered by SERVICE. It must provide SIGNAL.
1812 HANDLER is a Lisp function to be called when the signal is received.
1813 It must accept as arguments the values SIGNAL is sending.
1815 All other arguments ARGS, if specified, must be strings. They stand
1816 for the respective arguments of the signal in their order, and are
1817 used for filtering as well. A nil argument might be used to preserve
1820 INTERFACE, SIGNAL and HANDLER must not be nil. Example:
1822 \(defun my-signal-handler (device)
1823 (message "Device %s added" device))
1825 \(dbus-register-signal
1826 :system "org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
1827 "org.freedesktop.Hal.Manager" "DeviceAdded" 'my-signal-handler)
1829 => ((:system "org.freedesktop.Hal.Manager" "DeviceAdded")
1830 ("org.freedesktop.Hal" "/org/freedesktop/Hal/Manager" my-signal-handler))
1832 `dbus-register-signal' returns an object, which can be used in
1833 `dbus-unregister-object' for removing the registration.
1835 usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARGS) */)
1838 register Lisp_Object
*args
;
1840 Lisp_Object bus
, service
, path
, interface
, signal
, handler
;
1841 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
1842 Lisp_Object uname
, key
, key1
, value
;
1843 DBusConnection
*connection
;
1845 char rule
[DBUS_MAXIMUM_MATCH_RULE_LENGTH
];
1846 char x
[DBUS_MAXIMUM_MATCH_RULE_LENGTH
];
1849 /* Check parameters. */
1853 interface
= args
[3];
1858 if (!NILP (service
)) CHECK_STRING (service
);
1859 if (!NILP (path
)) CHECK_STRING (path
);
1860 CHECK_STRING (interface
);
1861 CHECK_STRING (signal
);
1862 if (!FUNCTIONP (handler
))
1863 wrong_type_argument (intern ("functionp"), handler
);
1864 GCPRO6 (bus
, service
, path
, interface
, signal
, handler
);
1866 /* Retrieve unique name of service. If service is a known name, we
1867 will register for the corresponding unique name, if any. Signals
1868 are sent always with the unique name as sender. Note: the unique
1869 name of "org.freedesktop.DBus" is that string itself. */
1870 if ((STRINGP (service
))
1871 && (SBYTES (service
) > 0)
1872 && (strcmp (SDATA (service
), DBUS_SERVICE_DBUS
) != 0)
1873 && (strncmp (SDATA (service
), ":", 1) != 0))
1875 uname
= call2 (intern ("dbus-get-name-owner"), bus
, service
);
1876 /* When there is no unique name, we mark it with an empty
1879 uname
= empty_unibyte_string
;
1884 /* Create a matching rule if the unique name exists (when no
1886 if (NILP (uname
) || (SBYTES (uname
) > 0))
1888 /* Open a connection to the bus. */
1889 connection
= xd_initialize (bus
);
1891 /* Create a rule to receive related signals. */
1893 "type='signal',interface='%s',member='%s'",
1897 /* Add unique name and path to the rule if they are non-nil. */
1900 sprintf (x
, ",sender='%s'", SDATA (uname
));
1906 sprintf (x
, ",path='%s'", SDATA (path
));
1910 /* Add arguments to the rule if they are non-nil. */
1911 for (i
= 6; i
< nargs
; ++i
)
1912 if (!NILP (args
[i
]))
1914 CHECK_STRING (args
[i
]);
1915 sprintf (x
, ",arg%d='%s'", i
-6, SDATA (args
[i
]));
1919 /* Add the rule to the bus. */
1920 dbus_error_init (&derror
);
1921 dbus_bus_add_match (connection
, rule
, &derror
);
1922 if (dbus_error_is_set (&derror
))
1929 dbus_error_free (&derror
);
1931 XD_DEBUG_MESSAGE ("Matching rule \"%s\" created", rule
);
1934 /* Create a hash table entry. */
1935 key
= list3 (bus
, interface
, signal
);
1936 key1
= list4 (uname
, service
, path
, handler
);
1937 value
= Fgethash (key
, Vdbus_registered_objects_table
, Qnil
);
1939 if (NILP (Fmember (key1
, value
)))
1940 Fputhash (key
, Fcons (key1
, value
), Vdbus_registered_objects_table
);
1942 /* Return object. */
1943 RETURN_UNGCPRO (list2 (key
, list3 (service
, path
, handler
)));
1946 DEFUN ("dbus-register-method", Fdbus_register_method
, Sdbus_register_method
,
1948 doc
: /* Register for method METHOD on the D-Bus BUS.
1950 BUS is either the symbol `:system' or the symbol `:session'.
1952 SERVICE is the D-Bus service name of the D-Bus object METHOD is
1953 registered for. It must be a known name.
1955 PATH is the D-Bus object path SERVICE is registered. INTERFACE is the
1956 interface offered by SERVICE. It must provide METHOD. HANDLER is a
1957 Lisp function to be called when a method call is received. It must
1958 accept the input arguments of METHOD. The return value of HANDLER is
1959 used for composing the returning D-Bus message. */)
1960 (bus
, service
, path
, interface
, method
, handler
)
1961 Lisp_Object bus
, service
, path
, interface
, method
, handler
;
1963 Lisp_Object key
, key1
, value
;
1964 DBusConnection
*connection
;
1968 /* Check parameters. */
1970 CHECK_STRING (service
);
1971 CHECK_STRING (path
);
1972 CHECK_STRING (interface
);
1973 CHECK_STRING (method
);
1974 if (!FUNCTIONP (handler
))
1975 wrong_type_argument (intern ("functionp"), handler
);
1976 /* TODO: We must check for a valid service name, otherwise there is
1977 a segmentation fault. */
1979 /* Open a connection to the bus. */
1980 connection
= xd_initialize (bus
);
1982 /* Request the known name from the bus. We can ignore the result,
1983 it is set to -1 if there is an error - kind of redundancy. */
1984 dbus_error_init (&derror
);
1985 result
= dbus_bus_request_name (connection
, SDATA (service
), 0, &derror
);
1986 if (dbus_error_is_set (&derror
))
1989 /* Create a hash table entry. We use nil for the unique name,
1990 because the method might be called from anybody. */
1991 key
= list3 (bus
, interface
, method
);
1992 key1
= list4 (Qnil
, service
, path
, handler
);
1993 value
= Fgethash (key
, Vdbus_registered_objects_table
, Qnil
);
1995 if (NILP (Fmember (key1
, value
)))
1996 Fputhash (key
, Fcons (key1
, value
), Vdbus_registered_objects_table
);
1999 dbus_error_free (&derror
);
2001 /* Return object. */
2002 return list2 (key
, list3 (service
, path
, handler
));
2010 Qdbus_init_bus
= intern_c_string ("dbus-init-bus");
2011 staticpro (&Qdbus_init_bus
);
2012 defsubr (&Sdbus_init_bus
);
2014 Qdbus_get_unique_name
= intern_c_string ("dbus-get-unique-name");
2015 staticpro (&Qdbus_get_unique_name
);
2016 defsubr (&Sdbus_get_unique_name
);
2018 Qdbus_call_method
= intern_c_string ("dbus-call-method");
2019 staticpro (&Qdbus_call_method
);
2020 defsubr (&Sdbus_call_method
);
2022 Qdbus_call_method_asynchronously
= intern_c_string ("dbus-call-method-asynchronously");
2023 staticpro (&Qdbus_call_method_asynchronously
);
2024 defsubr (&Sdbus_call_method_asynchronously
);
2026 Qdbus_method_return_internal
= intern_c_string ("dbus-method-return-internal");
2027 staticpro (&Qdbus_method_return_internal
);
2028 defsubr (&Sdbus_method_return_internal
);
2030 Qdbus_method_error_internal
= intern_c_string ("dbus-method-error-internal");
2031 staticpro (&Qdbus_method_error_internal
);
2032 defsubr (&Sdbus_method_error_internal
);
2034 Qdbus_send_signal
= intern_c_string ("dbus-send-signal");
2035 staticpro (&Qdbus_send_signal
);
2036 defsubr (&Sdbus_send_signal
);
2038 Qdbus_register_signal
= intern_c_string ("dbus-register-signal");
2039 staticpro (&Qdbus_register_signal
);
2040 defsubr (&Sdbus_register_signal
);
2042 Qdbus_register_method
= intern_c_string ("dbus-register-method");
2043 staticpro (&Qdbus_register_method
);
2044 defsubr (&Sdbus_register_method
);
2046 Qdbus_error
= intern_c_string ("dbus-error");
2047 staticpro (&Qdbus_error
);
2048 Fput (Qdbus_error
, Qerror_conditions
,
2049 list2 (Qdbus_error
, Qerror
));
2050 Fput (Qdbus_error
, Qerror_message
,
2051 make_pure_c_string ("D-Bus error"));
2053 QCdbus_system_bus
= intern_c_string (":system");
2054 staticpro (&QCdbus_system_bus
);
2056 QCdbus_session_bus
= intern_c_string (":session");
2057 staticpro (&QCdbus_session_bus
);
2059 QCdbus_timeout
= intern_c_string (":timeout");
2060 staticpro (&QCdbus_timeout
);
2062 QCdbus_type_byte
= intern_c_string (":byte");
2063 staticpro (&QCdbus_type_byte
);
2065 QCdbus_type_boolean
= intern_c_string (":boolean");
2066 staticpro (&QCdbus_type_boolean
);
2068 QCdbus_type_int16
= intern_c_string (":int16");
2069 staticpro (&QCdbus_type_int16
);
2071 QCdbus_type_uint16
= intern_c_string (":uint16");
2072 staticpro (&QCdbus_type_uint16
);
2074 QCdbus_type_int32
= intern_c_string (":int32");
2075 staticpro (&QCdbus_type_int32
);
2077 QCdbus_type_uint32
= intern_c_string (":uint32");
2078 staticpro (&QCdbus_type_uint32
);
2080 QCdbus_type_int64
= intern_c_string (":int64");
2081 staticpro (&QCdbus_type_int64
);
2083 QCdbus_type_uint64
= intern_c_string (":uint64");
2084 staticpro (&QCdbus_type_uint64
);
2086 QCdbus_type_double
= intern_c_string (":double");
2087 staticpro (&QCdbus_type_double
);
2089 QCdbus_type_string
= intern_c_string (":string");
2090 staticpro (&QCdbus_type_string
);
2092 QCdbus_type_object_path
= intern_c_string (":object-path");
2093 staticpro (&QCdbus_type_object_path
);
2095 QCdbus_type_signature
= intern_c_string (":signature");
2096 staticpro (&QCdbus_type_signature
);
2098 QCdbus_type_array
= intern_c_string (":array");
2099 staticpro (&QCdbus_type_array
);
2101 QCdbus_type_variant
= intern_c_string (":variant");
2102 staticpro (&QCdbus_type_variant
);
2104 QCdbus_type_struct
= intern_c_string (":struct");
2105 staticpro (&QCdbus_type_struct
);
2107 QCdbus_type_dict_entry
= intern_c_string (":dict-entry");
2108 staticpro (&QCdbus_type_dict_entry
);
2110 DEFVAR_LISP ("dbus-registered-objects-table",
2111 &Vdbus_registered_objects_table
,
2112 doc
: /* Hash table of registered functions for D-Bus.
2113 There are two different uses of the hash table: for accessing
2114 registered interfaces properties, targeted by signals or method calls,
2115 and for calling handlers in case of non-blocking method call returns.
2117 In the first case, the key in the hash table is the list (BUS
2118 INTERFACE MEMBER). BUS is either the symbol `:system' or the symbol
2119 `:session'. INTERFACE is a string which denotes a D-Bus interface,
2120 and MEMBER, also a string, is either a method, a signal or a property
2121 INTERFACE is offering. All arguments but BUS must not be nil.
2123 The value in the hash table is a list of quadruple lists
2124 \((UNAME SERVICE PATH OBJECT) (UNAME SERVICE PATH OBJECT) ...).
2125 SERVICE is the service name as registered, UNAME is the corresponding
2126 unique name. In case of registered methods and properties, UNAME is
2127 nil. PATH is the object path of the sending object. All of them can
2128 be nil, which means a wildcard then. OBJECT is either the handler to
2129 be called when a D-Bus message, which matches the key criteria,
2130 arrives (methods and signals), or a cons cell containing the value of
2133 In the second case, the key in the hash table is the list (BUS SERIAL).
2134 BUS is either the symbol `:system' or the symbol `:session'. SERIAL
2135 is the serial number of the non-blocking method call, a reply is
2136 expected. Both arguments must not be nil. The value in the hash
2137 table is HANDLER, the function to be called when the D-Bus reply
2138 message arrives. */);
2139 /* We initialize Vdbus_registered_objects_table in dbus.el, because
2140 we need to define a hash table function first. */
2141 Vdbus_registered_objects_table
= Qnil
;
2143 DEFVAR_LISP ("dbus-debug", &Vdbus_debug
,
2144 doc
: /* If non-nil, debug messages of D-Bus bindings are raised. */);
2147 /* We can also set environment variable DBUS_VERBOSE=1 in order to
2148 see more traces. This requires libdbus-1 to be configured with
2149 --enable-verbose-mode. */
2154 Fprovide (intern_c_string ("dbusbind"), Qnil
);
2158 #endif /* HAVE_DBUS */
2160 /* arch-tag: 0e828477-b571-4fe4-b559-5c9211bc14b8
2161 (do not change this comment) */