D-Bus  1.4.10
dbus-signature.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* dbus-signature.c Routines for reading recursive type signatures
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 
24 #include <config.h>
25 
26 #include "dbus-signature.h"
27 #include "dbus-marshal-recursive.h"
28 #include "dbus-marshal-basic.h"
29 #include "dbus-internals.h"
30 #include "dbus-test.h"
31 
35 typedef struct
36 {
37  const char *pos;
38  unsigned int finished : 1;
39  unsigned int in_array : 1;
41 
43 #define TYPE_IS_CONTAINER(typecode) \
44  ((typecode) == DBUS_TYPE_STRUCT || \
45  (typecode) == DBUS_TYPE_DICT_ENTRY || \
46  (typecode) == DBUS_TYPE_VARIANT || \
47  (typecode) == DBUS_TYPE_ARRAY)
48 
49 
66 void
68  const char *signature)
69 {
70  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
71 
72  real_iter->pos = signature;
73  real_iter->finished = FALSE;
74  real_iter->in_array = FALSE;
75 }
76 
91 int
93 {
94  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
95 
96  return _dbus_first_type_in_signature_c_str (real_iter->pos, 0);
97 }
98 
111 char *
113 {
114  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
115  DBusString str;
116  char *ret;
117  int pos;
118 
119  if (!_dbus_string_init (&str))
120  return NULL;
121 
122  pos = 0;
123  _dbus_type_signature_next (real_iter->pos, &pos);
124 
125  if (!_dbus_string_append_len (&str, real_iter->pos, pos))
126  return NULL;
127  if (!_dbus_string_steal_data (&str, &ret))
128  ret = NULL;
129  _dbus_string_free (&str);
130 
131  return ret;
132 }
133 
145 int
147 {
148  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
149 
150  _dbus_return_val_if_fail (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
151 
152  return _dbus_first_type_in_signature_c_str (real_iter->pos, 1);
153 }
154 
165 {
166  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
167 
168  if (real_iter->finished)
169  return FALSE;
170  else
171  {
172  int pos;
173 
174  if (real_iter->in_array)
175  {
176  real_iter->finished = TRUE;
177  return FALSE;
178  }
179 
180  pos = 0;
181  _dbus_type_signature_next (real_iter->pos, &pos);
182  real_iter->pos += pos;
183 
184  if (*real_iter->pos == DBUS_STRUCT_END_CHAR
185  || *real_iter->pos == DBUS_DICT_ENTRY_END_CHAR)
186  {
187  real_iter->finished = TRUE;
188  return FALSE;
189  }
190 
191  return *real_iter->pos != DBUS_TYPE_INVALID;
192  }
193 }
194 
206 void
208  DBusSignatureIter *subiter)
209 {
210  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
211  DBusSignatureRealIter *real_sub_iter = (DBusSignatureRealIter *) subiter;
212 
213  _dbus_return_if_fail (dbus_type_is_container (dbus_signature_iter_get_current_type (iter)));
214 
215  *real_sub_iter = *real_iter;
216  real_sub_iter->in_array = FALSE;
217  real_sub_iter->pos++;
218 
220  real_sub_iter->in_array = TRUE;
221 }
222 
233 dbus_signature_validate (const char *signature,
234  DBusError *error)
235 
236 {
237  DBusString str;
238  DBusValidity reason;
239 
240  _dbus_string_init_const (&str, signature);
242 
243  if (reason == DBUS_VALID)
244  return TRUE;
245  else
246  {
247  dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, _dbus_validity_to_error_message (reason));
248  return FALSE;
249  }
250 }
251 
264 dbus_signature_validate_single (const char *signature,
265  DBusError *error)
266 {
267  DBusSignatureIter iter;
268 
269  if (!dbus_signature_validate (signature, error))
270  return FALSE;
271 
272  dbus_signature_iter_init (&iter, signature);
274  goto lose;
275  if (!dbus_signature_iter_next (&iter))
276  return TRUE;
277  lose:
278  dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Exactly one complete type required in signature");
279  return FALSE;
280 }
281 
294 {
295  /* only reasonable (non-line-noise) typecodes are allowed */
296  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
297  FALSE);
298  return TYPE_IS_CONTAINER (typecode);
299 }
300 
316 dbus_type_is_basic (int typecode)
317 {
318  /* only reasonable (non-line-noise) typecodes are allowed */
319  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
320  FALSE);
321 
322  /* everything that isn't invalid or a container */
323  return !(typecode == DBUS_TYPE_INVALID || TYPE_IS_CONTAINER (typecode));
324 }
325 
346 dbus_type_is_fixed (int typecode)
347 {
348  /* only reasonable (non-line-noise) typecodes are allowed */
349  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
350  FALSE);
351 
352  switch (typecode)
353  {
354  case DBUS_TYPE_BYTE:
355  case DBUS_TYPE_BOOLEAN:
356  case DBUS_TYPE_INT16:
357  case DBUS_TYPE_UINT16:
358  case DBUS_TYPE_INT32:
359  case DBUS_TYPE_UINT32:
360  case DBUS_TYPE_INT64:
361  case DBUS_TYPE_UINT64:
362  case DBUS_TYPE_DOUBLE:
363  case DBUS_TYPE_UNIX_FD:
364  return TRUE;
365  default:
366  return FALSE;
367  }
368 }
369  /* end of DBusSignature group */
371 
372 #ifdef DBUS_BUILD_TESTS
373 
381 _dbus_signature_test (void)
382 {
383  DBusSignatureIter iter;
384  DBusSignatureIter subiter;
385  DBusSignatureIter subsubiter;
386  DBusSignatureIter subsubsubiter;
387  const char *sig;
388  dbus_bool_t boolres;
389 
391 
392  sig = "";
395  dbus_signature_iter_init (&iter, sig);
397 
401  dbus_signature_iter_init (&iter, sig);
403 
406  dbus_signature_iter_init (&iter, sig);
408  boolres = dbus_signature_iter_next (&iter);
409  _dbus_assert (boolres);
411 
420  dbus_signature_iter_init (&iter, sig);
422  boolres = dbus_signature_iter_next (&iter);
423  _dbus_assert (boolres);
425  dbus_signature_iter_recurse (&iter, &subiter);
427  boolres = dbus_signature_iter_next (&subiter);
428  _dbus_assert (boolres);
430  boolres = dbus_signature_iter_next (&subiter);
431  _dbus_assert (boolres);
433  boolres = dbus_signature_iter_next (&subiter);
434  _dbus_assert (boolres);
436 
440  DBUS_TYPE_BYTE_AS_STRING
445  DBUS_TYPE_BYTE_AS_STRING
446  DBUS_STRUCT_END_CHAR_AS_STRING
449  dbus_signature_iter_init (&iter, sig);
451  boolres = dbus_signature_iter_next (&iter);
452  _dbus_assert (boolres);
454  dbus_signature_iter_recurse (&iter, &subiter);
456  boolres = dbus_signature_iter_next (&subiter);
457  _dbus_assert (boolres);
459  boolres = dbus_signature_iter_next (&subiter);
460  _dbus_assert (boolres);
463 
464  dbus_signature_iter_recurse (&subiter, &subsubiter);
467 
468  dbus_signature_iter_recurse (&subsubiter, &subsubsubiter);
470  boolres = dbus_signature_iter_next (&subiter);
471  _dbus_assert (boolres);
473  dbus_signature_iter_recurse (&subiter, &subsubiter);
475 
484  dbus_signature_iter_init (&iter, sig);
487 
488  dbus_signature_iter_recurse (&iter, &subiter);
489  dbus_signature_iter_recurse (&subiter, &subsubiter);
491  boolres = dbus_signature_iter_next (&subsubiter);
492  _dbus_assert (boolres);
494  boolres = dbus_signature_iter_next (&subsubiter);
495  _dbus_assert (!boolres);
496 
497  boolres = dbus_signature_iter_next (&iter);
498  _dbus_assert (boolres);
500  boolres = dbus_signature_iter_next (&iter);
501  _dbus_assert (!boolres);
502 
505 
508 
512 
513  sig = DBUS_TYPE_ARRAY_AS_STRING
516 
519 
522 
526 
528  DBUS_TYPE_INT32_AS_STRING
531 
532  sig = DBUS_STRUCT_END_CHAR_AS_STRING
535 
536  sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
539  return TRUE;
540 #if 0
541  oom:
542  _dbus_assert_not_reached ("out of memory");
543  return FALSE;
544 #endif
545 }
546 
547 #endif
548