/**
* Launch applications over dbus that need to be synchronized
*/
int usb_moded_dbus_app_launch(const char *launch)
{
int ret = -1; // assume failure
if( dbus_connection_ses == 0 )
{
log_err("could not start '%s': no session bus connection", launch);
}
else
{
#if 0
if( startservicebyname(launch) )
{
// started request, actual results from startservicebyname_cb()
ret = 0;
}
#else
DBusError error = DBUS_ERROR_INIT;
if( !dbus_bus_start_service_by_name(dbus_connection_ses, launch, 0, NULL, &error) )
{
log_err("could not start '%s': %s: %s", launch, error.name, error.message);
dbus_error_free(&error);
}
else
{
ret = 0; // success
}
#endif
}
return ret;
}
bool Connection::start_service( const char* name, u32 flags )
{
Error e;
bool b = dbus_bus_start_service_by_name(_connection,name,flags,NULL,e);
if(e) throw e;
return b;
}
void call_name(DBusConnection* conn, char* service_name ){
DBusError error;
DBusMessage* msg;
DBusMessageIter args;
DBusPendingCall* pending;
dbus_uint32_t result;
dbus_error_init(&error);
char* param = "calling you with something in the param";
char* target = service_name ; // target for the method call;
//char* object = "/org/gnome/Tomboy/RemoteControl";
char* object = "/"; // started with root ....
// we need to some how create a dynamic linked list of object -> method mapping table to displace for call
char* interface = DBUS_INTERFACE_INTROSPECTABLE ;
//char* interface = "org.freedesktop.DBus.Introspectable";
//char* name = "RemoteName"; // name of the method
char* method = "Introspect";
if( !dbus_bus_start_service_by_name( conn, service_name, 0, &result, &error)){
fprintf(stderr, "Can't start service %s\n", error.message);
exit(1);
} else {
// we can start looping all the methods and interface in the object tree
msg = dbus_message_new_method_call( target, object, interface, method );
if( NULL == msg ) {
fprintf(stderr, "Reply Null\n");
exit(1);
} else {
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
} else {
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
method_callback(pending);
}
}
}
}
static DBusGProxy *dbus_connect (MoonshotError **error)
{
DBusConnection *dbconnection;
DBusError dbus_error;
DBusGConnection *connection;
DBusGProxy *g_proxy;
GError *g_error = NULL;
dbus_bool_t name_has_owner;
g_return_val_if_fail (*error == NULL, NULL);
dbus_error_init (&dbus_error);
/* Check for moonshot server and start the service if possible. We use
* libdbus here because dbus-glib doesn't handle autostarting the service.
* If/when we move to GDBus this code can become a one-liner.
*/
if (is_setid()) {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"Cannot use IPC while setid");
return NULL;
}
#ifdef IPC_DBUS_GLIB
if (getenv("DISPLAY")==NULL) {
connection = dbus_launch_moonshot();
if (connection == NULL) {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"Headless dbus launch failed");
return NULL;
}
} else
#endif
{
connection = dbus_g_bus_get (DBUS_BUS_SESSION, &g_error);
if (g_error_matches(g_error, DBUS_GERROR, DBUS_GERROR_NOT_SUPPORTED)) {
/*Generally this means autolaunch failed because probably DISPLAY is unset*/
connection = dbus_launch_moonshot();
if (connection != NULL) {
g_error_free(g_error);
g_error = NULL;
}
}
if (g_error != NULL) {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"DBus error: %s",
g_error->message);
g_error_free (g_error);
return NULL;
}
}
dbconnection = dbus_g_connection_get_connection(connection);
name_has_owner = dbus_bus_name_has_owner (dbconnection,
MOONSHOT_DBUS_NAME,
&dbus_error);
if (dbus_error_is_set (&dbus_error)) {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"DBus error: %s",
dbus_error.message);
dbus_error_free (&dbus_error);
return NULL;
}
if (! name_has_owner) {
dbus_bus_start_service_by_name (dbconnection,
MOONSHOT_DBUS_NAME,
0,
NULL,
&dbus_error);
if (dbus_error_is_set (&dbus_error)) {
if (strcmp (dbus_error.name + 27, "ServiceUnknown") == 0) {
/* Missing .service file; the moonshot-ui install is broken */
*error = moonshot_error_new (MOONSHOT_ERROR_UNABLE_TO_START_SERVICE,
"The Moonshot service was not found. "
"Please make sure that moonshot-ui is "
"correctly installed.");
} else {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"DBus error: %s",
dbus_error.message);
}
dbus_error_free (&dbus_error);
return NULL;
}
}
/* Now the service should be running */
g_error = NULL;
g_proxy = dbus_g_proxy_new_for_name_owner (connection,
MOONSHOT_DBUS_NAME,
MOONSHOT_DBUS_PATH,
MOONSHOT_DBUS_NAME,
&g_error);
if (g_error != NULL) {
*error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR,
"DBus error: %s",
g_error->message);
g_error_free (g_error);
return NULL;
}
return g_proxy;
}
static void
mojito_client_view_constructed (GObject *object)
{
MojitoClientViewPrivate *priv = GET_PRIVATE (object);
GError *error = NULL;
DBusConnection *conn;
DBusError derror;
priv->connection = dbus_g_bus_get (DBUS_BUS_STARTER, &error);
if (!priv->connection)
{
g_critical (G_STRLOC ": Error getting DBUS connection: %s",
error->message);
g_clear_error (&error);
return;
}
conn = dbus_g_connection_get_connection (priv->connection);
dbus_error_init (&derror);
if (!dbus_bus_start_service_by_name (conn,
MOJITO_SERVICE_NAME,
0,
NULL,
&derror))
{
g_critical (G_STRLOC ": Error starting mojito service: %s",
derror.message);
dbus_error_free (&derror);
return;
}
priv->proxy = dbus_g_proxy_new_for_name_owner (priv->connection,
MOJITO_SERVICE_NAME,
priv->object_path,
MOJITO_SERVICE_VIEW_INTERFACE,
&error);
if (!priv->proxy)
{
g_critical (G_STRLOC ": Error setting up proxy for remote object: %s",
error->message);
g_clear_error (&error);
return;
}
dbus_g_proxy_add_signal (priv->proxy,
"ItemsAdded",
_mojito_items_get_container_type (),
NULL);
dbus_g_proxy_connect_signal (priv->proxy,
"ItemsAdded",
(GCallback)_proxy_items_added_cb,
object,
NULL);
dbus_g_proxy_add_signal (priv->proxy,
"ItemsChanged",
_mojito_items_get_container_type (),
NULL);
dbus_g_proxy_connect_signal (priv->proxy,
"ItemsChanged",
(GCallback)_proxy_items_changed_cb,
object,
NULL);
dbus_g_proxy_add_signal (priv->proxy,
"ItemsRemoved",
_mojito_items_removed_get_container_type (),
NULL);
dbus_g_proxy_connect_signal (priv->proxy,
"ItemsRemoved",
(GCallback)_proxy_items_removed_cb,
object,
NULL);
}
void call_name(DBusConnection* conn, char* service_name ){
DBusError error;
DBusMessage* msg;
DBusMessageIter args;
DBusMessageIter contain_args;
DBusMessageIter dict_args;
DBusMessageIter var_args;
DBusPendingCall* pending;
dbus_uint32_t result;
dbus_error_init(&error);
char* param = "calling you with something in the param";
char* param_list[2] = { "stuff 1", "stuff 2" };
dbus_uint16_t number = 16;
char array_type[2];
char ele_type[5];
char* target = service_name ; // target for the method call;
char* object = "/com/avengergear/PushServer/Proxy/TypeTest"; // started with root ....
// we need to some how create a dynamic linked list of object -> method mapping table to displace for call
//char* interface = DBUS_INTERFACE_INTROSPECTABLE ;
//char* interface = "org.freedesktop.DBus.Introspectable";
char* interface = "com.avengergear.PushServer.Proxy.Interface";
//char* name = "RemoteName"; // name of the method
char* method = "TypeTest";
if( !dbus_bus_start_service_by_name( conn, service_name, 0, &result, &error)){
fprintf(stderr, "Can't start service %s\n", error.message);
exit(1);
} else {
// we can start looping all the methods and interface in the object tree
msg = dbus_message_new_method_call( target, object, interface, method );
if( NULL == msg ) {
fprintf(stderr, "Reply Null\n");
exit(1);
} else {
// send message and get a handle for a reply
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "String Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Send string\n");
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT16, &number)) {
fprintf(stderr, "UINT16 Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Send uint16\n");
array_type[0]='s';
array_type[1]='\0';
if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, array_type, &contain_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer \n");
if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[0])) {
fprintf(stderr, "Arrary String is Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Sending a string\n");
if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[1])) {
fprintf(stderr, "Arrary String is Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Sending a string\n");
if (!dbus_message_iter_close_container(&args, &contain_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer\n");
ele_type[0]=DBUS_DICT_ENTRY_BEGIN_CHAR;
ele_type[1]='s';
ele_type[2]='v';
ele_type[3]=DBUS_DICT_ENTRY_END_CHAR;
ele_type[4]='\0';
if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, ele_type, &contain_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array\n");
if (!dbus_message_iter_open_container(&contain_args, DBUS_TYPE_DICT_ENTRY, NULL, &dict_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array Dict\n");
if (!dbus_message_iter_append_basic(&dict_args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "Arrary Dict String is Out Of Memory!\n");
exit(1);
}
array_type[0]='q';
array_type[1]='\0';
if (!dbus_message_iter_open_container(&dict_args, DBUS_TYPE_VARIANT, array_type , &var_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array Dict Var\n");
if (!dbus_message_iter_append_basic(&var_args, DBUS_TYPE_UINT16, &number)) {
fprintf(stderr, "Array Dict UNIT16 String is Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_close_container(&dict_args, &var_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer Array Dict\n");
if (!dbus_message_iter_close_container(&contain_args, &dict_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer Array\n");
if (!dbus_message_iter_close_container(&args, &contain_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer\n");
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
} else {
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
method_callback(pending);
}
}
}
}
