← Back to branch summary

~jamesodhunt/ubuntu/raring/upstart/1.6

« back to all changes in this revision

Viewing changes to nih-dbus-tool/tests/expected/test_node_object_functions_structure.c

  • Committer: Scott James Remnant
  • Date: 2010-02-04 23:39:59 UTC
  • mfrom: (1182.1.45 upstart)
  • mto: This revision was merged to the branch mainline in revision 1250.
  • Revision ID: scott@netsplit.com-20100204233959-7kajqjnaoh7208ob
Tags: upstream-0.6.5
Import upstream version 0.6.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
nih-dbus-tool/tests/expected/test_node_object_functions_structure.c
1
 
static DBusHandlerResult
2
 
my_com_netsplit_Nih_Test_Search_method (NihDBusObject * object,
3
 
                                        NihDBusMessage *message)
4
 
{
5
 
        DBusMessageIter   iter;
6
 
        DBusMessage *     reply;
7
 
        MyTestSearchItem *item;
8
 
        DBusMessageIter   item_iter;
9
 
        const char *      item_item0_dbus;
10
 
        char *            item_item0;
11
 
        uint32_t          item_item1;
12
 
 
13
 
        nih_assert (object != NULL);
14
 
        nih_assert (message != NULL);
15
 
 
16
 
        /* Iterate the arguments to the message and demarshal into arguments
17
 
         * for our own function call.
18
 
         */
19
 
        dbus_message_iter_init (message->message, &iter);
20
 
 
21
 
        /* Demarshal a structure from the message */
22
 
        if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRUCT) {
23
 
                reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
24
 
                                                "Invalid arguments to Search method");
25
 
                if (! reply)
26
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
27
 
 
28
 
                if (! dbus_connection_send (message->connection, reply, NULL)) {
29
 
                        dbus_message_unref (reply);
30
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
31
 
                }
32
 
 
33
 
                dbus_message_unref (reply);
34
 
                return DBUS_HANDLER_RESULT_HANDLED;
35
 
        }
36
 
 
37
 
        dbus_message_iter_recurse (&iter, &item_iter);
38
 
 
39
 
        item = nih_new (message, MyTestSearchItem);
40
 
        if (! item) {
41
 
                return DBUS_HANDLER_RESULT_NEED_MEMORY;
42
 
        }
43
 
 
44
 
        /* Demarshal a char * from the message */
45
 
        if (dbus_message_iter_get_arg_type (&item_iter) != DBUS_TYPE_STRING) {
46
 
                nih_free (item);
47
 
                reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
48
 
                                                "Invalid arguments to Search method");
49
 
                if (! reply)
50
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
51
 
 
52
 
                if (! dbus_connection_send (message->connection, reply, NULL)) {
53
 
                        dbus_message_unref (reply);
54
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
55
 
                }
56
 
 
57
 
                dbus_message_unref (reply);
58
 
                return DBUS_HANDLER_RESULT_HANDLED;
59
 
        }
60
 
 
61
 
        dbus_message_iter_get_basic (&item_iter, &item_item0_dbus);
62
 
 
63
 
        item_item0 = nih_strdup (item, item_item0_dbus);
64
 
        if (! item_item0) {
65
 
                nih_free (item);
66
 
                return DBUS_HANDLER_RESULT_NEED_MEMORY;
67
 
        }
68
 
 
69
 
        dbus_message_iter_next (&item_iter);
70
 
 
71
 
        item->item0 = item_item0;
72
 
 
73
 
        /* Demarshal a uint32_t from the message */
74
 
        if (dbus_message_iter_get_arg_type (&item_iter) != DBUS_TYPE_UINT32) {
75
 
                nih_free (item);
76
 
                reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
77
 
                                                "Invalid arguments to Search method");
78
 
                if (! reply)
79
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
80
 
 
81
 
                if (! dbus_connection_send (message->connection, reply, NULL)) {
82
 
                        dbus_message_unref (reply);
83
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
84
 
                }
85
 
 
86
 
                dbus_message_unref (reply);
87
 
                return DBUS_HANDLER_RESULT_HANDLED;
88
 
        }
89
 
 
90
 
        dbus_message_iter_get_basic (&item_iter, &item_item1);
91
 
 
92
 
        dbus_message_iter_next (&item_iter);
93
 
 
94
 
        item->item1 = item_item1;
95
 
 
96
 
        if (dbus_message_iter_get_arg_type (&item_iter) != DBUS_TYPE_INVALID) {
97
 
                nih_free (item);
98
 
                reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
99
 
                                                "Invalid arguments to Search method");
100
 
                if (! reply)
101
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
102
 
 
103
 
                if (! dbus_connection_send (message->connection, reply, NULL)) {
104
 
                        dbus_message_unref (reply);
105
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
106
 
                }
107
 
 
108
 
                dbus_message_unref (reply);
109
 
                return DBUS_HANDLER_RESULT_HANDLED;
110
 
        }
111
 
 
112
 
        dbus_message_iter_next (&iter);
113
 
 
114
 
        if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
115
 
                reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
116
 
                                                "Invalid arguments to Search method");
117
 
                if (! reply)
118
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
119
 
 
120
 
                if (! dbus_connection_send (message->connection, reply, NULL)) {
121
 
                        dbus_message_unref (reply);
122
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
123
 
                }
124
 
 
125
 
                dbus_message_unref (reply);
126
 
                return DBUS_HANDLER_RESULT_HANDLED;
127
 
        }
128
 
 
129
 
        /* Call the handler function */
130
 
        nih_error_push_context ();
131
 
        if (my_test_search (object->data, message, item) < 0) {
132
 
                NihError *err;
133
 
 
134
 
                err = nih_error_get ();
135
 
                if (err->number == ENOMEM) {
136
 
                        nih_free (err);
137
 
                        nih_error_pop_context ();
138
 
 
139
 
                        return DBUS_HANDLER_RESULT_NEED_MEMORY;
140
 
                } else if (err->number == NIH_DBUS_ERROR) {
141
 
                        NihDBusError *dbus_err = (NihDBusError *)err;
142
 
 
143
 
                        reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
144
 
                        nih_free (err);
145
 
                        nih_error_pop_context ();
146
 
 
147
 
                        NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
148
 
 
149
 
                        dbus_message_unref (reply);
150
 
                        return DBUS_HANDLER_RESULT_HANDLED;
151
 
                } else {
152
 
                        reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
153
 
                        nih_free (err);
154
 
                        nih_error_pop_context ();
155
 
 
156
 
                        NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
157
 
 
158
 
                        dbus_message_unref (reply);
159
 
                        return DBUS_HANDLER_RESULT_HANDLED;
160
 
                }
161
 
        }
162
 
        nih_error_pop_context ();
163
 
 
164
 
        return DBUS_HANDLER_RESULT_HANDLED;
165
 
}
166
 
 
167
 
int
168
 
my_test_search_reply (NihDBusMessage *          message,
169
 
                      const MyTestSearchResult *result)
170
 
{
171
 
        DBusMessage *   reply;
172
 
        DBusMessageIter iter;
173
 
        DBusMessageIter result_iter;
174
 
        const char *    result_item0;
175
 
        const char *    result_item1;
176
 
 
177
 
        nih_assert (message != NULL);
178
 
        nih_assert (result != NULL);
179
 
 
180
 
        /* If the sender doesn't care about a reply, don't bother wasting
181
 
         * effort constructing and sending one.
182
 
         */
183
 
        if (dbus_message_get_no_reply (message->message))
184
 
                return 0;
185
 
 
186
 
        /* Construct the reply message. */
187
 
        reply = dbus_message_new_method_return (message->message);
188
 
        if (! reply)
189
 
                return -1;
190
 
 
191
 
        dbus_message_iter_init_append (reply, &iter);
192
 
 
193
 
        /* Marshal a structure onto the message */
194
 
        if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &result_iter)) {
195
 
                dbus_message_unref (reply);
196
 
                return -1;
197
 
        }
198
 
 
199
 
        result_item0 = result->item0;
200
 
 
201
 
        /* Marshal a char * onto the message */
202
 
        if (! dbus_message_iter_append_basic (&result_iter, DBUS_TYPE_STRING, &result_item0)) {
203
 
                dbus_message_iter_abandon_container (&iter, &result_iter);
204
 
                dbus_message_unref (reply);
205
 
                return -1;
206
 
        }
207
 
 
208
 
        result_item1 = result->item1;
209
 
 
210
 
        /* Marshal a char * onto the message */
211
 
        if (! dbus_message_iter_append_basic (&result_iter, DBUS_TYPE_STRING, &result_item1)) {
212
 
                dbus_message_iter_abandon_container (&iter, &result_iter);
213
 
                dbus_message_unref (reply);
214
 
                return -1;
215
 
        }
216
 
 
217
 
        if (! dbus_message_iter_close_container (&iter, &result_iter)) {
218
 
                dbus_message_unref (reply);
219
 
                return -1;
220
 
        }
221
 
 
222
 
        /* Send the reply, appending it to the outgoing queue. */
223
 
        if (! dbus_connection_send (message->connection, reply, NULL)) {
224
 
                dbus_message_unref (reply);
225
 
                return -1;
226
 
        }
227
 
 
228
 
        dbus_message_unref (reply);
229
 
 
230
 
        return 0;
231
 
}
232
 
 
233
 
 
234
 
int
235
 
my_test_emit_new_search (DBusConnection *            connection,
236
 
                         const char *                origin_path,
237
 
                         const MyTestNewSearchQuery *query)
238
 
{
239
 
        DBusMessage *   signal;
240
 
        DBusMessageIter iter;
241
 
        DBusMessageIter query_iter;
242
 
        const char *    query_item0;
243
 
        const char *    query_item1;
244
 
        uint32_t        query_item2;
245
 
 
246
 
        nih_assert (connection != NULL);
247
 
        nih_assert (origin_path != NULL);
248
 
        nih_assert (query != NULL);
249
 
 
250
 
        /* Construct the message. */
251
 
        signal = dbus_message_new_signal (origin_path, "com.netsplit.Nih.Test", "NewSearch");
252
 
        if (! signal)
253
 
                return -1;
254
 
 
255
 
        dbus_message_iter_init_append (signal, &iter);
256
 
 
257
 
        /* Marshal a structure onto the message */
258
 
        if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &query_iter)) {
259
 
                dbus_message_unref (signal);
260
 
                return -1;
261
 
        }
262
 
 
263
 
        query_item0 = query->item0;
264
 
 
265
 
        /* Marshal a char * onto the message */
266
 
        if (! dbus_message_iter_append_basic (&query_iter, DBUS_TYPE_STRING, &query_item0)) {
267
 
                dbus_message_iter_abandon_container (&iter, &query_iter);
268
 
                dbus_message_unref (signal);
269
 
                return -1;
270
 
        }
271
 
 
272
 
        query_item1 = query->item1;
273
 
 
274
 
        /* Marshal a char * onto the message */
275
 
        if (! dbus_message_iter_append_basic (&query_iter, DBUS_TYPE_STRING, &query_item1)) {
276
 
                dbus_message_iter_abandon_container (&iter, &query_iter);
277
 
                dbus_message_unref (signal);
278
 
                return -1;
279
 
        }
280
 
 
281
 
        query_item2 = query->item2;
282
 
 
283
 
        /* Marshal a uint32_t onto the message */
284
 
        if (! dbus_message_iter_append_basic (&query_iter, DBUS_TYPE_UINT32, &query_item2)) {
285
 
                dbus_message_iter_abandon_container (&iter, &query_iter);
286
 
                dbus_message_unref (signal);
287
 
                return -1;
288
 
        }
289
 
 
290
 
        if (! dbus_message_iter_close_container (&iter, &query_iter)) {
291
 
                dbus_message_unref (signal);
292
 
                return -1;
293
 
        }
294
 
 
295
 
        /* Send the signal, appending it to the outgoing queue. */
296
 
        if (! dbus_connection_send (connection, signal, NULL)) {
297
 
                dbus_message_unref (signal);
298
 
                return -1;
299
 
        }
300
 
 
301
 
        dbus_message_unref (signal);
302
 
 
303
 
        return 0;
304
 
}
305
 
 
306
 
 
307
 
static int
308
 
my_com_netsplit_Nih_Test_last_search_get (NihDBusObject *  object,
309
 
                                          NihDBusMessage * message,
310
 
                                          DBusMessageIter *iter)
311
 
{
312
 
        DBusMessageIter   variter;
313
 
        DBusMessageIter   value_iter;
314
 
        const char *      value_item0;
315
 
        uint32_t          value_item1;
316
 
        MyTestLastSearch *value;
317
 
 
318
 
        nih_assert (object != NULL);
319
 
        nih_assert (message != NULL);
320
 
        nih_assert (iter != NULL);
321
 
 
322
 
        /* Call the handler function */
323
 
        if (my_test_get_last_search (object->data, message, &value) < 0)
324
 
                return -1;
325
 
 
326
 
        /* Append a variant onto the message to contain the property value. */
327
 
        if (! dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "(su)", &variter)) {
328
 
                nih_error_raise_no_memory ();
329
 
                return -1;
330
 
        }
331
 
 
332
 
        /* Marshal a structure onto the message */
333
 
        if (! dbus_message_iter_open_container (&variter, DBUS_TYPE_STRUCT, NULL, &value_iter)) {
334
 
                dbus_message_iter_abandon_container (iter, &variter);
335
 
                nih_error_raise_no_memory ();
336
 
                return -1;
337
 
        }
338
 
 
339
 
        value_item0 = value->item0;
340
 
 
341
 
        /* Marshal a char * onto the message */
342
 
        if (! dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_STRING, &value_item0)) {
343
 
                dbus_message_iter_abandon_container (&variter, &value_iter);
344
 
                dbus_message_iter_abandon_container (iter, &variter);
345
 
                nih_error_raise_no_memory ();
346
 
                return -1;
347
 
        }
348
 
 
349
 
        value_item1 = value->item1;
350
 
 
351
 
        /* Marshal a uint32_t onto the message */
352
 
        if (! dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_UINT32, &value_item1)) {
353
 
                dbus_message_iter_abandon_container (&variter, &value_iter);
354
 
                dbus_message_iter_abandon_container (iter, &variter);
355
 
                nih_error_raise_no_memory ();
356
 
                return -1;
357
 
        }
358
 
 
359
 
        if (! dbus_message_iter_close_container (&variter, &value_iter)) {
360
 
                dbus_message_iter_abandon_container (iter, &variter);
361
 
                nih_error_raise_no_memory ();
362
 
                return -1;
363
 
        }
364
 
 
365
 
        /* Finish the variant */
366
 
        if (! dbus_message_iter_close_container (iter, &variter)) {
367
 
                nih_error_raise_no_memory ();
368
 
                return -1;
369
 
        }
370
 
 
371
 
        return 0;
372
 
}
373
 
 
374
 
 
375
 
static int
376
 
my_com_netsplit_Nih_Test_annotation_set (NihDBusObject *  object,
377
 
                                         NihDBusMessage * message,
378
 
                                         DBusMessageIter *iter)
379
 
{
380
 
        DBusMessageIter   variter;
381
 
        DBusMessageIter   value_iter;
382
 
        const char *      value_item0_dbus;
383
 
        char *            value_item0;
384
 
        const char *      value_item1_dbus;
385
 
        char *            value_item1;
386
 
        MyTestAnnotation *value;
387
 
 
388
 
        nih_assert (object != NULL);
389
 
        nih_assert (message != NULL);
390
 
        nih_assert (iter != NULL);
391
 
 
392
 
        /* Recurse into the variant */
393
 
        if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_VARIANT) {
394
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
395
 
                                             "Invalid arguments to annotation property");
396
 
                return -1;
397
 
        }
398
 
 
399
 
        dbus_message_iter_recurse (iter, &variter);
400
 
 
401
 
        /* Demarshal a structure from the message */
402
 
        if (dbus_message_iter_get_arg_type (&variter) != DBUS_TYPE_STRUCT) {
403
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
404
 
                                             "Invalid arguments to annotation property");
405
 
                return -1;
406
 
        }
407
 
 
408
 
        dbus_message_iter_recurse (&variter, &value_iter);
409
 
 
410
 
        value = nih_new (message, MyTestAnnotation);
411
 
        if (! value) {
412
 
                nih_error_raise_no_memory ();
413
 
                return -1;
414
 
        }
415
 
 
416
 
        /* Demarshal a char * from the message */
417
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_STRING) {
418
 
                nih_free (value);
419
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
420
 
                                             "Invalid arguments to annotation property");
421
 
                return -1;
422
 
        }
423
 
 
424
 
        dbus_message_iter_get_basic (&value_iter, &value_item0_dbus);
425
 
 
426
 
        value_item0 = nih_strdup (value, value_item0_dbus);
427
 
        if (! value_item0) {
428
 
                nih_free (value);
429
 
                nih_error_raise_no_memory ();
430
 
                return -1;
431
 
        }
432
 
 
433
 
        dbus_message_iter_next (&value_iter);
434
 
 
435
 
        value->item0 = value_item0;
436
 
 
437
 
        /* Demarshal a char * from the message */
438
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_STRING) {
439
 
                nih_free (value);
440
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
441
 
                                             "Invalid arguments to annotation property");
442
 
                return -1;
443
 
        }
444
 
 
445
 
        dbus_message_iter_get_basic (&value_iter, &value_item1_dbus);
446
 
 
447
 
        value_item1 = nih_strdup (value, value_item1_dbus);
448
 
        if (! value_item1) {
449
 
                nih_free (value);
450
 
                nih_error_raise_no_memory ();
451
 
                return -1;
452
 
        }
453
 
 
454
 
        dbus_message_iter_next (&value_iter);
455
 
 
456
 
        value->item1 = value_item1;
457
 
 
458
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_INVALID) {
459
 
                nih_free (value);
460
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
461
 
                                             "Invalid arguments to annotation property");
462
 
                return -1;
463
 
        }
464
 
 
465
 
        dbus_message_iter_next (&variter);
466
 
 
467
 
        dbus_message_iter_next (iter);
468
 
 
469
 
        if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INVALID) {
470
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
471
 
                                             "Invalid arguments to annotation property");
472
 
                return -1;
473
 
        }
474
 
 
475
 
        /* Call the handler function */
476
 
        if (my_test_set_annotation (object->data, message, value) < 0)
477
 
                return -1;
478
 
 
479
 
        return 0;
480
 
}
481
 
 
482
 
 
483
 
static int
484
 
my_com_netsplit_Nih_Test_preferences_get (NihDBusObject *  object,
485
 
                                          NihDBusMessage * message,
486
 
                                          DBusMessageIter *iter)
487
 
{
488
 
        DBusMessageIter    variter;
489
 
        DBusMessageIter    value_iter;
490
 
        uint32_t           value_item0;
491
 
        const char *       value_item1;
492
 
        MyTestPreferences *value;
493
 
 
494
 
        nih_assert (object != NULL);
495
 
        nih_assert (message != NULL);
496
 
        nih_assert (iter != NULL);
497
 
 
498
 
        /* Call the handler function */
499
 
        if (my_test_get_preferences (object->data, message, &value) < 0)
500
 
                return -1;
501
 
 
502
 
        /* Append a variant onto the message to contain the property value. */
503
 
        if (! dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "(us)", &variter)) {
504
 
                nih_error_raise_no_memory ();
505
 
                return -1;
506
 
        }
507
 
 
508
 
        /* Marshal a structure onto the message */
509
 
        if (! dbus_message_iter_open_container (&variter, DBUS_TYPE_STRUCT, NULL, &value_iter)) {
510
 
                dbus_message_iter_abandon_container (iter, &variter);
511
 
                nih_error_raise_no_memory ();
512
 
                return -1;
513
 
        }
514
 
 
515
 
        value_item0 = value->item0;
516
 
 
517
 
        /* Marshal a uint32_t onto the message */
518
 
        if (! dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_UINT32, &value_item0)) {
519
 
                dbus_message_iter_abandon_container (&variter, &value_iter);
520
 
                dbus_message_iter_abandon_container (iter, &variter);
521
 
                nih_error_raise_no_memory ();
522
 
                return -1;
523
 
        }
524
 
 
525
 
        value_item1 = value->item1;
526
 
 
527
 
        /* Marshal a char * onto the message */
528
 
        if (! dbus_message_iter_append_basic (&value_iter, DBUS_TYPE_STRING, &value_item1)) {
529
 
                dbus_message_iter_abandon_container (&variter, &value_iter);
530
 
                dbus_message_iter_abandon_container (iter, &variter);
531
 
                nih_error_raise_no_memory ();
532
 
                return -1;
533
 
        }
534
 
 
535
 
        if (! dbus_message_iter_close_container (&variter, &value_iter)) {
536
 
                dbus_message_iter_abandon_container (iter, &variter);
537
 
                nih_error_raise_no_memory ();
538
 
                return -1;
539
 
        }
540
 
 
541
 
        /* Finish the variant */
542
 
        if (! dbus_message_iter_close_container (iter, &variter)) {
543
 
                nih_error_raise_no_memory ();
544
 
                return -1;
545
 
        }
546
 
 
547
 
        return 0;
548
 
}
549
 
 
550
 
static int
551
 
my_com_netsplit_Nih_Test_preferences_set (NihDBusObject *  object,
552
 
                                          NihDBusMessage * message,
553
 
                                          DBusMessageIter *iter)
554
 
{
555
 
        DBusMessageIter    variter;
556
 
        DBusMessageIter    value_iter;
557
 
        uint32_t           value_item0;
558
 
        const char *       value_item1_dbus;
559
 
        char *             value_item1;
560
 
        MyTestPreferences *value;
561
 
 
562
 
        nih_assert (object != NULL);
563
 
        nih_assert (message != NULL);
564
 
        nih_assert (iter != NULL);
565
 
 
566
 
        /* Recurse into the variant */
567
 
        if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_VARIANT) {
568
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
569
 
                                             "Invalid arguments to preferences property");
570
 
                return -1;
571
 
        }
572
 
 
573
 
        dbus_message_iter_recurse (iter, &variter);
574
 
 
575
 
        /* Demarshal a structure from the message */
576
 
        if (dbus_message_iter_get_arg_type (&variter) != DBUS_TYPE_STRUCT) {
577
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
578
 
                                             "Invalid arguments to preferences property");
579
 
                return -1;
580
 
        }
581
 
 
582
 
        dbus_message_iter_recurse (&variter, &value_iter);
583
 
 
584
 
        value = nih_new (message, MyTestPreferences);
585
 
        if (! value) {
586
 
                nih_error_raise_no_memory ();
587
 
                return -1;
588
 
        }
589
 
 
590
 
        /* Demarshal a uint32_t from the message */
591
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_UINT32) {
592
 
                nih_free (value);
593
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
594
 
                                             "Invalid arguments to preferences property");
595
 
                return -1;
596
 
        }
597
 
 
598
 
        dbus_message_iter_get_basic (&value_iter, &value_item0);
599
 
 
600
 
        dbus_message_iter_next (&value_iter);
601
 
 
602
 
        value->item0 = value_item0;
603
 
 
604
 
        /* Demarshal a char * from the message */
605
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_STRING) {
606
 
                nih_free (value);
607
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
608
 
                                             "Invalid arguments to preferences property");
609
 
                return -1;
610
 
        }
611
 
 
612
 
        dbus_message_iter_get_basic (&value_iter, &value_item1_dbus);
613
 
 
614
 
        value_item1 = nih_strdup (value, value_item1_dbus);
615
 
        if (! value_item1) {
616
 
                nih_free (value);
617
 
                nih_error_raise_no_memory ();
618
 
                return -1;
619
 
        }
620
 
 
621
 
        dbus_message_iter_next (&value_iter);
622
 
 
623
 
        value->item1 = value_item1;
624
 
 
625
 
        if (dbus_message_iter_get_arg_type (&value_iter) != DBUS_TYPE_INVALID) {
626
 
                nih_free (value);
627
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
628
 
                                             "Invalid arguments to preferences property");
629
 
                return -1;
630
 
        }
631
 
 
632
 
        dbus_message_iter_next (&variter);
633
 
 
634
 
        dbus_message_iter_next (iter);
635
 
 
636
 
        if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_INVALID) {
637
 
                nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
638
 
                                             "Invalid arguments to preferences property");
639
 
                return -1;
640
 
        }
641
 
 
642
 
        /* Call the handler function */
643
 
        if (my_test_set_preferences (object->data, message, value) < 0)
644
 
                return -1;
645
 
 
646
 
        return 0;
647
 
}