/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-marshal-validate.c Validation routines for marshaled data

 *

 * Copyright (C) 2005 Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "dbus-internals.h"

#include "dbus-marshal-validate.h"

#include "dbus-marshal-recursive.h"

#include "dbus-marshal-basic.h"

#include "dbus-signature.h"

#include "dbus-string.h"

/**

 * @addtogroup DBusMarshal

 *

 * @{

 */

/**

 * Verifies that the range of type_str from type_pos to type_end is a

 * valid signature.  If this function returns #TRUE, it will be safe

 * to iterate over the signature with a types-only #DBusTypeReader.

 * The range passed in should NOT include the terminating

 * nul/DBUS_TYPE_INVALID.

 *

 * @param type_str the string

 * @param type_pos where the typecodes start

 * @param len length of typecodes

 * @returns #DBUS_VALID if valid, reason why invalid otherwise

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

 DBusValidity

_dbus_validate_signature_with_reason (const DBusString *type_str,

                                      int               type_pos,

                                      int               len)

{

  const unsigned char *p;

  const unsigned char *end;

  int last;

  int struct_depth;

  int array_depth;

  int dict_entry_depth;

  DBusValidity result;

  int element_count;

  DBusList *element_count_stack;

  result = DBUS_VALID;

  element_count_stack = NULL;

  if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (0)))

    {

      result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;

      goto out;

    }

  _dbus_assert (type_str != NULL);

  _dbus_assert (type_pos < _DBUS_INT32_MAX - len);

  _dbus_assert (len >= 0);

  _dbus_assert (type_pos >= 0);

  if (len > DBUS_MAXIMUM_SIGNATURE_LENGTH)

    {

      result = DBUS_INVALID_SIGNATURE_TOO_LONG;

      goto out;

    }

#ifndef __SYMBIAN32__

  p = _dbus_string_get_const_data_len (type_str, type_pos, 0);

  end = _dbus_string_get_const_data_len (type_str, type_pos + len, 0);

#else  

p = (const unsigned char*) _dbus_string_get_const_data_len (type_str, type_pos, 0);

end = (const unsigned char*) _dbus_string_get_const_data_len (type_str, type_pos + len, 0);

#endif

  struct_depth = 0;

  array_depth = 0;

  dict_entry_depth = 0;

  last = DBUS_TYPE_INVALID;

  while (p != end)

    {

      switch (*p)

        {

        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_VARIANT:

          break;

        case DBUS_TYPE_ARRAY:

          array_depth += 1;

          if (array_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)

            {

              result = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;

              goto out;

            }

          break;

        case DBUS_STRUCT_BEGIN_CHAR:

          struct_depth += 1;

          if (struct_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)

            {

              result = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;

              goto out;

            }

          if (!_dbus_list_append (&element_count_stack, 

                             _DBUS_INT_TO_POINTER (0)))

            {

              result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;

              goto out;

            }

          break;

        case DBUS_STRUCT_END_CHAR:

          if (struct_depth == 0)

            {

              result = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;

              goto out;

            }

          if (last == DBUS_STRUCT_BEGIN_CHAR)

            {

              result = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;

              goto out;

            }

          _dbus_list_pop_last (&element_count_stack);

          struct_depth -= 1;

          break;

        case DBUS_DICT_ENTRY_BEGIN_CHAR:

          if (last != DBUS_TYPE_ARRAY)

            {

              result = DBUS_INVALID_DICT_ENTRY_NOT_INSIDE_ARRAY;

              goto out;

            }

          dict_entry_depth += 1;

          if (dict_entry_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)

            {

              result = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;

              goto out;

            }

          if (!_dbus_list_append (&element_count_stack, 

                             _DBUS_INT_TO_POINTER (0)))

            {

              result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;

              goto out;

            }

          break;

        case DBUS_DICT_ENTRY_END_CHAR:

          if (dict_entry_depth == 0)

            {

              result = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;

              goto out;

            }

          dict_entry_depth -= 1;

          element_count = 

            _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack));

          if (element_count != 2)

            {

              if (element_count == 0)

                result = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;

              else if (element_count == 1)

                result = DBUS_INVALID_DICT_ENTRY_HAS_ONLY_ONE_FIELD;

              else

                result = DBUS_INVALID_DICT_ENTRY_HAS_TOO_MANY_FIELDS;

              goto out;

            }

          break;

        case DBUS_TYPE_STRUCT:     /* doesn't appear in signatures */

        case DBUS_TYPE_DICT_ENTRY: /* ditto */

        default:

          result = DBUS_INVALID_UNKNOWN_TYPECODE;

	  goto out;

        }

      if (*p != DBUS_TYPE_ARRAY && 

          *p != DBUS_DICT_ENTRY_BEGIN_CHAR && 

	  *p != DBUS_STRUCT_BEGIN_CHAR) 

        {

          element_count = 

            _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack));

          ++element_count;

          if (!_dbus_list_append (&element_count_stack, 

                             _DBUS_INT_TO_POINTER (element_count)))

            {

              result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR;

              goto out;

            }

        }

      if (array_depth > 0)

        {

          if (*p == DBUS_TYPE_ARRAY && p != end)

            {

#ifdef __SYMBIAN32__

	       const unsigned char *p1;

#else

	       const char *p1;

#endif

	       p1 = p + 1;

               if (*p1 == DBUS_STRUCT_END_CHAR ||

                   *p1 == DBUS_DICT_ENTRY_END_CHAR)

                 {

                   result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE;

                   goto out;

                 }

            }

          else

	    {

              array_depth = 0;

	    }

        }

      if (last == DBUS_DICT_ENTRY_BEGIN_CHAR &&

          !dbus_type_is_basic (*p))

        {

          result = DBUS_INVALID_DICT_KEY_MUST_BE_BASIC_TYPE;

          goto out;

        }

      last = *p;

      ++p;

    }

  if (array_depth > 0)

    {

      result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE;

      goto out;

    }

  if (struct_depth > 0)

    {

       result = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;

       goto out;

    }

  if (dict_entry_depth > 0)

    {

      result =  DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;

      goto out;

    }

  _dbus_assert (last != DBUS_TYPE_ARRAY);

  _dbus_assert (last != DBUS_STRUCT_BEGIN_CHAR);

  _dbus_assert (last != DBUS_DICT_ENTRY_BEGIN_CHAR);

  result = DBUS_VALID;

out:

  _dbus_list_clear (&element_count_stack);

  return result;

}

static DBusValidity

validate_body_helper (DBusTypeReader       *reader,

                      int                   byte_order,

                      dbus_bool_t           walk_reader_to_end,

                      const unsigned char  *p,

                      const unsigned char  *end,

                      const unsigned char **new_p)

{

  int current_type;

  while ((current_type = _dbus_type_reader_get_current_type (reader)) != DBUS_TYPE_INVALID)

    {

      const unsigned char *a;

      int alignment;

#if 0

      _dbus_verbose ("   validating value of type %s type reader %p type_pos %d p %p end %p %d remain\n",

                     _dbus_type_to_string (current_type), reader, reader->type_pos, p, end,

                     (int) (end - p));

#endif

      /* Guarantee that p has one byte to look at */

      if (p == end)

        return DBUS_INVALID_NOT_ENOUGH_DATA;

      switch (current_type)

        {

        case DBUS_TYPE_BYTE:

          ++p;

          break;

        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:

          alignment = _dbus_type_get_alignment (current_type);

          a = _DBUS_ALIGN_ADDRESS (p, alignment);

          if (a >= end)

            return DBUS_INVALID_NOT_ENOUGH_DATA;

          while (p != a)

            {

              if (*p != '\0')

                return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;

              ++p;

            }

          if (current_type == DBUS_TYPE_BOOLEAN)

            {

              dbus_uint32_t v = _dbus_unpack_uint32 (byte_order,

                                                     p);

              if (!(v == 0 || v == 1))

                return DBUS_INVALID_BOOLEAN_NOT_ZERO_OR_ONE;

            }

          p += alignment;

          break;

        case DBUS_TYPE_ARRAY:

        case DBUS_TYPE_STRING:

        case DBUS_TYPE_OBJECT_PATH:

          {

            dbus_uint32_t claimed_len;

            a = _DBUS_ALIGN_ADDRESS (p, 4);

            if (a + 4 > end)

              return DBUS_INVALID_NOT_ENOUGH_DATA;

            while (p != a)

              {

                if (*p != '\0')

                  return DBUS_INVALID_ALIGNMENT_PADDING_NOT_NUL;

                ++p;

              }

            claimed_len = _dbus_unpack_uint32 (byte_order, p);

            p += 4;

            /* p may now be == end */

            _dbus_assert (p <= end);

            if (current_type == DBUS_TYPE_ARRAY)

              {

                int array_elem_type = _dbus_type_reader_get_element_type (reader);

                alignment = _dbus_type_get_alignment (array_elem_type);

                p = _DBUS_ALIGN_ADDRESS (p, alignment);

              }

            if (claimed_len > (unsigned long) (end - p))

              return DBUS_INVALID_LENGTH_OUT_OF_BOUNDS;

            if (current_type == DBUS_TYPE_OBJECT_PATH)

              {

                DBusString str;

#ifdef __SYMBIAN32__

                _dbus_string_init_const_len (&str, (const char *) p, claimed_len);

#else

                _dbus_string_init_const_len (&str, p, claimed_len);

#endif              

              if (!_dbus_validate_path (&str, 0,

                                          _dbus_string_get_length (&str)))

                  return DBUS_INVALID_BAD_PATH;

                p += claimed_len;

              }

            else if (current_type == DBUS_TYPE_STRING)

              {

                DBusString str;

#ifdef __SYMBIAN32__

                _dbus_string_init_const_len (&str, (const char *) p, claimed_len);

#else

                _dbus_string_init_const_len (&str, p, claimed_len);

#endif

                if (!_dbus_string_validate_utf8 (&str, 0,

                                                 _dbus_string_get_length (&str)))

                  return DBUS_INVALID_BAD_UTF8_IN_STRING;

                p += claimed_len;

              }

            else if (current_type == DBUS_TYPE_ARRAY && claimed_len > 0)

              {

                DBusTypeReader sub;

                DBusValidity validity;

                const unsigned char *array_end;

                if (claimed_len > DBUS_MAXIMUM_ARRAY_LENGTH)

                  return DBUS_INVALID_ARRAY_LENGTH_EXCEEDS_MAXIMUM;

                /* Remember that the reader is types only, so we can't

                 * use it to iterate over elements. It stays the same

                 * for all elements.

                 */

                _dbus_type_reader_recurse (reader, &sub);

                array_end = p + claimed_len;

                while (p < array_end)

                  {

                    /* FIXME we are calling a function per array element! very bad

                     * need if (dbus_type_is_fixed(elem_type)) here to just skip

                     * big blocks of ints/bytes/etc.

                     */                     

                    validity = validate_body_helper (&sub, byte_order, FALSE, p, end, &p);

                    if (validity != DBUS_VALID)

                      return validity;

                  }

                if (p != array_end)

                  return DBUS_INVALID_ARRAY_LENGTH_INCORRECT;

              }

            /* check nul termination */

            if (current_type != DBUS_TYPE_ARRAY)

              {

                if (p == end)

                  return DBUS_INVALID_NOT_ENOUGH_DATA;

                if (*p != '\0')

                  return DBUS_INVALID_STRING_MISSING_NUL;

                ++p;

              }

          }

          break;

        case DBUS_TYPE_SIGNATURE:

          {

            dbus_uint32_t claimed_len;

            DBusString str;

            DBusValidity validity;

            claimed_len = *p;

            ++p;

            /* 1 is for nul termination */

            if (claimed_len + 1 > (unsigned long) (end - p))

              return DBUS_INVALID_SIGNATURE_LENGTH_OUT_OF_BOUNDS;

#ifdef __SYMBIAN32__

                _dbus_string_init_const_len (&str, (const char *) p, claimed_len);

#else

                _dbus_string_init_const_len (&str, p, claimed_len);

#endif

            validity =

              _dbus_validate_signature_with_reason (&str, 0,

                                                    _dbus_string_get_length (&str));

            if (validity != DBUS_VALID)

              return validity;

            p += claimed_len;

            _dbus_assert (p < end);

            if (*p != DBUS_TYPE_INVALID)

              return DBUS_INVALID_SIGNATURE_MISSING_NUL;

            ++p;

            _dbus_verbose ("p = %p end = %p claimed_len %u\n", p, end, claimed_len);

          }

          break;

        case DBUS_TYPE_VARIANT:

          {

            /* 1 byte sig len, sig typecodes, align to

             * contained-type-boundary, values.

             */

            /* In addition to normal signature validation, we need to be sure

             * the signature contains only a single (possibly container) type.

             */

            dbus_uint32_t claimed_len;

            DBusString sig;

            DBusTypeReader sub;

            DBusValidity validity;

            int contained_alignment;

            int contained_type;

            DBusValidity reason;

            claimed_len = *p;

            ++p;

            /* + 1 for nul */

            if (claimed_len + 1 > (unsigned long) (end - p))