Index: /trunk/include/VBox/dbus-calls.h =================================================================== --- /trunk/include/VBox/dbus-calls.h (revision 23860) +++ /trunk/include/VBox/dbus-calls.h (revision 23860) @@ -0,0 +1,101 @@ +/** @file + * + * Stubs for dynamically loading libdbus-1 and the symbols + * which are needed by VirtualBox. + */ + +/* + * Copyright (C) 2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#ifndef VBOX_PROXY_STUB +#error This file is a private header, intended to be included in specific places only +#endif + +/** The following are the symbols which we need from libdbus-1. */ +VBOX_PROXY_STUB(dbus_error_init, void, (DBusError *error), + (error)) +VBOX_PROXY_STUB(dbus_bus_get, DBusConnection *, + (DBusBusType type, DBusError *error), (type, error)) +VBOX_PROXY_STUB(dbus_bus_get_private, DBusConnection *, + (DBusBusType type, DBusError *error), (type, error)) +VBOX_PROXY_STUB(dbus_error_free, void, (DBusError *error), + (error)) +VBOX_PROXY_STUB(dbus_connection_unref, void, (DBusConnection *connection), + (connection)) +VBOX_PROXY_STUB(dbus_connection_close, void, (DBusConnection *connection), + (connection)) +VBOX_PROXY_STUB(dbus_connection_set_exit_on_disconnect, void, + (DBusConnection *connection, dbus_bool_t boolean), + (connection, boolean)) +VBOX_PROXY_STUB(dbus_bus_name_has_owner, dbus_bool_t, + (DBusConnection *connection, const char *string, DBusError *error), + (connection, string, error)) +VBOX_PROXY_STUB(dbus_bus_add_match, void, + (DBusConnection *connection, const char *string, + DBusError *error), + (connection, string, error)) +VBOX_PROXY_STUB(dbus_bus_remove_match, void, + (DBusConnection *connection, const char *string, + DBusError *error), + (connection, string, error)) +VBOX_PROXY_STUB(dbus_message_unref, void, (DBusMessage *message), + (message)) +VBOX_PROXY_STUB(dbus_message_new_method_call, DBusMessage*, + (const char *string1, const char *string2, const char *string3, + const char *string4), + (string1, string2, string3, string4)) +VBOX_PROXY_STUB(dbus_message_iter_init_append, void, + (DBusMessage *message, DBusMessageIter *iter), + (message, iter)) +VBOX_PROXY_STUB(dbus_message_iter_append_basic, dbus_bool_t, + (DBusMessageIter *iter, int val, const void *string), + (iter, val, string)) +VBOX_PROXY_STUB(dbus_connection_send_with_reply_and_block, DBusMessage *, + (DBusConnection *connection, DBusMessage *message, int val, + DBusError *error), + (connection, message, val, error)) +VBOX_PROXY_STUB(dbus_message_iter_init, dbus_bool_t, + (DBusMessage *message, DBusMessageIter *iter), + (message, iter)) +VBOX_PROXY_STUB(dbus_message_iter_get_arg_type, int, (DBusMessageIter *iter), + (iter)) +VBOX_PROXY_STUB(dbus_message_iter_get_element_type, int, + (DBusMessageIter *iter), (iter)) +VBOX_PROXY_STUB(dbus_message_iter_recurse, void, + (DBusMessageIter *iter1, DBusMessageIter *iter2), + (iter1, iter2)) +VBOX_PROXY_STUB(dbus_message_iter_get_basic, void, + (DBusMessageIter *iter, void *pvoid), (iter, pvoid)) +VBOX_PROXY_STUB(dbus_message_iter_next, dbus_bool_t, (DBusMessageIter *iter), + (iter)) +VBOX_PROXY_STUB(dbus_connection_add_filter, dbus_bool_t, + (DBusConnection *connection, + DBusHandleMessageFunction function1, void *pvoid, + DBusFreeFunction function2), + (connection, function1, pvoid, function2)) +VBOX_PROXY_STUB(dbus_connection_remove_filter, void, + (DBusConnection *connection, + DBusHandleMessageFunction function, void *pvoid), + (connection, function, pvoid)) +VBOX_PROXY_STUB(dbus_connection_read_write_dispatch, dbus_bool_t, + (DBusConnection *connection, int val), (connection, val)) +VBOX_PROXY_STUB(dbus_message_is_signal, dbus_bool_t, + (DBusMessage *message, const char *string1, + const char *string2), + (message, string1, string2)) +VBOX_PROXY_STUB(dbus_connection_pop_message, DBusMessage *, + (DBusConnection *connection), (connection)) + Index: /trunk/include/VBox/dbus.h =================================================================== --- /trunk/include/VBox/dbus.h (revision 23860) +++ /trunk/include/VBox/dbus.h (revision 23860) @@ -0,0 +1,105 @@ +/** @file + * + * Module to dynamically load libdbus and load all symbols + * which are needed by VirtualBox. + */ + +/* + * Copyright (C) 2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#ifndef ____H_VBOX_DBUS +#define ____H_VBOX_DBUS + +#include + +#define VBOX_DBUS_1_3_LIB "libdbus-1.so.3" + +/** Types and defines from the dbus header files which we need. These are + * taken more or less verbatim from the DBus public interface header files. */ +struct DBusError +{ + const char *name; + const char *message; + unsigned int dummy1 : 1; + unsigned int dummy2 : 1; + unsigned int dummy3 : 1; + unsigned int dummy4 : 1; + unsigned int dummy5 : 1; + void *padding1; +}; +struct DBusConnection; +typedef struct DBusConnection DBusConnection; +typedef uint32_t dbus_bool_t; +typedef uint32_t dbus_uint32_t; +typedef enum { DBUS_BUS_SESSON, DBUS_BUS_SYSTEM, DBUS_BUS_STARTER } DBusBusType; +struct DBusMessage; +typedef struct DBusMessage DBusMessage; +struct DBusMessageIter +{ + void *dummy1; + void *dummy2; + dbus_uint32_t dummy3; + int dummy4; + int dummy5; + int dummy6; + int dummy7; + int dummy8; + int dummy9; + int dummy10; + int dummy11; + int pad1; + int pad2; + void *pad3; +}; +typedef struct DBusMessageIter DBusMessageIter; + +#define DBUS_ERROR_NO_MEMORY "org.freedesktop.DBus.Error.NoMemory" +#define DBUS_TYPE_INVALID ((int) '\0') +#define DBUS_TYPE_STRING ((int) 's') +#define DBUS_TYPE_ARRAY ((int) 'a') +#define DBUS_TYPE_DICT_ENTRY ((int) 'e') + +typedef enum +{ + DBUS_HANDLER_RESULT_HANDLED, + DBUS_HANDLER_RESULT_NOT_YET_HANDLED, + DBUS_HANDLER_RESULT_NEED_MEMORY +} DBusHandlerResult; + +typedef DBusHandlerResult (*DBusHandleMessageFunction) (DBusConnection *, + DBusMessage *, void *); +typedef void (*DBusFreeFunction) (void *); + +/* Declarations of the functions that we need from libdbus-1 */ +#define VBOX_PROXY_STUB(function, rettype, signature, shortsig) \ +RTR3DECL(rettype) ( function ) signature ; + +#include + +#undef VBOX_PROXY_STUB + +/** + * Try to dynamically load the DBus library. This function should be called + * before attempting to use any of the DBus functions. It is safe to call this + * function multiple times. + * + * @returns iprt status code + */ +RTR3DECL(int) RTDBusLoadLib(void); + +#endif /* ____H_VBOX_DBUS not defined */ +/* vi: set tabstop=4 shiftwidth=4 expandtab: */ + Index: /trunk/src/VBox/Runtime/VBox/dbus.cpp =================================================================== --- /trunk/src/VBox/Runtime/VBox/dbus.cpp (revision 23860) +++ /trunk/src/VBox/Runtime/VBox/dbus.cpp (revision 23860) @@ -0,0 +1,82 @@ +/** @file + * + * Module to dynamically load libdbus and load all symbols + * which are needed by VirtualBox. + */ + +/* + * Copyright (C) 2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#define LOG_GROUP LOG_GROUP_MAIN +#include +#include +#include + +#include +#include +#include + +/** The following are the symbols which we need from libdbus. */ +#define VBOX_PROXY_STUB(function, rettype, signature, shortsig) \ +void (*function ## _fn)(void); \ +RTR3DECL(rettype) function signature \ +{ return ( (rettype (*) signature) function ## _fn ) shortsig; } + +#include + +#undef VBOX_PROXY_STUB + +/* Now comes a table of functions to be loaded from libdbus-1 */ +typedef struct +{ + const char *name; + void (**fn)(void); +} SHARED_FUNC; + +#define VBOX_PROXY_STUB(s, dummy1, dummy2, dummy3 ) { #s , & s ## _fn } , +static SHARED_FUNC SharedFuncs[] = +{ +#include + { NULL, NULL } +}; +#undef VBOX_PROXY_STUB + +/* The function which does the actual work for RTDBusLoadLib, serialised for + * thread safety. */ +DECLINLINE(int) loadDBusLibOnce(void *, void *) +{ + int rc = VINF_SUCCESS; + RTLDRMOD hLib; + + LogFlowFunc(("\n")); + rc = RTLdrLoad(VBOX_DBUS_1_3_LIB, &hLib); + if (RT_FAILURE(rc)) + LogRelFunc(("Failed to load library %s\n", VBOX_DBUS_1_3_LIB)); + for (unsigned i = 0; RT_SUCCESS(rc) && SharedFuncs[i].name != NULL; ++i) + rc = RTLdrGetSymbol(hLib, SharedFuncs[i].name, (void**)SharedFuncs[i].fn); + LogFlowFunc(("rc = %Rrc\n", rc)); + return rc; +} + +RTR3DECL(int) RTDBusLoadLib(void) +{ + static RTONCE sOnce = RTONCE_INITIALIZER; + + LogFlowFunc(("\n")); + int rc = RTOnce (&sOnce, loadDBusLibOnce, NULL, NULL); + LogFlowFunc(("rc = %Rrc\n", rc)); + return rc; +}