static gboolean
update_iface (StoragedObject *object,
const gchar *uevent_action,
StoragedObjectHasInterfaceFunc has_func,
StoragedObjectConnectInterfaceFunc connect_func,
StoragedObjectUpdateInterfaceFunc update_func,
GType skeleton_type,
gpointer _interface_pointer)
{
gboolean ret = FALSE;
gboolean has;
gboolean add;
GDBusInterface **interface_pointer = _interface_pointer;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (has_func != NULL, FALSE);
g_return_val_if_fail (update_func != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_OBJECT), FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_DBUS_INTERFACE), FALSE);
g_return_val_if_fail (interface_pointer != NULL, FALSE);
g_return_val_if_fail (*interface_pointer == NULL || G_IS_DBUS_INTERFACE (*interface_pointer), FALSE);
add = FALSE;
has = has_func (object);
if (*interface_pointer == NULL)
{
if (has)
{
*interface_pointer = g_object_new (skeleton_type, NULL);
if (connect_func != NULL)
connect_func (object);
add = TRUE;
}
}
else
{
if (!has)
{
g_dbus_object_skeleton_remove_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
g_object_unref (*interface_pointer);
*interface_pointer = NULL;
}
}
if (*interface_pointer != NULL)
{
if (update_func (object, uevent_action, G_DBUS_INTERFACE (*interface_pointer)))
ret = TRUE;
if (add)
g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
}
return ret;
}
static void
create_monitor_skeleton (GDBusObjectManagerServer *manager,
MetaIdleMonitor *monitor,
const char *path)
{
MetaDBusIdleMonitor *skeleton;
MetaDBusObjectSkeleton *object;
skeleton = meta_dbus_idle_monitor_skeleton_new ();
g_signal_connect_object (skeleton, "handle-add-idle-watch",
G_CALLBACK (handle_add_idle_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-add-user-active-watch",
G_CALLBACK (handle_add_user_active_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-remove-watch",
G_CALLBACK (handle_remove_watch), monitor, 0);
g_signal_connect_object (skeleton, "handle-reset-idletime",
G_CALLBACK (handle_reset_idletime), monitor, 0);
g_signal_connect_object (skeleton, "handle-get-idletime",
G_CALLBACK (handle_get_idletime), monitor, 0);
object = meta_dbus_object_skeleton_new (path);
meta_dbus_object_skeleton_set_idle_monitor (object, skeleton);
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (skeleton);
g_object_unref (object);
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
SubprocessData *sd)
{
EDBusSubprocessBackend *proxy;
EDBusSubprocessObjectSkeleton *object;
object = e_dbus_subprocess_object_skeleton_new (path);
proxy = e_dbus_subprocess_backend_skeleton_new ();
e_dbus_subprocess_object_skeleton_set_backend (object, proxy);
g_signal_connect (
proxy, "handle-create",
G_CALLBACK (subprocess_backend_handle_create_cb),
sd->subprocess_book_factory);
g_signal_connect (
proxy, "handle-close",
G_CALLBACK (subprocess_backend_handle_close_cb),
sd);
g_dbus_object_manager_server_export (sd->manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (proxy);
g_object_unref (object);
g_dbus_object_manager_server_set_connection (sd->manager, connection);
}
void
hs_dbus_handler_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
HsObjectSkeleton *object;
HsPower *power;
HsSession *session;
manager = g_dbus_object_manager_server_new ("/org/home/hsession/Manager");
object = hs_object_skeleton_new ("/org/home/hsession/Manager/Proxy");
power = hs_power_skeleton_new ();
session = hs_session_skeleton_new ();
hs_object_skeleton_set_power (object, power);
g_object_unref (power);
hs_object_skeleton_set_session (object, session);
g_object_unref (session);
g_signal_connect (session, "handle-logout", G_CALLBACK (_on_session_logout), user_data);
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
g_dbus_object_manager_server_set_connection (manager, connection);
}
static void
storaged_linux_block_object_constructed (GObject *_object)
{
StoragedLinuxBlockObject *object = STORAGED_LINUX_BLOCK_OBJECT (_object);
GString *str;
object->mount_monitor = storaged_daemon_get_mount_monitor (object->daemon);
g_signal_connect (object->mount_monitor,
"mount-added",
G_CALLBACK (on_mount_monitor_mount_added),
object);
g_signal_connect (object->mount_monitor,
"mount-removed",
G_CALLBACK (on_mount_monitor_mount_removed),
object);
/* initial coldplug */
storaged_linux_block_object_uevent (object, "add", NULL);
/* compute the object path */
str = g_string_new ("/org/storaged/Storaged/block_devices/");
storaged_safe_append_to_object_path (str, g_udev_device_get_name (object->device->udev_device));
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), str->str);
g_string_free (str, TRUE);
if (G_OBJECT_CLASS (storaged_linux_block_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storaged_linux_block_object_parent_class)->constructed (_object);
}
static gboolean
terminal_app_dbus_register (GApplication *application,
GDBusConnection *connection,
const gchar *object_path,
GError **error)
{
TerminalApp *app = TERMINAL_APP (application);
gs_unref_object TerminalObjectSkeleton *object = NULL;
gs_unref_object TerminalFactory *factory = NULL;
if (!G_APPLICATION_CLASS (terminal_app_parent_class)->dbus_register (application,
connection,
object_path,
error))
return FALSE;
object = terminal_object_skeleton_new (TERMINAL_FACTORY_OBJECT_PATH);
factory = terminal_factory_impl_new ();
terminal_object_skeleton_set_factory (object, factory);
app->object_manager = g_dbus_object_manager_server_new (TERMINAL_OBJECT_PATH_PREFIX);
g_dbus_object_manager_server_export (app->object_manager, G_DBUS_OBJECT_SKELETON (object));
/* And export the object */
g_dbus_object_manager_server_set_connection (app->object_manager, connection);
return TRUE;
}
/*****************************************************************************
* neardal_handoveragent_prv_manage: create or release an agent and register
* or unregister it with neardal object manager and Neard
****************************************************************************/
errorCode_t neardal_handoveragent_prv_manage(
neardal_handover_agent_t agentData)
{
errorCode_t err = NEARDAL_SUCCESS;
neardalObjectSkeleton *objSkel;
neardalHandoverAgent *handoverAgent;
neardal_handover_agent_t *data;
NEARDAL_TRACEIN();
if (agentData.cb_oob_push_agent != NULL &&
agentData.cb_oob_req_agent != NULL) {
data = g_try_malloc0(sizeof(neardal_handover_agent_t));
if (data == NULL)
return NEARDAL_ERROR_NO_MEMORY;
memcpy(data, &agentData, sizeof(neardal_handover_agent_t));
data->objPath = g_strdup(agentData.objPath);
data->carrierType = g_strdup(agentData.carrierType);
NEARDAL_TRACEF("Create agent '%s'\n", data->objPath);
objSkel = neardal_object_skeleton_new (data->objPath);
handoverAgent = neardal_handover_agent_skeleton_new();
neardal_object_skeleton_set_handover_agent(objSkel,
handoverAgent);
/* Handle RequestOOB() D-Bus method invocations */
g_signal_connect( handoverAgent, "handle-request-oob"
, G_CALLBACK (on_RequestOOB)
, data);
/* Handle PushOOB() D-Bus method invocations */
g_signal_connect( handoverAgent, "handle-push-oob"
, G_CALLBACK (on_PushOOB)
, data);
/* Handle Release D-Bus method invocations */
g_signal_connect( handoverAgent, "handle-release"
, G_CALLBACK (on_Handover_Release), data);
g_signal_connect( neardalMgr.agentMgr, "object-removed"
, G_CALLBACK (on_handover_object_removed)
, data);
g_object_unref(handoverAgent);
/* Export the object */
g_dbus_object_manager_server_export(neardalMgr.agentMgr
, G_DBUS_OBJECT_SKELETON (objSkel));
g_object_unref (objSkel);
} else {
NEARDAL_TRACEF("Release agent '%s'\n", agentData.objPath);
if (neardal_agent_prv_remove(agentData.objPath) == TRUE)
err = NEARDAL_SUCCESS;
else
err = NEARDAL_ERROR_DBUS;
}
return err;
}
static void
on_name_acquired(GDBusConnection *connection,
const gchar *name,
gpointer object)
{
g_dbus_object_manager_server_export(manager, G_DBUS_OBJECT_SKELETON(object));
}
/**
* g_dbus_object_skeleton_new:
* @object_path: An object path.
*
* Creates a new #GDBusObjectSkeleton.
*
* Returns: A #GDBusObjectSkeleton. Free with g_object_unref().
*
* Since: 2.30
*/
GDBusObjectSkeleton *
g_dbus_object_skeleton_new (const gchar *object_path)
{
g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
return G_DBUS_OBJECT_SKELETON (g_object_new (G_TYPE_DBUS_OBJECT_SKELETON,
"object-path", object_path,
NULL));
}
void
storage_daemon_unpublish (StorageDaemon *self,
const gchar *path,
gpointer thing)
{
GDBusObject *object;
gboolean unexport = FALSE;
GList *interfaces, *l;
g_return_if_fail (STORAGE_IS_DAEMON (self));
g_return_if_fail (path != NULL);
object = g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (self->object_manager), path);
if (object == NULL)
return;
path = g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
if (G_IS_DBUS_INTERFACE (thing))
{
g_debug ("unpublishing interface: %s %s", path,
g_dbus_interface_get_info(thing)->name);
unexport = TRUE;
interfaces = g_dbus_object_get_interfaces (object);
for (l = interfaces; l != NULL; l = g_list_next (l))
{
if (G_DBUS_INTERFACE (l->data) != G_DBUS_INTERFACE (thing))
unexport = FALSE;
}
g_list_free_full (interfaces, g_object_unref);
/*
* HACK: GDBusObjectManagerServer is broken ... and sends InterfaceRemoved
* too many times, if you remove all interfaces manually, and then unexport
* a GDBusObject. So only do it here if we're not unexporting the object.
*/
if (!unexport)
g_dbus_object_skeleton_remove_interface (G_DBUS_OBJECT_SKELETON (object), thing);
else
g_debug ("(unpublishing object, too)");
}
else if (thing == NULL)
{
unexport = TRUE;
}
else
{
g_critical ("Unsupported type to unpublish: %s", G_OBJECT_TYPE_NAME (thing));
}
if (unexport)
g_dbus_object_manager_server_unexport (self->object_manager, path);
g_object_unref (object);
}
static void
storaged_linux_volume_group_object_constructed (GObject *_object)
{
StoragedLinuxVolumeGroupObject *object = STORAGED_LINUX_VOLUME_GROUP_OBJECT (_object);
GString *s;
if (G_OBJECT_CLASS (storaged_linux_volume_group_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storaged_linux_volume_group_object_parent_class)->constructed (_object);
object->logical_volumes = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
(GDestroyNotify) g_object_unref);
/* compute the object path */
s = g_string_new ("/org/storaged/Storaged/lvm/");
storaged_safe_append_to_object_path (s, object->name);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), s->str);
g_string_free (s, TRUE);
/* create the DBus interface */
object->iface_volume_group = storaged_linux_volume_group_new ();
g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (object->iface_volume_group));
/* Watch fstab and crypttab for changes.
*/
g_signal_connect (storaged_daemon_get_fstab_monitor (object->daemon),
"entry-added",
G_CALLBACK (etctabs_changed),
object);
g_signal_connect (storaged_daemon_get_fstab_monitor (object->daemon),
"entry-removed",
G_CALLBACK (etctabs_changed),
object);
g_signal_connect (storaged_daemon_get_crypttab_monitor (object->daemon),
"entry-added",
G_CALLBACK (etctabs_changed),
object);
g_signal_connect (storaged_daemon_get_crypttab_monitor (object->daemon),
"entry-removed",
G_CALLBACK (etctabs_changed),
object);
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
ObjectSkeleton *object;
//g_print ("Acquired a message bus connection: %s\n",name);
cmdline *cmd = user_data;
if (cmd->argc < 2)
{
g_print("No objects created. Put object name(s) on command line\n");
return;
}
manager = g_dbus_object_manager_server_new (dbus_object_path);
int i=0;
gchar *s;
s = g_strdup_printf ("%s/%s",dbus_object_path,cmd->argv[1]);
object = object_skeleton_new (s);
g_free (s);
Button* button = button_skeleton_new ();
object_skeleton_set_button (object, button);
g_object_unref (button);
//define method callbacks
g_signal_connect (button,
"handle-is-on",
G_CALLBACK (on_is_on),
NULL); /* user_data */
g_signal_connect (button,
"handle-sim-button-press",
G_CALLBACK (on_button_press),
NULL); /* user_data */
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
/* Export all objects */
g_dbus_object_manager_server_set_connection (manager, connection);
// get gpio device paths
int rc = GPIO_OK;
do {
rc = gpio_init(connection,&gpio_button);
if (rc != GPIO_OK) { break; }
rc = gpio_open_interrupt(&gpio_button,on_button_interrupt,object);
if (rc != GPIO_OK) { break; }
} while(0);
if (rc != GPIO_OK)
{
printf("ERROR PowerButton: GPIO setup (rc=%d)\n",rc);
}
}
void
storage_daemon_publish (StorageDaemon *self,
const gchar *path,
gboolean uniquely,
gpointer thing)
{
GDBusInterface *prev;
GDBusInterfaceInfo *info;
GDBusObjectSkeleton *object;
GQuark detail;
g_return_if_fail (STORAGE_IS_DAEMON (self));
g_return_if_fail (path != NULL);
if (G_IS_DBUS_INTERFACE (thing))
{
g_debug ("%spublishing iface: %s %s", uniquely ? "uniquely " : "", path,
g_dbus_interface_get_info(thing)->name);
object = G_DBUS_OBJECT_SKELETON (g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (self->object_manager), path));
if (object != NULL)
{
if (uniquely)
{
info = g_dbus_interface_get_info (thing);
prev = g_dbus_object_get_interface (G_DBUS_OBJECT (object), info->name);
if (prev)
{
g_object_unref (prev);
g_object_unref (object);
object = NULL;
}
}
}
if (object == NULL)
object = g_dbus_object_skeleton_new (path);
g_dbus_object_skeleton_add_interface (object, thing);
}
else
{
g_critical ("Unsupported type to publish: %s", G_OBJECT_TYPE_NAME (thing));
return;
}
if (uniquely)
g_dbus_object_manager_server_export_uniquely (self->object_manager, object);
else
g_dbus_object_manager_server_export (self->object_manager, object);
detail = g_quark_from_static_string (G_OBJECT_TYPE_NAME (thing));
g_signal_emit (self, signals[PUBLISHED], detail, thing);
g_object_unref (object);
}
static const gchar *
g_dbus_object_skeleton_get_object_path (GDBusObject *_object)
{
GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
const gchar *ret;
g_mutex_lock (object->priv->lock);
ret = object->priv->object_path;
g_mutex_unlock (object->priv->lock);
return ret;
}
static void
on_bus_acquired(GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
cmdline *cmd = user_data;
if(cmd->argc < 4)
{
g_print("flasher [flash name] [filename] [source object]\n");
g_main_loop_quit(cmd->loop);
return;
}
printf("Starting flasher: %s,%s,%s,\n",cmd->argv[1],cmd->argv[2],cmd->argv[3]);
ObjectSkeleton *object;
manager = g_dbus_object_manager_server_new(dbus_object_path);
gchar *s;
s = g_strdup_printf("%s/%s",dbus_object_path,cmd->argv[1]);
object = object_skeleton_new(s);
g_free(s);
FlashControl* flash_control = flash_control_skeleton_new();
object_skeleton_set_flash_control(object, flash_control);
g_object_unref(flash_control);
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_export(manager, G_DBUS_OBJECT_SKELETON(object));
g_object_unref(object);
/* Export all objects */
g_dbus_object_manager_server_set_connection(manager, connection);
bool bmc_flash = false;
uint32_t address = 0;
if(strcmp(cmd->argv[1],"bmc")==0) {
bmc_flash = true;
}
if(strcmp(cmd->argv[1],"bmc_ramdisk")==0) {
bmc_flash = true;
address = 0x20300000;
}
if(strcmp(cmd->argv[1],"bmc_kernel")==0) {
bmc_flash = true;
address = 0x20080000;
}
int rc = flash(flash_control,bmc_flash,address,cmd->argv[2],cmd->argv[3]);
if(rc) {
flash_message(connection,cmd->argv[3],"error","Flash Error");
} else {
flash_message(connection,cmd->argv[3],"done","");
}
//Object exits when done flashing
g_main_loop_quit(cmd->loop);
}
static void
goa_daemon_init (GoaDaemon *daemon)
{
static volatile GQuark goa_error_domain = 0;
GoaObjectSkeleton *object;
gchar *path;
/* this will force associating errors in the GOA_ERROR error domain
* with org.freedesktop.Goa.Error.* errors via g_dbus_error_register_error_domain().
*/
goa_error_domain = GOA_ERROR;
goa_error_domain; /* shut up -Wunused-but-set-variable */
notify_init ("goa-daemon");
/* TODO: maybe nicer to pass in a GDBusConnection* construct property */
daemon->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
/* Create object manager */
daemon->object_manager = g_dbus_object_manager_server_new ("/org/gnome/OnlineAccounts");
/* Create and export Manager */
daemon->manager = goa_manager_skeleton_new ();
g_signal_connect (daemon->manager,
"handle-add-account",
G_CALLBACK (on_manager_handle_add_account),
daemon);
object = goa_object_skeleton_new ("/org/gnome/OnlineAccounts/Manager");
goa_object_skeleton_set_manager (object, daemon->manager);
g_dbus_object_manager_server_export (daemon->object_manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
/* create ~/.config/goa-1.0 directory */
path = g_strdup_printf ("%s/goa-1.0", g_get_user_config_dir ());
if (g_mkdir_with_parents (path, 0755) != 0)
{
goa_warning ("Error creating directory %s: %m", path);
}
g_free (path);
/* set up file monitoring */
path = g_strdup_printf ("%s/goa-1.0/accounts.conf", g_get_user_config_dir ());
daemon->home_conf_file_monitor = create_monitor (path, FALSE);
if (daemon->home_conf_file_monitor != NULL)
g_signal_connect (daemon->home_conf_file_monitor, "changed", G_CALLBACK (on_file_monitor_changed), daemon);
g_free (path);
/* prime the list of accounts */
goa_daemon_reload_configuration (daemon);
/* Export objects */
g_dbus_object_manager_server_set_connection (daemon->object_manager, daemon->connection);
}
void
get_iface (GObject *object, GType skeleton, gpointer _pointer_to_iface)
{
GDBusInterface **pointer_to_iface = _pointer_to_iface;
if (*pointer_to_iface == NULL) {
*pointer_to_iface = g_object_new(skeleton, NULL);
}
g_dbus_object_skeleton_add_interface(G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*pointer_to_iface));
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
ObjectSkeleton *object;
//g_print ("Acquired a message bus connection: %s\n",name);
cmdline *cmd = user_data;
if (cmd->argc < 2)
{
g_print("No objects created. Put object name(s) on command line\n");
return;
}
manager = g_dbus_object_manager_server_new (dbus_object_path);
int i=0;
for (i=1;i<cmd->argc;i++)
{
gchar *s;
s = g_strdup_printf ("%s/%s",dbus_object_path,cmd->argv[i]);
object = object_skeleton_new (s);
g_free (s);
ControlHost* control_host = control_host_skeleton_new ();
object_skeleton_set_control_host (object, control_host);
g_object_unref (control_host);
Control* control = control_skeleton_new ();
object_skeleton_set_control (object, control);
g_object_unref (control);
//define method callbacks here
g_signal_connect (control_host,
"handle-boot",
G_CALLBACK (on_boot),
object); /* user_data */
g_signal_connect (control,
"handle-init",
G_CALLBACK (on_init),
NULL); /* user_data */
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
}
/* Export all objects */
g_dbus_object_manager_server_set_connection (manager, connection);
gpio_init(connection,&fsi_data);
gpio_init(connection,&fsi_clk);
gpio_init(connection,&fsi_enable);
gpio_init(connection,&cronus_sel);
}
static void
storaged_linux_drive_object_constructed (GObject *_object)
{
StoragedLinuxDriveObject *object = STORAGED_LINUX_DRIVE_OBJECT (_object);
gchar *vendor;
gchar *model;
gchar *serial;
GString *str;
/* initial coldplug */
storaged_linux_drive_object_uevent (object, "add", object->devices->data);
/* compute the object path */
vendor = g_strdup (storaged_drive_get_vendor (object->iface_drive));
model = g_strdup (storaged_drive_get_model (object->iface_drive));
serial = g_strdup (storaged_drive_get_serial (object->iface_drive));
strip_and_replace_with_uscore (vendor);
strip_and_replace_with_uscore (model);
strip_and_replace_with_uscore (serial);
str = g_string_new ("/org/storaged/Storaged/drives/");
if (vendor == NULL && model == NULL && serial == NULL)
{
g_string_append (str, "drive");
}
else
{
/* <VENDOR>_<MODEL>_<SERIAL> */
if (vendor != NULL && strlen (vendor) > 0)
{
storaged_safe_append_to_object_path (str, vendor);
}
if (model != NULL && strlen (model) > 0)
{
if (str->str[str->len - 1] != '/')
g_string_append_c (str, '_');
storaged_safe_append_to_object_path (str, model);
}
if (serial != NULL && strlen (serial) > 0)
{
if (str->str[str->len - 1] != '/')
g_string_append_c (str, '_');
storaged_safe_append_to_object_path (str, serial);
}
}
g_free (vendor);
g_free (model);
g_free (serial);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), str->str);
g_string_free (str, TRUE);
if (G_OBJECT_CLASS (storaged_linux_drive_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storaged_linux_drive_object_parent_class)->constructed (_object);
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
cmdline *cmd = user_data;
manager = g_dbus_object_manager_server_new (dbus_object_path);
gchar *s;
s = g_strdup_printf ("%s/%s",dbus_object_path,instance_name);
ObjectSkeleton *object = object_skeleton_new (s);
g_free (s);
Watchdog *wd = watchdog_skeleton_new ();
object_skeleton_set_watchdog (object, wd);
g_object_unref (wd);
ObjectMapper* mapper = object_mapper_skeleton_new ();
object_skeleton_set_object_mapper (object, mapper);
g_object_unref (mapper);
// set properties
watchdog_set_watchdog(wd,1);
//define method callbacks here
g_signal_connect (wd,
"handle-start",
G_CALLBACK (on_start),
object); /* user_data */
g_signal_connect (wd,
"handle-poke",
G_CALLBACK (on_poke),
object); /* user_data */
g_signal_connect (wd,
"handle-stop",
G_CALLBACK (on_stop),
object); /* user_data */
g_signal_connect (wd,
"handle-set",
G_CALLBACK (set_poll_interval),
object); /* user_data */
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
/* Export all objects */
g_dbus_object_manager_server_set_connection (manager, connection);
emit_object_added((GDBusObjectManager*)manager);
}
static void
udisks_linux_logical_volume_object_constructed (GObject *_object)
{
UDisksLinuxLogicalVolumeObject *object = UDISKS_LINUX_LOGICAL_VOLUME_OBJECT (_object);
GString *s;
if (G_OBJECT_CLASS (udisks_linux_logical_volume_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (udisks_linux_logical_volume_object_parent_class)->constructed (_object);
/* compute the object path */
s = g_string_new (g_dbus_object_get_object_path (G_DBUS_OBJECT (object->volume_group)));
g_string_append_c (s, '/');
udisks_safe_append_to_object_path (s, object->name);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), s->str);
g_string_free (s, TRUE);
/* create the DBus interface */
object->iface_logical_volume = udisks_linux_logical_volume_new ();
g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (object->iface_logical_volume));
}
static void hev_dbus_interface_skeleton_constructed(GObject *obj)
{
GDBusObject *dbus_obj = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
G_OBJECT_CLASS(hev_dbus_interface_skeleton_parent_class)->constructed(obj);
g_object_get(obj, "object", &dbus_obj, NULL);
g_dbus_object_skeleton_add_interface(G_DBUS_OBJECT_SKELETON(dbus_obj),
G_DBUS_INTERFACE_SKELETON(obj));
g_object_unref(dbus_obj);
}
static void
dummy_loop_object_constructed (GObject *_object)
{
DummyLoopObject *object = DUMMY_LOOP_OBJECT (_object);
/* initial coldplug */
dummy_loop_object_process_uevent (STORAGED_MODULE_OBJECT (_object), "add", object->devices->data);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), "/org/storaged/Storaged/dummy/loops");
if (G_OBJECT_CLASS (dummy_loop_object_parent_class)->constructed != NULL)
G_OBJECT_CLASS (dummy_loop_object_parent_class)->constructed (_object);
}
static void
g_dbus_object_skeleton_finalize (GObject *_object)
{
GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
g_free (object->priv->object_path);
g_hash_table_unref (object->priv->map_name_to_iface);
g_mutex_free (object->priv->lock);
if (G_OBJECT_CLASS (g_dbus_object_skeleton_parent_class)->finalize != NULL)
G_OBJECT_CLASS (g_dbus_object_skeleton_parent_class)->finalize (_object);
}
/*****************************************************************************
* neardal_ndefagent_prv_manage: create or release an agent and register or
* unregister it with neardal object manager and Neard
****************************************************************************/
errorCode_t neardal_ndefagent_prv_manage(neardal_ndef_agent_t agentData)
{
errorCode_t err = NEARDAL_SUCCESS;
neardalObjectSkeleton *objSkel;
neardalNDEFAgent *ndefAgent;
neardal_ndef_agent_t *data;
NEARDAL_TRACEIN();
if (agentData.cb_ndef_agent != NULL) {
data = g_try_malloc0(sizeof(neardal_ndef_agent_t));
if (data == NULL)
return NEARDAL_ERROR_NO_MEMORY;
memcpy(data, &agentData, sizeof(neardal_ndef_agent_t));
data->objPath = g_strdup(agentData.objPath);
data->tagType = g_strdup(agentData.tagType);
NEARDAL_TRACEF("Create agent '%s'\n", data->objPath);
objSkel = neardal_object_skeleton_new (data->objPath);
ndefAgent = neardal_ndefagent_skeleton_new();
neardal_object_skeleton_set_ndefagent(objSkel, ndefAgent);
/* Handle GetNDEF D-Bus method invocations */
g_signal_connect( ndefAgent, "handle-get-ndef"
, G_CALLBACK (on_GetNDEF)
, data);
/* Handle Release D-Bus method invocations */
g_signal_connect( ndefAgent, "handle-release"
, G_CALLBACK (on_NDEF_Release), data);
g_signal_connect( neardalMgr.agentMgr, "object-removed"
, G_CALLBACK (on_ndef_object_removed), data);
g_object_unref(ndefAgent);
/* Export the object */
g_dbus_object_manager_server_export(neardalMgr.agentMgr
, G_DBUS_OBJECT_SKELETON (objSkel));
g_object_unref (objSkel);
} else {
NEARDAL_TRACEF("Release agent '%s'\n", agentData.objPath);
if (neardal_agent_prv_remove(agentData.objPath) == TRUE)
err = NEARDAL_SUCCESS;
else
err = NEARDAL_ERROR_DBUS;
}
return err;
}
static void
on_bus_acquired(GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
ObjectSkeleton *object;
cmdline *cmd = user_data;
manager = g_dbus_object_manager_server_new(dbus_object_path);
int i = 0;
for(i=0;i<NUM_HWMONS;i++)
{
if(!is_hwmon_valid(&hwmons[i])) { continue; }
gchar *s;
s = g_strdup_printf("%s/%s",dbus_object_path,hwmons[i].name);
object = object_skeleton_new(s);
g_free(s);
Hwmon *hwmon = hwmon_skeleton_new();
object_skeleton_set_hwmon(object, hwmon);
g_object_unref(hwmon);
SensorValue *sensor = sensor_value_skeleton_new();
object_skeleton_set_sensor_value(object, sensor);
g_object_unref(sensor);
hwmon_set_sysfs_path(hwmon,hwmons[i].filename);
hwmon_set_scale(hwmon,hwmons[i].scale);
sensor_value_set_units(sensor,hwmons[i].units);
//define method callbacks here
g_signal_connect(sensor,
"handle-set-value",
G_CALLBACK(on_set_value),
object); /* user_data */
if(hwmons[i].poll_interval > 0) {
g_timeout_add(hwmons[i].poll_interval, poll_hwmon, object);
}
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_set_connection(manager, connection);
g_dbus_object_manager_server_export(manager, G_DBUS_OBJECT_SKELETON(object));
g_object_unref(object);
}
}
static void
on_bus_acquired(GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
ObjectSkeleton *object;
//g_print ("Acquired a message bus connection: %s\n",name);
manager = g_dbus_object_manager_server_new(dbus_object_path);
gchar *s;
s = g_strdup_printf("%s/%s",dbus_object_path,instance_name);
object = object_skeleton_new(s);
g_free(s);
ControlHost* control_host = control_host_skeleton_new();
object_skeleton_set_control_host(object, control_host);
g_object_unref(control_host);
Control* control = control_skeleton_new();
object_skeleton_set_control(object, control);
g_object_unref(control);
//define method callbacks here
g_signal_connect(control_host,
"handle-boot",
G_CALLBACK(on_boot),
object); /* user_data */
g_signal_connect(control,
"handle-init",
G_CALLBACK(on_init),
NULL); /* user_data */
control_host_set_debug_mode(control_host,0);
control_host_set_flash_side(control_host,"primary");
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_set_connection(manager, connection);
g_dbus_object_manager_server_export(manager, G_DBUS_OBJECT_SKELETON(object));
g_object_unref(object);
gpio_init(connection,&fsi_data);
gpio_init(connection,&fsi_clk);
gpio_init(connection,&fsi_enable);
gpio_init(connection,&cronus_sel);
gpio_init(connection,&Throttle);
gpio_init(connection,&idbtn);
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
//g_print ("Acquired a message bus connection: %s\n",name);
cmdline *cmd = user_data;
if (cmd->argc < 2)
{
g_print("No objects created. Put object name(s) on command line\n");
return;
}
manager = g_dbus_object_manager_server_new (dbus_object_path);
int i=0;
for (i=1;i<cmd->argc;i++)
{
gchar *s;
s = g_strdup_printf ("%s/%s",dbus_object_path,cmd->argv[i]);
ObjectSkeleton *object = object_skeleton_new (s);
g_free (s);
Fan *fan = fan_skeleton_new ();
object_skeleton_set_fan (object, fan);
g_object_unref (fan);
//define method callbacks here
g_signal_connect (fan,
"handle-get-speed",
G_CALLBACK (on_get_speed),
NULL); /* user_data */
g_signal_connect (fan,
"handle-set-speed",
G_CALLBACK (on_set_speed),
NULL); /* user_data */
//g_timeout_add(poll_interval, poll_sensor, object);
/* Export the object (@manager takes its own reference to @object) */
g_dbus_object_manager_server_export (manager, G_DBUS_OBJECT_SKELETON (object));
g_object_unref (object);
}
/* Export all objects */
g_dbus_object_manager_server_set_connection (manager, connection);
}
static GList *
g_dbus_object_skeleton_get_interfaces (GDBusObject *_object)
{
GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (_object);
GList *ret;
g_return_val_if_fail (G_IS_DBUS_OBJECT_SKELETON (object), NULL);
ret = NULL;
g_mutex_lock (object->priv->lock);
ret = g_hash_table_get_values (object->priv->map_name_to_iface);
g_list_foreach (ret, (GFunc) g_object_ref, NULL);
g_mutex_unlock (object->priv->lock);
return ret;
}
/**
* udisks_linux_drive_object_get_block:
* @object: A #UDisksLinuxDriveObject.
* @get_hw: If the drive is multipath, set to %TRUE to get a path device instead of the multipath device.
*
* Gets a #UDisksLinuxBlockObject representing a block device associated with @object.
*
* Returns: A #UDisksLinuxBlockObject or %NULL. The returned object
* must be freed with g_object_unref().
*/
UDisksLinuxBlockObject *
udisks_linux_drive_object_get_block (UDisksLinuxDriveObject *object,
gboolean get_hw)
{
GDBusObjectManagerServer *object_manager;
UDisksLinuxBlockObject *ret;
GList *objects;
GList *l;
/* TODO: actually look at @get_hw */
ret = NULL;
object_manager = udisks_daemon_get_object_manager (object->daemon);
objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (object_manager));
for (l = objects; l != NULL; l = l->next)
{
GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data);
UDisksBlock *block;
UDisksLinuxDevice *device;
gboolean is_disk;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (iter_object))
continue;
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (iter_object));
is_disk = (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0);
g_object_unref (device);
if (!is_disk)
continue;
block = udisks_object_peek_block (UDISKS_OBJECT (iter_object));
if (g_strcmp0 (udisks_block_get_drive (block),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object))) == 0)
{
ret = g_object_ref (iter_object);
goto out;
}
}
out:
g_list_foreach (objects, (GFunc) g_object_unref, NULL);
g_list_free (objects);
return ret;
}
