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

/* dbus-bus.c  Convenience functions for communicating with the bus.

 *

 * Copyright (C) 2003  CodeFactory AB

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

#include "dbus-protocol.h"

#include "dbus-internals.h"

#include "dbus-message.h"

#include "dbus-marshal-validate.h"

#include "dbus-threads-internal.h"

#include "dbus-connection-internal.h"

#include <string.h>

#ifdef __SYMBIAN32__

#include "libdbus_wsd_solution.h"

#endif

/**

 * @defgroup DBusBus Message bus APIs

 * @ingroup DBus

 * @brief Functions for communicating with the message bus

 *

 * dbus_bus_get() allows all modules and libraries in a given

 * process to share the same connection to the bus daemon by storing

 * the connection globally.

 *

 * All other functions in this module are just convenience functions;

 * most of them invoke methods on the bus daemon, by sending method

 * call messages to #DBUS_SERVICE_DBUS. These convenience functions

 * often make blocking method calls. If you don't want to block,

 * you can send the method call messages manually in the same way

 * you would any other method call message.

 *

 * This module is the only one in libdbus that's specific to

 * communicating with the message bus daemon. The rest of the API can

 * also be used for connecting to another application directly.

 * 

 * @todo right now the default address of the system bus is hardcoded,

 * so if you change it in the global config file suddenly you have to

 * set DBUS_SYSTEM_BUS_ADDRESS env variable.  Might be nice if the

 * client lib somehow read the config file, or if the bus on startup

 * somehow wrote out its address to a well-known spot, but might also

 * not be worth it.

 */

/**

 * @defgroup DBusBusInternals Message bus APIs internals

 * @ingroup DBusInternals

 * @brief Internals of functions for communicating with the message bus

 *

 * @{

 */

/**

 * Block of message-bus-related data we attach to each

 * #DBusConnection used with these convenience functions.

 *

 */

typedef struct

{

  DBusConnection *connection; /**< Connection we're associated with */

  char *unique_name; /**< Unique name of this connection */

  unsigned int is_well_known : 1; /**< Is one of the well-known connections in our global array */

} BusData;

/** The slot we have reserved to store BusData.

 */

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(bus_data_slot,dbus_bus,dbus_int32_t)

#define bus_data_slot (*GET_DBUS_WSD_VAR_NAME(bus_data_slot,dbus_bus,s)())

#else

static dbus_int32_t bus_data_slot = -1;

#endif

/** Number of bus types */

#define N_BUS_TYPES 3

#if EMULATOR

GET_STATIC_ARRAY_FROM_TLS(bus_connections,dbus_bus,DBusConnection *)

#define bus_connections (GET_DBUS_WSD_VAR_NAME(bus_connections,dbus_bus, s)())

GET_STATIC_ARRAY_FROM_TLS(bus_connection_addresses,dbus_bus,char *)

#define bus_connection_addresses (GET_DBUS_WSD_VAR_NAME(bus_connection_addresses,dbus_bus, s)())

#else

static DBusConnection *bus_connections[N_BUS_TYPES];

static char *bus_connection_addresses[N_BUS_TYPES] = { NULL, NULL, NULL };

#endif

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(activation_bus_type,dbus_bus,DBusBusType)

#define activation_bus_type (*GET_DBUS_WSD_VAR_NAME(activation_bus_type,dbus_bus,s)())

#else

static DBusBusType activation_bus_type = DBUS_BUS_STARTER;

#endif

#if EMULATOR

GET_STATIC_VAR_FROM_TLS(initialized,dbus_bus,dbus_bool_t)

#define initialized (*GET_DBUS_WSD_VAR_NAME(initialized,dbus_bus,s)())

#else

static dbus_bool_t initialized = FALSE;

#endif

/**

 * Lock for globals in this file

 */

#if EMULATOR

GET_GLOBAL_VAR_FROM_TLS(_dbus_lock_bus,dbus_bus,DBusMutex *)

#define _dbus_lock_bus (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus,dbus_bus,g)())

#else

_DBUS_DEFINE_GLOBAL_LOCK (bus);

#endif

/**

 * Global lock covering all BusData on any connection. The bet is

 * that some lock contention is better than more memory

 * for a per-connection lock, but it's tough to imagine it mattering

 * either way.

 */

#if EMULATOR

GET_GLOBAL_VAR_FROM_TLS(_dbus_lock_bus_datas,dbus_bus,DBusMutex *)

#define _dbus_lock_bus_datas (*GET_DBUS_WSD_VAR_NAME(_dbus_lock_bus_datas,dbus_bus,g)())

#else

_DBUS_DEFINE_GLOBAL_LOCK (bus_datas);

#endif

static void

addresses_shutdown_func (void *data)

{

  int i;

  i = 0;

  while (i < N_BUS_TYPES)

    {

      if (bus_connections[i] != NULL)

        _dbus_warn_check_failed ("dbus_shutdown() called but connections were still live. This probably means the application did not drop all its references to bus connections.\n");

      dbus_free (bus_connection_addresses[i]);

      bus_connection_addresses[i] = NULL;

      ++i;

    }

  activation_bus_type = DBUS_BUS_STARTER;

}

static dbus_bool_t

get_from_env (char           **connection_p,

              const char      *env_var)

{

  const char *s;

  _dbus_assert (*connection_p == NULL);

  s = _dbus_getenv (env_var);

  if (s == NULL || *s == '\0')

    return TRUE; /* successfully didn't use the env var */

  else

    {

      *connection_p = _dbus_strdup (s);

      return *connection_p != NULL;

    }

}

#ifdef __SYMBIAN32__

#if 0

#include<fcntl.h>

extern int check_lock();

int check_lock()

{

	_LIT(KFileName,DBUS_LOCK_FILE);

  /*

       struct flock {

	off_t	l_start;	 starting offset 

	off_t	l_len;		 len = 0 means until end of file 

	pid_t	l_pid;		 lock owner 

	short	l_type;		 lock type: read/write, etc. 

	short	l_whence;	 type of l_start 

}; l_type   l_whence  l_start  l_len  l_pid   */

    //	struct flock fl = { F_WRLCK, 0 /*SEEK_SET*/, 0,       0,     0 };

    //	struct flock fl = { 0, 0, 0,F_WRLCK,/* SEEK_SET*/ 0};

    	int fd;int flags=0;

     //   fl.l_pid = getpid();

    	/*

    	if ((fd = open(DBUS_LOCK_FILE, O_EXCL|O_CREAT)) == -1) {

    	//	perror("open");

    		if(errno==EEXIST)

    		return 0;

    	}

    	*/

    		if ((fd = open(DBUS_LOCK_FILE, O_EXCL|O_CREAT)) == -1) 

    		{

    			if(errno==EEXIST)

    			{

    				RFs rf;

    				User::LeaveIfError(rf.Connect());

    				RFile fds;

    				User::LeaveIfError(fds.open(rf,KFileName,EFileWrite));	

    				if(fds.Lock(0,0) == KErrNone)

    				{

						fds.UnLock(0,0)			

    					return 1;

    				}

    				else

    					return 0;

    			}

    		}

/*	 if (fcntl(fd, F_SETLK, &fl) == -1)

	  {

        if (errno == EACCES || errno == EAGAIN) 

        {

		//printf("Already locked by another process\n");

	 	close(fd);

		return 0;	

        }

	 }

*/	 

    else

    {

    close(fd);

	return 1;	

    }

}

#endif

static dbus_bool_t

init_connections_unlocked (void)

{

      const char *s;

      int i;

      if(initialized==FALSE)

      {

      i = 0;

      while (i < N_BUS_TYPES)

        {

          bus_connections[i] = NULL;

          ++i;

        }

      }

     #ifdef __SYMBIAN32__  

      if(!_dbus_semaphore_dec())

      	return FALSE;

     #endif 

      if(check_lock())     //lock is free..means no bus running..start a new bus

      {

      	if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

	    bus_connection_addresses[DBUS_BUS_SESSION] =

	      _dbus_strdup (DBUS_SESSION_BUS_DEFAULT_ADDRESS);

          if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

             return FALSE;

          _dbus_verbose ("  \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?

                         bus_connection_addresses[DBUS_BUS_SESSION] : "none set");

       initialized = TRUE;                  

      }

      else				//lock is set..means already a bus is running

      {

      	 bus_connection_addresses[DBUS_BUS_SESSION] =

	      _dbus_strdup (DBUS_SYMBIAN_SESSION_BUS_DEFAULT_ADDRESS);

	      initialized = TRUE; 

	       if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

             return FALSE;

      }

      /* If we return FALSE we have to be sure that restarting

       * the above code will work right

       */

      if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", NULL))

        return FALSE;

      if (!_dbus_setenv ("DBUS_ACTIVATION_BUS_TYPE", NULL))

        return FALSE;

      if (!_dbus_register_shutdown_func (addresses_shutdown_func,

                                         NULL))

        return FALSE;

  return initialized;

}

#else

static dbus_bool_t

init_connections_unlocked (void)

{

  if (!initialized)

    {

      const char *s;

      int i;

      i = 0;

      while (i < N_BUS_TYPES)

        {

          bus_connections[i] = NULL;

          ++i;

        }

      /* Don't init these twice, we may run this code twice if

       * init_connections_unlocked() fails midway through.

       * In practice, each block below should contain only one

       * "return FALSE" or running through twice may not

       * work right.

       */

       if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)

         {

           _dbus_verbose ("Filling in system bus address...\n");

           if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM],

                              "DBUS_SYSTEM_BUS_ADDRESS"))

             return FALSE;

         }

       if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)

         {

           /* Use default system bus address if none set in environment */

           bus_connection_addresses[DBUS_BUS_SYSTEM] =

             _dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS);

           if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)

             return FALSE;

           _dbus_verbose ("  used default system bus \"%s\"\n",

                          bus_connection_addresses[DBUS_BUS_SYSTEM]);

         }

       else

         _dbus_verbose ("  used env var system bus \"%s\"\n",

                        bus_connection_addresses[DBUS_BUS_SYSTEM]);

      if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

        {

          _dbus_verbose ("Filling in session bus address...\n");

          if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION],

                             "DBUS_SESSION_BUS_ADDRESS"))

            return FALSE;

	  if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

	    bus_connection_addresses[DBUS_BUS_SESSION] =

	      _dbus_strdup (DBUS_SESSION_BUS_DEFAULT_ADDRESS);

          if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)

             return FALSE;

          _dbus_verbose ("  \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?

                         bus_connection_addresses[DBUS_BUS_SESSION] : "none set");

        }

      if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)

        {

          _dbus_verbose ("Filling in activation bus address...\n");

          if (!get_from_env (&bus_connection_addresses[DBUS_BUS_STARTER],

                             "DBUS_STARTER_ADDRESS"))

            return FALSE;

          _dbus_verbose ("  \"%s\"\n", bus_connection_addresses[DBUS_BUS_STARTER] ?

                         bus_connection_addresses[DBUS_BUS_STARTER] : "none set");

        }

      if (bus_connection_addresses[DBUS_BUS_STARTER] != NULL)

        {

          s = _dbus_getenv ("DBUS_STARTER_BUS_TYPE");

          if (s != NULL)

            {

              _dbus_verbose ("Bus activation type was set to \"%s\"\n", s);

              if (strcmp (s, "system") == 0)

                activation_bus_type = DBUS_BUS_SYSTEM;

              else if (strcmp (s, "session") == 0)

                activation_bus_type = DBUS_BUS_SESSION;

            }

        }

      else

        {

          /* Default to the session bus instead if available */

          if (bus_connection_addresses[DBUS_BUS_SESSION] != NULL)

            {

              bus_connection_addresses[DBUS_BUS_STARTER] =

                _dbus_strdup (bus_connection_addresses[DBUS_BUS_SESSION]);

              if (bus_connection_addresses[DBUS_BUS_STARTER] == NULL)

                return FALSE;

            }

        }

      /* If we return FALSE we have to be sure that restarting

       * the above code will work right

       */

      if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", NULL))

        return FALSE;

      if (!_dbus_setenv ("DBUS_ACTIVATION_BUS_TYPE", NULL))

        return FALSE;

      if (!_dbus_register_shutdown_func (addresses_shutdown_func,

                                         NULL))

        return FALSE;

      initialized = TRUE;

    }

  return initialized;

}

#endif

static void

bus_data_free (void *data)

{

  BusData *bd = data;

  if (bd->is_well_known)

    {

      int i;

      _DBUS_LOCK (bus);

      /* We may be stored in more than one slot */

      /* This should now be impossible - these slots are supposed to

       * be cleared on disconnect, so should not need to be cleared on

       * finalize

       */

      i = 0;

      while (i < N_BUS_TYPES)

        {

          if (bus_connections[i] == bd->connection)

            bus_connections[i] = NULL;

          ++i;

        }

      _DBUS_UNLOCK (bus);

    }

  dbus_free (bd->unique_name);

  dbus_free (bd);

  dbus_connection_free_data_slot (&bus_data_slot);

}

static BusData*

ensure_bus_data (DBusConnection *connection)

{

  BusData *bd;

  if (!dbus_connection_allocate_data_slot (&bus_data_slot))

    return NULL;

  bd = dbus_connection_get_data (connection, bus_data_slot);

  if (bd == NULL)

    {      

      bd = dbus_new0 (BusData, 1);

      if (bd == NULL)

        {

          dbus_connection_free_data_slot (&bus_data_slot);

          return NULL;

        }

      bd->connection = connection;

      if (!dbus_connection_set_data (connection, bus_data_slot, bd,

                                     bus_data_free))

        {

          dbus_free (bd);

          dbus_connection_free_data_slot (&bus_data_slot);

          return NULL;

        }