D-Bus  1.13.7
dbus-asv-util.c
1 /* dbus-asv-util.c - utility functions for a{sv}
2  *
3  * Copyright © 2011-2012 Nokia Corporation
4  * Copyright © 2012-2013 Collabora Ltd.
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
21  * 02110-1301 USA
22  */
23 
24 #include <config.h>
25 
26 #include <dbus/dbus.h>
27 
28 #include "dbus/dbus-asv-util.h"
29 
46 _dbus_asv_new_method_return (DBusMessage *message,
47  DBusMessageIter *iter,
48  DBusMessageIter *arr_iter)
49 {
51 
52  if (reply == NULL)
53  return NULL;
54 
55  dbus_message_iter_init_append (reply, iter);
56 
58  arr_iter))
59  {
60  dbus_message_unref (reply);
61  return NULL;
62  }
63 
64  return reply;
65 }
66 
67 /*
68  * Open a new entry in an a{sv} (map from string to variant).
69  *
70  * This must be paired with a call to either _dbus_asv_close_entry()
71  * or _dbus_asv_abandon_entry().
72  *
73  * If this function fails, the a{sv} must be abandoned, for instance
74  * with _dbus_asv_abandon().
75  *
76  * @param arr_iter the iterator which is appending to the array
77  * @param entry_iter will be initialized to append to the dict-entry
78  * @param key a UTF-8 key for the map
79  * @param type the type of the variant value, e.g. DBUS_TYPE_STRING_AS_STRING
80  * @param var_iter will be initialized to append (i.e. write) to the variant
81  * @returns #TRUE on success, or #FALSE if not enough memory
82  */
84 _dbus_asv_open_entry (DBusMessageIter *arr_iter,
85  DBusMessageIter *entry_iter,
86  const char *key,
87  const char *type,
88  DBusMessageIter *var_iter)
89 {
91  NULL, entry_iter))
92  return FALSE;
93 
94  if (!dbus_message_iter_append_basic (entry_iter, DBUS_TYPE_STRING, &key))
95  {
96  dbus_message_iter_abandon_container (arr_iter, entry_iter);
97  return FALSE;
98  }
99 
101  type, var_iter))
102  {
103  dbus_message_iter_abandon_container (arr_iter, entry_iter);
104  return FALSE;
105  }
106 
107  return TRUE;
108 }
109 
110 /*
111  * Closes an a{sv} entry after successfully appending the value.
112  *
113  * If this function fails, the a{sv} must be abandoned, for instance
114  * with _dbus_asv_abandon().
115  *
116  * @param arr_iter the iterator which is appending to the array
117  * @param entry_iter the iterator appending to the dict-entry, will be closed
118  * @param var_iter the iterator appending to the variant, will be closed
119  * @returns #TRUE on success, or #FALSE if not enough memory
120  */
122 _dbus_asv_close_entry (DBusMessageIter *arr_iter,
123  DBusMessageIter *entry_iter,
124  DBusMessageIter *var_iter)
125 {
126  if (!dbus_message_iter_close_container (entry_iter, var_iter))
127  {
128  dbus_message_iter_abandon_container (arr_iter, entry_iter);
129  return FALSE;
130  }
131 
132  if (!dbus_message_iter_close_container (arr_iter, entry_iter))
133  return FALSE;
134 
135  return TRUE;
136 }
137 
149 _dbus_asv_close (DBusMessageIter *iter,
150  DBusMessageIter *arr_iter)
151 {
152  return dbus_message_iter_close_container (iter, arr_iter);
153 }
154 
155 /*
156  * Closes an a{sv} entry after unsuccessfully appending a value.
157  * You must also abandon the a{sv} itself (for instance with
158  * _dbus_asv_abandon()), and abandon whatever larger data structure
159  * the a{sv} was embedded in.
160  *
161  * @param iter the iterator which is appending to the message or other data structure containing the a{sv}
162  * @param arr_iter the iterator appending to the array, will be closed
163  * @returns #TRUE on success, or #FALSE if not enough memory
164  */
165 void
166 _dbus_asv_abandon_entry (DBusMessageIter *arr_iter,
167  DBusMessageIter *entry_iter,
168  DBusMessageIter *var_iter)
169 {
170  dbus_message_iter_abandon_container (entry_iter, var_iter);
171  dbus_message_iter_abandon_container (arr_iter, entry_iter);
172 }
173 
183 void
184 _dbus_asv_abandon (DBusMessageIter *iter,
185  DBusMessageIter *arr_iter)
186 {
187  dbus_message_iter_abandon_container (iter, arr_iter);
188 }
189 
203 _dbus_asv_add_uint32 (DBusMessageIter *arr_iter,
204  const char *key,
205  dbus_uint32_t value)
206 {
207  DBusMessageIter entry_iter, var_iter;
208 
209  if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key,
210  DBUS_TYPE_UINT32_AS_STRING, &var_iter))
211  return FALSE;
212 
214  &value))
215  {
216  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
217  return FALSE;
218  }
219 
220  if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter))
221  return FALSE;
222 
223  return TRUE;
224 }
225 
239 _dbus_asv_add_string (DBusMessageIter *arr_iter,
240  const char *key,
241  const char *value)
242 {
243  DBusMessageIter entry_iter, var_iter;
244 
245  if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key,
246  DBUS_TYPE_STRING_AS_STRING, &var_iter))
247  return FALSE;
248 
250  &value))
251  {
252  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
253  return FALSE;
254  }
255 
256  if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter))
257  return FALSE;
258 
259  return TRUE;
260 }
261 
275 _dbus_asv_add_object_path (DBusMessageIter *arr_iter,
276  const char *key,
277  const char *value)
278 {
279  DBusMessageIter entry_iter, var_iter;
280 
281  if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key,
283  return FALSE;
284 
286  &value))
287  {
288  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
289  return FALSE;
290  }
291 
292  if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter))
293  return FALSE;
294 
295  return TRUE;
296 }
297 
312 _dbus_asv_add_byte_array (DBusMessageIter *arr_iter,
313  const char *key,
314  const void *value,
315  int n_elements)
316 {
317  DBusMessageIter entry_iter;
318  DBusMessageIter var_iter;
319  DBusMessageIter byte_array_iter;
320 
321  if (!_dbus_asv_open_entry (arr_iter, &entry_iter, key, "ay", &var_iter))
322  return FALSE;
323 
326  &byte_array_iter))
327  {
328  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
329  return FALSE;
330  }
331 
333  &value, n_elements))
334  {
335  dbus_message_iter_abandon_container (&var_iter, &byte_array_iter);
336  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
337  return FALSE;
338  }
339 
340  if (!dbus_message_iter_close_container (&var_iter, &byte_array_iter))
341  {
342  _dbus_asv_abandon_entry (arr_iter, &entry_iter, &var_iter);
343  return FALSE;
344  }
345 
346  if (!_dbus_asv_close_entry (arr_iter, &entry_iter, &var_iter))
347  return FALSE;
348 
349  return TRUE;
350 }
#define NULL
A null pointer, defined appropriately for C or C++.
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...
#define DBUS_TYPE_DICT_ENTRY
Type code used to represent a dict entry; however, this type code does not appear in type signatures...
#define DBUS_TYPE_STRING
Type code marking a UTF-8 encoded, nul-terminated Unicode string.
void dbus_message_iter_init_append(DBusMessage *message, DBusMessageIter *iter)
Initializes a DBusMessageIter for appending arguments to the end of a message.
#define DBUS_TYPE_BYTE
Type code marking an 8-bit unsigned integer.
Definition: dbus-protocol.h:66
DBusMessageIter struct; contains no public fields.
Definition: dbus-message.h:61
#define DBUS_TYPE_ARRAY
Type code marking a D-Bus array type.
dbus_bool_t dbus_message_iter_append_fixed_array(DBusMessageIter *iter, int element_type, const void *value, int n_elements)
Appends a block of fixed-length values to an array.
Internals of DBusMessage.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
#define DBUS_TYPE_BYTE_AS_STRING
DBUS_TYPE_BYTE as a string literal instead of a int literal
Definition: dbus-protocol.h:68
#define DBUS_TYPE_VARIANT
Type code marking a D-Bus variant type.
#define DBUS_TYPE_UINT32
Type code marking a 32-bit unsigned integer.
Definition: dbus-protocol.h:86
#define TRUE
Expands to "1".
#define DBUS_TYPE_OBJECT_PATH_AS_STRING
DBUS_TYPE_OBJECT_PATH as a string literal instead of a int literal
#define DBUS_TYPE_OBJECT_PATH
Type code marking a D-Bus object path.
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.
#define DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING as a string literal instead of a int literal
dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter *iter, int type, const void *value)
Appends a basic-typed value to the message.
#define FALSE
Expands to "0".
void dbus_message_iter_abandon_container(DBusMessageIter *iter, DBusMessageIter *sub)
Abandons creation of a contained-typed value and frees resources created by dbus_message_iter_open_co...
void dbus_message_unref(DBusMessage *message)
Decrements the reference count of a DBusMessage, freeing the message if the count reaches 0...
#define DBUS_TYPE_UINT32_AS_STRING
DBUS_TYPE_UINT32 as a string literal instead of a int literal
Definition: dbus-protocol.h:88
DBusMessage * dbus_message_new_method_return(DBusMessage *method_call)
Constructs a message that is a reply to a method call.