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

/* dbus-message.c  DBusMessage object

 *

 * Copyright (C) 2002, 2003, 2004, 2005  Red Hat Inc.

 * Copyright (C) 2002, 2003  CodeFactory AB

 * 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-recursive.h"

#include "dbus-marshal-validate.h"

#include "dbus-marshal-byteswap.h"

#include "dbus-marshal-header.h"

#include "dbus-signature.h"

#include "dbus-message-private.h"

#include "dbus-object-tree.h"

#include "dbus-memory.h"

#include "dbus-list.h"

#include "dbus-threads-internal.h"

#include <string.h>

#ifdef __SYMBIAN32__

#include "libdbus_wsd_solution.h"

#endif

static void dbus_message_finalize (DBusMessage *message);

/**

 * @defgroup DBusMessageInternals DBusMessage implementation details

 * @ingroup DBusInternals

 * @brief DBusMessage private implementation details.

 *

 * The guts of DBusMessage and its methods.

 *

 * @{

 */

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

 */

/** An static string representing an empty signature */

_DBUS_STRING_DEFINE_STATIC(_dbus_empty_signature_str,  "");

/* these have wacky values to help trap uninitialized iterators;

 * but has to fit in 3 bits

 */

enum {

  DBUS_MESSAGE_ITER_TYPE_READER = 3,

  DBUS_MESSAGE_ITER_TYPE_WRITER = 7

};

/** typedef for internals of message iterator */

typedef struct DBusMessageRealIter DBusMessageRealIter;

/**

 * @brief Internals of DBusMessageIter

 *

 * Object representing a position in a message. All fields are internal.

 */

struct DBusMessageRealIter

{

  DBusMessage *message; /**< Message used */

  dbus_uint32_t changed_stamp : CHANGED_STAMP_BITS; /**< stamp to detect invalid iters */

  dbus_uint32_t iter_type : 3;      /**< whether this is a reader or writer iter */

  dbus_uint32_t sig_refcount : 8;   /**< depth of open_signature() */

  union

  {

    DBusTypeWriter writer; /**< writer */

    DBusTypeReader reader; /**< reader */

  } u; /**< the type writer or reader that does all the work */

};

#if EMULATOR

int GET_DBUS_WSD_VAR_NAME(_dbus_current_generation,dbus_memory,g)();

#define _dbus_current_generation (GET_DBUS_WSD_VAR_NAME(_dbus_current_generation,dbus_memory,g)())

#endif

static void

get_const_signature (DBusHeader        *header,

                     const DBusString **type_str_p,

                     int               *type_pos_p)

{

  if (_dbus_header_get_field_raw (header,

                                  DBUS_HEADER_FIELD_SIGNATURE,

                                  type_str_p,

                                  type_pos_p))

    {

      *type_pos_p += 1; /* skip the signature length which is 1 byte */

    }

  else

    {

      *type_str_p = &_dbus_empty_signature_str;

      *type_pos_p = 0;

    }

}

/**

 * Swaps the message to compiler byte order if required

 *

 * @param message the message

 */

static void

_dbus_message_byteswap (DBusMessage *message)

{

  const DBusString *type_str;

  int type_pos;

  if (message->byte_order == DBUS_COMPILER_BYTE_ORDER)

    return;

  _dbus_verbose ("Swapping message into compiler byte order\n");

  get_const_signature (&message->header, &type_str, &type_pos);

  _dbus_marshal_byteswap (type_str, type_pos,

                          message->byte_order,

                          DBUS_COMPILER_BYTE_ORDER,

                          &message->body, 0);

  message->byte_order = DBUS_COMPILER_BYTE_ORDER;

  _dbus_header_byteswap (&message->header, DBUS_COMPILER_BYTE_ORDER);

}

/** byte-swap the message if it doesn't match our byte order.

 *  Called only when we need the message in our own byte order,

 *  normally when reading arrays of integers or doubles.

 *  Otherwise should not be called since it would do needless

 *  work.

 */

#define ensure_byte_order(message)                      \

 if (message->byte_order != DBUS_COMPILER_BYTE_ORDER)   \

   _dbus_message_byteswap (message)

/**

 * Gets the data to be sent over the network for this message.

 * The header and then the body should be written out.

 * This function is guaranteed to always return the same

 * data once a message is locked (with _dbus_message_lock()).

 *

 * @param message the message.

 * @param header return location for message header data.

 * @param body return location for message body data.

 */

void

_dbus_message_get_network_data (DBusMessage          *message,

                                const DBusString    **header,

                                const DBusString    **body)

{

  _dbus_assert (message->locked);

  *header = &message->header.data;

  *body = &message->body;

}

/**

 * Sets the serial number of a message.

 * This can only be done once on a message.

 *

 * @param message the message

 * @param serial the serial

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

 void

_dbus_message_set_serial (DBusMessage   *message,

                          dbus_uint32_t  serial)

{

  _dbus_assert (message != NULL);

  _dbus_assert (!message->locked);

  _dbus_assert (dbus_message_get_serial (message) == 0);

  _dbus_header_set_serial (&message->header, serial);

}

/**

 * Adds a counter to be incremented immediately with the

 * size of this message, and decremented by the size

 * of this message when this message if finalized.

 * The link contains a counter with its refcount already

 * incremented, but the counter itself not incremented.

 * Ownership of link and counter refcount is passed to

 * the message.

 *

 * @param message the message

 * @param link link with counter as data

 */

void

_dbus_message_add_size_counter_link (DBusMessage  *message,

                                     DBusList     *link)

{

  /* right now we don't recompute the delta when message

   * size changes, and that's OK for current purposes

   * I think, but could be important to change later.

   * Do recompute it whenever there are no outstanding counters,

   * since it's basically free.

   */

  if (message->size_counters == NULL)

    {

      message->size_counter_delta =

        _dbus_string_get_length (&message->header.data) +

        _dbus_string_get_length (&message->body);

#if 0

      _dbus_verbose ("message has size %ld\n",

                     message->size_counter_delta);

#endif

    }

  _dbus_list_append_link (&message->size_counters, link);

  _dbus_counter_adjust (link->data, message->size_counter_delta);

}

/**

 * Adds a counter to be incremented immediately with the

 * size of this message, and decremented by the size

 * of this message when this message if finalized.

 *

 * @param message the message

 * @param counter the counter

 * @returns #FALSE if no memory

 */

dbus_bool_t

_dbus_message_add_size_counter (DBusMessage *message,

                                DBusCounter *counter)

{

  DBusList *link;

  link = _dbus_list_alloc_link (counter);

  if (link == NULL)

    return FALSE;

  _dbus_counter_ref (counter);

  _dbus_message_add_size_counter_link (message, link);

  return TRUE;

}

/**

 * Removes a counter tracking the size of this message, and decrements

 * the counter by the size of this message.

 *

 * @param message the message

 * @param link_return return the link used

 * @param counter the counter

 */

void

_dbus_message_remove_size_counter (DBusMessage  *message,

                                   DBusCounter  *counter,

                                   DBusList    **link_return)

{

  DBusList *link;

  link = _dbus_list_find_last (&message->size_counters,

                               counter);

  _dbus_assert (link != NULL);

  _dbus_list_unlink (&message->size_counters,

                     link);

  if (link_return)

    *link_return = link;

  else

    _dbus_list_free_link (link);

  _dbus_counter_adjust (counter, - message->size_counter_delta);

  _dbus_counter_unref (counter);

}

/**

 * Locks a message. Allows checking that applications don't keep a

 * reference to a message in the outgoing queue and change it

 * underneath us. Messages are locked when they enter the outgoing

 * queue (dbus_connection_send_message()), and the library complains

 * if the message is modified while locked.

 *

 * @param message the message to lock.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

 void

_dbus_message_lock (DBusMessage  *message)

{

  if (!message->locked)

    {

      _dbus_header_update_lengths (&message->header,

                                   _dbus_string_get_length (&message->body));

      /* must have a signature if you have a body */

      _dbus_assert (_dbus_string_get_length (&message->body) == 0 ||

                    dbus_message_get_signature (message) != NULL);

      message->locked = TRUE;

    }

}

static dbus_bool_t

set_or_delete_string_field (DBusMessage *message,

                            int          field,

                            int          typecode,

                            const char  *value)

{

  if (value == NULL)

    return _dbus_header_delete_field (&message->header, field);

  else

    return _dbus_header_set_field_basic (&message->header,

                                         field,

                                         typecode,

                                         &value);

}

#if 0

/* Probably we don't need to use this */

/**

 * Sets the signature of the message, i.e. the arguments in the

 * message payload. The signature includes only "in" arguments for

 * #DBUS_MESSAGE_TYPE_METHOD_CALL and only "out" arguments for

 * #DBUS_MESSAGE_TYPE_METHOD_RETURN, so is slightly different from

 * what you might expect (it does not include the signature of the

 * entire C++-style method).

 *

 * The signature is a string made up of type codes such as

 * #DBUS_TYPE_INT32. The string is terminated with nul (nul is also

 * the value of #DBUS_TYPE_INVALID). The macros such as

 * #DBUS_TYPE_INT32 evaluate to integers; to assemble a signature you

 * may find it useful to use the string forms, such as

 * #DBUS_TYPE_INT32_AS_STRING.

 *

 * An "unset" or #NULL signature is considered the same as an empty

 * signature. In fact dbus_message_get_signature() will never return

 * #NULL.

 *

 * @param message the message

 * @param signature the type signature or #NULL to unset

 * @returns #FALSE if no memory

 */

static dbus_bool_t

_dbus_message_set_signature (DBusMessage *message,

                             const char  *signature)

{

  _dbus_return_val_if_fail (message != NULL, FALSE);

  _dbus_return_val_if_fail (!message->locked, FALSE);

  _dbus_return_val_if_fail (signature == NULL ||

                            _dbus_check_is_valid_signature (signature));

  /* can't delete the signature if you have a message body */

  _dbus_return_val_if_fail (_dbus_string_get_length (&message->body) == 0 ||

                            signature != NULL);

  return set_or_delete_string_field (message,

                                     DBUS_HEADER_FIELD_SIGNATURE,

                                     DBUS_TYPE_SIGNATURE,

                                     signature);

}

#endif

/* Message Cache

 *

 * We cache some DBusMessage to reduce the overhead of allocating

 * them.  In my profiling this consistently made about an 8%

 * difference.  It avoids the malloc for the message, the malloc for

 * the slot list, the malloc for the header string and body string,

 * and the associated free() calls. It does introduce another global

 * lock which could be a performance issue in certain cases.

 *

 * For the echo client/server the round trip time goes from around

 * .000077 to .000069 with the message cache on my laptop. The sysprof

 * change is as follows (numbers are cumulative percentage):

 *

 *  with message cache implemented as array as it is now (0.000069 per):

 *    new_empty_header           1.46

 *      mutex_lock               0.56    # i.e. _DBUS_LOCK(message_cache)

 *      mutex_unlock             0.25

 *      self                     0.41

 *    unref                      2.24

 *      self                     0.68

 *      list_clear               0.43

 *      mutex_lock               0.33    # i.e. _DBUS_LOCK(message_cache)

 *      mutex_unlock             0.25

 *

 *  with message cache implemented as list (0.000070 per roundtrip):

 *    new_empty_header           2.72

 *      list_pop_first           1.88

 *    unref                      3.3

 *      list_prepend             1.63

 *

 * without cache (0.000077 per roundtrip):

 *    new_empty_header           6.7

 *      string_init_preallocated 3.43

 *        dbus_malloc            2.43

 *      dbus_malloc0             2.59

 *

 *    unref                      4.02

 *      string_free              1.82

 *        dbus_free              1.63

 *      dbus_free                0.71

 *

 * If you implement the message_cache with a list, the primary reason

 * it's slower is that you add another thread lock (on the DBusList

 * mempool).

 */

/** Avoid caching huge messages */

#define MAX_MESSAGE_SIZE_TO_CACHE 10 * _DBUS_ONE_KILOBYTE

/** Avoid caching too many messages */

#define MAX_MESSAGE_CACHE_SIZE    5

#if EMULATOR

GET_GLOBAL_VAR_FROM_TLS(_dbus_lock_message_cache,dbus_message,DBusMutex *)

#define _dbus_lock_message_cache (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_message_cache,dbus_message,g)())

#else

_DBUS_DEFINE_GLOBAL_LOCK (message_cache);

#endif

#ifndef EMULATOR

static DBusMessage *message_cache[MAX_MESSAGE_CACHE_SIZE];

static int message_cache_count = 0;

static dbus_bool_t message_cache_shutdown_registered = FALSE;

#else

GET_STATIC_VAR_FROM_TLS(message_cache_count,dbus_message,int)

#define message_cache_count (*GET_DBUS_WSD_VAR_NAME(message_cache_count,dbus_message,s)())

GET_STATIC_VAR_FROM_TLS(message_cache_shutdown_registered,dbus_message,dbus_bool_t)

#define message_cache_shutdown_registered (*GET_DBUS_WSD_VAR_NAME(message_cache_shutdown_registered,dbus_message,s)())

GET_STATIC_ARRAY_FROM_TLS(message_cache_array,dbus_message,DBusMessage *)

#define message_cache_array (GET_DBUS_WSD_VAR_NAME(message_cache_array,dbus_message,s)())

#endif

static void

dbus_message_cache_shutdown (void *data)

{

  int i;

  _DBUS_LOCK (message_cache);

  i = 0;

  while (i < MAX_MESSAGE_CACHE_SIZE)

    {

#ifndef EMULATOR    

      if (message_cache[i])

        dbus_message_finalize (message_cache[i]);

#else      

      if (message_cache_array[i])

        dbus_message_finalize (message_cache_array[i]);

#endif

      ++i;

    }

  message_cache_count = 0;

  message_cache_shutdown_registered = FALSE;

  _DBUS_UNLOCK (message_cache);

}

/**

 * Tries to get a message from the message cache.  The retrieved

 * message will have junk in it, so it still needs to be cleared out

 * in dbus_message_new_empty_header()

 *

 * @returns the message, or #NULL if none cached

 */

static DBusMessage*

dbus_message_get_cached (void)

{

  DBusMessage *message;

  int i;

  message = NULL;

  _DBUS_LOCK (message_cache);

  _dbus_assert (message_cache_count >= 0);

  if (message_cache_count == 0)

    {

      _DBUS_UNLOCK (message_cache);

      return NULL;

    }

  /* This is not necessarily true unless count > 0, and

   * message_cache is uninitialized until the shutdown is

   * registered

   */

  _dbus_assert (message_cache_shutdown_registered);

  i = 0;

  while (i < MAX_MESSAGE_CACHE_SIZE)

    {

    #ifndef EMULATOR

      if (message_cache[i])

        {

          message = message_cache[i];

          message_cache[i] = NULL;

          message_cache_count -= 1;

          break;

        }

#else

      if (message_cache_array[i])

        {

          message = message_cache_array[i];

          message_cache_array[i] = NULL;

          message_cache_count -= 1;

          break;

        }

#endif