1 /++
2 A module mostly copied from https://github.com/trishume/ddbus to help access the C dbus library on Linux.
3 +/
4 module arsd.dbus;
5
6 pragma(lib, "dbus-1");
7
8 import core.time : Duration;
9 import std.meta;
10 import std..string;
11 import std.typecons;
12 import std.exception;
13 import std.traits;
14 import std.conv;
15 import std.range;
16 import std.algorithm;
17
18 import core.memory;
19 import std.array;
20 import std.format;
21
22 import std.meta : AliasSeq, staticIndexOf;
23 import std.range;
24 import std.traits;
25 import std.variant : VariantN;
26
27
28 /++
29 Flags for use with dbusMarshaling UDA
30
31 Default is to include public fields only
32 +/
33 enum MarshalingFlag : ubyte {
34 includePrivateFields = 1 << 0, /// Automatically include private fields
35 manualOnly = 1 << 7 /// Only include fields with explicit
36 /// `@Yes.DBusMarshal`. This overrides any
37 /// `include` flags.
38 }
39
40 /++
41 UDA for specifying DBus marshaling options on structs
42 +/
43 auto dbusMarshaling(Args)(Args args ...)
44 if (allSatisfy!(isMarshalingFlag, Args)) {
45 return BitFlags!MarshalingFlag(args);
46 }
47
48 private template isAllowedField(alias field) {
49 private enum flags = marshalingFlags!(__traits(parent, field));
50 private alias getUDAs!(field, Flag!"DBusMarshal") UDAs;
51
52 static if (UDAs.length != 0) {
53 static assert (UDAs.length == 1,
54 "Only one UDA of type Flag!\"DBusMarshal\" allowed on struct field.");
55 static assert (is(typeof(UDAs[0]) == Flag!"DBusMarshal"),
56 "Did you intend to add UDA Yes.DBusMarshal or No.DBusMarshal?");
57 enum isAllowedField = cast(bool) UDAs[0];
58 } else static if (!(flags & MarshalingFlag.manualOnly)) {
59 static if (__traits(getProtection, field) == "public")
60 enum isAllowedField = true;
61 else static if (cast(bool) (flags & MarshalingFlag.includePrivateFields))
62 enum isAllowedField = true;
63 else
64 enum isAllowedField = false;
65 } else
66 enum isAllowedField = false;
67 }
68
69 private template isMarshalingFlag(T) {
70 enum isMarshalingFlag = is(T == MarshalingFlag);
71 }
72
73 private template marshalingFlags(S) if (is(S == struct)) {
74 private alias getUDAs!(S, BitFlags!MarshalingFlag) UDAs;
75
76 static if (UDAs.length == 0)
77 enum marshalingFlags = BitFlags!MarshalingFlag.init;
78 else {
79 static assert (UDAs.length == 1,
80 "Only one @dbusMarshaling UDA allowed on type.");
81 static assert (is(typeof(UDAs[0]) == BitFlags!MarshalingFlag),
82 "Huh? Did you intend to use @dbusMarshaling UDA?");
83 enum marshalingFlags = UDAs[0];
84 }
85 }
86
87 struct DictionaryEntry(K, V) {
88 K key;
89 V value;
90 }
91
92 auto byDictionaryEntries(K, V)(V[K] aa) {
93 return aa.byKeyValue.map!(pair => DictionaryEntry!(K, V)(pair.key, pair.value));
94 }
95
96 template VariantType(T) {
97 alias VariantType = TemplateArgsOf!(T)[0];
98 }
99
100 template allCanDBus(TS...) {
101 static if (TS.length == 0) {
102 enum allCanDBus = true;
103 } else static if(!canDBus!(TS[0])) {
104 enum allCanDBus = false;
105 } else {
106 enum allCanDBus = allCanDBus!(TS[1..$]);
107 }
108 }
109
110 /++
111 AliasSeq of all basic types in terms of the DBus typesystem
112 +/
113 private // Don't add to the API yet, 'cause I intend to move it later
114 alias BasicTypes = AliasSeq!(
115 bool,
116 byte,
117 short,
118 ushort,
119 int,
120 uint,
121 long,
122 ulong,
123 double,
124 string,
125 ObjectPath
126 );
127
128 template basicDBus(T) {
129 static if(staticIndexOf!(T, BasicTypes) >= 0) {
130 enum basicDBus = true;
131 } else static if(is(T B == enum)) {
132 enum basicDBus = basicDBus!B;
133 } else static if(isInstanceOf!(BitFlags, T)) {
134 alias TemplateArgsOf!T[0] E;
135 enum basicDBus = basicDBus!E;
136 } else {
137 enum basicDBus = false;
138 }
139 }
140
141 template canDBus(T) {
142 static if(basicDBus!T || is(T == DBusAny)) {
143 enum canDBus = true;
144 } else static if(isInstanceOf!(Variant, T)) {
145 enum canDBus = canDBus!(VariantType!T);
146 } else static if(isInstanceOf!(VariantN, T)) {
147 // Phobos-style variants are supported if limited to DBus compatible types.
148 enum canDBus = (T.AllowedTypes.length > 0) && allCanDBus!(T.AllowedTypes);
149 } else static if(isTuple!T) {
150 enum canDBus = allCanDBus!(T.Types);
151 } else static if(isInputRange!T) {
152 static if(is(ElementType!T == DictionaryEntry!(K, V), K, V)) {
153 enum canDBus = basicDBus!K && canDBus!V;
154 } else {
155 enum canDBus = canDBus!(ElementType!T);
156 }
157 } else static if(isAssociativeArray!T) {
158 enum canDBus = basicDBus!(KeyType!T) && canDBus!(ValueType!T);
159 } else static if(is(T == struct) && !isInstanceOf!(DictionaryEntry, T)) {
160 enum canDBus = allCanDBus!(AllowedFieldTypes!T);
161 } else {
162 enum canDBus = false;
163 }
164 }
165
166 string typeSig(T)() if(canDBus!T) {
167 static if(is(T == byte)) {
168 return "y";
169 } else static if(is(T == bool)) {
170 return "b";
171 } else static if(is(T == short)) {
172 return "n";
173 } else static if(is(T == ushort)) {
174 return "q";
175 } else static if(is(T == int)) {
176 return "i";
177 } else static if(is(T == uint)) {
178 return "u";
179 } else static if(is(T == long)) {
180 return "x";
181 } else static if(is(T == ulong)) {
182 return "t";
183 } else static if(is(T == double)) {
184 return "d";
185 } else static if(is(T == string)) {
186 return "s";
187 } else static if(is(T == ObjectPath)) {
188 return "o";
189 } else static if(isInstanceOf!(Variant, T) || isInstanceOf!(VariantN, T)) {
190 return "v";
191 } else static if(is(T B == enum)) {
192 return typeSig!B;
193 } else static if(isInstanceOf!(BitFlags, T)) {
194 alias TemplateArgsOf!T[0] E;
195 return typeSig!E;
196 } else static if(is(T == DBusAny)) {
197 static assert(false, "Cannot determine type signature of DBusAny. Change to Variant!DBusAny if a variant was desired.");
198 } else static if(isTuple!T) {
199 string sig = "(";
200 foreach(i, S; T.Types) {
201 sig ~= typeSig!S();
202 }
203 sig ~= ")";
204 return sig;
205 } else static if(isInputRange!T) {
206 return "a" ~ typeSig!(ElementType!T)();
207 } else static if(isAssociativeArray!T) {
208 return "a{" ~ typeSig!(KeyType!T) ~ typeSig!(ValueType!T) ~ "}";
209 } else static if(is(T == struct)) {
210 string sig = "(";
211 foreach(i, S; AllowedFieldTypes!T) {
212 sig ~= typeSig!S();
213 }
214 sig ~= ")";
215 return sig;
216 }
217 }
218
219 string typeSig(T)() if(isInstanceOf!(DictionaryEntry, T)) {
220 alias typeof(T.key) K;
221 alias typeof(T.value) V;
222 return "{" ~ typeSig!K ~ typeSig!V ~ '}';
223 }
224
225 string[] typeSigReturn(T)() if(canDBus!T) {
226 static if(is(T == Tuple!TS, TS...))
227 return typeSigArr!TS;
228 else
229 return [typeSig!T];
230 }
231
232 string typeSigAll(TS...)() if(allCanDBus!TS) {
233 string sig = "";
234 foreach(i,T; TS) {
235 sig ~= typeSig!T();
236 }
237 return sig;
238 }
239
240 string[] typeSigArr(TS...)() if(allCanDBus!TS) {
241 string[] sig = [];
242 foreach(i,T; TS) {
243 sig ~= typeSig!T();
244 }
245 return sig;
246 }
247
248 int typeCode(T)() if(canDBus!T) {
249 int code = typeSig!T()[0];
250 return (code != '(') ? code : 'r';
251 }
252
253 int typeCode(T)() if(isInstanceOf!(DictionaryEntry, T) && canDBus!(T[])) {
254 return 'e';
255 }
256
257 private template AllowedFieldTypes(S) if (is(S == struct)) {
258 static alias TypeOf(alias sym) = typeof(sym);
259
260 alias AllowedFieldTypes =
261 staticMap!(TypeOf, Filter!(isAllowedField, S.tupleof));
262 }
263
264 struct ObjectPath {
265 private string _value;
266
267 this(string objPath) pure @safe {
268 enforce(isValid(objPath));
269 _value = objPath;
270 }
271
272 string toString() const {
273 return _value;
274 }
275
276 /++
277 Returns the string representation of this ObjectPath.
278 +/
279 string value() const pure @nogc nothrow @safe {
280 return _value;
281 }
282
283 size_t toHash() const pure @nogc nothrow @trusted {
284 return hashOf(_value);
285 }
286
287 bool opEquals(ref const typeof(this) b) const pure @nogc nothrow @safe {
288 return _value == b._value;
289 }
290
291 ObjectPath opBinary(string op : "~")(string rhs) const pure @safe {
292 if (!rhs.startsWith("/"))
293 return opBinary!"~"(ObjectPath("/" ~ rhs));
294 else
295 return opBinary!"~"(ObjectPath(rhs));
296 }
297
298 ObjectPath opBinary(string op : "~")(ObjectPath rhs) const pure @safe
299 in {
300 assert(ObjectPath.isValid(_value) && ObjectPath.isValid(rhs._value));
301 } out (v) {
302 assert(ObjectPath.isValid(v._value));
303 } body {
304 ObjectPath ret;
305
306 if (_value == "/")
307 ret._value = rhs._value;
308 else
309 ret._value = _value ~ rhs._value;
310
311 return ret;
312 }
313
314 void opOpAssign(string op : "~")(string rhs) pure @safe {
315 _value = opBinary!"~"(rhs)._value;
316 }
317
318 void opOpAssign(string op : "~")(ObjectPath rhs) pure @safe {
319 _value = opBinary!"~"(rhs)._value;
320 }
321
322 /++
323 Returns: `false` for empty strings or strings that don't match the
324 pattern `(/[0-9A-Za-z_]+)+|/`.
325 +/
326 static bool isValid(string objPath) pure @nogc nothrow @safe {
327 import std.ascii : isAlphaNum;
328
329 if (!objPath.length)
330 return false;
331 if (objPath == "/")
332 return true;
333 if (objPath[0] != '/' || objPath[$ - 1] == '/')
334 return false;
335 // .representation to avoid unicode exceptions -> @nogc & nothrow
336 return objPath.representation.splitter('/').drop(1)
337 .all!(a =>
338 a.length &&
339 a.all!(c =>
340 c.isAlphaNum || c == '_'
341 )
342 );
343 }
344 }
345
346 /// Structure allowing typeless parameters
347 struct DBusAny {
348 /// DBus type of the value (never 'v'), see typeSig!T
349 int type;
350 /// Child signature for Arrays & Tuples
351 string signature;
352 /// If true, this value will get serialized as variant value, otherwise it is serialized like it wasn't in a DBusAny wrapper.
353 /// Same functionality as Variant!T but with dynamic types if true.
354 bool explicitVariant;
355
356 union
357 {
358 ///
359 byte int8;
360 ///
361 short int16;
362 ///
363 ushort uint16;
364 ///
365 int int32;
366 ///
367 uint uint32;
368 ///
369 long int64;
370 ///
371 ulong uint64;
372 ///
373 double float64;
374 ///
375 string str;
376 ///
377 bool boolean;
378 ///
379 ObjectPath obj;
380 ///
381 DBusAny[] array;
382 ///
383 alias tuple = array;
384 ///
385 DictionaryEntry!(DBusAny, DBusAny)* entry;
386 ///
387 ubyte[] binaryData;
388 }
389
390 /// Manually creates a DBusAny object using a type, signature and implicit specifier.
391 this(int type, string signature, bool explicit) {
392 this.type = type;
393 this.signature = signature;
394 this.explicitVariant = explicit;
395 }
396
397 /// Automatically creates a DBusAny object with fitting parameters from a D type or Variant!T.
398 /// Pass a `Variant!T` to make this an explicit variant.
399 this(T)(T value) {
400 static if(is(T == byte) || is(T == ubyte)) {
401 this(typeCode!byte, null, false);
402 int8 = cast(byte) value;
403 } else static if(is(T == short)) {
404 this(typeCode!short, null, false);
405 int16 = cast(short) value;
406 } else static if(is(T == ushort)) {
407 this(typeCode!ushort, null, false);
408 uint16 = cast(ushort) value;
409 } else static if(is(T == int)) {
410 this(typeCode!int, null, false);
411 int32 = cast(int) value;
412 } else static if(is(T == uint)) {
413 this(typeCode!uint, null, false);
414 uint32 = cast(uint) value;
415 } else static if(is(T == long)) {
416 this(typeCode!long, null, false);
417 int64 = cast(long) value;
418 } else static if(is(T == ulong)) {
419 this(typeCode!ulong, null, false);
420 uint64 = cast(ulong) value;
421 } else static if(is(T == double)) {
422 this(typeCode!double, null, false);
423 float64 = cast(double) value;
424 } else static if(isSomeString!T) {
425 this(typeCode!string, null, false);
426 str = value.to!string;
427 } else static if(is(T == bool)) {
428 this(typeCode!bool, null, false);
429 boolean = cast(bool) value;
430 } else static if(is(T == ObjectPath)) {
431 this(typeCode!ObjectPath, null, false);
432 obj = value;
433 } else static if(is(T == Variant!R, R)) {
434 static if(is(R == DBusAny)) {
435 type = value.data.type;
436 signature = value.data.signature;
437 explicitVariant = true;
438 if(type == 'a' || type == 'r') {
439 if(signature == ['y'])
440 binaryData = value.data.binaryData;
441 else
442 array = value.data.array;
443 } else if(type == 's')
444 str = value.data.str;
445 else if(type == 'e')
446 entry = value.data.entry;
447 else
448 uint64 = value.data.uint64;
449 } else {
450 this(value.data);
451 explicitVariant = true;
452 }
453 } else static if(is(T : DictionaryEntry!(K, V), K, V)) {
454 this('e', null, false);
455 entry = new DictionaryEntry!(DBusAny, DBusAny)();
456 static if(is(K == DBusAny))
457 entry.key = value.key;
458 else
459 entry.key = DBusAny(value.key);
460 static if(is(V == DBusAny))
461 entry.value = value.value;
462 else
463 entry.value = DBusAny(value.value);
464 } else static if(is(T == ubyte[]) || is(T == byte[])) {
465 this('a', ['y'], false);
466 binaryData = cast(ubyte[]) value;
467 } else static if(isInputRange!T) {
468 this.type = 'a';
469 static assert(!is(ElementType!T == DBusAny), "Array must consist of the same type, use Variant!DBusAny or DBusAny(tuple(...)) instead");
470 static assert(.typeSig!(ElementType!T) != "y");
471 this.signature = .typeSig!(ElementType!T);
472 this.explicitVariant = false;
473 foreach(elem; value)
474 array ~= DBusAny(elem);
475 } else static if(isTuple!T) {
476 this.type = 'r';
477 this.signature = ['('];
478 this.explicitVariant = false;
479 foreach(index, R; value.Types) {
480 auto var = DBusAny(value[index]);
481 tuple ~= var;
482 if(var.explicitVariant)
483 this.signature ~= 'v';
484 else {
485 if (var.type != 'r')
486 this.signature ~= cast(char) var.type;
487 if(var.type == 'a' || var.type == 'r')
488 this.signature ~= var.signature;
489 }
490 }
491 this.signature ~= ')';
492 } else static if(isAssociativeArray!T) {
493 this(value.byDictionaryEntries);
494 } else static assert(false, T.stringof ~ " not convertible to a Variant");
495 }
496
497 ///
498 string toString() const {
499 string valueStr;
500 switch(type) {
501 case typeCode!byte:
502 valueStr = int8.to!string;
503 break;
504 case typeCode!short:
505 valueStr = int16.to!string;
506 break;
507 case typeCode!ushort:
508 valueStr = uint16.to!string;
509 break;
510 case typeCode!int:
511 valueStr = int32.to!string;
512 break;
513 case typeCode!uint:
514 valueStr = uint32.to!string;
515 break;
516 case typeCode!long:
517 valueStr = int64.to!string;
518 break;
519 case typeCode!ulong:
520 valueStr = uint64.to!string;
521 break;
522 case typeCode!double:
523 valueStr = float64.to!string;
524 break;
525 case typeCode!string:
526 valueStr = '"' ~ str ~ '"';
527 break;
528 case typeCode!ObjectPath:
529 valueStr = '"' ~ obj.to!string ~ '"';
530 break;
531 case typeCode!bool:
532 valueStr = boolean ? "true" : "false";
533 break;
534 case 'a':
535 import std.digest : toHexString;
536
537 if(signature == ['y'])
538 valueStr = "binary(" ~ binaryData.toHexString ~ ')';
539 else
540 valueStr = '[' ~ array.map!(a => a.toString).join(", ") ~ ']';
541 break;
542 case 'r':
543 valueStr = '(' ~ tuple.map!(a => a.toString).join(", ") ~ ')';
544 break;
545 case 'e':
546 valueStr = entry.key.toString ~ ": " ~ entry.value.toString;
547 break;
548 default:
549 valueStr = "unknown";
550 break;
551 }
552 return "DBusAny(" ~ cast(char) type
553 ~ ", \"" ~ signature.idup
554 ~ "\", " ~ (explicitVariant ? "explicit" : "implicit")
555 ~ ", " ~ valueStr ~ ")";
556 }
557
558 /++
559 Get the value stored in the DBusAny object.
560
561 Parameters:
562 T = The requested type. The currently stored value must match the
563 requested type exactly.
564
565 Returns:
566 The current value of the DBusAny object.
567
568 Throws:
569 TypeMismatchException if the DBus type of the current value of the
570 DBusAny object is not the same as the DBus type used to represent T.
571 +/
572 T get(T)() @property const
573 if(staticIndexOf!(T, BasicTypes) >= 0)
574 {
575 enforce(type == typeCode!T,
576 new TypeMismatchException(
577 "Cannot get a " ~ T.stringof ~ " from a DBusAny with"
578 ~ " a value of DBus type '" ~ typeSig ~ "'.", typeCode!T, type));
579
580 static if(isIntegral!T) {
581 enum memberName =
582 (isUnsigned!T ? "uint" : "int") ~ (T.sizeof * 8).to!string;
583 return __traits(getMember, this, memberName);
584 } else static if(is(T == double)) {
585 return float64;
586 } else static if(is(T == string)) {
587 return str;
588 } else static if(is(T == ObjectPath)) {
589 return obj;
590 } else static if(is(T == bool)) {
591 return boolean;
592 } else {
593 static assert(false);
594 }
595 }
596
597 /// ditto
598 T get(T)() @property const
599 if(is(T == const(DBusAny)[]))
600 {
601 enforce((type == 'a' && signature != "y") || type == 'r',
602 new TypeMismatchException(
603 "Cannot get a " ~ T.stringof ~ " from a DBusAny with"
604 ~ " a value of DBus type '" ~ this.typeSig ~ "'.",
605 typeCode!T, type));
606
607 return array;
608 }
609
610 /// ditto
611 T get(T)() @property const
612 if (is(T == const(ubyte)[]))
613 {
614 enforce(type == 'a' && signature == "y",
615 new TypeMismatchException(
616 "Cannot get a " ~ T.stringof ~ " from a DBusAny with"
617 ~ " a value of DBus type '" ~ this.typeSig ~ "'.",
618 typeCode!T, type));
619
620 return binaryData;
621 }
622
623 /// If the value is an array of DictionaryEntries this will return a HashMap
624 DBusAny[DBusAny] toAA() {
625 enforce(type == 'a' && signature && signature[0] == '{');
626 DBusAny[DBusAny] aa;
627 foreach(val; array) {
628 enforce(val.type == 'e');
629 aa[val.entry.key] = val.entry.value;
630 }
631 return aa;
632 }
633
634 /++
635 Get the DBus type signature of the value stored in the DBusAny object.
636
637 Returns:
638 The type signature of the value stored in this DBusAny object.
639 +/
640 string typeSig() @property const pure nothrow @safe
641 {
642 if(type == 'a') {
643 return "a" ~ signature;
644 } else if(type == 'r') {
645 return signature;
646 } else if(type == 'e') {
647 return () @trusted {
648 return "{" ~ entry.key.signature ~ entry.value.signature ~ "}";
649 } ();
650 } else {
651 return [ cast(char) type ];
652 }
653 }
654
655 /// Converts a basic type, a tuple or an array to the D type with type checking. Tuples can get converted to an array too.
656 T to(T)() {
657 static if(is(T == Variant!R, R)) {
658 static if(is(R == DBusAny)) {
659 auto v = to!R;
660 v.explicitVariant = false;
661 return Variant!R(v);
662 } else
663 return Variant!R(to!R);
664 } else static if(is(T == DBusAny)) {
665 return this;
666 } else static if(isIntegral!T || isFloatingPoint!T) {
667 switch(type) {
668 case typeCode!byte:
669 return cast(T) int8;
670 case typeCode!short:
671 return cast(T) int16;
672 case typeCode!ushort:
673 return cast(T) uint16;
674 case typeCode!int:
675 return cast(T) int32;
676 case typeCode!uint:
677 return cast(T) uint32;
678 case typeCode!long:
679 return cast(T) int64;
680 case typeCode!ulong:
681 return cast(T) uint64;
682 case typeCode!double:
683 return cast(T) float64;
684 default:
685 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
686 }
687 } else static if(is(T == bool)) {
688 if(type == 'b')
689 return boolean;
690 else
691 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
692 } else static if(isSomeString!T) {
693 if(type == 's')
694 return str.to!T;
695 else if(type == 'o')
696 return obj.toString();
697 else
698 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
699 } else static if(is(T == ObjectPath)) {
700 if(type == 'o')
701 return obj;
702 else
703 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
704 } else static if(isDynamicArray!T) {
705 if(type != 'a' && type != 'r')
706 throw new Exception("Can't convert type " ~ cast(char) type ~ " to an array");
707 T ret;
708 if(signature == ['y']) {
709 static if(isIntegral!(ElementType!T))
710 foreach(elem; binaryData)
711 ret ~= elem.to!(ElementType!T);
712 } else
713 foreach(elem; array)
714 ret ~= elem.to!(ElementType!T);
715 return ret;
716 } else static if(isTuple!T) {
717 if(type != 'r')
718 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
719 T ret;
720 enforce(ret.Types.length == tuple.length, "Tuple length mismatch");
721 foreach(index, T; ret.Types)
722 ret[index] = tuple[index].to!T;
723 return ret;
724 } else static if(isAssociativeArray!T) {
725 if(type != 'a' || !signature || signature[0] != '{')
726 throw new Exception("Can't convert type " ~ cast(char) type ~ " to " ~ T.stringof);
727 T ret;
728 foreach(pair; array) {
729 enforce(pair.type == 'e');
730 ret[pair.entry.key.to!(KeyType!T)] = pair.entry.value.to!(ValueType!T);
731 }
732 return ret;
733 } else static assert(false, "Can't convert variant to " ~ T.stringof);
734 }
735
736 bool opEquals(ref in DBusAny b) const {
737 if(b.type != type || b.explicitVariant != explicitVariant)
738 return false;
739 if((type == 'a' || type == 'r') && b.signature != signature)
740 return false;
741 if(type == 'a' && signature == ['y'])
742 return binaryData == b.binaryData;
743 if(type == 'a')
744 return array == b.array;
745 else if(type == 'r')
746 return tuple == b.tuple;
747 else if(type == 's')
748 return str == b.str;
749 else if(type == 'o')
750 return obj == b.obj;
751 else if(type == 'e')
752 return entry == b.entry || (entry && b.entry && *entry == *b.entry);
753 else
754 return uint64 == b.uint64;
755 }
756 }
757
758 /// Marks the data as variant on serialization
759 struct Variant(T) {
760 ///
761 T data;
762 }
763
764 Variant!T variant(T)(T data) {
765 return Variant!T(data);
766 }
767
768 enum MessageType {
769 Invalid = 0,
770 Call, Return, Error, Signal
771 }
772
773 void emitSignal(Args...)(Connection conn, string path, string iface, string name, Args args) {
774 Message msg = Message(null, path, iface, name, true);
775 msg.build(args);
776 conn.send(msg);
777 }
778
779 struct Message {
780 DBusMessage *msg;
781
782 this(string dest, string path, string iface, string method, bool signal = false) {
783 if(signal)
784 msg = dbus_message_new_signal(path.toStringz(), iface.toStringz(), method.toStringz());
785 else
786 msg = dbus_message_new_method_call(dest.toStringz(), path.toStringz(), iface.toStringz(), method.toStringz());
787 }
788
789 this(DBusMessage *m) {
790 msg = m;
791 }
792
793 this(this) {
794 dbus_message_ref(msg);
795 }
796
797 ~this() {
798 dbus_message_unref(msg);
799 }
800
801 void build(TS...)(TS args) if(allCanDBus!TS) {
802 DBusMessageIter iter;
803 dbus_message_iter_init_append(msg, &iter);
804 buildIter(&iter, args);
805 }
806
807 /**
808 Reads the first argument of the message.
809 Note that this creates a new iterator every time so calling it multiple times will always
810 read the first argument. This is suitable for single item returns.
811 To read multiple arguments use readTuple.
812 */
813 T read(T)() if(canDBus!T) {
814 DBusMessageIter iter;
815 dbus_message_iter_init(msg, &iter);
816 return readIter!T(&iter);
817 }
818 alias read to;
819
820 Tup readTuple(Tup)() if(isTuple!Tup && allCanDBus!(Tup.Types)) {
821 DBusMessageIter iter;
822 dbus_message_iter_init(msg, &iter);
823 Tup ret;
824 readIterTuple(&iter, ret);
825 return ret;
826 }
827
828 Message createReturn() {
829 return Message(dbus_message_new_method_return(msg));
830 }
831
832 MessageType type() {
833 return cast(MessageType)dbus_message_get_type(msg);
834 }
835
836 bool isCall() {
837 return type() == MessageType.Call;
838 }
839
840 // Various string members
841 // TODO: make a mixin to avoid this copy-paste
842 string signature() {
843 const(char)* cStr = dbus_message_get_signature(msg);
844 assert(cStr != null);
845 return cStr.fromStringz().idup;
846 }
847 string path() {
848 const(char)* cStr = dbus_message_get_path(msg);
849 assert(cStr != null);
850 return cStr.fromStringz().idup;
851 }
852 string iface() {
853 const(char)* cStr = dbus_message_get_interface(msg);
854 assert(cStr != null);
855 return cStr.fromStringz().idup;
856 }
857 string member() {
858 const(char)* cStr = dbus_message_get_member(msg);
859 assert(cStr != null);
860 return cStr.fromStringz().idup;
861 }
862 string sender() {
863 const(char)* cStr = dbus_message_get_sender(msg);
864 assert(cStr != null);
865 return cStr.fromStringz().idup;
866 }
867 }
868
869 struct Connection {
870 DBusConnection *conn;
871 this(DBusConnection *connection) {
872 conn = connection;
873 }
874
875 this(this) {
876 dbus_connection_ref(conn);
877 }
878
879 ~this() {
880 dbus_connection_unref(conn);
881 }
882
883 void close() {
884 dbus_connection_close(conn);
885 }
886
887 void send(Message msg) {
888 dbus_connection_send(conn,msg.msg, null);
889 }
890
891 void sendBlocking(Message msg) {
892 send(msg);
893 dbus_connection_flush(conn);
894 }
895
896 Message sendWithReplyBlocking(Message msg, int timeout = -1) {
897 DBusMessage *dbusMsg = msg.msg;
898 dbus_message_ref(dbusMsg);
899 DBusMessage *reply = wrapErrors((err) {
900 auto ret = dbus_connection_send_with_reply_and_block(conn,dbusMsg,timeout,err);
901 dbus_message_unref(dbusMsg);
902 return ret;
903 });
904 return Message(reply);
905 }
906
907 Message sendWithReplyBlocking(Message msg, Duration timeout) {
908 return sendWithReplyBlocking(msg, timeout.total!"msecs"().to!int);
909 }
910 }
911
912 Connection connectToBus(DBusBusType bus = DBusBusType.DBUS_BUS_SESSION) {
913 DBusConnection *conn = wrapErrors((err) { return dbus_bus_get(bus,err); });
914 return Connection(conn);
915 }
916
917 class PathIface {
918 this(Connection conn, string dest, ObjectPath path, string iface) {
919 this(conn, dest, path.value, iface);
920 }
921
922 this(Connection conn, string dest, string path, string iface) {
923 this.conn = conn;
924 this.dest = dest.toStringz();
925 this.path = path.toStringz();
926 this.iface = iface.toStringz();
927 }
928
929 Ret call(Ret, Args...)(string meth, Args args) if(allCanDBus!Args && canDBus!Ret) {
930 Message msg = Message(dbus_message_new_method_call(dest,path,iface,meth.toStringz()));
931 msg.build(args);
932 Message ret = conn.sendWithReplyBlocking(msg);
933 return ret.read!Ret();
934 }
935
936 Message opDispatch(string meth, Args...)(Args args) {
937 Message msg = Message(dbus_message_new_method_call(dest,path,iface,meth.toStringz()));
938 msg.build(args);
939 return conn.sendWithReplyBlocking(msg);
940 }
941
942 Connection conn;
943 const(char)* dest;
944 const(char)* path;
945 const(char)* iface;
946 }
947
948 enum SignalMethod;
949
950 /**
951 Registers all *possible* methods of an object in a router.
952 It will not register methods that use types that ddbus can't handle.
953
954 The implementation is rather hacky and uses the compiles trait to check for things
955 working so if some methods randomly don't seem to be added, you should probably use
956 setHandler on the router directly. It is also not efficient and creates a closure for every method.
957
958 TODO: replace this with something that generates a wrapper class who's methods take and return messages
959 and basically do what MessageRouter.setHandler does but avoiding duplication. Then this DBusWrapper!Class
960 could be instantiated with any object efficiently and placed in the router table with minimal duplication.
961 */
962 void registerMethods(T : Object)(MessageRouter router, string path, string iface, T obj) {
963 MessagePattern patt = MessagePattern(path,iface,"",false);
964 foreach(member; __traits(allMembers, T)) {
965 static if (__traits(compiles, __traits(getOverloads, obj, member))
966 && __traits(getOverloads, obj, member).length > 0
967 && __traits(compiles, router.setHandler(patt, &__traits(getOverloads,obj,member)[0]))) {
968 patt.method = member;
969 patt.signal = hasUDA!(__traits(getOverloads,obj,member)[0], SignalMethod);
970 router.setHandler(patt, &__traits(getOverloads,obj,member)[0]);
971 }
972 }
973 }
974
975 struct MessagePattern {
976 string path;
977 string iface;
978 string method;
979 bool signal;
980
981 this(Message msg) {
982 path = msg.path();
983 iface = msg.iface();
984 method = msg.member();
985 signal = (msg.type() == MessageType.Signal);
986 }
987
988 this(string path, string iface, string method, bool signal = false) {
989 this.path = path;
990 this.iface = iface;
991 this.method = method;
992 this.signal = signal;
993 }
994
995 size_t toHash() const @safe nothrow {
996 size_t hash = 0;
997 auto stringHash = &(typeid(path).getHash);
998 hash += stringHash(&path);
999 hash += stringHash(&iface);
1000 hash += stringHash(&method);
1001 hash += (signal?1:0);
1002 return hash;
1003 }
1004
1005 bool opEquals(ref const typeof(this) s) const @safe pure nothrow {
1006 return (path == s.path) && (iface == s.iface) && (method == s.method) && (signal == s.signal);
1007 }
1008 }
1009
1010 struct MessageHandler {
1011 alias HandlerFunc = void delegate(Message call, Connection conn);
1012 HandlerFunc func;
1013 string[] argSig;
1014 string[] retSig;
1015 }
1016
1017 class MessageRouter {
1018 MessageHandler[MessagePattern] callTable;
1019
1020 bool handle(Message msg, Connection conn) {
1021 MessageType type = msg.type();
1022 if(type != MessageType.Call && type != MessageType.Signal)
1023 return false;
1024 auto pattern = MessagePattern(msg);
1025 // import std.stdio; debug writeln("Handling ", pattern);
1026
1027 if(pattern.iface == "org.freedesktop.DBus.Introspectable" &&
1028 pattern.method == "Introspect" && !pattern.signal) {
1029 handleIntrospect(pattern.path, msg, conn);
1030 return true;
1031 }
1032
1033 MessageHandler* handler = (pattern in callTable);
1034 if(handler is null) return false;
1035
1036 // Check for matching argument types
1037 version(DDBusNoChecking) {
1038
1039 } else {
1040 if(!equal(join(handler.argSig), msg.signature())) {
1041 return false;
1042 }
1043 }
1044
1045 handler.func(msg,conn);
1046 return true;
1047 }
1048
1049 void setHandler(Ret, Args...)(MessagePattern patt, Ret delegate(Args) handler) {
1050 void handlerWrapper(Message call, Connection conn) {
1051 Tuple!Args args = call.readTuple!(Tuple!Args)();
1052 auto retMsg = call.createReturn();
1053 static if(!is(Ret == void)) {
1054 Ret ret = handler(args.expand);
1055 static if (is(Ret == Tuple!T, T...))
1056 retMsg.build!T(ret.expand);
1057 else
1058 retMsg.build(ret);
1059 } else {
1060 handler(args.expand);
1061 }
1062 if(!patt.signal)
1063 conn.send(retMsg);
1064 }
1065 static string[] args = typeSigArr!Args;
1066 static if(is(Ret==void)) {
1067 static string[] ret = [];
1068 } else {
1069 static string[] ret = typeSigReturn!Ret;
1070 }
1071 MessageHandler handleStruct = {func: &handlerWrapper, argSig: args, retSig: ret};
1072 callTable[patt] = handleStruct;
1073 }
1074
1075 static string introspectHeader = `<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
1076 <node name="%s">`;
1077
1078 string introspectXML(string path) {
1079 auto methods = callTable.byKey().filter!(a => (a.path == path) && !a.signal)().array()
1080 // .schwartzSort!((a) => a.iface, "a<b")();
1081 .sort!((a,b) => a.iface < b.iface)();
1082 auto ifaces = methods.groupBy();
1083 auto app = appender!string;
1084 formattedWrite(app,introspectHeader,path);
1085 foreach(iface; ifaces) {
1086 formattedWrite(app,`<interface name="%s">`,iface.front.iface);
1087 foreach(methodPatt; iface.array()) {
1088 formattedWrite(app,`<method name="%s">`,methodPatt.method);
1089 auto handler = callTable[methodPatt];
1090 foreach(arg; handler.argSig) {
1091 formattedWrite(app,`<arg type="%s" direction="in"/>`,arg);
1092 }
1093 foreach(arg; handler.retSig) {
1094 formattedWrite(app,`<arg type="%s" direction="out"/>`,arg);
1095 }
1096 app.put("</method>");
1097 }
1098 app.put("</interface>");
1099 }
1100
1101 string childPath = path;
1102 if(!childPath.endsWith("/")) {
1103 childPath ~= "/";
1104 }
1105 auto children = callTable.byKey().filter!(a => (a.path.startsWith(childPath)) && !a.signal)()
1106 .map!((s) => s.path.chompPrefix(childPath))
1107 .map!((s) => s.splitter('/').front)
1108 .array().sort().uniq();
1109 foreach(child; children) {
1110 formattedWrite(app,`<node name="%s"/>`,child);
1111 }
1112
1113 app.put("</node>");
1114 return app.data;
1115 }
1116
1117 void handleIntrospect(string path, Message call, Connection conn) {
1118 auto retMsg = call.createReturn();
1119 retMsg.build(introspectXML(path));
1120 conn.sendBlocking(retMsg);
1121 }
1122 }
1123
1124 extern(C) private DBusHandlerResult filterFunc(DBusConnection *dConn, DBusMessage *dMsg, void *routerP) {
1125 MessageRouter router = cast(MessageRouter)routerP;
1126 dbus_message_ref(dMsg);
1127 Message msg = Message(dMsg);
1128 dbus_connection_ref(dConn);
1129 Connection conn = Connection(dConn);
1130 bool handled = router.handle(msg, conn);
1131 if(handled) {
1132 return DBusHandlerResult.DBUS_HANDLER_RESULT_HANDLED;
1133 } else {
1134 return DBusHandlerResult.DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1135 }
1136 }
1137
1138 extern(C) private void unrootUserData(void *userdata) {
1139 GC.removeRoot(userdata);
1140 }
1141
1142 void registerRouter(Connection conn, MessageRouter router) {
1143 void *routerP = cast(void*)router;
1144 GC.addRoot(routerP);
1145 dbus_connection_add_filter(conn.conn, &filterFunc, routerP, &unrootUserData);
1146 }
1147
1148 private T wrapErrors(T)(
1149 T delegate(DBusError *err) del,
1150 string file = __FILE__,
1151 size_t line = __LINE__,
1152 Throwable next = null
1153 ) {
1154 DBusError error;
1155 dbus_error_init(&error);
1156 T ret = del(&error);
1157 if(dbus_error_is_set(&error)) {
1158 auto ex = new DBusException(&error, file, line, next);
1159 dbus_error_free(&error);
1160 throw ex;
1161 }
1162 return ret;
1163 }
1164
1165 /++
1166 Thrown when a DBus error code was returned by libdbus.
1167 +/
1168 class DBusException : Exception {
1169 private this(
1170 scope DBusError *err,
1171 string file = __FILE__,
1172 size_t line = __LINE__,
1173 Throwable next = null
1174 ) pure nothrow {
1175
1176 super(err.message.fromStringz().idup, file, line, next);
1177 }
1178 }
1179
1180 /++
1181 Thrown when the signature of a message does not match the requested types or
1182 when trying to get a value from a DBusAny object that does not match the type
1183 of its actual value.
1184 +/
1185 class TypeMismatchException : Exception {
1186 private this(
1187 int expectedType,
1188 int actualType,
1189 string file = __FILE__,
1190 size_t line = __LINE__,
1191 Throwable next = null
1192 ) pure nothrow @safe {
1193 string message;
1194
1195 if (expectedType == 'v') {
1196 message = "The type of value at the current position in the message is"
1197 ~ " incompatible to the target variant type."
1198 ~ " Type code of the value: '" ~ cast(char) actualType ~ '\'';
1199 } else {
1200 message = "The type of value at the current position in the message does"
1201 ~ " not match the type of value to be read."
1202 ~ " Expected: '" ~ cast(char) expectedType ~ "',"
1203 ~ " Got: '" ~ cast(char) actualType ~ '\'';
1204 }
1205
1206 this(message, expectedType, actualType, file, line, next);
1207 }
1208
1209 this(
1210 string message,
1211 int expectedType,
1212 int actualType,
1213 string file = __FILE__,
1214 size_t line = __LINE__,
1215 Throwable next = null
1216 ) pure nothrow @safe {
1217 _expectedType = expectedType;
1218 _actualType = actualType;
1219 super(message, file, line, next);
1220 }
1221
1222 int expectedType() @property pure const nothrow @safe @nogc {
1223 return _expectedType;
1224 }
1225
1226 int actualType() @property pure const nothrow @safe @nogc {
1227 return _actualType;
1228 }
1229
1230 private:
1231 int _expectedType;
1232 int _actualType;
1233 }
1234
1235 /++
1236 Thrown during type conversion between DBus types and D types when a value is
1237 encountered that can not be represented in the target type.
1238
1239 This exception should not normally be thrown except when dealing with D types
1240 that have a constrained value set, such as Enums.
1241 +/
1242 class InvalidValueException : Exception {
1243 private this(Source)(
1244 Source value,
1245 string targetType,
1246 string file = __FILE__,
1247 size_t line = __LINE__,
1248 Throwable next = null
1249 ) {
1250 import std.conv : to;
1251
1252 static if(__traits(compiles, value.to!string))
1253 string valueString = value.to!string;
1254 else
1255 string valueString = "(unprintable)";
1256
1257 super("Value " ~ valueString ~ " cannot be represented in type " ~ targetType);
1258 }
1259 }
1260
1261 import std.exception : enforce;
1262 import std.meta: allSatisfy;
1263 import std.range;
1264 import std.traits;
1265 import std.variant : VariantN;
1266
1267 void buildIter(TS...)(DBusMessageIter *iter, TS args) if(allCanDBus!TS) {
1268 foreach(index, arg; args) {
1269 alias TS[index] T;
1270 static if(is(T == string)) {
1271 immutable(char)* cStr = arg.toStringz();
1272 dbus_message_iter_append_basic(iter,typeCode!T,&cStr);
1273 } else static if(is(T == ObjectPath)) {
1274 immutable(char)* cStr = arg.toString().toStringz();
1275 dbus_message_iter_append_basic(iter,typeCode!T,&cStr);
1276 } else static if(is(T==bool)) {
1277 dbus_bool_t longerBool = arg; // dbus bools are ints
1278 dbus_message_iter_append_basic(iter,typeCode!T,&longerBool);
1279 } else static if(isTuple!T) {
1280 DBusMessageIter sub;
1281 dbus_message_iter_open_container(iter, 'r', null, &sub);
1282 buildIter(&sub, arg.expand);
1283 dbus_message_iter_close_container(iter, &sub);
1284 } else static if(isInputRange!T) {
1285 DBusMessageIter sub;
1286 const(char)* subSig = (typeSig!(ElementType!T)()).toStringz();
1287 dbus_message_iter_open_container(iter, 'a', subSig, &sub);
1288 foreach(x; arg) {
1289 static if(isInstanceOf!(DictionaryEntry, typeof(x))) {
1290 DBusMessageIter entry;
1291 dbus_message_iter_open_container(&sub, 'e', null, &entry);
1292 buildIter(&entry, x.key);
1293 buildIter(&entry, x.value);
1294 dbus_message_iter_close_container(&sub, &entry);
1295 } else {
1296 buildIter(&sub, x);
1297 }
1298 }
1299 dbus_message_iter_close_container(iter, &sub);
1300 } else static if(isAssociativeArray!T) {
1301 DBusMessageIter sub;
1302 const(char)* subSig = typeSig!T[1..$].toStringz();
1303 dbus_message_iter_open_container(iter, 'a', subSig, &sub);
1304 foreach(k, v; arg) {
1305 DBusMessageIter entry;
1306 dbus_message_iter_open_container(&sub, 'e', null, &entry);
1307 buildIter(&entry, k);
1308 buildIter(&entry, v);
1309 dbus_message_iter_close_container(&sub, &entry);
1310 }
1311 dbus_message_iter_close_container(iter, &sub);
1312 } else static if(isInstanceOf!(VariantN, T)) {
1313 enforce(arg.hasValue,
1314 new InvalidValueException(arg, "dbus:" ~ cast(char) typeCode!T));
1315
1316 DBusMessageIter sub;
1317 foreach(AT; T.AllowedTypes) {
1318 if (arg.peek!AT) {
1319 dbus_message_iter_open_container(iter, 'v', typeSig!AT.ptr, &sub);
1320 buildIter(&sub, arg.get!AT);
1321 dbus_message_iter_close_container(iter, &sub);
1322 break;
1323 }
1324 }
1325 } else static if(is(T == DBusAny) || is(T == Variant!DBusAny)) {
1326 static if(is(T == Variant!DBusAny)) {
1327 auto val = arg.data;
1328 val.explicitVariant = true;
1329 } else {
1330 auto val = arg;
1331 }
1332 DBusMessageIter subStore;
1333 DBusMessageIter* sub = &subStore;
1334 const(char)[] sig = [ cast(char) val.type ];
1335 if(val.type == 'a')
1336 sig ~= val.signature;
1337 else if(val.type == 'r')
1338 sig = val.signature;
1339 sig ~= '\0';
1340 if (!val.explicitVariant)
1341 sub = iter;
1342 else
1343 dbus_message_iter_open_container(iter, 'v', sig.ptr, sub);
1344 if(val.type == 's') {
1345 buildIter(sub, val.str);
1346 } else if(val.type == 'o') {
1347 buildIter(sub, val.obj);
1348 } else if(val.type == 'b') {
1349 buildIter(sub,val.boolean);
1350 } else if(dbus_type_is_basic(val.type)) {
1351 dbus_message_iter_append_basic(sub,val.type,&val.int64);
1352 } else if(val.type == 'a') {
1353 DBusMessageIter arr;
1354 dbus_message_iter_open_container(sub, 'a', sig[1 .. $].ptr, &arr);
1355 if (val.signature == ['y'])
1356 foreach (item; val.binaryData)
1357 dbus_message_iter_append_basic(&arr, 'y', &item);
1358 else
1359 foreach(item; val.array)
1360 buildIter(&arr, item);
1361 dbus_message_iter_close_container(sub, &arr);
1362 } else if(val.type == 'r') {
1363 DBusMessageIter arr;
1364 dbus_message_iter_open_container(sub, 'r', null, &arr);
1365 foreach(item; val.tuple)
1366 buildIter(&arr, item);
1367 dbus_message_iter_close_container(sub, &arr);
1368 } else if(val.type == 'e') {
1369 DBusMessageIter entry;
1370 dbus_message_iter_open_container(sub, 'e', null, &entry);
1371 buildIter(&entry, val.entry.key);
1372 buildIter(&entry, val.entry.value);
1373 dbus_message_iter_close_container(sub, &entry);
1374 }
1375 if(val.explicitVariant)
1376 dbus_message_iter_close_container(iter, sub);
1377 } else static if(isInstanceOf!(Variant, T)) {
1378 DBusMessageIter sub;
1379 const(char)* subSig = typeSig!(VariantType!T).toStringz();
1380 dbus_message_iter_open_container(iter, 'v', subSig, &sub);
1381 buildIter(&sub, arg.data);
1382 dbus_message_iter_close_container(iter, &sub);
1383 } else static if(is(T == struct)) {
1384 DBusMessageIter sub;
1385 dbus_message_iter_open_container(iter, 'r', null, &sub);
1386
1387 // Following failed because of missing 'this' for members of arg.
1388 // That sucks. It worked without Filter.
1389 // Reported: https://issues.dlang.org/show_bug.cgi?id=17692
1390 // buildIter(&sub, Filter!(isAllowedField, arg.tupleof));
1391
1392 // Using foreach to work around the issue
1393 foreach(i, member; arg.tupleof) {
1394 // Ugly, but we need to use tupleof again in the condition, because when
1395 // we use `member`, isAllowedField will fail because it'll find this
1396 // nice `buildIter` function instead of T when it looks up the parent
1397 // scope of its argument.
1398 static if (isAllowedField!(arg.tupleof[i]))
1399 buildIter(&sub, member);
1400 }
1401
1402 dbus_message_iter_close_container(iter, &sub);
1403 } else static if(basicDBus!T) {
1404 dbus_message_iter_append_basic(iter,typeCode!T,&arg);
1405 }
1406 }
1407 }
1408
1409 T readIter(T)(DBusMessageIter *iter) if (is(T == enum)) {
1410 import std.algorithm.searching : canFind;
1411
1412 alias OriginalType!T B;
1413
1414 B value = readIter!B(iter);
1415 enforce(
1416 only(EnumMembers!T).canFind(value),
1417 new InvalidValueException(value, T.stringof)
1418 );
1419 return cast(T) value;
1420 }
1421
1422 T readIter(T)(DBusMessageIter *iter) if (isInstanceOf!(BitFlags, T)) {
1423 import std.algorithm.iteration : fold;
1424
1425 alias TemplateArgsOf!T[0] E;
1426 alias OriginalType!E B;
1427
1428 B mask = only(EnumMembers!E).fold!((a, b) => cast(B) (a | b));
1429
1430 B value = readIter!B(iter);
1431 enforce(
1432 !(value & ~mask),
1433 new InvalidValueException(value, T.stringof)
1434 );
1435
1436 return T(cast(E) value);
1437 }
1438
1439 T readIter(T)(DBusMessageIter *iter) if (!is(T == enum) && !isInstanceOf!(BitFlags, T) && canDBus!T) {
1440 auto argType = dbus_message_iter_get_arg_type(iter);
1441 T ret;
1442
1443 static if(!isInstanceOf!(Variant, T) || is(T == Variant!DBusAny)) {
1444 if(argType == 'v') {
1445 DBusMessageIter sub;
1446 dbus_message_iter_recurse(iter, &sub);
1447 static if(is(T == Variant!DBusAny)) {
1448 ret = variant(readIter!DBusAny(&sub));
1449 } else {
1450 ret = readIter!T(&sub);
1451 static if(is(T == DBusAny))
1452 ret.explicitVariant = true;
1453 }
1454 dbus_message_iter_next(iter);
1455 return ret;
1456 }
1457 }
1458
1459 static if(
1460 !is(T == DBusAny)
1461 && !is(T == Variant!DBusAny)
1462 && !isInstanceOf!(VariantN, T)
1463 ) {
1464 enforce(argType == typeCode!T(),
1465 new TypeMismatchException(typeCode!T(), argType));
1466 }
1467 static if(is(T==string) || is(T==ObjectPath)) {
1468 const(char)* cStr;
1469 dbus_message_iter_get_basic(iter, &cStr);
1470 string str = cStr.fromStringz().idup; // copy string
1471 static if(is(T==string))
1472 ret = str;
1473 else
1474 ret = ObjectPath(str);
1475 } else static if(is(T==bool)) {
1476 dbus_bool_t longerBool;
1477 dbus_message_iter_get_basic(iter, &longerBool);
1478 ret = cast(bool)longerBool;
1479 } else static if(isTuple!T) {
1480 DBusMessageIter sub;
1481 dbus_message_iter_recurse(iter, &sub);
1482 readIterTuple!T(&sub, ret);
1483 } else static if(is(T t : U[], U)) {
1484 assert(dbus_message_iter_get_element_type(iter) == typeCode!U);
1485 DBusMessageIter sub;
1486 dbus_message_iter_recurse(iter, &sub);
1487 while(dbus_message_iter_get_arg_type(&sub) != 0) {
1488 static if(is(U == DictionaryEntry!(K,V), K, V)) {
1489 DBusMessageIter entry;
1490 dbus_message_iter_recurse(&sub, &entry);
1491 ret ~= U(readIter!K(&entry), readIter!V(&entry));
1492 dbus_message_iter_next(&sub);
1493 } else {
1494 ret ~= readIter!U(&sub);
1495 }
1496 }
1497 } else static if(isInstanceOf!(Variant, T)) {
1498 DBusMessageIter sub;
1499 dbus_message_iter_recurse(iter, &sub);
1500 ret.data = readIter!(VariantType!T)(&sub);
1501 } else static if(isInstanceOf!(VariantN, T)) {
1502 scope const(char)[] argSig =
1503 dbus_message_iter_get_signature(iter).fromStringz();
1504 scope(exit)
1505 dbus_free(cast(void*) argSig.ptr);
1506
1507 foreach(AT; T.AllowedTypes) {
1508 // We have to compare the full signature here, not just the typecode.
1509 // Otherwise, in case of container types, we might select the wrong one.
1510 // We would then be calling an incorrect instance of readIter, which would
1511 // probably throw a TypeMismatchException.
1512 if (typeSig!AT == argSig) {
1513 ret = readIter!AT(iter);
1514 break;
1515 }
1516 }
1517
1518 // If no value is in ret, apparently none of the types matched.
1519 enforce(ret.hasValue, new TypeMismatchException(typeCode!T, argType));
1520 } else static if(isAssociativeArray!T) {
1521 DBusMessageIter sub;
1522 dbus_message_iter_recurse(iter, &sub);
1523 while(dbus_message_iter_get_arg_type(&sub) != 0) {
1524 DBusMessageIter entry;
1525 dbus_message_iter_recurse(&sub, &entry);
1526 auto k = readIter!(KeyType!T)(&entry);
1527 auto v = readIter!(ValueType!T)(&entry);
1528 ret[k] = v;
1529 dbus_message_iter_next(&sub);
1530 }
1531 } else static if(is(T == DBusAny)) {
1532 ret.type = argType;
1533 ret.explicitVariant = false;
1534 if(ret.type == 's') {
1535 ret.str = readIter!string(iter);
1536 return ret;
1537 } else if(ret.type == 'o') {
1538 ret.obj = readIter!ObjectPath(iter);
1539 return ret;
1540 } else if(ret.type == 'b') {
1541 ret.boolean = readIter!bool(iter);
1542 return ret;
1543 } else if(dbus_type_is_basic(ret.type)) {
1544 dbus_message_iter_get_basic(iter, &ret.int64);
1545 } else if(ret.type == 'a') {
1546 DBusMessageIter sub;
1547 dbus_message_iter_recurse(iter, &sub);
1548 auto sig = dbus_message_iter_get_signature(&sub);
1549 ret.signature = sig.fromStringz.dup;
1550 dbus_free(sig);
1551 if (ret.signature == ['y'])
1552 while(dbus_message_iter_get_arg_type(&sub) != 0) {
1553 ubyte b;
1554 assert(dbus_message_iter_get_arg_type(&sub) == 'y');
1555 dbus_message_iter_get_basic(&sub, &b);
1556 dbus_message_iter_next(&sub);
1557 ret.binaryData ~= b;
1558 }
1559 else
1560 while(dbus_message_iter_get_arg_type(&sub) != 0) {
1561 ret.array ~= readIter!DBusAny(&sub);
1562 }
1563 } else if(ret.type == 'r') {
1564 auto sig = dbus_message_iter_get_signature(iter);
1565 ret.signature = sig.fromStringz.dup;
1566 dbus_free(sig);
1567 DBusMessageIter sub;
1568 dbus_message_iter_recurse(iter, &sub);
1569 while(dbus_message_iter_get_arg_type(&sub) != 0) {
1570 ret.tuple ~= readIter!DBusAny(&sub);
1571 }
1572 } else if(ret.type == 'e') {
1573 DBusMessageIter sub;
1574 dbus_message_iter_recurse(iter, &sub);
1575 ret.entry = new DictionaryEntry!(DBusAny, DBusAny);
1576 ret.entry.key = readIter!DBusAny(&sub);
1577 ret.entry.value = readIter!DBusAny(&sub);
1578 }
1579 } else static if(is(T == struct)) {
1580 DBusMessageIter sub;
1581 dbus_message_iter_recurse(iter, &sub);
1582 readIterStruct!T(&sub, ret);
1583 } else static if(basicDBus!T) {
1584 dbus_message_iter_get_basic(iter, &ret);
1585 }
1586
1587 dbus_message_iter_next(iter);
1588 return ret;
1589 }
1590
1591 void readIterTuple(Tup)(DBusMessageIter *iter, ref Tup tuple) if(isTuple!Tup && allCanDBus!(Tup.Types)) {
1592 foreach(index, T; Tup.Types) {
1593 tuple[index] = readIter!T(iter);
1594 }
1595 }
1596
1597 void readIterStruct(S)(DBusMessageIter *iter, ref S s) if(is(S == struct) && canDBus!S)
1598 {
1599 foreach(index, T; Fields!S) {
1600 static if (isAllowedField!(s.tupleof[index])) {
1601 s.tupleof[index] = readIter!T(iter);
1602 }
1603 }
1604 }
1605
1606 import core.stdc.config;
1607 import core.stdc.stdarg;
1608 extern (C) {
1609 // START dbus/dbus-arch-deps.d
1610 alias c_long dbus_int64_t;
1611 alias c_ulong dbus_uint64_t;
1612 alias int dbus_int32_t;
1613 alias uint dbus_uint32_t;
1614 alias short dbus_int16_t;
1615 alias ushort dbus_uint16_t;
1616 // END dbus/dbus-arch-deps.d
1617 // START dbus/dbus-types.d
1618 alias uint dbus_unichar_t;
1619 alias uint dbus_bool_t;
1620
1621
1622
1623 struct DBus8ByteStruct
1624 {
1625 dbus_uint32_t first32;
1626 dbus_uint32_t second32;
1627 }
1628
1629 union DBusBasicValue
1630 {
1631 ubyte[8] bytes;
1632 dbus_int16_t i16;
1633 dbus_uint16_t u16;
1634 dbus_int32_t i32;
1635 dbus_uint32_t u32;
1636 dbus_bool_t bool_val;
1637 dbus_int64_t i64;
1638 dbus_uint64_t u64;
1639 DBus8ByteStruct eight;
1640 double dbl;
1641 ubyte byt;
1642 char* str;
1643 int fd;
1644 }
1645 // END dbus/dbus-types.d
1646 // START dbus/dbus-protocol.d
1647
1648 // END dbus/dbus-protocol.d
1649 // START dbus/dbus-errors.d
1650 struct DBusError
1651 {
1652 const(char)* name;
1653 const(char)* message;
1654 uint dummy1;
1655 uint dummy2;
1656 uint dummy3;
1657 uint dummy4;
1658 uint dummy5;
1659 void* padding1;
1660 }
1661
1662 void dbus_error_init (DBusError* error);
1663 void dbus_error_free (DBusError* error);
1664 void dbus_set_error (DBusError* error, const(char)* name, const(char)* message, ...);
1665 void dbus_set_error_const (DBusError* error, const(char)* name, const(char)* message);
1666 void dbus_move_error (DBusError* src, DBusError* dest);
1667 dbus_bool_t dbus_error_has_name (const(DBusError)* error, const(char)* name);
1668 dbus_bool_t dbus_error_is_set (const(DBusError)* error);
1669 // END dbus/dbus-errors.d
1670 // START dbus/dbus-macros.d
1671
1672 // END dbus/dbus-macros.d
1673 // START dbus/dbus-memory.d
1674 alias void function (void*) DBusFreeFunction;
1675
1676 void* dbus_malloc (size_t bytes);
1677 void* dbus_malloc0 (size_t bytes);
1678 void* dbus_realloc (void* memory, size_t bytes);
1679 void dbus_free (void* memory);
1680 void dbus_free_string_array (char** str_array);
1681 void dbus_shutdown ();
1682 // END dbus/dbus-memory.d
1683 // START dbus/dbus-shared.d
1684 enum DBusBusType
1685 {
1686 DBUS_BUS_SESSION = 0,
1687 DBUS_BUS_SYSTEM = 1,
1688 DBUS_BUS_STARTER = 2
1689 }
1690
1691 enum DBusHandlerResult
1692 {
1693 DBUS_HANDLER_RESULT_HANDLED = 0,
1694 DBUS_HANDLER_RESULT_NOT_YET_HANDLED = 1,
1695 DBUS_HANDLER_RESULT_NEED_MEMORY = 2
1696 }
1697 // END dbus/dbus-shared.d
1698 // START dbus/dbus-address.d
1699 struct DBusAddressEntry;
1700
1701
1702 dbus_bool_t dbus_parse_address (const(char)* address, DBusAddressEntry*** entry, int* array_len, DBusError* error);
1703 const(char)* dbus_address_entry_get_value (DBusAddressEntry* entry, const(char)* key);
1704 const(char)* dbus_address_entry_get_method (DBusAddressEntry* entry);
1705 void dbus_address_entries_free (DBusAddressEntry** entries);
1706 char* dbus_address_escape_value (const(char)* value);
1707 char* dbus_address_unescape_value (const(char)* value, DBusError* error);
1708 // END dbus/dbus-address.d
1709 // START dbus/dbus-syntax.d
1710 dbus_bool_t dbus_validate_path (const(char)* path, DBusError* error);
1711 dbus_bool_t dbus_validate_interface (const(char)* name, DBusError* error);
1712 dbus_bool_t dbus_validate_member (const(char)* name, DBusError* error);
1713 dbus_bool_t dbus_validate_error_name (const(char)* name, DBusError* error);
1714 dbus_bool_t dbus_validate_bus_name (const(char)* name, DBusError* error);
1715 dbus_bool_t dbus_validate_utf8 (const(char)* alleged_utf8, DBusError* error);
1716 // END dbus/dbus-syntax.d
1717 // START dbus/dbus-signature.d
1718 struct DBusSignatureIter
1719 {
1720 void* dummy1;
1721 void* dummy2;
1722 dbus_uint32_t dummy8;
1723 int dummy12;
1724 int dummy17;
1725 }
1726
1727 void dbus_signature_iter_init (DBusSignatureIter* iter, const(char)* signature);
1728 int dbus_signature_iter_get_current_type (const(DBusSignatureIter)* iter);
1729 char* dbus_signature_iter_get_signature (const(DBusSignatureIter)* iter);
1730 int dbus_signature_iter_get_element_type (const(DBusSignatureIter)* iter);
1731 dbus_bool_t dbus_signature_iter_next (DBusSignatureIter* iter);
1732 void dbus_signature_iter_recurse (const(DBusSignatureIter)* iter, DBusSignatureIter* subiter);
1733 dbus_bool_t dbus_signature_validate (const(char)* signature, DBusError* error);
1734 dbus_bool_t dbus_signature_validate_single (const(char)* signature, DBusError* error);
1735 dbus_bool_t dbus_type_is_valid (int typecode);
1736 dbus_bool_t dbus_type_is_basic (int typecode);
1737 dbus_bool_t dbus_type_is_container (int typecode);
1738 dbus_bool_t dbus_type_is_fixed (int typecode);
1739 // END dbus/dbus-signature.d
1740 // START dbus/dbus-misc.d
1741 char* dbus_get_local_machine_id ();
1742 void dbus_get_version (int* major_version_p, int* minor_version_p, int* micro_version_p);
1743 dbus_bool_t dbus_setenv (const(char)* variable, const(char)* value);
1744 // END dbus/dbus-misc.d
1745 // START dbus/dbus-threads.d
1746 alias DBusMutex* function () DBusMutexNewFunction;
1747 alias void function (DBusMutex*) DBusMutexFreeFunction;
1748 alias uint function (DBusMutex*) DBusMutexLockFunction;
1749 alias uint function (DBusMutex*) DBusMutexUnlockFunction;
1750 alias DBusMutex* function () DBusRecursiveMutexNewFunction;
1751 alias void function (DBusMutex*) DBusRecursiveMutexFreeFunction;
1752 alias void function (DBusMutex*) DBusRecursiveMutexLockFunction;
1753 alias void function (DBusMutex*) DBusRecursiveMutexUnlockFunction;
1754 alias DBusCondVar* function () DBusCondVarNewFunction;
1755 alias void function (DBusCondVar*) DBusCondVarFreeFunction;
1756 alias void function (DBusCondVar*, DBusMutex*) DBusCondVarWaitFunction;
1757 alias uint function (DBusCondVar*, DBusMutex*, int) DBusCondVarWaitTimeoutFunction;
1758 alias void function (DBusCondVar*) DBusCondVarWakeOneFunction;
1759 alias void function (DBusCondVar*) DBusCondVarWakeAllFunction;
1760
1761
1762
1763 enum DBusThreadFunctionsMask
1764 {
1765 DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK = 1,
1766 DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK = 2,
1767 DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK = 4,
1768 DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK = 8,
1769 DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK = 16,
1770 DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK = 32,
1771 DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK = 64,
1772 DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK = 128,
1773 DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK = 256,
1774 DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK = 512,
1775 DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_NEW_MASK = 1024,
1776 DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_FREE_MASK = 2048,
1777 DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_LOCK_MASK = 4096,
1778 DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_UNLOCK_MASK = 8192,
1779 DBUS_THREAD_FUNCTIONS_ALL_MASK = 16383
1780 }
1781
1782 struct DBusThreadFunctions
1783 {
1784 uint mask;
1785 DBusMutexNewFunction mutex_new;
1786 DBusMutexFreeFunction mutex_free;
1787 DBusMutexLockFunction mutex_lock;
1788 DBusMutexUnlockFunction mutex_unlock;
1789 DBusCondVarNewFunction condvar_new;
1790 DBusCondVarFreeFunction condvar_free;
1791 DBusCondVarWaitFunction condvar_wait;
1792 DBusCondVarWaitTimeoutFunction condvar_wait_timeout;
1793 DBusCondVarWakeOneFunction condvar_wake_one;
1794 DBusCondVarWakeAllFunction condvar_wake_all;
1795 DBusRecursiveMutexNewFunction recursive_mutex_new;
1796 DBusRecursiveMutexFreeFunction recursive_mutex_free;
1797 DBusRecursiveMutexLockFunction recursive_mutex_lock;
1798 DBusRecursiveMutexUnlockFunction recursive_mutex_unlock;
1799 void function () padding1;
1800 void function () padding2;
1801 void function () padding3;
1802 void function () padding4;
1803 }
1804
1805 struct DBusCondVar;
1806
1807
1808 struct DBusMutex;
1809
1810
1811 dbus_bool_t dbus_threads_init (const(DBusThreadFunctions)* functions);
1812 dbus_bool_t dbus_threads_init_default ();
1813 // END dbus/dbus-threads.d
1814 // START dbus/dbus-message.d
1815 struct DBusMessageIter
1816 {
1817 void* dummy1;
1818 void* dummy2;
1819 dbus_uint32_t dummy3;
1820 int dummy4;
1821 int dummy5;
1822 int dummy6;
1823 int dummy7;
1824 int dummy8;
1825 int dummy9;
1826 int dummy10;
1827 int dummy11;
1828 int pad1;
1829 int pad2;
1830 void* pad3;
1831 }
1832
1833 struct DBusMessage;
1834
1835
1836 DBusMessage* dbus_message_new (int message_type);
1837 DBusMessage* dbus_message_new_method_call (const(char)* bus_name, const(char)* path, const(char)* iface, const(char)* method);
1838 DBusMessage* dbus_message_new_method_return (DBusMessage* method_call);
1839 DBusMessage* dbus_message_new_signal (const(char)* path, const(char)* iface, const(char)* name);
1840 DBusMessage* dbus_message_new_error (DBusMessage* reply_to, const(char)* error_name, const(char)* error_message);
1841 DBusMessage* dbus_message_new_error_printf (DBusMessage* reply_to, const(char)* error_name, const(char)* error_format, ...);
1842 DBusMessage* dbus_message_copy (const(DBusMessage)* message);
1843 DBusMessage* dbus_message_ref (DBusMessage* message);
1844 void dbus_message_unref (DBusMessage* message);
1845 int dbus_message_get_type (DBusMessage* message);
1846 dbus_bool_t dbus_message_set_path (DBusMessage* message, const(char)* object_path);
1847 const(char)* dbus_message_get_path (DBusMessage* message);
1848 dbus_bool_t dbus_message_has_path (DBusMessage* message, const(char)* object_path);
1849 dbus_bool_t dbus_message_set_interface (DBusMessage* message, const(char)* iface);
1850 const(char)* dbus_message_get_interface (DBusMessage* message);
1851 dbus_bool_t dbus_message_has_interface (DBusMessage* message, const(char)* iface);
1852 dbus_bool_t dbus_message_set_member (DBusMessage* message, const(char)* member);
1853 const(char)* dbus_message_get_member (DBusMessage* message);
1854 dbus_bool_t dbus_message_has_member (DBusMessage* message, const(char)* member);
1855 dbus_bool_t dbus_message_set_error_name (DBusMessage* message, const(char)* name);
1856 const(char)* dbus_message_get_error_name (DBusMessage* message);
1857 dbus_bool_t dbus_message_set_destination (DBusMessage* message, const(char)* destination);
1858 const(char)* dbus_message_get_destination (DBusMessage* message);
1859 dbus_bool_t dbus_message_set_sender (DBusMessage* message, const(char)* sender);
1860 const(char)* dbus_message_get_sender (DBusMessage* message);
1861 const(char)* dbus_message_get_signature (DBusMessage* message);
1862 void dbus_message_set_no_reply (DBusMessage* message, dbus_bool_t no_reply);
1863 dbus_bool_t dbus_message_get_no_reply (DBusMessage* message);
1864 dbus_bool_t dbus_message_is_method_call (DBusMessage* message, const(char)* iface, const(char)* method);
1865 dbus_bool_t dbus_message_is_signal (DBusMessage* message, const(char)* iface, const(char)* signal_name);
1866 dbus_bool_t dbus_message_is_error (DBusMessage* message, const(char)* error_name);
1867 dbus_bool_t dbus_message_has_destination (DBusMessage* message, const(char)* bus_name);
1868 dbus_bool_t dbus_message_has_sender (DBusMessage* message, const(char)* unique_bus_name);
1869 dbus_bool_t dbus_message_has_signature (DBusMessage* message, const(char)* signature);
1870 dbus_uint32_t dbus_message_get_serial (DBusMessage* message);
1871 void dbus_message_set_serial (DBusMessage* message, dbus_uint32_t serial);
1872 dbus_bool_t dbus_message_set_reply_serial (DBusMessage* message, dbus_uint32_t reply_serial);
1873 dbus_uint32_t dbus_message_get_reply_serial (DBusMessage* message);
1874 void dbus_message_set_auto_start (DBusMessage* message, dbus_bool_t auto_start);
1875 dbus_bool_t dbus_message_get_auto_start (DBusMessage* message);
1876 dbus_bool_t dbus_message_get_path_decomposed (DBusMessage* message, char*** path);
1877 dbus_bool_t dbus_message_append_args (DBusMessage* message, int first_arg_type, ...);
1878 dbus_bool_t dbus_message_append_args_valist (DBusMessage* message, int first_arg_type, va_list var_args);
1879 dbus_bool_t dbus_message_get_args (DBusMessage* message, DBusError* error, int first_arg_type, ...);
1880 dbus_bool_t dbus_message_get_args_valist (DBusMessage* message, DBusError* error, int first_arg_type, va_list var_args);
1881 dbus_bool_t dbus_message_contains_unix_fds (DBusMessage* message);
1882 dbus_bool_t dbus_message_iter_init (DBusMessage* message, DBusMessageIter* iter);
1883 dbus_bool_t dbus_message_iter_has_next (DBusMessageIter* iter);
1884 dbus_bool_t dbus_message_iter_next (DBusMessageIter* iter);
1885 char* dbus_message_iter_get_signature (DBusMessageIter* iter);
1886 int dbus_message_iter_get_arg_type (DBusMessageIter* iter);
1887 int dbus_message_iter_get_element_type (DBusMessageIter* iter);
1888 void dbus_message_iter_recurse (DBusMessageIter* iter, DBusMessageIter* sub);
1889 void dbus_message_iter_get_basic (DBusMessageIter* iter, void* value);
1890 int dbus_message_iter_get_array_len (DBusMessageIter* iter);
1891 void dbus_message_iter_get_fixed_array (DBusMessageIter* iter, void* value, int* n_elements);
1892 void dbus_message_iter_init_append (DBusMessage* message, DBusMessageIter* iter);
1893 dbus_bool_t dbus_message_iter_append_basic (DBusMessageIter* iter, int type, const(void)* value);
1894 dbus_bool_t dbus_message_iter_append_fixed_array (DBusMessageIter* iter, int element_type, const(void)* value, int n_elements);
1895 dbus_bool_t dbus_message_iter_open_container (DBusMessageIter* iter, int type, const(char)* contained_signature, DBusMessageIter* sub);
1896 dbus_bool_t dbus_message_iter_close_container (DBusMessageIter* iter, DBusMessageIter* sub);
1897 void dbus_message_iter_abandon_container (DBusMessageIter* iter, DBusMessageIter* sub);
1898 void dbus_message_lock (DBusMessage* message);
1899 dbus_bool_t dbus_set_error_from_message (DBusError* error, DBusMessage* message);
1900 dbus_bool_t dbus_message_allocate_data_slot (dbus_int32_t* slot_p);
1901 void dbus_message_free_data_slot (dbus_int32_t* slot_p);
1902 dbus_bool_t dbus_message_set_data (DBusMessage* message, dbus_int32_t slot, void* data, DBusFreeFunction free_data_func);
1903 void* dbus_message_get_data (DBusMessage* message, dbus_int32_t slot);
1904 int dbus_message_type_from_string (const(char)* type_str);
1905 const(char)* dbus_message_type_to_string (int type);
1906 dbus_bool_t dbus_message_marshal (DBusMessage* msg, char** marshalled_data_p, int* len_p);
1907 DBusMessage* dbus_message_demarshal (const(char)* str, int len, DBusError* error);
1908 int dbus_message_demarshal_bytes_needed (const(char)* str, int len);
1909 // END dbus/dbus-message.d
1910 // START dbus/dbus-connection.d
1911 alias uint function (DBusWatch*, void*) DBusAddWatchFunction;
1912 alias void function (DBusWatch*, void*) DBusWatchToggledFunction;
1913 alias void function (DBusWatch*, void*) DBusRemoveWatchFunction;
1914 alias uint function (DBusTimeout*, void*) DBusAddTimeoutFunction;
1915 alias void function (DBusTimeout*, void*) DBusTimeoutToggledFunction;
1916 alias void function (DBusTimeout*, void*) DBusRemoveTimeoutFunction;
1917 alias void function (DBusConnection*, DBusDispatchStatus, void*) DBusDispatchStatusFunction;
1918 alias void function (void*) DBusWakeupMainFunction;
1919 alias uint function (DBusConnection*, c_ulong, void*) DBusAllowUnixUserFunction;
1920 alias uint function (DBusConnection*, const(char)*, void*) DBusAllowWindowsUserFunction;
1921 alias void function (DBusPendingCall*, void*) DBusPendingCallNotifyFunction;
1922 alias DBusHandlerResult function (DBusConnection*, DBusMessage*, void*) DBusHandleMessageFunction;
1923 alias void function (DBusConnection*, void*) DBusObjectPathUnregisterFunction;
1924 alias DBusHandlerResult function (DBusConnection*, DBusMessage*, void*) DBusObjectPathMessageFunction;
1925
1926 enum DBusWatchFlags
1927 {
1928 DBUS_WATCH_READABLE = 1,
1929 DBUS_WATCH_WRITABLE = 2,
1930 DBUS_WATCH_ERROR = 4,
1931 DBUS_WATCH_HANGUP = 8
1932 }
1933
1934 enum DBusDispatchStatus
1935 {
1936 DBUS_DISPATCH_DATA_REMAINS = 0,
1937 DBUS_DISPATCH_COMPLETE = 1,
1938 DBUS_DISPATCH_NEED_MEMORY = 2
1939 }
1940
1941 struct DBusObjectPathVTable
1942 {
1943 DBusObjectPathUnregisterFunction unregister_function;
1944 DBusObjectPathMessageFunction message_function;
1945 void function (void*) dbus_internal_pad1;
1946 void function (void*) dbus_internal_pad2;
1947 void function (void*) dbus_internal_pad3;
1948 void function (void*) dbus_internal_pad4;
1949 }
1950
1951 struct DBusPreallocatedSend;
1952
1953
1954 struct DBusTimeout;
1955
1956
1957 struct DBusPendingCall;
1958
1959
1960 struct DBusConnection;
1961
1962
1963 struct DBusWatch;
1964
1965
1966 DBusConnection* dbus_connection_open (const(char)* address, DBusError* error);
1967 DBusConnection* dbus_connection_open_private (const(char)* address, DBusError* error);
1968 DBusConnection* dbus_connection_ref (DBusConnection* connection);
1969 void dbus_connection_unref (DBusConnection* connection);
1970 void dbus_connection_close (DBusConnection* connection);
1971 dbus_bool_t dbus_connection_get_is_connected (DBusConnection* connection);
1972 dbus_bool_t dbus_connection_get_is_authenticated (DBusConnection* connection);
1973 dbus_bool_t dbus_connection_get_is_anonymous (DBusConnection* connection);
1974 char* dbus_connection_get_server_id (DBusConnection* connection);
1975 dbus_bool_t dbus_connection_can_send_type (DBusConnection* connection, int type);
1976 void dbus_connection_set_exit_on_disconnect (DBusConnection* connection, dbus_bool_t exit_on_disconnect);
1977 void dbus_connection_flush (DBusConnection* connection);
1978 dbus_bool_t dbus_connection_read_write_dispatch (DBusConnection* connection, int timeout_milliseconds);
1979 dbus_bool_t dbus_connection_read_write (DBusConnection* connection, int timeout_milliseconds);
1980 DBusMessage* dbus_connection_borrow_message (DBusConnection* connection);
1981 void dbus_connection_return_message (DBusConnection* connection, DBusMessage* message);
1982 void dbus_connection_steal_borrowed_message (DBusConnection* connection, DBusMessage* message);
1983 DBusMessage* dbus_connection_pop_message (DBusConnection* connection);
1984 DBusDispatchStatus dbus_connection_get_dispatch_status (DBusConnection* connection);
1985 DBusDispatchStatus dbus_connection_dispatch (DBusConnection* connection);
1986 dbus_bool_t dbus_connection_has_messages_to_send (DBusConnection* connection);
1987 dbus_bool_t dbus_connection_send (DBusConnection* connection, DBusMessage* message, dbus_uint32_t* client_serial);
1988 dbus_bool_t dbus_connection_send_with_reply (DBusConnection* connection, DBusMessage* message, DBusPendingCall** pending_return, int timeout_milliseconds);
1989 DBusMessage* dbus_connection_send_with_reply_and_block (DBusConnection* connection, DBusMessage* message, int timeout_milliseconds, DBusError* error);
1990 dbus_bool_t dbus_connection_set_watch_functions (DBusConnection* connection, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void* data, DBusFreeFunction free_data_function);
1991 dbus_bool_t dbus_connection_set_timeout_functions (DBusConnection* connection, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void* data, DBusFreeFunction free_data_function);
1992 void dbus_connection_set_wakeup_main_function (DBusConnection* connection, DBusWakeupMainFunction wakeup_main_function, void* data, DBusFreeFunction free_data_function);
1993 void dbus_connection_set_dispatch_status_function (DBusConnection* connection, DBusDispatchStatusFunction function_, void* data, DBusFreeFunction free_data_function);
1994 dbus_bool_t dbus_connection_get_unix_user (DBusConnection* connection, c_ulong* uid);
1995 dbus_bool_t dbus_connection_get_unix_process_id (DBusConnection* connection, c_ulong* pid);
1996 dbus_bool_t dbus_connection_get_adt_audit_session_data (DBusConnection* connection, void** data, dbus_int32_t* data_size);
1997 void dbus_connection_set_unix_user_function (DBusConnection* connection, DBusAllowUnixUserFunction function_, void* data, DBusFreeFunction free_data_function);
1998 dbus_bool_t dbus_connection_get_windows_user (DBusConnection* connection, char** windows_sid_p);
1999 void dbus_connection_set_windows_user_function (DBusConnection* connection, DBusAllowWindowsUserFunction function_, void* data, DBusFreeFunction free_data_function);
2000 void dbus_connection_set_allow_anonymous (DBusConnection* connection, dbus_bool_t value);
2001 void dbus_connection_set_route_peer_messages (DBusConnection* connection, dbus_bool_t value);
2002 dbus_bool_t dbus_connection_add_filter (DBusConnection* connection, DBusHandleMessageFunction function_, void* user_data, DBusFreeFunction free_data_function);
2003 void dbus_connection_remove_filter (DBusConnection* connection, DBusHandleMessageFunction function_, void* user_data);
2004 dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t* slot_p);
2005 void dbus_connection_free_data_slot (dbus_int32_t* slot_p);
2006 dbus_bool_t dbus_connection_set_data (DBusConnection* connection, dbus_int32_t slot, void* data, DBusFreeFunction free_data_func);
2007 void* dbus_connection_get_data (DBusConnection* connection, dbus_int32_t slot);
2008 void dbus_connection_set_change_sigpipe (dbus_bool_t will_modify_sigpipe);
2009 void dbus_connection_set_max_message_size (DBusConnection* connection, c_long size);
2010 c_long dbus_connection_get_max_message_size (DBusConnection* connection);
2011 void dbus_connection_set_max_received_size (DBusConnection* connection, c_long size);
2012 c_long dbus_connection_get_max_received_size (DBusConnection* connection);
2013 void dbus_connection_set_max_message_unix_fds (DBusConnection* connection, c_long n);
2014 c_long dbus_connection_get_max_message_unix_fds (DBusConnection* connection);
2015 void dbus_connection_set_max_received_unix_fds (DBusConnection* connection, c_long n);
2016 c_long dbus_connection_get_max_received_unix_fds (DBusConnection* connection);
2017 c_long dbus_connection_get_outgoing_size (DBusConnection* connection);
2018 c_long dbus_connection_get_outgoing_unix_fds (DBusConnection* connection);
2019 DBusPreallocatedSend* dbus_connection_preallocate_send (DBusConnection* connection);
2020 void dbus_connection_free_preallocated_send (DBusConnection* connection, DBusPreallocatedSend* preallocated);
2021 void dbus_connection_send_preallocated (DBusConnection* connection, DBusPreallocatedSend* preallocated, DBusMessage* message, dbus_uint32_t* client_serial);
2022 dbus_bool_t dbus_connection_try_register_object_path (DBusConnection* connection, const(char)* path, const(DBusObjectPathVTable)* vtable, void* user_data, DBusError* error);
2023 dbus_bool_t dbus_connection_register_object_path (DBusConnection* connection, const(char)* path, const(DBusObjectPathVTable)* vtable, void* user_data);
2024 dbus_bool_t dbus_connection_try_register_fallback (DBusConnection* connection, const(char)* path, const(DBusObjectPathVTable)* vtable, void* user_data, DBusError* error);
2025 dbus_bool_t dbus_connection_register_fallback (DBusConnection* connection, const(char)* path, const(DBusObjectPathVTable)* vtable, void* user_data);
2026 dbus_bool_t dbus_connection_unregister_object_path (DBusConnection* connection, const(char)* path);
2027 dbus_bool_t dbus_connection_get_object_path_data (DBusConnection* connection, const(char)* path, void** data_p);
2028 dbus_bool_t dbus_connection_list_registered (DBusConnection* connection, const(char)* parent_path, char*** child_entries);
2029 dbus_bool_t dbus_connection_get_unix_fd (DBusConnection* connection, int* fd);
2030 dbus_bool_t dbus_connection_get_socket (DBusConnection* connection, int* fd);
2031 int dbus_watch_get_fd (DBusWatch* watch);
2032 int dbus_watch_get_unix_fd (DBusWatch* watch);
2033 int dbus_watch_get_socket (DBusWatch* watch);
2034 uint dbus_watch_get_flags (DBusWatch* watch);
2035 void* dbus_watch_get_data (DBusWatch* watch);
2036 void dbus_watch_set_data (DBusWatch* watch, void* data, DBusFreeFunction free_data_function);
2037 dbus_bool_t dbus_watch_handle (DBusWatch* watch, uint flags);
2038 dbus_bool_t dbus_watch_get_enabled (DBusWatch* watch);
2039 int dbus_timeout_get_interval (DBusTimeout* timeout);
2040 void* dbus_timeout_get_data (DBusTimeout* timeout);
2041 void dbus_timeout_set_data (DBusTimeout* timeout, void* data, DBusFreeFunction free_data_function);
2042 dbus_bool_t dbus_timeout_handle (DBusTimeout* timeout);
2043 dbus_bool_t dbus_timeout_get_enabled (DBusTimeout* timeout);
2044 // END dbus/dbus-connection.d
2045 // START dbus/dbus-pending-call.d
2046 DBusPendingCall* dbus_pending_call_ref (DBusPendingCall* pending);
2047 void dbus_pending_call_unref (DBusPendingCall* pending);
2048 dbus_bool_t dbus_pending_call_set_notify (DBusPendingCall* pending, DBusPendingCallNotifyFunction function_, void* user_data, DBusFreeFunction free_user_data);
2049 void dbus_pending_call_cancel (DBusPendingCall* pending);
2050 dbus_bool_t dbus_pending_call_get_completed (DBusPendingCall* pending);
2051 DBusMessage* dbus_pending_call_steal_reply (DBusPendingCall* pending);
2052 void dbus_pending_call_block (DBusPendingCall* pending);
2053 dbus_bool_t dbus_pending_call_allocate_data_slot (dbus_int32_t* slot_p);
2054 void dbus_pending_call_free_data_slot (dbus_int32_t* slot_p);
2055 dbus_bool_t dbus_pending_call_set_data (DBusPendingCall* pending, dbus_int32_t slot, void* data, DBusFreeFunction free_data_func);
2056 void* dbus_pending_call_get_data (DBusPendingCall* pending, dbus_int32_t slot);
2057 // END dbus/dbus-pending-call.d
2058 // START dbus/dbus-server.d
2059 alias void function (DBusServer*, DBusConnection*, void*) DBusNewConnectionFunction;
2060
2061 struct DBusServer;
2062
2063
2064 DBusServer* dbus_server_listen (const(char)* address, DBusError* error);
2065 DBusServer* dbus_server_ref (DBusServer* server);
2066 void dbus_server_unref (DBusServer* server);
2067 void dbus_server_disconnect (DBusServer* server);
2068 dbus_bool_t dbus_server_get_is_connected (DBusServer* server);
2069 char* dbus_server_get_address (DBusServer* server);
2070 char* dbus_server_get_id (DBusServer* server);
2071 void dbus_server_set_new_connection_function (DBusServer* server, DBusNewConnectionFunction function_, void* data, DBusFreeFunction free_data_function);
2072 dbus_bool_t dbus_server_set_watch_functions (DBusServer* server, DBusAddWatchFunction add_function, DBusRemoveWatchFunction remove_function, DBusWatchToggledFunction toggled_function, void* data, DBusFreeFunction free_data_function);
2073 dbus_bool_t dbus_server_set_timeout_functions (DBusServer* server, DBusAddTimeoutFunction add_function, DBusRemoveTimeoutFunction remove_function, DBusTimeoutToggledFunction toggled_function, void* data, DBusFreeFunction free_data_function);
2074 dbus_bool_t dbus_server_set_auth_mechanisms (DBusServer* server, const(char*)* mechanisms);
2075 dbus_bool_t dbus_server_allocate_data_slot (dbus_int32_t* slot_p);
2076 void dbus_server_free_data_slot (dbus_int32_t* slot_p);
2077 dbus_bool_t dbus_server_set_data (DBusServer* server, int slot, void* data, DBusFreeFunction free_data_func);
2078 void* dbus_server_get_data (DBusServer* server, int slot);
2079 // END dbus/dbus-server.d
2080 // START dbus/dbus-bus.d
2081 DBusConnection* dbus_bus_get (DBusBusType type, DBusError* error);
2082 DBusConnection* dbus_bus_get_private (DBusBusType type, DBusError* error);
2083 dbus_bool_t dbus_bus_register (DBusConnection* connection, DBusError* error);
2084 dbus_bool_t dbus_bus_set_unique_name (DBusConnection* connection, const(char)* unique_name);
2085 const(char)* dbus_bus_get_unique_name (DBusConnection* connection);
2086 c_ulong dbus_bus_get_unix_user (DBusConnection* connection, const(char)* name, DBusError* error);
2087 char* dbus_bus_get_id (DBusConnection* connection, DBusError* error);
2088 int dbus_bus_request_name (DBusConnection* connection, const(char)* name, uint flags, DBusError* error);
2089 int dbus_bus_release_name (DBusConnection* connection, const(char)* name, DBusError* error);
2090 dbus_bool_t dbus_bus_name_has_owner (DBusConnection* connection, const(char)* name, DBusError* error);
2091 dbus_bool_t dbus_bus_start_service_by_name (DBusConnection* connection, const(char)* name, dbus_uint32_t flags, dbus_uint32_t* reply, DBusError* error);
2092 void dbus_bus_add_match (DBusConnection* connection, const(char)* rule, DBusError* error);
2093 void dbus_bus_remove_match (DBusConnection* connection, const(char)* rule, DBusError* error);
2094 // END dbus/dbus-bus.d
2095 // START dbus/dbus.d
2096
2097 // END dbus/dbus.d
2098 }
2099
2100
2101 enum BusService = "org.freedesktop.DBus";
2102 enum BusPath = "/org/freedesktop/DBus";
2103 enum BusInterface = "org.freedesktop.DBus";
2104
2105 enum NameFlags {
2106 AllowReplace = 1, ReplaceExisting = 2, NoQueue = 4
2107 }
2108
2109 /// Requests a DBus well-known name.
2110 /// returns if the name is owned after the call.
2111 /// Involves blocking call on a DBus method, may throw an exception on failure.
2112 bool requestName(Connection conn, string name,
2113 NameFlags flags = NameFlags.NoQueue | NameFlags.AllowReplace) {
2114 auto msg = Message(BusService,BusPath,BusInterface,"RequestName");
2115 msg.build(name,cast(uint)(flags));
2116 auto res = conn.sendWithReplyBlocking(msg).to!uint;
2117 return (res == 1) || (res == 4);
2118 }
2119
2120 /// A simple main loop that isn't necessarily efficient
2121 /// and isn't guaranteed to work with other tasks and threads.
2122 /// Use only for apps that only do DBus triggered things.
2123 void simpleMainLoop(Connection conn) {
2124 while(dbus_connection_read_write_dispatch(conn.conn, -1)) {} // empty loop body
2125 }
2126
2127 /// Single tick in the DBus connection which can be used for
2128 /// concurrent updates.
2129 bool tick(Connection conn) {
2130 return cast(bool) dbus_connection_read_write_dispatch(conn.conn, 0);
2131 }
2132
2133
The D Programming Language's Unofficial Docs
beta