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

/* dbus-sysdeps.c Wrappers around system/libc features shared between UNIX and Windows (internal to D-Bus implementation)

 * 

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

 * Copyright (C) 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-sysdeps.h"

#include "dbus-threads.h"

#include "dbus-protocol.h"

#include "dbus-string.h"

/* NOTE: If you include any unix/windows-specific headers here, you are probably doing something

 * wrong and should be putting some code in dbus-sysdeps-unix.c or dbus-sysdeps-win.c.

 *

 * These are the standard ANSI C headers...

 */

#include <locale.h>

#include <stdlib.h>

#include <string.h>

#ifdef __SYMBIAN32__

#include "config.h"

#include "libdbus_wsd_solution.h"

#endif //__SYMBIAN32__

/* This is UNIX-specific (on windows it's just in stdlib.h I believe)

 * but OK since the same stuff does exist on Windows in stdlib.h

 * and covered by a configure check.

 */

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#if EMULATOR

GET_GLOBAL_VAR_FROM_TLS(_dbus_lock_win_fds,dbus_sysdeps,DBusMutex *)

#define _dbus_lock_win_fds (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_win_fds,dbus_sysdeps,g)())

GET_GLOBAL_VAR_FROM_TLS(_dbus_lock_sid_atom_cache,dbus_sysdeps,DBusMutex *)

#define _dbus_lock_sid_atom_cache (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_sid_atom_cache,dbus_sysdeps,g)())

#else

_DBUS_DEFINE_GLOBAL_LOCK (win_fds);

_DBUS_DEFINE_GLOBAL_LOCK (sid_atom_cache);

#endif

/**

 * @defgroup DBusSysdeps Internal system-dependent API

 * @ingroup DBusInternals

 * @brief Internal system-dependent API available on UNIX and Windows

 *

 * The system-dependent API has a dual purpose. First, it encapsulates

 * all usage of operating system APIs for ease of auditing and to

 * avoid cluttering the rest of the code with bizarre OS quirks and

 * headers. Second, it abstracts different operating system APIs for

 * portability.

 * 

 * @{

 */

/**

 * Aborts the program with SIGABRT (dumping core).

 */

void

_dbus_abort (void)

{

  const char *s;

  _dbus_print_backtrace ();

  s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT");

  if (s && *s)

    {

      /* don't use _dbus_warn here since it can _dbus_abort() */

      //fprintf (stderr, "  Process %lu sleeping for gdb attach\n", (unsigned long) _dbus_getpid());

      _dbus_sleep_milliseconds (1000 * 180);

    }

  abort ();

  _dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */

}

/**

 * Wrapper for setenv(). If the value is #NULL, unsets

 * the environment variable.

 *

 * There is an unfixable memleak in that it is unsafe to

 * free memory malloced for use with setenv. This is because

 * we can not rely on internal implementation details of

 * the underlying libc library.

 *

 * @param varname name of environment variable

 * @param value value of environment variable

 * @returns #TRUE on success.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_setenv (const char *varname,

              const char *value)

{

  _dbus_assert (varname != NULL);

  if (value == NULL)

    {

#ifdef HAVE_UNSETENV

      unsetenv (varname);

      return TRUE;

#else

      char *putenv_value;

      size_t len;

      len = strlen (varname);

      /* Use system malloc to avoid memleaks that dbus_malloc

       * will get upset about.

       */

      putenv_value = malloc (len + 1);

      if (putenv_value == NULL)

        return FALSE;

      strcpy (putenv_value, varname);

      return (putenv (putenv_value) == 0);

#endif

    }

  else

    {

#ifdef HAVE_SETENV

      return (setenv (varname, value, TRUE) == 0);

#else

      char *putenv_value;

      size_t len;

      size_t varname_len;

      size_t value_len;

      varname_len = strlen (varname);

      value_len = strlen (value);

      len = varname_len + value_len + 1 /* '=' */ ;

      /* Use system malloc to avoid memleaks that dbus_malloc

       * will get upset about.

       */

      putenv_value = malloc (len + 1);

      if (putenv_value == NULL)

        return FALSE;

      strcpy (putenv_value, varname);

      strcpy (putenv_value + varname_len, "=");

      strcpy (putenv_value + varname_len + 1, value);

      return (putenv (putenv_value) == 0);

#endif

    }

}

/**

 * Wrapper for getenv().

 *

 * @param varname name of environment variable

 * @returns value of environment variable or #NULL if unset

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

const char*

_dbus_getenv (const char *varname)

{  

  return getenv (varname);

}

/** @} */

/**

 * @addtogroup DBusString

 *

 * @{

 */

/**

 * Appends an integer to a DBusString.

 * 

 * @param str the string

 * @param value the integer value

 * @returns #FALSE if not enough memory or other failure.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_string_append_int (DBusString *str,

                         long        value)

{

  /* this calculation is from comp.lang.c faq */

#define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1)  /* +1 for '-' */

  int orig_len;

  int i;

  char *buf;

  orig_len = _dbus_string_get_length (str);

  if (!_dbus_string_lengthen (str, MAX_LONG_LEN))

    return FALSE;

  buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);

  snprintf (buf, MAX_LONG_LEN, "%ld", value);

  i = 0;

  while (*buf)

    {

      ++buf;

      ++i;

    }

  _dbus_string_shorten (str, MAX_LONG_LEN - i);

  return TRUE;

}

/**

 * Appends an unsigned integer to a DBusString.

 * 

 * @param str the string

 * @param value the integer value

 * @returns #FALSE if not enough memory or other failure.

 */

dbus_bool_t

_dbus_string_append_uint (DBusString    *str,

                          unsigned long  value)

{

  /* this is wrong, but definitely on the high side. */

#define MAX_ULONG_LEN (MAX_LONG_LEN * 2)

  int orig_len;

  int i;

  char *buf;

  orig_len = _dbus_string_get_length (str);

  if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))

    return FALSE;

  buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);

  snprintf (buf, MAX_ULONG_LEN, "%lu", value);

  i = 0;

  while (*buf)

    {

      ++buf;

      ++i;

    }

  _dbus_string_shorten (str, MAX_ULONG_LEN - i);

  return TRUE;

}

#ifdef DBUS_BUILD_TESTS

/**

 * Appends a double to a DBusString.

 * 

 * @param str the string

 * @param value the floating point value

 * @returns #FALSE if not enough memory or other failure.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_string_append_double (DBusString *str,

                            double      value)

{

#define MAX_DOUBLE_LEN 64 /* this is completely made up :-/ */

  int orig_len;

  char *buf;

  int i;

  orig_len = _dbus_string_get_length (str);

  if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN))

    return FALSE;

  buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN);

  snprintf (buf, MAX_LONG_LEN, "%g", value);

  i = 0;

  while (*buf)

    {

      ++buf;

      ++i;

    }

  _dbus_string_shorten (str, MAX_DOUBLE_LEN - i);

  return TRUE;

}

#endif /* DBUS_BUILD_TESTS */

/**

 * Parses an integer contained in a DBusString. Either return parameter

 * may be #NULL if you aren't interested in it. The integer is parsed

 * and stored in value_return. Return parameters are not initialized

 * if the function returns #FALSE.

 *

 * @param str the string

 * @param start the byte index of the start of the integer

 * @param value_return return location of the integer value or #NULL

 * @param end_return return location of the end of the integer, or #NULL

 * @returns #TRUE on success

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_string_parse_int (const DBusString *str,

                        int               start,

                        long             *value_return,

                        int              *end_return)

{

  long v;

  const char *p;

  char *end;

  p = _dbus_string_get_const_data_len (str, start,

                                       _dbus_string_get_length (str) - start);

  end = NULL;

  errno = 0;

  v = strtol (p, &end, 0);

  if (end == NULL || end == p || errno != 0)

    return FALSE;

  if (value_return)

    *value_return = v;

  if (end_return)

    *end_return = start + (end - p);

  return TRUE;

}

/**

 * Parses an unsigned integer contained in a DBusString. Either return

 * parameter may be #NULL if you aren't interested in it. The integer

 * is parsed and stored in value_return. Return parameters are not

 * initialized if the function returns #FALSE.

 *

 * @param str the string

 * @param start the byte index of the start of the integer

 * @param value_return return location of the integer value or #NULL

 * @param end_return return location of the end of the integer, or #NULL

 * @returns #TRUE on success

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_string_parse_uint (const DBusString *str,

                         int               start,

                         unsigned long    *value_return,

                         int              *end_return)

{

  unsigned long v;

  const char *p;

  char *end;

  p = _dbus_string_get_const_data_len (str, start,

                                       _dbus_string_get_length (str) - start);

  end = NULL;

  errno = 0;

  v = strtoul (p, &end, 0);

  if (end == NULL || end == p || errno != 0)

    return FALSE;

  if (value_return)

    *value_return = v;

  if (end_return)

    *end_return = start + (end - p);

  return TRUE;

}

#ifdef DBUS_BUILD_TESTS

static dbus_bool_t

ascii_isspace (char c)

{

  return (c == ' ' ||

	  c == '\f' ||

	  c == '\n' ||

	  c == '\r' ||

	  c == '\t' ||

	  c == '\v');

}

#endif /* DBUS_BUILD_TESTS */

#ifdef DBUS_BUILD_TESTS

static dbus_bool_t

ascii_isdigit (char c)

{

  return c >= '0' && c <= '9';

}

#endif /* DBUS_BUILD_TESTS */

#ifdef DBUS_BUILD_TESTS

static dbus_bool_t

ascii_isxdigit (char c)

{

  return (ascii_isdigit (c) ||

	  (c >= 'a' && c <= 'f') ||

	  (c >= 'A' && c <= 'F'));

}

#endif /* DBUS_BUILD_TESTS */

#ifdef DBUS_BUILD_TESTS

/* Calls strtod in a locale-independent fashion, by looking at

 * the locale data and patching the decimal comma to a point.

 *

 * Relicensed from glib.

 */

static double

ascii_strtod (const char *nptr,

	      char      **endptr)

{

  char *fail_pos;

  double val;

  struct lconv *locale_data;

  const char *decimal_point;

  int decimal_point_len;

  const char *p, *decimal_point_pos;

  const char *end = NULL; /* Silence gcc */

  fail_pos = NULL;

  locale_data = localeconv ();

  decimal_point = locale_data->decimal_point;

  decimal_point_len = strlen (decimal_point);

  _dbus_assert (decimal_point_len != 0);

  decimal_point_pos = NULL;

  if (decimal_point[0] != '.' ||

      decimal_point[1] != 0)

    {

      p = nptr;

      /* Skip leading space */

      while (ascii_isspace (*p))

	p++;

      /* Skip leading optional sign */

      if (*p == '+' || *p == '-')

	p++;

      if (p[0] == '0' &&

	  (p[1] == 'x' || p[1] == 'X'))

	{

	  p += 2;

	  /* HEX - find the (optional) decimal point */

	  while (ascii_isxdigit (*p))

	    p++;

	  if (*p == '.')

	    {

	      decimal_point_pos = p++;

	      while (ascii_isxdigit (*p))

		p++;

	      if (*p == 'p' || *p == 'P')

		p++;

	      if (*p == '+' || *p == '-')

		p++;

	      while (ascii_isdigit (*p))

		p++;

	      end = p;

	    }

	}

      else

	{

	  while (ascii_isdigit (*p))

	    p++;

	  if (*p == '.')

	    {

	      decimal_point_pos = p++;

	      while (ascii_isdigit (*p))

		p++;

	      if (*p == 'e' || *p == 'E')

		p++;

	      if (*p == '+' || *p == '-')

		p++;

	      while (ascii_isdigit (*p))

		p++;

	      end = p;

	    }

	}

      /* For the other cases, we need not convert the decimal point */

    }