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

/* dbus-marshal-header.c  Managing marshaling/demarshaling of message headers

 *

 * 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/dbus-shared.h"

#include "dbus-marshal-header.h"

#include "dbus-marshal-recursive.h"

#include "dbus-marshal-byteswap.h"

/**

 * @addtogroup DBusMarshal

 *

 * @{

 */

/* Not thread locked, but strictly const/read-only so should be OK

 */

/** Static #DBusString containing the signature of a message header */

_DBUS_STRING_DEFINE_STATIC(_dbus_header_signature_str, DBUS_HEADER_SIGNATURE);

/** Static #DBusString containing the local interface */

_DBUS_STRING_DEFINE_STATIC(_dbus_local_interface_str,  DBUS_INTERFACE_LOCAL);

/** Static #DBusString containing the local path */

_DBUS_STRING_DEFINE_STATIC(_dbus_local_path_str,       DBUS_PATH_LOCAL);

/** Offset from start of _dbus_header_signature_str to the signature of the fields array */

#define FIELDS_ARRAY_SIGNATURE_OFFSET 6

/** Offset from start of _dbus_header_signature_str to the signature of an element of the fields array */

#define FIELDS_ARRAY_ELEMENT_SIGNATURE_OFFSET 7

/** Offset to byte order from start of header */

#define BYTE_ORDER_OFFSET    0

/** Offset to type from start of header */

#define TYPE_OFFSET          1

/** Offset to flags from start of header */

#define FLAGS_OFFSET         2

/** Offset to version from start of header */

#define VERSION_OFFSET       3

/** Offset to body length from start of header */

#define BODY_LENGTH_OFFSET 4

/** Offset to client serial from start of header */

#define SERIAL_OFFSET 8

/** Offset to fields array length from start of header */

#define FIELDS_ARRAY_LENGTH_OFFSET 12

/** Offset to first field in header */

#define FIRST_FIELD_OFFSET 16

typedef struct

{

  unsigned char code; /**< the field code */

  unsigned char type; /**< the value type */

} HeaderFieldType;

static const HeaderFieldType

_dbus_header_field_types[DBUS_HEADER_FIELD_LAST+1] = {

  { DBUS_HEADER_FIELD_INVALID, DBUS_TYPE_INVALID },

  { DBUS_HEADER_FIELD_PATH, DBUS_TYPE_OBJECT_PATH },

  { DBUS_HEADER_FIELD_INTERFACE, DBUS_TYPE_STRING },

  { DBUS_HEADER_FIELD_MEMBER, DBUS_TYPE_STRING },

  { DBUS_HEADER_FIELD_ERROR_NAME, DBUS_TYPE_STRING },

  { DBUS_HEADER_FIELD_REPLY_SERIAL, DBUS_TYPE_UINT32 },

  { DBUS_HEADER_FIELD_DESTINATION, DBUS_TYPE_STRING },

  { DBUS_HEADER_FIELD_SENDER, DBUS_TYPE_STRING },

  { DBUS_HEADER_FIELD_SIGNATURE, DBUS_TYPE_SIGNATURE }

};

/** Macro to look up the correct type for a field */

#define EXPECTED_TYPE_OF_FIELD(field) (_dbus_header_field_types[field].type)

/** The most padding we could ever need for a header */

#define MAX_POSSIBLE_HEADER_PADDING 7

static dbus_bool_t

reserve_header_padding (DBusHeader *header)

{

  _dbus_assert (header->padding <= MAX_POSSIBLE_HEADER_PADDING);

  if (!_dbus_string_lengthen (&header->data,

                              MAX_POSSIBLE_HEADER_PADDING - header->padding))

    return FALSE;

  header->padding = MAX_POSSIBLE_HEADER_PADDING;

  return TRUE;

}

static void

correct_header_padding (DBusHeader *header)

{

  int unpadded_len;

  _dbus_assert (header->padding == 7);

  _dbus_string_shorten (&header->data, header->padding);

  unpadded_len = _dbus_string_get_length (&header->data);

  if (!_dbus_string_align_length (&header->data, 8))

    _dbus_assert_not_reached ("couldn't pad header though enough padding was preallocated");

  header->padding = _dbus_string_get_length (&header->data) - unpadded_len;

}

/** Compute the end of the header, ignoring padding */

#define HEADER_END_BEFORE_PADDING(header) \

  (_dbus_string_get_length (&(header)->data) - (header)->padding)

/**

 * Invalidates all fields in the cache. This may be used when the

 * cache is totally uninitialized (contains junk) so should not

 * look at what's in there now.

 *

 * @param header the header

 */

static void

_dbus_header_cache_invalidate_all (DBusHeader *header)

{

  int i;

  i = 0;

  while (i <= DBUS_HEADER_FIELD_LAST)

    {

      header->fields[i].value_pos = _DBUS_HEADER_FIELD_VALUE_UNKNOWN;

      ++i;

    }

}

/**

 * Caches one field

 *

 * @param header the header

 * @param field_code the field

 * @param variant_reader the reader for the variant in the field

 */

static void

_dbus_header_cache_one (DBusHeader     *header,

                        int             field_code,

                        DBusTypeReader *variant_reader)

{

  header->fields[field_code].value_pos =

    _dbus_type_reader_get_value_pos (variant_reader);

#if 0

  _dbus_verbose ("cached value_pos %d for field %d\n",

                 header->fields[field_code].value_pos, field_code)

#endif

}

/**

 * Revalidates the fields cache

 *

 * @param header the header

 */

static void

_dbus_header_cache_revalidate (DBusHeader *header)

{

  DBusTypeReader array;

  DBusTypeReader reader;

  int i;

  i = 0;

  while (i <= DBUS_HEADER_FIELD_LAST)

    {

      header->fields[i].value_pos = _DBUS_HEADER_FIELD_VALUE_NONEXISTENT;

      ++i;

    }

  _dbus_type_reader_init (&reader,

                          header->byte_order,

                          &_dbus_header_signature_str,

                          FIELDS_ARRAY_SIGNATURE_OFFSET,

                          &header->data,

                          FIELDS_ARRAY_LENGTH_OFFSET);

  _dbus_type_reader_recurse (&reader, &array);

  while (_dbus_type_reader_get_current_type (&array) != DBUS_TYPE_INVALID)

    {

      DBusTypeReader sub;

      DBusTypeReader variant;

      unsigned char field_code;

      _dbus_type_reader_recurse (&array, &sub);

      _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_BYTE);

      _dbus_type_reader_read_basic (&sub, &field_code);

      /* Unknown fields should be ignored */

      if (field_code > DBUS_HEADER_FIELD_LAST)

        goto next_field;

      _dbus_type_reader_next (&sub);

      _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_VARIANT);

      _dbus_type_reader_recurse (&sub, &variant);

      _dbus_header_cache_one (header, field_code, &variant);

    next_field:

      _dbus_type_reader_next (&array);

    }

}

/**

 * Checks for a field, updating the cache if required.

 *

 * @param header the header

 * @param field the field to check

 * @returns #FALSE if the field doesn't exist

 */

static dbus_bool_t

_dbus_header_cache_check (DBusHeader    *header,

                          int            field)

{

  _dbus_assert (field <= DBUS_HEADER_FIELD_LAST);

  if (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_UNKNOWN)

    _dbus_header_cache_revalidate (header);

  if (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_NONEXISTENT)

    return FALSE;

  return TRUE;

}

/**

 * Checks whether a field is known not to exist. It may exist

 * even if it's not known to exist.

 *

 * @param header the header

 * @param field the field to check

 * @returns #FALSE if the field definitely doesn't exist

 */

static dbus_bool_t

_dbus_header_cache_known_nonexistent (DBusHeader    *header,

                                      int            field)

{

  _dbus_assert (field <= DBUS_HEADER_FIELD_LAST);

  return (header->fields[field].value_pos == _DBUS_HEADER_FIELD_VALUE_NONEXISTENT);

}

/**

 * Writes a struct of { byte, variant } with the given basic type.

 *

 * @param writer the writer (should be ready to write a struct)

 * @param type the type of the value

 * @param value the value as for _dbus_marshal_set_basic()

 * @returns #FALSE if no memory

 */

static dbus_bool_t

write_basic_field (DBusTypeWriter *writer,

                   int             field,

                   int             type,

                   const void     *value)

{

  DBusTypeWriter sub;

  DBusTypeWriter variant;

  int start;

  int padding;

  unsigned char field_byte;

  DBusString contained_type;

  char buf[2];

  start = writer->value_pos;

  padding = _dbus_string_get_length (writer->value_str) - start;

  if (!_dbus_type_writer_recurse (writer, DBUS_TYPE_STRUCT,

                                  NULL, 0, &sub))

    goto append_failed;

  field_byte = field;

  if (!_dbus_type_writer_write_basic (&sub, DBUS_TYPE_BYTE,

                                      &field_byte))

    goto append_failed;

  buf[0] = type;

  buf[1] = '\0';

  _dbus_string_init_const_len (&contained_type, buf, 1);

  if (!_dbus_type_writer_recurse (&sub, DBUS_TYPE_VARIANT,

                                  &contained_type, 0, &variant))

    goto append_failed;

  if (!_dbus_type_writer_write_basic (&variant, type, value))

    goto append_failed;

  if (!_dbus_type_writer_unrecurse (&sub, &variant))

    goto append_failed;

  if (!_dbus_type_writer_unrecurse (writer, &sub))

    goto append_failed;

  return TRUE;

 append_failed:

  _dbus_string_delete (writer->value_str,

                       start,

                       _dbus_string_get_length (writer->value_str) - start - padding);

  return FALSE;

}

/**

 * Sets a struct of { byte, variant } with the given basic type.

 *

 * @param reader the reader (should be iterating over the array pointing at the field to set)

 * @param type the type of the value

 * @param value the value as for _dbus_marshal_set_basic()

 * @param realign_root where to realign from

 * @returns #FALSE if no memory

 */

static dbus_bool_t

set_basic_field (DBusTypeReader       *reader,

                 int                   field,

                 int                   type,

                 const void           *value,

                 const DBusTypeReader *realign_root)

{

  DBusTypeReader sub;

  DBusTypeReader variant;

  _dbus_type_reader_recurse (reader, &sub);

  _dbus_assert (_dbus_type_reader_get_current_type (&sub) == DBUS_TYPE_BYTE);

#ifndef DBUS_DISABLE_ASSERT

 {

   unsigned char v_BYTE;

   _dbus_type_reader_read_basic (&sub, &v_BYTE);

   _dbus_assert (((int) v_BYTE) == field);

 }

#endif

  if (!_dbus_type_reader_next (&sub))

    _dbus_assert_not_reached ("no variant field?");

  _dbus_type_reader_recurse (&sub, &variant);

  _dbus_assert (_dbus_type_reader_get_current_type (&variant) == type);

  if (!_dbus_type_reader_set_basic (&variant, value, realign_root))

    return FALSE;

  return TRUE;

}

/**

 * Gets the type of the message.

 *

 * @param header the header

 * @returns the type

 */

int

_dbus_header_get_message_type (DBusHeader *header)

{

  int type;

  type = _dbus_string_get_byte (&header->data, TYPE_OFFSET);

  _dbus_assert (type != DBUS_MESSAGE_TYPE_INVALID);

  return type;

}

/**

 * Sets the serial number of a header.  This can only be done once on

 * a header.

 *

 * @param header the header

 * @param serial the serial

 */

void

_dbus_header_set_serial (DBusHeader    *header,

                         dbus_uint32_t  serial)

{

  /* we use this function to set the serial on outgoing

   * messages, and to reset the serial in dbus_message_copy;

   * this assertion should catch a double-set on outgoing.

   */

  _dbus_assert (_dbus_header_get_serial (header) == 0 ||

                serial == 0);

  _dbus_marshal_set_uint32 (&header->data,

                            SERIAL_OFFSET,

			    serial,

                            header->byte_order);

}

/**

 * See dbus_message_get_serial()

 *

 * @param header the header

 * @returns the client serial

 */

dbus_uint32_t

_dbus_header_get_serial (DBusHeader *header)

{

  return _dbus_marshal_read_uint32 (&header->data,

                                    SERIAL_OFFSET,

                                    header->byte_order,

                                    NULL);

}

/**

 * Re-initializes a header that was previously initialized and never

 * freed.  After this, to make the header valid you have to call

 * _dbus_header_create().

 *

 * @param header header to re-initialize

 * @param byte_order byte order of the header

 */

void

_dbus_header_reinit (DBusHeader *header,

                     int         byte_order)

{

  _dbus_string_set_length (&header->data, 0);

  header->byte_order = byte_order;

  header->padding = 0;

  _dbus_header_cache_invalidate_all (header);

}

/**

 * Initializes a header, but doesn't prepare it for use;

 * to make the header valid, you have to call _dbus_header_create().

 *

 * @param header header to initialize

 * @param byte_order byte order of the header

 * @returns #FALSE if not enough memory

 */

dbus_bool_t

_dbus_header_init (DBusHeader *header,

                   int         byte_order)

{

  if (!_dbus_string_init_preallocated (&header->data, 32))

    return FALSE;

  _dbus_header_reinit (header, byte_order);

  return TRUE;

}

/**

 * Frees a header.

 *

 * @param header the header

 */

void

_dbus_header_free (DBusHeader *header)

{

  _dbus_string_free (&header->data);

}

/**

 * Initializes dest with a copy of the given header.

 * Resets the message serial to 0 on the copy.

 *

 * @param header header to copy

 * @param dest destination for copy

 * @returns #FALSE if not enough memory

 */

dbus_bool_t

_dbus_header_copy (const DBusHeader *header,

                   DBusHeader       *dest)

{

  *dest = *header;

  if (!_dbus_string_init_preallocated (&dest->data,

                                       _dbus_string_get_length (&header->data)))

    return FALSE;

  if (!_dbus_string_copy (&header->data, 0, &dest->data, 0))

    {

      _dbus_string_free (&dest->data);

      return FALSE;

    }

  /* Reset the serial */

  _dbus_header_set_serial (dest, 0);

  return TRUE;

}

/**

 * Fills in the primary fields of the header, so the header is ready

 * for use. #NULL may be specified for some or all of the fields to

 * avoid adding those fields. Some combinations of fields don't make

 * sense, and passing them in will trigger an assertion failure.

 *

 * @param header the header

 * @param message_type the message type

 * @param destination destination field or #NULL

 * @param path path field or #NULL

 * @param interface interface field or #NULL

 * @param member member field or #NULL

 * @param error_name error name or #NULL

 * @returns #FALSE if not enough memory

 */

dbus_bool_t

_dbus_header_create (DBusHeader  *header,

                     int          message_type,

                     const char  *destination,

                     const char  *path,

                     const char  *interface,

                     const char  *member,

                     const char  *error_name)

{

  unsigned char v_BYTE;

  dbus_uint32_t v_UINT32;

  DBusTypeWriter writer;

  DBusTypeWriter array;

  _dbus_assert (((interface || message_type != DBUS_MESSAGE_TYPE_SIGNAL) && member) ||

                (error_name) ||