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

/* dbus-internals.c  random utility stuff (internal to D-Bus implementation)

 *

 * Copyright (C) 2002, 2003  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 <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <stdlib.h>

#include "dbus-protocol.h"

#include "dbus-marshal-basic.h"

#include "dbus-test.h"

#include "dbus-internals.h"

#ifdef __SYMBIAN32__

#include "config.h"

#include "libdbus_wsd_solution.h"

#endif

#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

/**

 * @defgroup DBusInternals D-Bus secret internal implementation details

 * @brief Documentation useful when developing or debugging D-Bus itself.

 * 

 */

/**

 * @defgroup DBusInternalsUtils Utilities and portability

 * @ingroup DBusInternals

 * @brief Utility functions (_dbus_assert(), _dbus_warn(), etc.)

 * @{

 */

/**

 * @def _dbus_assert

 *

 * Aborts with an error message if the condition is false.

 * 

 * @param condition condition which must be true.

 */

/**

 * @def _dbus_assert_not_reached

 *

 * Aborts with an error message if called.

 * The given explanation will be printed.

 * 

 * @param explanation explanation of what happened if the code was reached.

 */

/**

 * @def _DBUS_N_ELEMENTS

 *

 * Computes the number of elements in a fixed-size array using

 * sizeof().

 *

 * @param array the array to count elements in.

 */

/**

 * @def _DBUS_POINTER_TO_INT

 *

 * Safely casts a void* to an integer; should only be used on void*

 * that actually contain integers, for example one created with

 * _DBUS_INT_TO_POINTER.  Only guaranteed to preserve 32 bits.

 * (i.e. it's used to store 32-bit ints in pointers, but

 * can't be used to store 64-bit pointers in ints.)

 *

 * @param pointer pointer to extract an integer from.

 */

/**

 * @def _DBUS_INT_TO_POINTER

 *

 * Safely stuffs an integer into a pointer, to be extracted later with

 * _DBUS_POINTER_TO_INT. Only guaranteed to preserve 32 bits.

 *

 * @param integer the integer to stuff into a pointer.

 */

/**

 * @def _DBUS_ZERO

 *

 * Sets all bits in an object to zero.

 *

 * @param object the object to be zeroed.

 */

/**

 * @def _DBUS_INT16_MIN

 *

 * Minimum value of type "int16"

 */

/**

 * @def _DBUS_INT16_MAX

 *

 * Maximum value of type "int16"

 */

/**

 * @def _DBUS_UINT16_MAX

 *

 * Maximum value of type "uint16"

 */

/**

 * @def _DBUS_INT32_MIN

 *

 * Minimum value of type "int32"

 */

/**

 * @def _DBUS_INT32_MAX

 *

 * Maximum value of type "int32"

 */

/**

 * @def _DBUS_UINT32_MAX

 *

 * Maximum value of type "uint32"

 */

/**

 * @def _DBUS_INT_MIN

 *

 * Minimum value of type "int"

 */

/**

 * @def _DBUS_INT_MAX

 *

 * Maximum value of type "int"

 */

/**

 * @def _DBUS_UINT_MAX

 *

 * Maximum value of type "uint"

 */

/**

 * @typedef DBusForeachFunction

 * 

 * Used to iterate over each item in a collection, such as

 * a DBusList.

 */

/**

 * @def _DBUS_LOCK_NAME

 *

 * Expands to name of a global lock variable.

 */

/**

 * @def _DBUS_DEFINE_GLOBAL_LOCK

 *

 * Defines a global lock variable with the given name.

 * The lock must be added to the list to initialize

 * in dbus_threads_init().

 */

/**

 * @def _DBUS_DECLARE_GLOBAL_LOCK

 *

 * Expands to declaration of a global lock defined

 * with _DBUS_DEFINE_GLOBAL_LOCK.

 * The lock must be added to the list to initialize

 * in dbus_threads_init().

 */

/**

 * @def _DBUS_LOCK

 *

 * Locks a global lock

 */

/**

 * @def _DBUS_UNLOCK

 *

 * Unlocks a global lock

 */

/**

 * Fixed "out of memory" error message, just to avoid

 * making up a different string every time and wasting

 * space.

 */

#ifdef __SYMBIAN32__

 EXPORT_C 

char * symbian_dbus_no_memory_message()

{	

	return "Not enough memory";

}

#else

const char _dbus_no_memory_message[] = "Not enough memory";

#endif

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(warn_initted,dbus_internal,dbus_bool_t)

#define warn_initted (*GET_DBUS_WSD_VAR_NAME(warn_initted,dbus_internal,s)())

GET_STATIC_VAR_FROM_TLS(fatal_warnings,dbus_internal,dbus_bool_t)

#define fatal_warnings (*GET_DBUS_WSD_VAR_NAME(fatal_warnings,dbus_internal,s)())

GET_STATIC_VAR_FROM_TLS(fatal_warnings_on_check_failed,dbus_internal,dbus_bool_t)

#define fatal_warnings_on_check_failed (*GET_DBUS_WSD_VAR_NAME(fatal_warnings_on_check_failed,dbus_internal,s)())

#else

static dbus_bool_t warn_initted = FALSE;

static dbus_bool_t fatal_warnings = FALSE;

static dbus_bool_t fatal_warnings_on_check_failed = TRUE;

#endif

static void

init_warnings(void)

{

  if (!warn_initted)

    {

      const char *s;

      s = _dbus_getenv ("DBUS_FATAL_WARNINGS");

      if (s && *s)

        {

          if (*s == '0')

            {

              fatal_warnings = FALSE;

              fatal_warnings_on_check_failed = FALSE;

            }

          else if (*s == '1')

            {

              fatal_warnings = TRUE;

              fatal_warnings_on_check_failed = TRUE;

            }

          else

            {

              fprintf(stderr, "DBUS_FATAL_WARNINGS should be set to 0 or 1 if set, not '%s'",

                      s);

            }

        }

      warn_initted = TRUE;

    }

}

/**

 * Prints a warning message to stderr. Can optionally be made to exit

 * fatally by setting DBUS_FATAL_WARNINGS, but this is rarely

 * used. This function should be considered pretty much equivalent to

 * fprintf(stderr). _dbus_warn_check_failed() on the other hand is

 * suitable for use when a programming mistake has been made.

 *

 * @param format printf-style format string.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_dbus_warn (const char *format,

            ...)

{

  va_list args;

  if (!warn_initted)

    init_warnings ();

  va_start (args, format);

  vfprintf (stderr, format, args);

  va_end (args);

  if (fatal_warnings)

    {

      fflush (stderr);

      _dbus_abort ();

    }

}

/**

 * Prints a "critical" warning to stderr when an assertion fails;

 * differs from _dbus_warn primarily in that it prefixes the pid and

 * defaults to fatal. This should be used only when a programming

 * error has been detected. (NOT for unavoidable errors that an app

 * might handle - those should be returned as DBusError.) Calling this

 * means "there is a bug"

 */

#ifdef __SYMBIAN32__

 EXPORT_C

 #endif

void

_dbus_warn_check_failed(const char *format,

                        ...)

{

  va_list args;

  if (!warn_initted)

    init_warnings ();

  fprintf (stderr, "process %lu: ", _dbus_getpid ());

  va_start (args, format);

  vfprintf (stderr, format, args);

  va_end (args);

  if (fatal_warnings_on_check_failed)

    {

      fflush (stderr);

      _dbus_abort ();

    }

}

#ifdef __SYMBIAN32__

#ifndef DBUS_ENABLE_VERBOSE_MODE

#define DBUS_ENABLE_VERBOSE_MODE 1

#endif //DBUS_ENABLE_VERBOSE_MODE

#endif //__SYMBIAN32__

#ifdef DBUS_ENABLE_VERBOSE_MODE

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(verbose_initted,dbus_internals,dbus_bool_t)

#define verbose_initted (*GET_DBUS_WSD_VAR_NAME(verbose_initted,dbus_internals,s)())

GET_STATIC_VAR_FROM_TLS(verbose,dbus_internals,dbus_bool_t)

#define verbose (*GET_DBUS_WSD_VAR_NAME(verbose,dbus_internals,s)())

#else

static dbus_bool_t verbose_initted = FALSE;

static dbus_bool_t verbose = TRUE;

#endif

/** Whether to show the current thread in verbose messages */

#define PTHREAD_IN_VERBOSE 0

#if PTHREAD_IN_VERBOSE

#include <pthread.h>

#endif

static inline void

_dbus_verbose_init (void)

{

  if (!verbose_initted)

    {

      const char *p = _dbus_getenv ("DBUS_VERBOSE"); 

      verbose = p != NULL && *p == '1';

      verbose_initted = TRUE;

    }

}

/**

 * Implementation of dbus_is_verbose() macro if built with verbose logging

 * enabled.

 * @returns whether verbose logging is active.

 */

dbus_bool_t

_dbus_is_verbose_real (void)

{

  _dbus_verbose_init ();

  return verbose;

}

/**

 * Prints a warning message to stderr

 * if the user has enabled verbose mode.

 * This is the real function implementation,

 * use _dbus_verbose() macro in code.

 *

 * @param format printf-style format string.

 */

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(need_pid,dbus_internals,dbus_bool_t)

#define need_pid (*GET_DBUS_WSD_VAR_NAME(need_pid,dbus_internals,s)())

#endif

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

void

_dbus_verbose_real (const char *format,

                    ...)

{

  va_list args;

#if !(EMULATOR)

  static dbus_bool_t need_pid = TRUE;

#endif // EMULATOR  

  int len;

  /* things are written a bit oddly here so that

   * in the non-verbose case we just have the one

   * conditional and return immediately.

   */

  if (!_dbus_is_verbose_real())

    return;

  /* Print out pid before the line */

  if (need_pid)

    {

#if PTHREAD_IN_VERBOSE

      fprintf (stderr, "%lu: 0x%lx: ", _dbus_getpid (), pthread_self ());

#else

      fprintf (stderr, "%lu: ", _dbus_getpid ());

#endif

    }

  /* Only print pid again if the next line is a new line */

  len = strlen (format);

  if (format[len-1] == '\n')

    need_pid = TRUE;

  else

    need_pid = FALSE;

  va_start (args, format);

  vfprintf (stderr, format, args);

  va_end (args);

  fflush (stderr);

}

#if EMULATOR

#undef need_pid

#endif //EMULATOR

/**

 * Reinitializes the verbose logging code, used

 * as a hack in dbus-spawn.c so that a child

 * process re-reads its pid

 *

 */

#ifdef __SYMBIAN32__

 EXPORT_C

 #endif

 void

_dbus_verbose_reset_real (void)

{

  verbose_initted = FALSE;

}

#endif /* DBUS_ENABLE_VERBOSE_MODE */

/**

 * Duplicates a string. Result must be freed with

 * dbus_free(). Returns #NULL if memory allocation fails.

 * If the string to be duplicated is #NULL, returns #NULL.

 * 

 * @param str string to duplicate.

 * @returns newly-allocated copy.

 */

#ifdef __SYMBIAN32__

 EXPORT_C

 #endif

 char*

_dbus_strdup (const char *str)

{

  size_t len;

  char *copy;

  if (str == NULL)

    return NULL;

  len = strlen (str);

  copy = dbus_malloc (len + 1);

  if (copy == NULL)

    return NULL;

  memcpy (copy, str, len + 1);

  return copy;

}

/**

 * Duplicates a block of memory. Returns

 * #NULL on failure.

 *

 * @param mem memory to copy

 * @param n_bytes number of bytes to copy

 * @returns the copy

 */

void*

_dbus_memdup (const void  *mem,

              size_t       n_bytes)

{

  void *copy;

  copy = dbus_malloc (n_bytes);

  if (copy == NULL)

    return NULL;

  memcpy (copy, mem, n_bytes);

  return copy;

}

/**

 * Duplicates a string array. Result may be freed with

 * dbus_free_string_array(). Returns #NULL if memory allocation fails.

 * If the array to be duplicated is #NULL, returns #NULL.

 * 

 * @param array array to duplicate.

 * @returns newly-allocated copy.

 */

char**

_dbus_dup_string_array (const char **array)

{

  int len;

  int i;

  char **copy;

  if (array == NULL)

    return NULL;

  for (len = 0; array[len] != NULL; ++len)

    ;