D-Bus: dbus-message-factory.c Source File

D-Bus 1.10.10

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List

dbus-message-factory.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-message-factory.c Generator of valid and invalid message data for test suite
3 *
4 * Copyright (C) 2005 Red Hat Inc.
5 *
6 * Licensed under the Academic Free License version 2.1
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 */
23 #include <config.h>
24
25 #ifndef DOXYGEN_SHOULD_SKIP_THIS
26
27 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
28 #include "dbus-message-factory.h"
29 #include "dbus-message-private.h"
30 #include "dbus-signature.h"
31 #include "dbus-test.h"
32 #include <stdio.h>
33
34 typedef enum
35 {
36 CHANGE_TYPE_ADJUST,
37 CHANGE_TYPE_ABSOLUTE
38 } ChangeType;
39
40 #define BYTE_ORDER_OFFSET 0
41 #define TYPE_OFFSET 1
42 #define BODY_LENGTH_OFFSET 4
43 #define FIELDS_ARRAY_LENGTH_OFFSET 12
44
45 static void
46 iter_recurse (DBusMessageDataIter *iter)
47 {
48 iter->depth += 1;
49 _dbus_assert (iter->depth < _DBUS_MESSAGE_DATA_MAX_NESTING);
50 _dbus_assert (iter->sequence_nos[iter->depth] >= 0);
51 }
52
53 static int
54 iter_get_sequence (DBusMessageDataIter *iter)
55 {
56 _dbus_assert (iter->sequence_nos[iter->depth] >= 0);
57 return iter->sequence_nos[iter->depth];
58 }
59
60 static void
61 iter_set_sequence (DBusMessageDataIter *iter,
62 int sequence)
63 {
64 _dbus_assert (sequence >= 0);
65 iter->sequence_nos[iter->depth] = sequence;
66 }
67
68 static void
69 iter_unrecurse (DBusMessageDataIter *iter)
70 {
71 iter->depth -= 1;
72 _dbus_assert (iter->depth >= 0);
73 }
74
75 static void
76 iter_next (DBusMessageDataIter *iter)
77 {
78 iter->sequence_nos[iter->depth] += 1;
79 }
80
81 static dbus_bool_t
82 iter_first_in_series (DBusMessageDataIter *iter)
83 {
84 int i;
85
86 i = iter->depth;
87 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
88 {
89 if (iter->sequence_nos[i] != 0)
90 return FALSE;
91 ++i;
92 }
93 return TRUE;
94 }
95
96 typedef dbus_bool_t (* DBusInnerGeneratorFunc) (DBusMessageDataIter *iter,
97 DBusMessage **message_p);
98 typedef dbus_bool_t (* DBusMessageGeneratorFunc) (DBusMessageDataIter *iter,
99 DBusString *data,
100 DBusValidity *expected_validity);
101
102 static void
103 set_reply_serial (DBusMessage *message)
104 {
105 if (message == NULL)
106 _dbus_assert_not_reached ("oom");
107 if (!dbus_message_set_reply_serial (message, 100))
108 _dbus_assert_not_reached ("oom");
109 }
110
111 static dbus_bool_t
112 generate_trivial_inner (DBusMessageDataIter *iter,
113 DBusMessage **message_p)
114 {
115 DBusMessage *message;
116
117 switch (iter_get_sequence (iter))
118 {
119 case 0:
120 message = dbus_message_new_method_call ("org.freedesktop.TextEditor",
121 "/foo/bar",
122 "org.freedesktop.DocumentFactory",
123 "Create");
124 break;
125 case 1:
126 message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
127 set_reply_serial (message);
128 break;
129 case 2:
130 message = dbus_message_new_signal ("/foo/bar",
131 "org.freedesktop.DocumentFactory",
132 "Created");
133 break;
134 case 3:
135 message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
136
137 if (!dbus_message_set_error_name (message,
138 "org.freedesktop.TestErrorName"))
139 _dbus_assert_not_reached ("oom");
140
141 {
142 DBusMessageIter iter;
143 const char *v_STRING = "This is an error";
144
145 dbus_message_iter_init_append (message, &iter);
146 if (!dbus_message_iter_append_basic (&iter,
147 DBUS_TYPE_STRING,
148 &v_STRING))
149 _dbus_assert_not_reached ("oom");
150 }
151
152 set_reply_serial (message);
153 break;
154 default:
155 return FALSE;
156 }
157
158 if (message == NULL)
159 _dbus_assert_not_reached ("oom");
160
161 *message_p = message;
162
163 return TRUE;
164 }
165
166 static dbus_bool_t
167 generate_many_bodies_inner (DBusMessageDataIter *iter,
168 DBusMessage **message_p)
169 {
170 DBusMessage *message;
171 DBusString signature;
172 DBusString body;
173 char byte_order;
174
175 /* Keeping this small makes things go faster */
176 message = dbus_message_new_method_call ("o.z.F",
177 "/",
178 "o.z.B",
179 "Nah");
180 if (message == NULL)
181 _dbus_assert_not_reached ("oom");
182
183 byte_order = _dbus_header_get_byte_order (&message->header);
184
185 set_reply_serial (message);
186
187 if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
188 _dbus_assert_not_reached ("oom");
189
190 if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
191 byte_order,
192 &signature, &body))
193 {
194 const char *v_SIGNATURE;
195
196 v_SIGNATURE = _dbus_string_get_const_data (&signature);
197 if (!_dbus_header_set_field_basic (&message->header,
198 DBUS_HEADER_FIELD_SIGNATURE,
199 DBUS_TYPE_SIGNATURE,
200 &v_SIGNATURE))
201 _dbus_assert_not_reached ("oom");
202
203 if (!_dbus_string_move (&body, 0, &message->body, 0))
204 _dbus_assert_not_reached ("oom");
205
206 _dbus_marshal_set_uint32 (&message->header.data, BODY_LENGTH_OFFSET,
207 _dbus_string_get_length (&message->body),
208 byte_order);
209
210 *message_p = message;
211 }
212 else
213 {
214 dbus_message_unref (message);
215 *message_p = NULL;
216 }
217
218 _dbus_string_free (&signature);
219 _dbus_string_free (&body);
220
221 return *message_p != NULL;
222 }
223
224 static void
225 generate_from_message (DBusString *data,
226 DBusValidity *expected_validity,
227 DBusMessage *message)
228 {
229 dbus_message_set_serial (message, 1);
230 dbus_message_lock (message);
231
232 *expected_validity = DBUS_VALID;
233
234 /* move for efficiency, since we'll nuke the message anyway */
235 if (!_dbus_string_move (&message->header.data, 0,
236 data, 0))
237 _dbus_assert_not_reached ("oom");
238
239 if (!_dbus_string_copy (&message->body, 0,
240 data, _dbus_string_get_length (data)))
241 _dbus_assert_not_reached ("oom");
242 }
243
244 static dbus_bool_t
245 generate_outer (DBusMessageDataIter *iter,
246 DBusString *data,
247 DBusValidity *expected_validity,
248 DBusInnerGeneratorFunc func)
249 {
250 DBusMessage *message;
251
252 message = NULL;
253 if (!(*func)(iter, &message))
254 return FALSE;
255
256 iter_next (iter);
257
258 _dbus_assert (message != NULL);
259
260 generate_from_message (data, expected_validity, message);
261
262 dbus_message_unref (message);
263
264 return TRUE;
265 }
266
267 static dbus_bool_t
268 generate_trivial (DBusMessageDataIter *iter,
269 DBusString *data,
270 DBusValidity *expected_validity)
271 {
272 return generate_outer (iter, data, expected_validity,
273 generate_trivial_inner);
274 }
275
276 static dbus_bool_t
277 generate_many_bodies (DBusMessageDataIter *iter,
278 DBusString *data,
279 DBusValidity *expected_validity)
280 {
281 return generate_outer (iter, data, expected_validity,
282 generate_many_bodies_inner);
283 }
284
285 static DBusMessage*
286 simple_method_call (void)
287 {
288 DBusMessage *message;
289 /* Keeping this small makes stuff go faster */
290 message = dbus_message_new_method_call ("o.b.Q",
291 "/f/b",
292 "o.b.Z",
293 "Fro");
294 if (message == NULL)
295 _dbus_assert_not_reached ("oom");
296 return message;
297 }
298
299 static DBusMessage*
300 simple_signal (void)
301 {
302 DBusMessage *message;
303 message = dbus_message_new_signal ("/f/b",
304 "o.b.Z",
305 "Fro");
306 if (message == NULL)
307 _dbus_assert_not_reached ("oom");
308 return message;
309 }
310
311 static DBusMessage*
312 simple_method_return (void)
313 {
314 DBusMessage *message;
315 message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
316 if (message == NULL)
317 _dbus_assert_not_reached ("oom");
318
319 set_reply_serial (message);
320
321 return message;
322 }
323
324 static DBusMessage*
325 simple_error (void)
326 {
327 DBusMessage *message;
328 message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
329 if (message == NULL)
330 _dbus_assert_not_reached ("oom");
331
332 if (!dbus_message_set_error_name (message, "foo.bar"))
333 _dbus_assert_not_reached ("oom");
334
335 set_reply_serial (message);
336
337 return message;
338 }
339
340 static DBusMessage*
341 message_with_nesting_levels (int levels)
342 {
343 DBusMessage *message;
344 dbus_int32_t v_INT32;
345 DBusMessageIter *parents;
346 DBusMessageIter *children;
347 int i;
348
349 /* If levels is higher it breaks sig_refcount in DBusMessageRealIter
350 * in dbus-message.c, this assert is just to help you know you need
351 * to fix that if you hit it
352 */
353 _dbus_assert (levels < 256);
354
355 parents = dbus_new(DBusMessageIter, levels + 1);
356 children = dbus_new(DBusMessageIter, levels + 1);
357
358 v_INT32 = 42;
359 message = simple_method_call ();
360
361 i = 0;
362 dbus_message_iter_init_append (message, &parents[i]);
363 while (i < levels)
364 {
365 dbus_message_iter_open_container (&parents[i], DBUS_TYPE_VARIANT,
366 i == (levels - 1) ?
367 DBUS_TYPE_INT32_AS_STRING :
368 DBUS_TYPE_VARIANT_AS_STRING,
369 &children[i]);
370 ++i;
371 parents[i] = children[i-1];
372 }
373 --i;
374 dbus_message_iter_append_basic (&children[i], DBUS_TYPE_INT32, &v_INT32);
375 while (i >= 0)
376 {
377 dbus_message_iter_close_container (&parents[i], &children[i]);
378 --i;
379 }
380
381 dbus_free(parents);
382 dbus_free(children);
383
384 return message;
385 }
386
387 static dbus_bool_t
388 generate_special (DBusMessageDataIter *iter,
389 DBusString *data,
390 DBusValidity *expected_validity)
391 {
392 int item_seq;
393 DBusMessage *message;
394 int pos;
395 dbus_int32_t v_INT32;
396
397 _dbus_assert (_dbus_string_get_length (data) == 0);
398
399 message = NULL;
400 pos = -1;
401 v_INT32 = 42;
402 item_seq = iter_get_sequence (iter);
403
404 if (item_seq == 0)
405 {
406 message = simple_method_call ();
407 if (!dbus_message_append_args (message,
408 DBUS_TYPE_INT32, &v_INT32,
409 DBUS_TYPE_INT32, &v_INT32,
410 DBUS_TYPE_INT32, &v_INT32,
411 DBUS_TYPE_INVALID))
412 _dbus_assert_not_reached ("oom");
413
414 _dbus_header_get_field_raw (&message->header,
415 DBUS_HEADER_FIELD_SIGNATURE,
416 NULL, &pos);
417 generate_from_message (data, expected_validity, message);
418
419 /* set an invalid typecode */
420 _dbus_string_set_byte (data, pos + 1, '$');
421
422 *expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;
423 }
424 else if (item_seq == 1)
425 {
426 char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH+2];
427 const char *v_STRING;
428 int i;
429
430 message = simple_method_call ();
431 if (!dbus_message_append_args (message,
432 DBUS_TYPE_INT32, &v_INT32,
433 DBUS_TYPE_INT32, &v_INT32,
434 DBUS_TYPE_INT32, &v_INT32,
435 DBUS_TYPE_INVALID))
436 _dbus_assert_not_reached ("oom");
437
438 i = 0;
439 while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
440 {
441 long_sig[i] = DBUS_TYPE_ARRAY;
442 ++i;
443 }
444 long_sig[i] = DBUS_TYPE_INVALID;
445
446 v_STRING = long_sig;
447 if (!_dbus_header_set_field_basic (&message->header,
448 DBUS_HEADER_FIELD_SIGNATURE,
449 DBUS_TYPE_SIGNATURE,
450 &v_STRING))
451 _dbus_assert_not_reached ("oom");
452
453 _dbus_header_get_field_raw (&message->header,
454 DBUS_HEADER_FIELD_SIGNATURE,
455 NULL, &pos);
456 generate_from_message (data, expected_validity, message);
457
458 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
459 }
460 else if (item_seq == 2)
461 {
462 char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2+4];
463 const char *v_STRING;
464 int i;
465
466 message = simple_method_call ();
467 if (!dbus_message_append_args (message,
468 DBUS_TYPE_INT32, &v_INT32,
469 DBUS_TYPE_INT32, &v_INT32,
470 DBUS_TYPE_INT32, &v_INT32,
471 DBUS_TYPE_INVALID))
472 _dbus_assert_not_reached ("oom");
473
474 i = 0;
475 while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
476 {
477 long_sig[i] = DBUS_STRUCT_BEGIN_CHAR;
478 ++i;
479 }
480
481 long_sig[i] = DBUS_TYPE_INT32;
482 ++i;
483
484 while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2 + 3))
485 {
486 long_sig[i] = DBUS_STRUCT_END_CHAR;
487 ++i;
488 }
489 long_sig[i] = DBUS_TYPE_INVALID;
490
491 v_STRING = long_sig;
492 if (!_dbus_header_set_field_basic (&message->header,
493 DBUS_HEADER_FIELD_SIGNATURE,
494 DBUS_TYPE_SIGNATURE,
495 &v_STRING))
496 _dbus_assert_not_reached ("oom");
497
498 _dbus_header_get_field_raw (&message->header,
499 DBUS_HEADER_FIELD_SIGNATURE,
500 NULL, &pos);
501 generate_from_message (data, expected_validity, message);
502
503 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
504 }
505 else if (item_seq == 3)
506 {
507 message = simple_method_call ();
508 if (!dbus_message_append_args (message,
509 DBUS_TYPE_INT32, &v_INT32,
510 DBUS_TYPE_INT32, &v_INT32,
511 DBUS_TYPE_INT32, &v_INT32,
512 DBUS_TYPE_INVALID))
513 _dbus_assert_not_reached ("oom");
514
515 _dbus_header_get_field_raw (&message->header,
516 DBUS_HEADER_FIELD_SIGNATURE,
517 NULL, &pos);
518 generate_from_message (data, expected_validity, message);
519
520 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
521
522 *expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
523 }
524 else if (item_seq == 4)
525 {
526 message = simple_method_call ();
527 if (!dbus_message_append_args (message,
528 DBUS_TYPE_INT32, &v_INT32,
529 DBUS_TYPE_INT32, &v_INT32,
530 DBUS_TYPE_INT32, &v_INT32,
531 DBUS_TYPE_INVALID))
532 _dbus_assert_not_reached ("oom");
533
534 _dbus_header_get_field_raw (&message->header,
535 DBUS_HEADER_FIELD_SIGNATURE,
536 NULL, &pos);
537 generate_from_message (data, expected_validity, message);
538
539 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_END_CHAR);
540
541 *expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
542 }
543 else if (item_seq == 5)
544 {
545 message = simple_method_call ();
546 if (!dbus_message_append_args (message,
547 DBUS_TYPE_INT32, &v_INT32,
548 DBUS_TYPE_INT32, &v_INT32,
549 DBUS_TYPE_INT32, &v_INT32,
550 DBUS_TYPE_INVALID))
551 _dbus_assert_not_reached ("oom");
552
553 _dbus_header_get_field_raw (&message->header,
554 DBUS_HEADER_FIELD_SIGNATURE,
555 NULL, &pos);
556 generate_from_message (data, expected_validity, message);
557
558 _dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
559 _dbus_string_set_byte (data, pos + 2, DBUS_STRUCT_END_CHAR);
560
561 *expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
562 }
563 else if (item_seq == 6)
564 {
565 message = simple_method_call ();
566 generate_from_message (data, expected_validity, message);
567
568 _dbus_string_set_byte (data, TYPE_OFFSET, DBUS_MESSAGE_TYPE_INVALID);
569
570 *expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;
571 }
572 else if (item_seq == 7)
573 {
574 /* Messages of unknown type are considered valid */
575 message = simple_method_call ();
576 generate_from_message (data, expected_validity, message);
577
578 _dbus_string_set_byte (data, TYPE_OFFSET, 100);
579
580 *expected_validity = DBUS_VALID;
581 }
582 else if (item_seq == 8)
583 {
584 char byte_order;
585
586 message = simple_method_call ();
587 byte_order = _dbus_header_get_byte_order (&message->header);
588 generate_from_message (data, expected_validity, message);
589
590 _dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
591 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
592 byte_order);
593 _dbus_marshal_set_uint32 (data, FIELDS_ARRAY_LENGTH_OFFSET,
594 DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
595 byte_order);
596 *expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
597 }
598 else if (item_seq == 9)
599 {
600 const char *v_STRING = "not a valid bus name";
601 message = simple_method_call ();
602
603 if (!_dbus_header_set_field_basic (&message->header,
604 DBUS_HEADER_FIELD_SENDER,
605 DBUS_TYPE_STRING, &v_STRING))
606 _dbus_assert_not_reached ("oom");
607
608 generate_from_message (data, expected_validity, message);
609
610 *expected_validity = DBUS_INVALID_BAD_SENDER;
611 }
612 else if (item_seq == 10)
613 {
614 message = simple_method_call ();
615
616 if (!dbus_message_set_interface (message, DBUS_INTERFACE_LOCAL))
617 _dbus_assert_not_reached ("oom");
618
619 generate_from_message (data, expected_validity, message);
620
621 *expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
622 }
623 else if (item_seq == 11)
624 {
625 message = simple_method_call ();
626
627 if (!dbus_message_set_path (message, DBUS_PATH_LOCAL))
628 _dbus_assert_not_reached ("oom");
629
630 generate_from_message (data, expected_validity, message);
631
632 *expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
633 }
634 else if (item_seq == 12)
635 {
636 /* Method calls don't have to have interface */
637 message = simple_method_call ();
638
639 if (!dbus_message_set_interface (message, NULL))
640 _dbus_assert_not_reached ("oom");
641
642 generate_from_message (data, expected_validity, message);
643
644 *expected_validity = DBUS_VALID;
645 }
646 else if (item_seq == 13)
647 {
648 /* Signals require an interface */
649 message = simple_signal ();
650
651 if (!dbus_message_set_interface (message, NULL))
652 _dbus_assert_not_reached ("oom");
653
654 generate_from_message (data, expected_validity, message);
655
656 *expected_validity = DBUS_INVALID_MISSING_INTERFACE;
657 }
658 else if (item_seq == 14)
659 {
660 message = simple_method_return ();
661
662 if (!_dbus_header_delete_field (&message->header, DBUS_HEADER_FIELD_REPLY_SERIAL))
663 _dbus_assert_not_reached ("oom");
664
665 generate_from_message (data, expected_validity, message);
666
667 *expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
668 }
669 else if (item_seq == 15)
670 {
671 message = simple_error ();
672
673 if (!dbus_message_set_error_name (message, NULL))
674 _dbus_assert_not_reached ("oom");
675
676 generate_from_message (data, expected_validity, message);
677
678 *expected_validity = DBUS_INVALID_MISSING_ERROR_NAME;
679 }
680 else if (item_seq == 16)
681 {
682 char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*4+10];
683 const char *v_STRING;
684 int i;
685 int n_begins;
686
687 message = simple_method_call ();
688 if (!dbus_message_append_args (message,
689 DBUS_TYPE_INT32, &v_INT32,
690 DBUS_TYPE_INT32, &v_INT32,
691 DBUS_TYPE_INT32, &v_INT32,
692 DBUS_TYPE_INVALID))
693 _dbus_assert_not_reached ("oom");
694
695 i = 0;
696 while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*3 + 3))
697 {
698 long_sig[i] = DBUS_TYPE_ARRAY;
699 ++i;
700 long_sig[i] = DBUS_DICT_ENTRY_BEGIN_CHAR;
701 ++i;
702 long_sig[i] = DBUS_TYPE_INT32;
703 ++i;
704 }
705 n_begins = i / 3;
706
707 long_sig[i] = DBUS_TYPE_INT32;
708 ++i;
709
710 while (n_begins > 0)
711 {
712 long_sig[i] = DBUS_DICT_ENTRY_END_CHAR;
713 ++i;
714 n_begins -= 1;
715 }
716 long_sig[i] = DBUS_TYPE_INVALID;
717
718 v_STRING = long_sig;
719 if (!_dbus_header_set_field_basic (&message->header,
720 DBUS_HEADER_FIELD_SIGNATURE,
721 DBUS_TYPE_SIGNATURE,
722 &v_STRING))
723 _dbus_assert_not_reached ("oom");
724
725 _dbus_header_get_field_raw (&message->header,
726 DBUS_HEADER_FIELD_SIGNATURE,
727 NULL, &pos);
728 generate_from_message (data, expected_validity, message);
729
730 *expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;
731 }
732 else if (item_seq == 17)
733 {
734 message = simple_method_call ();
735 if (!dbus_message_append_args (message,
736 DBUS_TYPE_INT32, &v_INT32,
737 DBUS_TYPE_INT32, &v_INT32,
738 DBUS_TYPE_INT32, &v_INT32,
739 DBUS_TYPE_INVALID))
740 _dbus_assert_not_reached ("oom");
741
742 _dbus_header_get_field_raw (&message->header,
743 DBUS_HEADER_FIELD_SIGNATURE,
744 NULL, &pos);
745 generate_from_message (data, expected_validity, message);
746
747 _dbus_string_set_byte (data, pos + 1, DBUS_TYPE_ARRAY);
748 _dbus_string_set_byte (data, pos + 2, DBUS_DICT_ENTRY_BEGIN_CHAR);
749
750 *expected_validity = DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;
751 }
752 else if (item_seq == 18)
753 {
754 message = simple_method_call ();
755 if (!dbus_message_append_args (message,
756 DBUS_TYPE_INT32, &v_INT32,
757 DBUS_TYPE_INT32, &v_INT32,
758 DBUS_TYPE_INT32, &v_INT32,
759 DBUS_TYPE_INVALID))
760 _dbus_assert_not_reached ("oom");
761
762 _dbus_header_get_field_raw (&message->header,
763 DBUS_HEADER_FIELD_SIGNATURE,
764 NULL, &pos);
765 generate_from_message (data, expected_validity, message);
766
767 _dbus_string_set_byte (data, pos + 1, DBUS_DICT_ENTRY_END_CHAR);
768
769 *expected_validity = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;
770 }
771 else if (item_seq == 19)
772 {
773 message = simple_method_call ();
774 if (!dbus_message_append_args (message,
775 DBUS_TYPE_INT32, &v_INT32,
776 DBUS_TYPE_INT32, &v_INT32,
777 DBUS_TYPE_INT32, &v_INT32,
778 DBUS_TYPE_INVALID))
779 _dbus_assert_not_reached ("oom");
780
781 _dbus_header_get_field_raw (&message->header,
782 DBUS_HEADER_FIELD_SIGNATURE,
783 NULL, &pos);
784 generate_from_message (data, expected_validity, message);
785
786 _dbus_string_set_byte (data, pos + 1, DBUS_TYPE_ARRAY);
787 _dbus_string_set_byte (data, pos + 2, DBUS_DICT_ENTRY_BEGIN_CHAR);
788 _dbus_string_set_byte (data, pos + 3, DBUS_DICT_ENTRY_END_CHAR);
789
790 *expected_validity = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
791 }
792 else if (item_seq == 20)
793 {
794 /* 64 levels of nesting is OK */
795 message = message_with_nesting_levels(64);
796
797 generate_from_message (data, expected_validity, message);
798
799 *expected_validity = DBUS_VALID;
800 }
801 else if (item_seq == 21)
802 {
803 /* 65 levels of nesting is not OK */
804 message = message_with_nesting_levels(65);
805
806 generate_from_message (data, expected_validity, message);
807
808 *expected_validity = DBUS_INVALID_NESTED_TOO_DEEPLY;
809 }
810 else
811 {
812 return FALSE;
813 }
814
815 if (message)
816 dbus_message_unref (message);
817
818 iter_next (iter);
819 return TRUE;
820 }
821
822 static dbus_bool_t
823 generate_wrong_length (DBusMessageDataIter *iter,
824 DBusString *data,
825 DBusValidity *expected_validity)
826 {
827 int lengths[] = { -42, -17, -16, -15, -9, -8, -7, -6, -5, -4, -3, -2, -1,
828 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 30 };
829 int adjust;
830 int len_seq;
831
832 restart:
833 len_seq = iter_get_sequence (iter);
834 if (len_seq == _DBUS_N_ELEMENTS (lengths))
835 return FALSE;
836
837 _dbus_assert (len_seq < _DBUS_N_ELEMENTS (lengths));
838
839 iter_recurse (iter);
840 if (!generate_many_bodies (iter, data, expected_validity))
841 {
842 iter_set_sequence (iter, 0); /* reset to first body */
843 iter_unrecurse (iter);
844 iter_next (iter); /* next length adjustment */
845 goto restart;
846 }
847 iter_unrecurse (iter);
848
849 adjust = lengths[len_seq];
850
851 if (adjust < 0)
852 {
853 if ((_dbus_string_get_length (data) + adjust) < DBUS_MINIMUM_HEADER_SIZE)
854 _dbus_string_set_length (data, DBUS_MINIMUM_HEADER_SIZE);
855 else
856 _dbus_string_shorten (data, - adjust);
857 *expected_validity = DBUS_INVALID_FOR_UNKNOWN_REASON;
858 }
859 else
860 {
861 if (!_dbus_string_lengthen (data, adjust))
862 _dbus_assert_not_reached ("oom");
863 *expected_validity = DBUS_INVALID_TOO_MUCH_DATA;
864 }
865
866 /* Fixup lengths */
867 {
868 int old_body_len;
869 int new_body_len;
870 int byte_order;
871
872 _dbus_assert (_dbus_string_get_length (data) >= DBUS_MINIMUM_HEADER_SIZE);
873
874 byte_order = _dbus_string_get_byte (data, BYTE_ORDER_OFFSET);
875 old_body_len = _dbus_marshal_read_uint32 (data,
876 BODY_LENGTH_OFFSET,
877 byte_order,
878 NULL);
879 _dbus_assert (old_body_len < _dbus_string_get_length (data));
880 new_body_len = old_body_len + adjust;
881 if (new_body_len < 0)
882 {
883 new_body_len = 0;
884 /* we just munged the header, and aren't sure how */
885 *expected_validity = DBUS_VALIDITY_UNKNOWN;
886 }
887
888 _dbus_verbose ("changing body len from %u to %u by adjust %d\n",
889 old_body_len, new_body_len, adjust);
890
891 _dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
892 new_body_len,
893 byte_order);
894 }
895
896 return TRUE;
897 }
898
899 static dbus_bool_t
900 generate_byte_changed (DBusMessageDataIter *iter,
901 DBusString *data,
902 DBusValidity *expected_validity)
903 {
904 int byte_seq;
905 int v_BYTE;
906
907 /* This is a little convoluted to make the bodies the
908 * outer loop and each byte of each body the inner
909 * loop
910 */
911
912 restart:
913 if (!generate_many_bodies (iter, data, expected_validity))
914 return FALSE;
915
916 iter_recurse (iter);
917 byte_seq = iter_get_sequence (iter);
918 iter_next (iter);
919 iter_unrecurse (iter);
920
921 if (byte_seq == _dbus_string_get_length (data))
922 {
923 _dbus_string_set_length (data, 0);
924 /* reset byte count */
925 iter_recurse (iter);
926 iter_set_sequence (iter, 0);
927 iter_unrecurse (iter);
928 goto restart;
929 }
930 else
931 {
932 /* Undo the "next" in generate_many_bodies */
933 iter_set_sequence (iter, iter_get_sequence (iter) - 1);
934 }
935
936 _dbus_assert (byte_seq < _dbus_string_get_length (data));
937 v_BYTE = _dbus_string_get_byte (data, byte_seq);
938 v_BYTE += byte_seq; /* arbitrary but deterministic change to the byte */
939 _dbus_string_set_byte (data, byte_seq, v_BYTE);
940 *expected_validity = DBUS_VALIDITY_UNKNOWN;
941
942 return TRUE;
943 }
944
945 #if 0
946 /* This is really expensive and doesn't add too much coverage */
947
948 static dbus_bool_t
949 find_next_typecode (DBusMessageDataIter *iter,
950 DBusString *data,
951 DBusValidity *expected_validity)
952 {
953 int body_seq;
954 int byte_seq;
955 int base_depth;
956
957 base_depth = iter->depth;
958
959 restart:
960 _dbus_assert (iter->depth == (base_depth + 0));
961 _dbus_string_set_length (data, 0);
962
963 body_seq = iter_get_sequence (iter);
964
965 if (!generate_many_bodies (iter, data, expected_validity))
966 return FALSE;
967 /* Undo the "next" in generate_many_bodies */
968 iter_set_sequence (iter, body_seq);
969
970 iter_recurse (iter);
971 while (TRUE)
972 {
973 _dbus_assert (iter->depth == (base_depth + 1));
974
975 byte_seq = iter_get_sequence (iter);
976
977 _dbus_assert (byte_seq <= _dbus_string_get_length (data));
978
979 if (byte_seq == _dbus_string_get_length (data))
980 {
981 /* reset byte count */
982 iter_set_sequence (iter, 0);
983 iter_unrecurse (iter);
984 _dbus_assert (iter->depth == (base_depth + 0));
985 iter_next (iter); /* go to the next body */
986 goto restart;
987 }
988
989 _dbus_assert (byte_seq < _dbus_string_get_length (data));
990
991 if (dbus_type_is_valid (_dbus_string_get_byte (data, byte_seq)))
992 break;
993 else
994 iter_next (iter);
995 }
996
997 _dbus_assert (byte_seq == iter_get_sequence (iter));
998 _dbus_assert (byte_seq < _dbus_string_get_length (data));
999
1000 iter_unrecurse (iter);
1001
1002 _dbus_assert (iter->depth == (base_depth + 0));
1003
1004 return TRUE;
1005 }
1006
1007 static const int typecodes[] = {
1008 DBUS_TYPE_INVALID,
1009 DBUS_TYPE_BYTE,
1010 DBUS_TYPE_BOOLEAN,
1011 DBUS_TYPE_INT16,
1012 DBUS_TYPE_UINT16,
1013 DBUS_TYPE_INT32,
1014 DBUS_TYPE_UINT32,
1015 DBUS_TYPE_INT64,
1016 DBUS_TYPE_UINT64,
1017 DBUS_TYPE_DOUBLE,
1018 DBUS_TYPE_STRING,
1019 DBUS_TYPE_OBJECT_PATH,
1020 DBUS_TYPE_SIGNATURE,
1021 DBUS_TYPE_ARRAY,
1022 DBUS_TYPE_VARIANT,
1023 DBUS_STRUCT_BEGIN_CHAR,
1024 DBUS_STRUCT_END_CHAR,
1025 DBUS_DICT_ENTRY_BEGIN_CHAR,
1026 DBUS_DICT_ENTRY_END_CHAR,
1027 DBUS_TYPE_UNIX_FD,
1028 255 /* random invalid typecode */
1029 };
1030
1031 static dbus_bool_t
1032 generate_typecode_changed (DBusMessageDataIter *iter,
1033 DBusString *data,
1034 DBusValidity *expected_validity)
1035 {
1036 int byte_seq;
1037 int typecode_seq;
1038 int base_depth;
1039
1040 base_depth = iter->depth;
1041
1042 restart:
1043 _dbus_assert (iter->depth == (base_depth + 0));
1044 _dbus_string_set_length (data, 0);
1045
1046 if (!find_next_typecode (iter, data, expected_validity))
1047 return FALSE;
1048
1049 iter_recurse (iter);
1050 byte_seq = iter_get_sequence (iter);
1051
1052 _dbus_assert (byte_seq < _dbus_string_get_length (data));
1053
1054 iter_recurse (iter);
1055 typecode_seq = iter_get_sequence (iter);
1056 iter_next (iter);
1057
1058 _dbus_assert (typecode_seq <= _DBUS_N_ELEMENTS (typecodes));
1059
1060 if (typecode_seq == _DBUS_N_ELEMENTS (typecodes))
1061 {
1062 _dbus_assert (iter->depth == (base_depth + 2));
1063 iter_set_sequence (iter, 0); /* reset typecode sequence */
1064 iter_unrecurse (iter);
1065 _dbus_assert (iter->depth == (base_depth + 1));
1066 iter_next (iter); /* go to the next byte_seq */
1067 iter_unrecurse (iter);
1068 _dbus_assert (iter->depth == (base_depth + 0));
1069 goto restart;
1070 }
1071
1072 _dbus_assert (iter->depth == (base_depth + 2));
1073 iter_unrecurse (iter);
1074 _dbus_assert (iter->depth == (base_depth + 1));
1075 iter_unrecurse (iter);
1076 _dbus_assert (iter->depth == (base_depth + 0));
1077
1078 #if 0
1079 printf ("Changing byte %d in message %d to %c\n",
1080 byte_seq, iter_get_sequence (iter), typecodes[typecode_seq]);
1081 #endif
1082
1083 _dbus_string_set_byte (data, byte_seq, typecodes[typecode_seq]);
1084 *expected_validity = DBUS_VALIDITY_UNKNOWN;
1085 return TRUE;
1086 }
1087 #endif
1088
1089 typedef struct
1090 {
1091 ChangeType type;
1092 dbus_uint32_t value; /* cast to signed for adjusts */
1093 } UIntChange;
1094
1095 static const UIntChange uint32_changes[] = {
1096 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -1 },
1097 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -2 },
1098 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) -3 },
1099 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 1 },
1100 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 2 },
1101 { CHANGE_TYPE_ADJUST, (dbus_uint32_t) 3 },
1102 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX },
1103 { CHANGE_TYPE_ABSOLUTE, 0 },
1104 { CHANGE_TYPE_ABSOLUTE, 1 },
1105 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 1 },
1106 { CHANGE_TYPE_ABSOLUTE, _DBUS_UINT32_MAX - 5 }
1107 };
1108
1109 static dbus_bool_t
1110 generate_uint32_changed (DBusMessageDataIter *iter,
1111 DBusString *data,
1112 DBusValidity *expected_validity)
1113 {
1114 int body_seq;
1115 int byte_seq;
1116 int change_seq;
1117 dbus_uint32_t v_UINT32;
1118 int byte_order;
1119 const UIntChange *change;
1120 int base_depth;
1121
1122 /* Outer loop is each body, next loop is each change,
1123 * inner loop is each change location
1124 */
1125
1126 base_depth = iter->depth;
1127
1128 next_body:
1129 _dbus_assert (iter->depth == (base_depth + 0));
1130 _dbus_string_set_length (data, 0);
1131 body_seq = iter_get_sequence (iter);
1132
1133 if (!generate_many_bodies (iter, data, expected_validity))
1134 return FALSE;
1135
1136 _dbus_assert (iter->depth == (base_depth + 0));
1137
1138 iter_set_sequence (iter, body_seq); /* undo the "next" from generate_many_bodies */
1139 iter_recurse (iter);
1140 next_change:
1141 _dbus_assert (iter->depth == (base_depth + 1));
1142 change_seq = iter_get_sequence (iter);
1143
1144 if (change_seq == _DBUS_N_ELEMENTS (uint32_changes))
1145 {
1146 /* Reset change count */
1147 iter_set_sequence (iter, 0);
1148 iter_unrecurse (iter);
1149 iter_next (iter);
1150 goto next_body;
1151 }
1152
1153 _dbus_assert (iter->depth == (base_depth + 1));
1154
1155 iter_recurse (iter);
1156 _dbus_assert (iter->depth == (base_depth + 2));
1157 byte_seq = iter_get_sequence (iter);
1158 /* skip 4 bytes at a time */
1159 iter_next (iter);
1160 iter_next (iter);
1161 iter_next (iter);
1162 iter_next (iter);
1163 iter_unrecurse (iter);
1164
1165 _dbus_assert (_DBUS_ALIGN_VALUE (byte_seq, 4) == (unsigned) byte_seq);
1166 if (byte_seq >= (_dbus_string_get_length (data) - 4))
1167 {
1168 /* reset byte count */
1169 _dbus_assert (iter->depth == (base_depth + 1));
1170 iter_recurse (iter);
1171 _dbus_assert (iter->depth == (base_depth + 2));
1172 iter_set_sequence (iter, 0);
1173 iter_unrecurse (iter);
1174 _dbus_assert (iter->depth == (base_depth + 1));
1175 iter_next (iter);
1176 goto next_change;
1177 }
1178
1179 _dbus_assert (byte_seq <= (_dbus_string_get_length (data) - 4));
1180
1181 byte_order = _dbus_string_get_byte (data, BYTE_ORDER_OFFSET);
1182
1183 v_UINT32 = _dbus_marshal_read_uint32 (data, byte_seq, byte_order, NULL);
1184
1185 change = &uint32_changes[change_seq];
1186
1187 if (change->type == CHANGE_TYPE_ADJUST)
1188 {
1189 v_UINT32 += (int) change->value;
1190 }
1191 else
1192 {
1193 v_UINT32 = change->value;
1194 }
1195
1196 #if 0
1197 printf ("body %d change %d pos %d ",
1198 body_seq, change_seq, byte_seq);
1199
1200 if (change->type == CHANGE_TYPE_ADJUST)
1201 printf ("adjust by %d", (int) change->value);
1202 else
1203 printf ("set to %u", change->value);
1204
1205 printf (" \t%u -> %u\n",
1206 _dbus_marshal_read_uint32 (data, byte_seq, byte_order, NULL),
1207 v_UINT32);
1208 #endif
1209
1210 _dbus_marshal_set_uint32 (data, byte_seq, v_UINT32, byte_order);
1211 *expected_validity = DBUS_VALIDITY_UNKNOWN;
1212
1213 _dbus_assert (iter->depth == (base_depth + 1));
1214 iter_unrecurse (iter);
1215 _dbus_assert (iter->depth == (base_depth + 0));
1216
1217 return TRUE;
1218 }
1219
1220 typedef struct
1221 {
1222 const char *name;
1223 DBusMessageGeneratorFunc func;
1224 } DBusMessageGenerator;
1225
1226 static const DBusMessageGenerator generators[] = {
1227 { "trivial example of each message type", generate_trivial },
1228 { "assorted arguments", generate_many_bodies },
1229 { "assorted special cases", generate_special },
1230 { "each uint32 modified", generate_uint32_changed },
1231 { "wrong body lengths", generate_wrong_length },
1232 { "each byte modified", generate_byte_changed },
1233 #if 0
1234 /* This is really expensive and doesn't add too much coverage */
1235 { "change each typecode", generate_typecode_changed }
1236 #endif
1237 };
1238
1239 void
1240 _dbus_message_data_free (DBusMessageData *data)
1241 {
1242 _dbus_string_free (&data->data);
1243 }
1244
1245 void
1246 _dbus_message_data_iter_init (DBusMessageDataIter *iter)
1247 {
1248 int i;
1249
1250 iter->depth = 0;
1251 i = 0;
1252 while (i < _DBUS_MESSAGE_DATA_MAX_NESTING)
1253 {
1254 iter->sequence_nos[i] = 0;
1255 ++i;
1256 }
1257 iter->count = 0;
1258 }
1259
1260 dbus_bool_t
1261 _dbus_message_data_iter_get_and_next (DBusMessageDataIter *iter,
1262 DBusMessageData *data)
1263 {
1264 DBusMessageGeneratorFunc func;
1265 int generator;
1266
1267 restart:
1268 generator = iter_get_sequence (iter);
1269
1270 if (generator == _DBUS_N_ELEMENTS (generators))
1271 return FALSE;
1272
1273 iter_recurse (iter);
1274
1275 if (iter_first_in_series (iter))
1276 {
1277 printf (" testing message loading: %s ", generators[generator].name);
1278 fflush (stdout);
1279 }
1280
1281 func = generators[generator].func;
1282
1283 if (!_dbus_string_init (&data->data))
1284 _dbus_assert_not_reached ("oom");
1285
1286 if ((*func)(iter, &data->data, &data->expected_validity))
1287 ;
1288 else
1289 {
1290 iter_set_sequence (iter, 0);
1291 iter_unrecurse (iter);
1292 iter_next (iter); /* next generator */
1293 _dbus_string_free (&data->data);
1294 printf ("%d test loads cumulative\n", iter->count);
1295 goto restart;
1296 }
1297 iter_unrecurse (iter);
1298
1299 iter->count += 1;
1300 return TRUE;
1301 }
1302
1303 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */
1304
1305 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */
dbus_uint32_t
unsigned int dbus_uint32_t
A 32-bit unsigned integer on all platforms.
Definition: dbus-arch-deps.h:43
DBUS_TYPE_UINT16
#define DBUS_TYPE_UINT16
Type code marking a 16-bit unsigned integer.
Definition: dbus-protocol.h:78
dbus_message_lock
void dbus_message_lock(DBusMessage *message)
Locks a message.
Definition: dbus-message.c:407
NULL
#define NULL
A null pointer, defined appropriately for C or C++.
DBUS_INVALID_TOO_MUCH_DATA
trailing junk makes it invalid
Definition: dbus-marshal-validate.h:70
_dbus_marshal_set_uint32
void _dbus_marshal_set_uint32(DBusString *str, int pos, dbus_uint32_t value, int byte_order)
Sets the 4 bytes at the given offset to a marshaled unsigned integer, replacing anything found there ...
Definition: dbus-marshal-basic.c:253
_dbus_string_lengthen
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
Definition: dbus-string.c:760
dbus_free
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:701
dbus_message_set_interface
dbus_bool_t dbus_message_set_interface(DBusMessage *message, const char *iface)
Sets the interface this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the interface...
Definition: dbus-message.c:3271
dbus_new
#define dbus_new(type, count)
Safe macro for using dbus_malloc().
Definition: dbus-memory.h:58
DBUS_HEADER_FIELD_SIGNATURE
#define DBUS_HEADER_FIELD_SIGNATURE
Header field code for the type signature of a message.
Definition: dbus-protocol.h:297
dbus_message_iter_close_container
dbus_bool_t dbus_message_iter_close_container(DBusMessageIter *iter, DBusMessageIter *sub)
Closes a container-typed value appended to the message; may write out more information to the message...
Definition: dbus-message.c:2991
DBUS_MAXIMUM_TYPE_RECURSION_DEPTH
#define DBUS_MAXIMUM_TYPE_RECURSION_DEPTH
Depth of recursion in the type tree.
Definition: dbus-protocol.h:227
DBUS_TYPE_STRING
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
Definition: dbus-protocol.h:102
DBusMessage::body
DBusString body
Body network data.
Definition: dbus-message-private.h:105
_dbus_assert
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
Definition: dbus-internals.h:148
dbus_message_new
DBusMessage * dbus_message_new(int message_type)
Constructs a new message of the given message type.
Definition: dbus-message.c:1312
dbus_message_iter_init_append
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
Definition: dbus-message.c:2494
DBUS_TYPE_BYTE
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer.
Definition: dbus-protocol.h:66
DBUS_INTERFACE_LOCAL
#define DBUS_INTERFACE_LOCAL
This is a special interface whose methods can only be invoked by the local implementation (messages f...
Definition: dbus-shared.h:105
DBusHeader::data
DBusString data
Header network data, stored separately from body so we can independently realloc it.
Definition: dbus-marshal-header.h:49
DBUS_MESSAGE_TYPE_ERROR
#define DBUS_MESSAGE_TYPE_ERROR
Message type of an error reply message, see dbus_message_get_type()
Definition: dbus-protocol.h:238
_dbus_string_init
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
DBUS_MESSAGE_TYPE_METHOD_RETURN
#define DBUS_MESSAGE_TYPE_METHOD_RETURN
Message type of a method return message, see dbus_message_get_type()
Definition: dbus-protocol.h:236
dbus_message_new_signal
DBusMessage * dbus_message_new_signal(const char *path, const char *iface, const char *name)
Constructs a new message representing a signal emission.
Definition: dbus-message.c:1447
_dbus_string_shorten
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
Definition: dbus-string.c:780
_dbus_string_copy
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that&#39;s copied to the d...
Definition: dbus-string.c:1283
DBUS_DICT_ENTRY_BEGIN_CHAR
#define DBUS_DICT_ENTRY_BEGIN_CHAR
Code marking the start of a dict entry type in a type signature.
Definition: dbus-protocol.h:164
DBusValidity
DBusValidity
This is primarily used in unit testing, so we can verify that each invalid message is invalid for the...
Definition: dbus-marshal-validate.h:49
DBUS_STRUCT_END_CHAR
#define DBUS_STRUCT_END_CHAR
Code marking the end of a struct type in a type signature.
Definition: dbus-protocol.h:160
DBusMessageIter
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:51
DBUS_TYPE_DOUBLE
#define DBUS_TYPE_DOUBLE
Type code marking an 8-byte double in IEEE 754 format.
Definition: dbus-protocol.h:98
DBUS_PATH_LOCAL
#define DBUS_PATH_LOCAL
The object path used in local/in-process-generated messages.
Definition: dbus-shared.h:82
DBUS_TYPE_ARRAY
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
Definition: dbus-protocol.h:120
DBUS_TYPE_INT64
#define DBUS_TYPE_INT64
Type code marking a 64-bit signed integer.
Definition: dbus-protocol.h:90
dbus_message_set_error_name
dbus_bool_t dbus_message_set_error_name(DBusMessage *message, const char *error_name)
Sets the name of the error (DBUS_MESSAGE_TYPE_ERROR).
Definition: dbus-message.c:3444
BYTE_ORDER_OFFSET
#define BYTE_ORDER_OFFSET
Offset to byte order from start of header.
Definition: dbus-marshal-header.c:53
TYPE_OFFSET
#define TYPE_OFFSET
Offset to type from start of header.
Definition: dbus-marshal-header.c:55
DBusMessage
Internals of DBusMessage.
Definition: dbus-message-private.h:99
_dbus_string_move
dbus_bool_t _dbus_string_move(DBusString *source, int start, DBusString *dest, int insert_at)
Moves the end of one string into another string.
Definition: dbus-string.c:1259
BODY_LENGTH_OFFSET
#define BODY_LENGTH_OFFSET
Offset to body length from start of header.
Definition: dbus-marshal-header.c:61
DBusString
Definition: dbus-string.h:42
DBUS_MINIMUM_HEADER_SIZE
#define DBUS_MINIMUM_HEADER_SIZE
The smallest header size that can occur.
Definition: dbus-protocol.h:346
dbus_bool_t
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
DBusMessage::header
DBusHeader header
Header network data and associated cache.
Definition: dbus-message-private.h:103
_DBUS_UINT32_MAX
#define _DBUS_UINT32_MAX
Maximum value of type "uint32".
Definition: dbus-internals.h:260
DBUS_TYPE_INT32_AS_STRING
#define DBUS_TYPE_INT32_AS_STRING
DBUS_TYPE_INT32 as a string literal instead of a int literal
Definition: dbus-protocol.h:84
DBUS_TYPE_VARIANT_AS_STRING
#define DBUS_TYPE_VARIANT_AS_STRING
DBUS_TYPE_VARIANT as a string literal instead of a int literal
Definition: dbus-protocol.h:126
dbus_message_set_path
dbus_bool_t dbus_message_set_path(DBusMessage *message, const char *object_path)
Sets the object path this message is being sent to (for DBUS_MESSAGE_TYPE_METHOD_CALL) or the one a s...
Definition: dbus-message.c:3140
DBUS_TYPE_INT32
#define DBUS_TYPE_INT32
Type code marking a 32-bit signed integer.
Definition: dbus-protocol.h:82
DBUS_TYPE_SIGNATURE
#define DBUS_TYPE_SIGNATURE
Type code marking a D-Bus type signature.
Definition: dbus-protocol.h:110
dbus_message_append_args
dbus_bool_t dbus_message_append_args(DBusMessage *message, int first_arg_type,...)
Appends fields to a message given a variable argument list.
Definition: dbus-message.c:1815
DBUS_TYPE_UINT64
#define DBUS_TYPE_UINT64
Type code marking a 64-bit unsigned integer.
Definition: dbus-protocol.h:94
DBUS_STRUCT_BEGIN_CHAR
#define DBUS_STRUCT_BEGIN_CHAR
Code marking the start of a struct type in a type signature.
Definition: dbus-protocol.h:156
DBUS_TYPE_VARIANT
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type.
Definition: dbus-protocol.h:124
_DBUS_N_ELEMENTS
#define _DBUS_N_ELEMENTS(array)
Computes the number of elements in a fixed-size array using sizeof().
Definition: dbus-internals.h:189
DBUS_TYPE_UINT32
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
Definition: dbus-protocol.h:86
DBUS_VALID
the data is valid
Definition: dbus-marshal-validate.h:56
dbus_message_new_method_call
DBusMessage * dbus_message_new_method_call(const char *destination, const char *path, const char *iface, const char *method)
Constructs a new message to invoke a method on a remote object.
Definition: dbus-message.c:1356
_dbus_header_delete_field
dbus_bool_t _dbus_header_delete_field(DBusHeader *header, int field)
Deletes a field, if it exists.
Definition: dbus-marshal-header.c:1416
DBUS_MESSAGE_TYPE_INVALID
#define DBUS_MESSAGE_TYPE_INVALID
This value is never a valid message type, see dbus_message_get_type()
Definition: dbus-protocol.h:232
_dbus_string_free
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
TRUE
#define TRUE
Expands to "1".
_dbus_header_set_field_basic
dbus_bool_t _dbus_header_set_field_basic(DBusHeader *header, int field, int type, const void *value)
Sets the value of a field with basic type.
Definition: dbus-marshal-header.c:1273
_dbus_assert_not_reached
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
Definition: dbus-internals.h:159
DBUS_HEADER_FIELD_SENDER
#define DBUS_HEADER_FIELD_SENDER
Header field code for the sender of a message; usually initialized by the message bus...
Definition: dbus-protocol.h:293
DBUS_TYPE_OBJECT_PATH
#define DBUS_TYPE_OBJECT_PATH
Type code marking a D-Bus object path.
Definition: dbus-protocol.h:106
DBUS_TYPE_UNIX_FD
#define DBUS_TYPE_UNIX_FD
Type code marking a unix file descriptor.
Definition: dbus-protocol.h:114
DBUS_TYPE_INVALID
#define DBUS_TYPE_INVALID
Type code that is never equal to a legitimate type code.
Definition: dbus-protocol.h:60
dbus_message_set_reply_serial
dbus_bool_t dbus_message_set_reply_serial(DBusMessage *message, dbus_uint32_t reply_serial)
Sets the reply serial of a message (the serial of the message this is a reply to).
Definition: dbus-message.c:1166
DBUS_TYPE_INT16
#define DBUS_TYPE_INT16
Type code marking a 16-bit signed integer.
Definition: dbus-protocol.h:74
DBUS_TYPE_BOOLEAN
#define DBUS_TYPE_BOOLEAN
Type code marking a boolean.
Definition: dbus-protocol.h:70
FIELDS_ARRAY_LENGTH_OFFSET
#define FIELDS_ARRAY_LENGTH_OFFSET
Offset to fields array length from start of header.
Definition: dbus-marshal-header.c:65
_dbus_header_get_byte_order
char _dbus_header_get_byte_order(const DBusHeader *header)
Returns the header&#39;s byte order.
Definition: dbus-marshal-header.c:174
dbus_message_iter_open_container
dbus_bool_t dbus_message_iter_open_container(DBusMessageIter *iter, int type, const char *contained_signature, DBusMessageIter *sub)
Appends a container-typed value to the message; you are required to append the contents of the contai...
Definition: dbus-message.c:2922
_dbus_header_get_field_raw
dbus_bool_t _dbus_header_get_field_raw(DBusHeader *header, int field, const DBusString **str, int *pos)
Gets the raw marshaled data for a field.
Definition: dbus-marshal-header.c:1392
dbus_message_iter_append_basic
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
Definition: dbus-message.c:2729
FALSE
#define FALSE
Expands to "0".
DBUS_HEADER_FIELD_REPLY_SERIAL
#define DBUS_HEADER_FIELD_REPLY_SERIAL
Header field code for a reply serial, used to match a DBUS_MESSAGE_TYPE_METHOD_RETURN message with th...
Definition: dbus-protocol.h:284
DBUS_DICT_ENTRY_END_CHAR
#define DBUS_DICT_ENTRY_END_CHAR
Code marking the end of a dict entry type in a type signature.
Definition: dbus-protocol.h:168
_dbus_string_set_length
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
Definition: dbus-string.c:802
dbus_int32_t
int dbus_int32_t
A 32-bit signed integer on all platforms.
Definition: dbus-arch-deps.h:42
dbus_message_unref
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
Definition: dbus-message.c:1713
dbus_type_is_valid
dbus_bool_t dbus_type_is_valid(int typecode)
Return TRUE if the argument is a valid typecode.
Definition: dbus-signature.c:383
dbus_message_set_serial
void dbus_message_set_serial(DBusMessage *message, dbus_uint32_t serial)
Sets the serial number of a message.
Definition: dbus-message.c:277
DBUS_MAXIMUM_MESSAGE_LENGTH
#define DBUS_MAXIMUM_MESSAGE_LENGTH
The maximum total message size including header and body; similar rationale to max array size...
Definition: dbus-protocol.h:210
_dbus_marshal_read_uint32
dbus_uint32_t _dbus_marshal_read_uint32(const DBusString *str, int pos, int byte_order, int *new_pos)
Convenience function to demarshal a 32 bit unsigned integer.
Definition: dbus-marshal-basic.c:454