dbus-signature.c

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* dbus-signature.c  Routines for reading recursive type signatures
 *
 * Copyright (C) 2005 Red Hat, Inc.
 *
 * SPDX-License-Identifier: AFL-2.1 OR GPL-2.0-or-later
 *
 * Licensed under the Academic Free License version 2.1
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
#include <config.h>
 
#include "dbus-signature.h"
#include "dbus-marshal-recursive.h"
#include "dbus-marshal-basic.h"
#include "dbus-internals.h"
#include "dbus-test.h"
#include <dbus/dbus-test-tap.h>
 
typedef struct
{ 
  const char *pos;           
  unsigned int finished : 1; 
  unsigned int in_array : 1; 
} DBusSignatureRealIter;
 
_DBUS_STATIC_ASSERT (sizeof (DBusSignatureIter) >= sizeof (DBusSignatureRealIter));
 
#define TYPE_IS_CONTAINER(typecode)             \
    ((typecode) == DBUS_TYPE_STRUCT ||          \
     (typecode) == DBUS_TYPE_DICT_ENTRY ||      \
     (typecode) == DBUS_TYPE_VARIANT ||         \
     (typecode) == DBUS_TYPE_ARRAY)
 
 
void
dbus_signature_iter_init (DBusSignatureIter *iter,
                          const char        *signature)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 
  real_iter->pos = signature;
  real_iter->finished = FALSE;
  real_iter->in_array = FALSE;
}
 
int
dbus_signature_iter_get_current_type (const DBusSignatureIter *iter)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 
  return _dbus_first_type_in_signature_c_str (real_iter->pos, 0);
}
 
char *
dbus_signature_iter_get_signature (const DBusSignatureIter *iter)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
  DBusString str;
  char *ret;
  int pos;
  
  if (!_dbus_string_init (&str))
    return NULL;
 
  pos = 0;
  _dbus_type_signature_next (real_iter->pos, &pos);
 
  if (!_dbus_string_append_len (&str, real_iter->pos, pos))
    return NULL;
  if (!_dbus_string_steal_data (&str, &ret))
    ret = NULL;
  _dbus_string_free (&str);
 
  return ret; 
}
 
int
dbus_signature_iter_get_element_type (const DBusSignatureIter *iter)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 
  _dbus_return_val_if_fail (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
 
  return _dbus_first_type_in_signature_c_str (real_iter->pos, 1);
}
 
dbus_bool_t
dbus_signature_iter_next (DBusSignatureIter *iter)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 
  if (real_iter->finished)
    return FALSE;
  else
    {
      int pos;
 
      if (real_iter->in_array)
        {
          real_iter->finished = TRUE;
          return FALSE;
        }
 
      pos = 0;
      _dbus_type_signature_next (real_iter->pos, &pos);
      real_iter->pos += pos;
 
      if (*real_iter->pos == DBUS_STRUCT_END_CHAR
          || *real_iter->pos == DBUS_DICT_ENTRY_END_CHAR)
        {
          real_iter->finished = TRUE;
          return FALSE;
        }
 
      return *real_iter->pos != DBUS_TYPE_INVALID;
    }
}
 
void
dbus_signature_iter_recurse (const DBusSignatureIter *iter,
                             DBusSignatureIter       *subiter)
{
  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
  DBusSignatureRealIter *real_sub_iter = (DBusSignatureRealIter *) subiter;
 
  _dbus_return_if_fail (dbus_type_is_container (dbus_signature_iter_get_current_type (iter)));
 
  *real_sub_iter = *real_iter;
  real_sub_iter->in_array = FALSE;
  real_sub_iter->pos++;
 
  if (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY)
    real_sub_iter->in_array = TRUE;
}
 
dbus_bool_t
dbus_signature_validate (const char       *signature,
                         DBusError        *error)
                         
{
  DBusString str;
  DBusValidity reason;
 
  _dbus_string_init_const (&str, signature);
  reason = _dbus_validate_signature_with_reason (&str, 0, _dbus_string_get_length (&str));
 
  if (reason == DBUS_VALID)
    return TRUE;
  else
    {
      dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "%s",
          _dbus_validity_to_error_message (reason));
      return FALSE;
    }
}
 
dbus_bool_t
dbus_signature_validate_single (const char       *signature,
                                DBusError        *error)
{
  DBusSignatureIter iter;
 
  if (!dbus_signature_validate (signature, error))
    return FALSE;
 
  dbus_signature_iter_init (&iter, signature);
  if (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID)
    goto lose;
  if (!dbus_signature_iter_next (&iter))
    return TRUE;
 lose:
  dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Exactly one complete type required in signature");
  return FALSE;
}
 
dbus_bool_t
dbus_type_is_container (int typecode)
{
  /* only reasonable (non-line-noise) typecodes are allowed */
  _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
                            FALSE);
  return TYPE_IS_CONTAINER (typecode);
}
 
dbus_bool_t
dbus_type_is_basic (int typecode)
{
  /* only reasonable (non-line-noise) typecodes are allowed */
  _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
                            FALSE);
 
  /* everything that isn't invalid or a container */
  return !(typecode == DBUS_TYPE_INVALID || TYPE_IS_CONTAINER (typecode));
}
 
dbus_bool_t
dbus_type_is_fixed (int typecode)
{
  /* only reasonable (non-line-noise) typecodes are allowed */
  _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
                            FALSE);
  
  switch (typecode)
    {
    case DBUS_TYPE_BYTE:
    case DBUS_TYPE_BOOLEAN:
    case DBUS_TYPE_INT16:
    case DBUS_TYPE_UINT16:
    case DBUS_TYPE_INT32:
    case DBUS_TYPE_UINT32:
    case DBUS_TYPE_INT64:
    case DBUS_TYPE_UINT64:
    case DBUS_TYPE_DOUBLE:
    case DBUS_TYPE_UNIX_FD:
      return TRUE;
    default:
      return FALSE;
    }
}
 
dbus_bool_t
dbus_type_is_valid (int typecode)
{
  switch (typecode)
    {
    case DBUS_TYPE_BYTE:
    case DBUS_TYPE_BOOLEAN:
    case DBUS_TYPE_INT16:
    case DBUS_TYPE_UINT16:
    case DBUS_TYPE_INT32:
    case DBUS_TYPE_UINT32:
    case DBUS_TYPE_INT64:
    case DBUS_TYPE_UINT64:
    case DBUS_TYPE_DOUBLE:
    case DBUS_TYPE_STRING:
    case DBUS_TYPE_OBJECT_PATH:
    case DBUS_TYPE_SIGNATURE:
    case DBUS_TYPE_ARRAY:
    case DBUS_TYPE_STRUCT:
    case DBUS_TYPE_DICT_ENTRY:
    case DBUS_TYPE_VARIANT:
    case DBUS_TYPE_UNIX_FD:
      return TRUE;
 
    default:
      return FALSE;
    }
}