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

/* dbus-marshal-basic.c  Marshalling routines for basic (primitive) types

 *

 * Copyright (C) 2002 CodeFactory AB

 * Copyright (C) 2003, 2004, 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-basic.h"

#include "dbus-signature.h"

#include <string.h>

/**

 * @defgroup DBusMarshal marshaling and unmarshaling

 * @ingroup  DBusInternals

 * @brief functions to marshal/unmarshal data from the wire

 *

 * Types and functions related to converting primitive data types from

 * wire format to native machine format, and vice versa.

 *

 * A signature is just a string with multiple types one after the other.

 * for example a type is "i" or "(ii)", a signature is "i(ii)"

 * where i is int and (ii) is struct { int; int; }

 *

 * @{

 */

static void

pack_2_octets (dbus_uint16_t   value,

               int             byte_order,

               unsigned char  *data)

{

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);

  if ((byte_order) == DBUS_LITTLE_ENDIAN)

    *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_LE (value);

  else

    *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_BE (value);

}

static void

pack_4_octets (dbus_uint32_t   value,

               int             byte_order,

               unsigned char  *data)

{

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);

  if ((byte_order) == DBUS_LITTLE_ENDIAN)

    *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);

  else

    *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);

}

static void

pack_8_octets (DBusBasicValue     value,

               int                byte_order,

               unsigned char     *data)

{

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);

#ifdef DBUS_HAVE_INT64

  if ((byte_order) == DBUS_LITTLE_ENDIAN)

    *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);

  else

    *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);

#else

  *(DBus8ByteStruct*)data = value.u64;

  swap_8_octets ((DBusBasicValue*)data, byte_order);

#endif

}

/**

 * Packs a 32 bit unsigned integer into a data pointer.

 *

 * @param value the value

 * @param byte_order the byte order to use

 * @param data the data pointer

 */

void

_dbus_pack_uint32 (dbus_uint32_t   value,

                   int             byte_order,

                   unsigned char  *data)

{

  pack_4_octets (value, byte_order, data);

}

#ifndef DBUS_HAVE_INT64

/* from ORBit */

static void

swap_bytes (unsigned char *data,

            unsigned int   len)

{

  unsigned char *p1 = data;

  unsigned char *p2 = data + len - 1;

  while (p1 < p2)

    {

      unsigned char tmp = *p1;

      *p1 = *p2;

      *p2 = tmp;

      --p2;

      ++p1;

    }

}

#endif /* !DBUS_HAVE_INT64 */

static void

swap_8_octets (DBusBasicValue    *value,

               int                byte_order)

{

  if (byte_order != DBUS_COMPILER_BYTE_ORDER)

    {

#ifdef DBUS_HAVE_INT64

      value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);

#else

      swap_bytes ((unsigned char *)value, 8);

#endif

    }

}

#if 0

static DBusBasicValue

unpack_8_octets (int                  byte_order,

                 const unsigned char *data)

{

  DBusBasicValue r;

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);

  _dbus_assert (sizeof (r) == 8);

#ifdef DBUS_HAVE_INT64

  if (byte_order == DBUS_LITTLE_ENDIAN)

    r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);

  else

    r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);

#else

  r.u64 = *(DBus8ByteStruct*)data;

  swap_8_octets (&r, byte_order);

#endif

  return r;

}

#endif

#ifndef _dbus_unpack_uint16

/**

 * Unpacks a 16 bit unsigned integer from a data pointer

 *

 * @param byte_order The byte order to use

 * @param data the data pointer

 * @returns the integer

 */

dbus_uint16_t

_dbus_unpack_uint16 (int                  byte_order,

                     const unsigned char *data)

{

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);

  if (byte_order == DBUS_LITTLE_ENDIAN)

    return DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)data);

  else

    return DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)data);

}

#endif /* _dbus_unpack_uint16 */

#ifndef _dbus_unpack_uint32

/**

 * Unpacks a 32 bit unsigned integer from a data pointer

 *

 * @param byte_order The byte order to use

 * @param data the data pointer

 * @returns the integer

 */

dbus_uint32_t

_dbus_unpack_uint32 (int                  byte_order,

                     const unsigned char *data)

{

  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);

  if (byte_order == DBUS_LITTLE_ENDIAN)

    return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);

  else

    return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);

}

#endif /* _dbus_unpack_uint32 */

static void

set_2_octets (DBusString          *str,

              int                  offset,

              dbus_uint16_t        value,

              int                  byte_order)

{

  char *data;

  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||

                byte_order == DBUS_BIG_ENDIAN);

  data = _dbus_string_get_data_len (str, offset, 2);

#ifdef __SYMBIAN32__

  pack_2_octets (value, byte_order, (unsigned char *) data);

#else

  pack_2_octets (value, byte_order, data);

#endif

}

static void

set_4_octets (DBusString          *str,

              int                  offset,

              dbus_uint32_t        value,

              int                  byte_order)

{

  char *data;

  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||

                byte_order == DBUS_BIG_ENDIAN);

  data = _dbus_string_get_data_len (str, offset, 4);

#ifdef __SYMBIAN32__

  pack_4_octets (value, byte_order, (unsigned char *) data);

#else

  pack_4_octets (value, byte_order, data);

#endif

}

static void

set_8_octets (DBusString          *str,

              int                  offset,

              DBusBasicValue       value,

              int                  byte_order)

{

  char *data;

  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||

                byte_order == DBUS_BIG_ENDIAN);

  data = _dbus_string_get_data_len (str, offset, 8);

#ifdef __SYMBIAN32__

  pack_8_octets (value, byte_order, (unsigned char *) data);

#else

  pack_8_octets (value, byte_order, data);

#endif

}

/**

 * Sets the 4 bytes at the given offset to a marshaled unsigned

 * integer, replacing anything found there previously.

 *

 * @param str the string to write the marshalled int to

 * @param pos the byte offset where int should be written

 * @param value the value

 * @param byte_order the byte order to use

 *

 */

 #ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_dbus_marshal_set_uint32 (DBusString          *str,

                          int                  pos,

                          dbus_uint32_t        value,

                          int                  byte_order)

{

  set_4_octets (str, pos, value, byte_order);

}

/**

 * Sets the existing marshaled string at the given offset with

 * a new marshaled string. The given offset must point to

 * an existing string or the wrong length will be deleted

 * and replaced with the new string.

 *

 * Note: no attempt is made by this function to re-align

 * any data which has been already marshalled after this

 * string. Use with caution.

 *

 * @param str the string to write the marshalled string to

 * @param pos the position of the marshaled string length

 * @param value the value

 * @param byte_order the byte order to use

 * @param old_end_pos place to store byte after the nul byte of the old value

 * @param new_end_pos place to store byte after the nul byte of the new value

 * @returns #TRUE on success, #FALSE if no memory

 *

 */

static dbus_bool_t

set_string (DBusString          *str,

            int                  pos,

            const char          *value,

            int                  byte_order,

            int                 *old_end_pos,

            int                 *new_end_pos)

{

  int old_len, new_len;

  DBusString dstr;

  _dbus_string_init_const (&dstr, value);

  _dbus_assert (_DBUS_ALIGN_VALUE (pos, 4) == (unsigned) pos);

  old_len = _dbus_unpack_uint32 (byte_order,

                                 _dbus_string_get_const_data_len (str, pos, 4));

  new_len = _dbus_string_get_length (&dstr);

  if (!_dbus_string_replace_len (&dstr, 0, new_len,

                                 str, pos + 4, old_len))

    return FALSE;

  _dbus_marshal_set_uint32 (str, pos, new_len, byte_order);

  if (old_end_pos)

    *old_end_pos = pos + 4 + old_len + 1;

  if (new_end_pos)

    *new_end_pos = pos + 4 + new_len + 1;

  return TRUE;

}

/**

 * Sets the existing marshaled signature at the given offset to a new

 * marshaled signature. Same basic ideas as set_string().

 *

 * @param str the string to write the marshalled signature to

 * @param pos the position of the marshaled signature length

 * @param value the value

 * @param byte_order the byte order to use

 * @param old_end_pos place to store byte after the nul byte of the old value

 * @param new_end_pos place to store byte after the nul byte of the new value

 * @returns #TRUE on success, #FALSE if no memory

 *

 */

static dbus_bool_t

set_signature (DBusString          *str,

               int                  pos,

               const char          *value,

               int                  byte_order,

               int                 *old_end_pos,

               int                 *new_end_pos)

{

  int old_len, new_len;

  DBusString dstr;

  _dbus_string_init_const (&dstr, value);

  old_len = _dbus_string_get_byte (str, pos);

  new_len = _dbus_string_get_length (&dstr);

  if (!_dbus_string_replace_len (&dstr, 0, new_len,

                                 str, pos + 1, old_len))

    return FALSE;

  _dbus_string_set_byte (str, pos, new_len);

  if (old_end_pos)

    *old_end_pos = pos + 1 + old_len + 1;

  if (new_end_pos)

    *new_end_pos = pos + 1 + new_len + 1;

  return TRUE;

}

/**

 * Sets an existing basic type value to a new value.

 * Arguments work the same way as _dbus_marshal_basic_type().

 *

 * @param str the string

 * @param pos location of the current value

 * @param type the type of the current and new values

 * @param value the address of the new value

 * @param byte_order byte order for marshaling

 * @param old_end_pos location to store end position of the old value, or #NULL

 * @param new_end_pos location to store end position of the new value, or #NULL

 * @returns #FALSE if no memory

 */

dbus_bool_t

_dbus_marshal_set_basic (DBusString       *str,

                         int               pos,

                         int               type,

                         const void       *value,

                         int               byte_order,

                         int              *old_end_pos,

                         int              *new_end_pos)

{

  const DBusBasicValue *vp;

  vp = value;

  switch (type)

    {

    case DBUS_TYPE_BYTE:

      _dbus_string_set_byte (str, pos, vp->byt);

      if (old_end_pos)

        *old_end_pos = pos + 1;

      if (new_end_pos)

        *new_end_pos = pos + 1;

      return TRUE;

      break;

    case DBUS_TYPE_INT16:

    case DBUS_TYPE_UINT16:

      pos = _DBUS_ALIGN_VALUE (pos, 2);

      set_2_octets (str, pos, vp->u16, byte_order);

      if (old_end_pos)

        *old_end_pos = pos + 2;

      if (new_end_pos)

        *new_end_pos = pos + 2;

      return TRUE;

      break;

    case DBUS_TYPE_BOOLEAN:

    case DBUS_TYPE_INT32:

    case DBUS_TYPE_UINT32:

      pos = _DBUS_ALIGN_VALUE (pos, 4);

      set_4_octets (str, pos, vp->u32, byte_order);

      if (old_end_pos)

        *old_end_pos = pos + 4;

      if (new_end_pos)

        *new_end_pos = pos + 4;

      return TRUE;

      break;

    case DBUS_TYPE_INT64:

    case DBUS_TYPE_UINT64:

    case DBUS_TYPE_DOUBLE:

      pos = _DBUS_ALIGN_VALUE (pos, 8);

      set_8_octets (str, pos, *vp, byte_order);

      if (old_end_pos)

        *old_end_pos = pos + 8;

      if (new_end_pos)

        *new_end_pos = pos + 8;

      return TRUE;

      break;

    case DBUS_TYPE_STRING:

    case DBUS_TYPE_OBJECT_PATH:

      pos = _DBUS_ALIGN_VALUE (pos, 4);

      _dbus_assert (vp->str != NULL);

      return set_string (str, pos, vp->str, byte_order,

                         old_end_pos, new_end_pos);

      break;

    case DBUS_TYPE_SIGNATURE:

      _dbus_assert (vp->str != NULL);

      return set_signature (str, pos, vp->str, byte_order,

                            old_end_pos, new_end_pos);

      break;

    default:

      _dbus_assert_not_reached ("not a basic type");

      return FALSE;

      break;

    }

}

/**

 * Convenience function to demarshal a 32 bit unsigned integer.

 *

 * @param str the string containing the data

 * @param byte_order the byte order

 * @param pos the position in the string

 * @param new_pos the new position of the string

 * @returns the demarshaled integer.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

 dbus_uint32_t

_dbus_marshal_read_uint32  (const DBusString *str,

                            int               pos,

                            int               byte_order,

                            int              *new_pos)

{

  pos = _DBUS_ALIGN_VALUE (pos, 4);

  if (new_pos)

    *new_pos = pos + 4;

  _dbus_assert (pos + 4 <= _dbus_string_get_length (str));

  return _dbus_unpack_uint32 (byte_order,

                              _dbus_string_get_const_data (str) + pos);

}

/**

 * Demarshals a basic-typed value. The "value" pointer is always

 * the address of a variable of the basic type. So e.g.

 * if the basic type is "double" then the pointer is

 * a double*, and if it's "char*" then the pointer is

 * a "char**".

 *

 * A value of type #DBusBasicValue is guaranteed to be large enough to

 * hold any of the types that may be returned, which is handy if you

 * are trying to do things generically. For example you can pass

 * a DBusBasicValue* in to this function, and then pass the same

 * DBusBasicValue* in to _dbus_marshal_basic_type() in order to

 * move a value from one place to another.

 *

 * @param str the string containing the data

 * @param pos position in the string

 * @param type type of value to demarshal

 * @param value pointer to return value data

 * @param byte_order the byte order

 * @param new_pos pointer to update with new position, or #NULL

 **/

void

_dbus_marshal_read_basic (const DBusString      *str,

                          int                    pos,

                          int                    type,

                          void                  *value,

                          int                    byte_order,

                          int                   *new_pos)

{

  const char *str_data;