static dbus_bool_t
init_global_locks (void)
{
int i;
DBusMutex ***dynamic_global_locks;
DBusMutex **global_locks[] = {
#define LOCK_ADDR(name) (& _dbus_lock_##name)
LOCK_ADDR (list),
LOCK_ADDR (connection_slots),
LOCK_ADDR (pending_call_slots),
LOCK_ADDR (server_slots),
LOCK_ADDR (message_slots),
LOCK_ADDR (atomic),
LOCK_ADDR (bus),
LOCK_ADDR (shutdown_funcs),
LOCK_ADDR (system_users),
LOCK_ADDR (message_cache),
LOCK_ADDR (shared_connections)
#undef LOCK_ADDR
};
_dbus_assert (_DBUS_N_ELEMENTS (global_locks) ==
_DBUS_N_GLOBAL_LOCKS);
i = 0;
dynamic_global_locks = dbus_new (DBusMutex**, _DBUS_N_GLOBAL_LOCKS);
if (dynamic_global_locks == NULL)
goto failed;
while (i < _DBUS_N_ELEMENTS (global_locks))
{
*global_locks[i] = _dbus_mutex_new ();
if (*global_locks[i] == NULL)
goto failed;
dynamic_global_locks[i] = global_locks[i];
++i;
}
if (!_dbus_register_shutdown_func (shutdown_global_locks,
dynamic_global_locks))
goto failed;
return TRUE;
failed:
dbus_free (dynamic_global_locks);
for (i = i - 1; i >= 0; i--)
{
_dbus_mutex_free (*global_locks[i]);
*global_locks[i] = NULL;
}
return FALSE;
}
static int
_init_kqueue (BusContext *context)
{
if (kq < 0)
{
kq = kqueue ();
if (kq < 0)
{
_dbus_warn ("Cannot create kqueue; error '%s'\n", _dbus_strerror (errno));
goto out;
}
loop = bus_context_get_loop (context);
_dbus_loop_ref (loop);
watch = _dbus_watch_new (kq, DBUS_WATCH_READABLE, TRUE,
_handle_kqueue_watch, NULL, NULL);
if (watch == NULL)
{
_dbus_warn ("Unable to create kqueue watch\n");
goto out1;
}
if (!_dbus_loop_add_watch (loop, watch))
{
_dbus_warn ("Unable to add reload watch to main loop");
goto out2;
}
if (!_dbus_register_shutdown_func (_shutdown_kqueue, NULL))
{
_dbus_warn ("Unable to register shutdown function");
goto out3;
}
}
return 1;
out3:
_dbus_loop_remove_watch (loop, watch);
out2:
if (watch)
{
_dbus_watch_invalidate (watch);
_dbus_watch_unref (watch);
watch = NULL;
}
out1:
if (kq >= 0)
{
close (kq);
kq = -1;
}
if (loop)
{
_dbus_loop_unref (loop);
loop = NULL;
}
out:
return 0;
}
static dbus_bool_t
init_system_db (void)
{
_dbus_assert (database_locked);
if (system_db == NULL)
{
DBusError error;
const DBusUserInfo *info;
system_db = _dbus_user_database_new ();
if (system_db == NULL)
return FALSE;
dbus_error_init (&error);
if (!_dbus_user_database_get_uid (system_db,
_dbus_getuid (),
&info,
&error))
{
_dbus_user_database_unref (system_db);
system_db = NULL;
if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
{
dbus_error_free (&error);
return FALSE;
}
else
{
/* This really should not happen. */
_dbus_warn ("Could not get password database information for UID of current process: %s\n",
error.message);
dbus_error_free (&error);
return FALSE;
}
}
if (!_dbus_string_init (&process_username))
{
_dbus_user_database_unref (system_db);
system_db = NULL;
return FALSE;
}
if (!_dbus_string_init (&process_homedir))
{
_dbus_string_free (&process_username);
_dbus_user_database_unref (system_db);
system_db = NULL;
return FALSE;
}
if (!_dbus_string_append (&process_username,
info->username) ||
!_dbus_string_append (&process_homedir,
info->homedir) ||
!_dbus_register_shutdown_func (shutdown_system_db, NULL))
{
_dbus_string_free (&process_username);
_dbus_string_free (&process_homedir);
_dbus_user_database_unref (system_db);
system_db = NULL;
return FALSE;
}
}
return TRUE;
}
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;
}
static dbus_bool_t
init_uninitialized_locks (void)
{
DBusList *link;
_dbus_assert (thread_init_generation != _dbus_current_generation);
link = uninitialized_mutex_list;
while (link != NULL)
{
DBusMutex **mp;
mp = (DBusMutex **)link->data;
_dbus_assert (*mp == _DBUS_DUMMY_MUTEX);
*mp = _dbus_mutex_new ();
if (*mp == NULL)
goto fail_mutex;
link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);
}
link = uninitialized_condvar_list;
while (link != NULL)
{
DBusCondVar **cp;
cp = (DBusCondVar **)link->data;
_dbus_assert (*cp == _DBUS_DUMMY_CONDVAR);
*cp = _dbus_condvar_new ();
if (*cp == NULL)
goto fail_condvar;
link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);
}
_dbus_list_clear (&uninitialized_mutex_list);
_dbus_list_clear (&uninitialized_condvar_list);
if (!_dbus_register_shutdown_func (shutdown_uninitialized_locks,
NULL))
goto fail_condvar;
return TRUE;
fail_condvar:
link = uninitialized_condvar_list;
while (link != NULL)
{
DBusCondVar **cp;
cp = (DBusCondVar **)link->data;
if (*cp != _DBUS_DUMMY_CONDVAR)
_dbus_condvar_free (*cp);
else
break;
*cp = _DBUS_DUMMY_CONDVAR;
link = _dbus_list_get_next_link (&uninitialized_condvar_list, link);
}
fail_mutex:
link = uninitialized_mutex_list;
while (link != NULL)
{
DBusMutex **mp;
mp = (DBusMutex **)link->data;
if (*mp != _DBUS_DUMMY_MUTEX)
_dbus_mutex_free (*mp);
else
break;
*mp = _DBUS_DUMMY_MUTEX;
link = _dbus_list_get_next_link (&uninitialized_mutex_list, link);
}
return FALSE;
}
static dbus_bool_t
init_locks (void)
{
int i;
DBusMutex ***dynamic_global_locks;
#ifndef EMULATOR
DBusMutex **global_locks[] = {
#define LOCK_ADDR(name) (& _dbus_lock_##name)
LOCK_ADDR (win_fds),
LOCK_ADDR (sid_atom_cache),
LOCK_ADDR (list),
LOCK_ADDR (connection_slots),
LOCK_ADDR (pending_call_slots),
LOCK_ADDR (server_slots),
LOCK_ADDR (message_slots),
LOCK_ADDR (atomic),
LOCK_ADDR (bus),
LOCK_ADDR (bus_datas),
LOCK_ADDR (shutdown_funcs),
LOCK_ADDR (system_users),
LOCK_ADDR (message_cache),
LOCK_ADDR (shared_connections),
LOCK_ADDR (machine_uuid)
#undef LOCK_ADDR
};
#else
DBusMutex **global_locks[15];
#define LOCK_ADDR(name) ((DBusMutex **)& _dbus_lock_##name)
global_locks[0]=LOCK_ADDR (win_fds);
global_locks[1]=LOCK_ADDR (sid_atom_cache);
global_locks[2]=LOCK_ADDR (list);
global_locks[3]=LOCK_ADDR (connection_slots);
global_locks[4]=LOCK_ADDR (pending_call_slots);
global_locks[5]=LOCK_ADDR (server_slots);
global_locks[6]=LOCK_ADDR (message_slots);
global_locks[7]=LOCK_ADDR (atomic);
global_locks[8]=LOCK_ADDR (bus);
global_locks[9]=LOCK_ADDR (bus_datas);
global_locks[10]=LOCK_ADDR (shutdown_funcs);
global_locks[11]=LOCK_ADDR (system_users);
global_locks[12]=LOCK_ADDR (message_cache);
global_locks[13]=LOCK_ADDR (shared_connections);
global_locks[14]=LOCK_ADDR (machine_uuid);
#undef LOCK_ADDR
#endif
_dbus_assert (_DBUS_N_ELEMENTS (global_locks) ==
_DBUS_N_GLOBAL_LOCKS);
i = 0;
dynamic_global_locks = dbus_new (DBusMutex**, _DBUS_N_GLOBAL_LOCKS);
if (dynamic_global_locks == NULL)
goto failed;
while (i < _DBUS_N_ELEMENTS (global_locks))
{
*global_locks[i] = _dbus_mutex_new ();
if (*global_locks[i] == NULL)
goto failed;
dynamic_global_locks[i] = global_locks[i];
++i;
}
if (!_dbus_register_shutdown_func (shutdown_global_locks,
dynamic_global_locks))
goto failed;
if (!init_uninitialized_locks ())
goto failed;
return TRUE;
failed:
dbus_free (dynamic_global_locks);
for (i = i - 1; i >= 0; i--)
{
_dbus_mutex_free (*global_locks[i]);
*global_locks[i] = NULL;
}
return FALSE;
}