/******************************************************************************
* GetProperty : get input device properties
*/
static HRESULT WINAPI JoystickAImpl_GetProperty(
LPDIRECTINPUTDEVICE8A iface,
REFGUID rguid,
LPDIPROPHEADER pdiph)
{
JoystickImpl *This = (JoystickImpl *)iface;
TRACE("(%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
if (TRACE_ON(dinput))
_dump_DIPROPHEADER(pdiph);
if (!HIWORD(rguid)) {
switch (LOWORD(rguid)) {
case (DWORD_PTR) DIPROP_RANGE: {
LPDIPROPRANGE pr = (LPDIPROPRANGE)pdiph;
int obj = find_property(&This->base.data_format, pdiph);
/* The app is querying the current range of the axis
* return the lMin and lMax values */
if (obj >= 0) {
pr->lMin = This->props[obj].lMin;
pr->lMax = This->props[obj].lMax;
TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
return DI_OK;
}
break;
}
case (DWORD_PTR) DIPROP_DEADZONE: {
LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
int obj = find_property(&This->base.data_format, pdiph);
if (obj >= 0) {
pd->dwData = This->props[obj].lDeadZone;
TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
return DI_OK;
}
break;
}
case (DWORD_PTR) DIPROP_SATURATION: {
LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
int obj = find_property(&This->base.data_format, pdiph);
if (obj >= 0) {
pd->dwData = This->props[obj].lSaturation;
TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
return DI_OK;
}
break;
}
default:
return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
}
}
return DI_OK;
}
int __system_property_add(const char *name, unsigned int namelen,
const char *value, unsigned int valuelen)
{
prop_area *pa = __system_property_area__;
const prop_info *pi;
if (namelen >= PROP_NAME_MAX)
return -1;
if (valuelen >= PROP_VALUE_MAX)
return -1;
if (namelen < 1)
return -1;
pi = find_property(root_node(), name, namelen, value, valuelen, true);
if (!pi)
return -1;
// There is only a single mutator, but we want to make sure that
// updates are visible to a reader waiting for the update.
atomic_store_explicit(
&pa->serial,
atomic_load_explicit(&pa->serial, memory_order_relaxed) + 1,
memory_order_release);
__futex_wake(&pa->serial, INT32_MAX);
return 0;
}
static GsmClientRestartStyle
xsmp_get_restart_style_hint (GsmClient *client)
{
SmProp *prop;
GsmClientRestartStyle hint;
g_debug ("GsmXSMPClient: getting restart style");
hint = GSM_CLIENT_RESTART_IF_RUNNING;
prop = find_property (GSM_XSMP_CLIENT (client), SmRestartStyleHint, NULL);
if (!prop || strcmp (prop->type, SmCARD8) != 0) {
return GSM_CLIENT_RESTART_IF_RUNNING;
}
switch (((unsigned char *)prop->vals[0].value)[0]) {
case SmRestartIfRunning:
hint = GSM_CLIENT_RESTART_IF_RUNNING;
break;
case SmRestartAnyway:
hint = GSM_CLIENT_RESTART_ANYWAY;
break;
case SmRestartImmediately:
hint = GSM_CLIENT_RESTART_IMMEDIATELY;
break;
case SmRestartNever:
hint = GSM_CLIENT_RESTART_NEVER;
break;
default:
break;
}
return hint;
}
void g_dbus_emit_property_changed(DBusConnection *connection,
const char *path, const char *interface,
const char *name)
{
const GDBusPropertyTable *property;
struct generic_data *data;
struct interface_data *iface;
if (!dbus_connection_get_object_path_data(connection, path,
(void **) &data) || data == NULL)
return;
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return;
property = find_property(iface->properties, name);
if (property == NULL) {
error("Could not find property %s in %p", name,
iface->properties);
return;
}
data->pending_prop = TRUE;
iface->pending_prop = g_slist_prepend(iface->pending_prop,
(void *) property);
if (!data->process_id) {
data->process_id = g_idle_add(process_changes, data);
return;
}
}
static void
delete_property (GsmXSMPClient *client,
const char *name)
{
int index;
SmProp *prop;
prop = find_property (client, name, &index);
if (!prop) {
return;
}
#if 0
/* This is wrong anyway; we can't unconditionally run the current
* discard command; if this client corresponds to a GsmAppResumed,
* and the current discard command is identical to the app's
* discard_command, then we don't run the discard command now,
* because that would delete a saved state we may want to resume
* again later.
*/
if (!strcmp (name, SmDiscardCommand)) {
gsm_client_run_discard (GSM_CLIENT (client));
}
#endif
g_ptr_array_remove_index_fast (client->priv->props, index);
SmFreeProperty (prop);
}
const prop_info *__system_property_find(const char *name)
{
if (__predict_false(compat_mode)) {
return __system_property_find_compat(name);
}
return find_property(root_node(), name, strlen(name), NULL, 0, false);
}
/******************************************************************************
Specify a property of an element that is to be returned. This should be
called (usually multiple times) before a call to the routine ply_get_element().
This routine should be used in preference to the less flexible old routine
called ply_get_element_setup().
Entry:
plyfile - file identifier
elem_name - which element we're talking about
prop - property to add to those that will be returned
******************************************************************************/
void ply_get_property(PlyFile *plyfile, char *elem_name, PlyProperty *prop)
{
PlyElement *elem;
PlyProperty *prop_ptr;
int index;
// find information about the element
elem = find_element (plyfile, elem_name);
plyfile->which_elem = elem;
// deposit the property information into the element's description */
prop_ptr = find_property (elem, prop->name, &index);
if (prop_ptr == NULL) {
log_error("Can't find property '%s' in element '%s'\n",
prop->name, elem_name);
return;
}
prop_ptr->internal_type = prop->internal_type;
prop_ptr->offset = prop->offset;
prop_ptr->count_internal = prop->count_internal;
prop_ptr->count_offset = prop->count_offset;
// specify that the user wants this property */
elem->store_prop[index] = STORE_PROP;
}
bool get_bool(const std::string& name, size_t* lineno = nullptr) const {
auto it = find_property(name, lineno);
if (it == properties_.end()) {
return false;
}
return it->second.value() == "true";
}
static int no_getprop(int node,char *name,char *value)
{
struct property *prop = find_property(node,name);
if (prop) {
memcpy(value,prop->value,prop->length);
return 1;
}
return -1;
}
/******************************************************************************
* GetProperty : get input device properties
*/
static HRESULT WINAPI JoystickAImpl_GetProperty(LPDIRECTINPUTDEVICE8A iface,
REFGUID rguid,
LPDIPROPHEADER pdiph)
{
JoystickImpl *This = (JoystickImpl *)iface;
TRACE("(this=%p,%s,%p)\n", iface, debugstr_guid(rguid), pdiph);
_dump_DIPROPHEADER(pdiph);
if (HIWORD(rguid)) return DI_OK;
switch (LOWORD(rguid)) {
case (DWORD) DIPROP_RANGE:
{
LPDIPROPRANGE pr = (LPDIPROPRANGE) pdiph;
int obj = find_property(&This->base.data_format, pdiph);
if (obj < 0) return DIERR_OBJECTNOTFOUND;
pr->lMin = This->props[obj].lMin;
pr->lMax = This->props[obj].lMax;
TRACE("range(%d, %d) obj=%d\n", pr->lMin, pr->lMax, obj);
break;
}
case (DWORD) DIPROP_DEADZONE:
{
LPDIPROPDWORD pd = (LPDIPROPDWORD)pdiph;
int obj = find_property(&This->base.data_format, pdiph);
if (obj < 0) return DIERR_OBJECTNOTFOUND;
pd->dwData = This->props[obj].lDeadZone;
TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
break;
}
default:
return IDirectInputDevice2AImpl_GetProperty(iface, rguid, pdiph);
}
return DI_OK;
}
static char *
xsmp_get_app_name (GsmClient *client)
{
SmProp *prop;
char *name;
prop = find_property (GSM_XSMP_CLIENT (client), SmProgram, NULL);
name = prop_to_command (prop);
return name;
}
static DBusMessage *properties_get(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
struct interface_data *iface;
const GDBusPropertyTable *property;
const char *interface, *name;
DBusMessageIter iter, value;
DBusMessage *reply;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
return NULL;
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"No such interface '%s'", interface);
property = find_property(iface->properties, name);
if (property == NULL)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"No such property '%s'", name);
if (property->exists != NULL &&
!property->exists(property, iface->user_data))
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"No such property '%s'", name);
if (property->get == NULL)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"Property '%s' is not readable", name);
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
property->type, &value);
if (!property->get(property, &value, iface->user_data)) {
dbus_message_unref(reply);
return NULL;
}
dbus_message_iter_close_container(&iter, &value);
return reply;
}
static char *
xsmp_get_restart_command (CsmClient *client)
{
SmProp *prop;
prop = find_property (CSM_XSMP_CLIENT (client), SmRestartCommand, NULL);
if (!prop || strcmp (prop->type, SmLISTofARRAY8) != 0) {
return NULL;
}
return prop_to_command (prop);
}
static char *
xsmp_get_discard_command (GsmClient *client)
{
SmProp *prop;
prop = find_property (GSM_XSMP_CLIENT (client), SmDiscardCommand, NULL);
if (!prop || strcmp (prop->type, SmLISTofARRAY8) != 0) {
return NULL;
}
return prop_to_command (prop);
}
bool PlyReader::hasProperty(const std::string& elementName, const std::string& propertyName) const
{
SURGSIM_ASSERT(isValid()) << "'" << m_filename << "' is an invalid .ply file";
bool result = false;
PlyElement* element = find_element(m_data->plyFile, elementName.c_str());
if (element != nullptr)
{
int index;
result = find_property(element, propertyName.c_str(), &index) != nullptr;
}
return result;
}
static char *
get_desktop_file_path (GsmXSMPClient *client)
{
SmProp *prop;
char *desktop_file_path = NULL;
char **dirs;
const char *program_name;
/* XSMP clients using eggsmclient defines a special property
* pointing to their respective desktop entry file */
prop = find_property (client, GsmDesktopFile, NULL);
if (prop) {
GFile *file = g_file_new_for_uri (prop->vals[0].value);
desktop_file_path = g_file_get_path (file);
g_object_unref (file);
goto out;
}
/* If we can't get desktop file from GsmDesktopFile then we
* try to find the desktop file from its program name */
prop = find_property (client, SmProgram, NULL);
program_name = prop->vals[0].value;
dirs = gsm_util_get_autostart_dirs ();
desktop_file_path =
gsm_util_find_desktop_file_for_app_name (program_name,
dirs);
g_strfreev (dirs);
out:
g_debug ("GsmXSMPClient: desktop file for client %s is %s",
gsm_client_peek_id (GSM_CLIENT (client)),
desktop_file_path ? desktop_file_path : "(null)");
return desktop_file_path;
}
unsigned char *
prom_get_property( mol_device_node_t *dn, const char *name, int *lenp )
{
p_property_t *pp;
if( lenp )
*lenp=0;
if( (pp=find_property( dn, name )) ) {
if( lenp )
*lenp = pp->length;
return pp->value ? (unsigned char*)pp->value : (unsigned char *)"";
}
return NULL;
}
static void
set_desktop_file_keys_from_client (CsmClient *client,
GKeyFile *keyfile)
{
SmProp *prop;
const char *name;
char *comment;
prop = find_property (CSM_XSMP_CLIENT (client), SmProgram, NULL);
if (prop) {
name = prop->vals[0].value;
} else {
/* It'd be really surprising to reach this code: if we're here,
* then the XSMP client already has set several XSMP
* properties. But it could still be that SmProgram is not set.
*/
name = _("Remembered Application");
}
comment = g_strdup_printf ("Client %s which was automatically saved",
csm_client_peek_startup_id (client));
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_NAME,
name);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_COMMENT,
comment);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_ICON,
CSM_ICON_XSMP_DEFAULT);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE,
"Application");
g_key_file_set_boolean (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY,
TRUE);
g_free (comment);
}
std::vector<std::string> get_strings(const std::string& name, size_t* lineno = nullptr) const {
auto it = find_property(name, lineno);
if (it == properties_.end()) {
// return empty vector
return std::vector<std::string>();
}
std::vector<std::string> strings = android::base::Split(it->second.value(), ",");
for (size_t i = 0; i < strings.size(); ++i) {
strings[i] = android::base::Trim(strings[i]);
}
return strings;
}
bool PlyReader::isScalar(const std::string& elementName, const std::string& propertyName) const
{
SURGSIM_ASSERT(isValid()) << "'" << m_filename << "' is an invalid .ply file";
bool result = false;
PlyElement* element = find_element(m_data->plyFile, elementName.c_str());
if (element != nullptr)
{
int index;
PlyProperty* property = find_property(element, propertyName.c_str(), &index);
if (property != nullptr)
{
result = (property->is_list == PLY_SCALAR);
}
}
return result;
}
static void
set_desktop_file_keys_from_client (GsmClient *client,
GKeyFile *keyfile)
{
SmProp *prop;
char *name;
char *comment;
prop = find_property (GSM_XSMP_CLIENT (client), SmProgram, NULL);
name = g_strdup (prop->vals[0].value);
comment = g_strdup_printf ("Client %s which was automatically saved",
gsm_client_peek_startup_id (client));
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_NAME,
name);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_COMMENT,
comment);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_ICON,
"system-run");
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE,
"Application");
g_key_file_set_boolean (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY,
TRUE);
g_free (name);
g_free (comment);
}
void g_dbus_emit_property_changed(DBusConnection *connection,
const char *path, const char *interface,
const char *name)
{
const GDBusPropertyTable *property;
struct generic_data *data;
struct interface_data *iface;
if (path == NULL)
return;
if (!dbus_connection_get_object_path_data(connection, path,
(void **) &data) || data == NULL)
return;
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return;
/*
* If ObjectManager is attached, don't emit property changed if
* interface is not yet published
*/
if (root && g_slist_find(data->added, iface))
return;
property = find_property(iface->properties, name);
if (property == NULL) {
error("Could not find property %s in %p", name,
iface->properties);
return;
}
if (g_slist_find(iface->pending_prop, (void *) property) != NULL)
return;
data->pending_prop = TRUE;
iface->pending_prop = g_slist_prepend(iface->pending_prop,
(void *) property);
add_pending(data);
}
/* dynamically modify the device tree (dn must belong to the emulated tree!) */
void
prom_add_property( mol_device_node_t *dn, const char *name, const char *data, int len )
{
p_property_t *pp;
unsigned char *ptr = NULL;
if( (pp=find_property(dn, name)) ) {
if( pp->length >= len )
ptr = pp->value;
} else {
pp = obstack_alloc( &oftree.stack, sizeof( p_property_t ));
pp->name = obstack_copy0( &oftree.stack, name, strlen(name) );
pp->next = dn->properties;
dn->properties = pp;
}
if( !ptr )
ptr = obstack_alloc( &oftree.stack, len );
pp->value = ptr;
pp->length = len;
memmove( pp->value, data, len );
}
int __system_property_add(const char *name, unsigned int namelen,
const char *value, unsigned int valuelen)
{
prop_area *pa = __system_property_area__;
const prop_info *pi;
if (namelen >= PROP_NAME_MAX)
return -1;
if (valuelen >= PROP_VALUE_MAX)
return -1;
if (namelen < 1)
return -1;
pi = find_property(root_node(), name, namelen, value, valuelen, true);
if (!pi)
return -1;
pa->serial++;
__futex_wake(&pa->serial, INT32_MAX);
return 0;
}
static void
set_description (GsmXSMPClient *client)
{
SmProp *prop;
const char *id;
prop = find_property (client, SmProgram, NULL);
id = gsm_client_peek_startup_id (GSM_CLIENT (client));
g_free (client->priv->description);
if (prop) {
client->priv->description = g_strdup_printf ("%p [%.*s %s]",
client,
prop->vals[0].length,
(char *)prop->vals[0].value,
id);
} else if (id != NULL) {
client->priv->description = g_strdup_printf ("%p [%s]", client, id);
} else {
client->priv->description = g_strdup_printf ("%p", client);
}
}
static void
attribute_mapping_changed (GtkComboBox *combo,
GtkInspectorPropEditor *editor)
{
gint col;
gpointer layout;
GtkCellRenderer *cell;
GtkCellArea *area;
col = gtk_combo_box_get_active (combo) - 1;
layout = g_object_get_data (editor->priv->object, "gtk-inspector-cell-layout");
if (GTK_IS_CELL_LAYOUT (layout))
{
cell = GTK_CELL_RENDERER (editor->priv->object);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
gtk_cell_area_attribute_disconnect (area, cell, editor->priv->name);
if (col != -1)
gtk_cell_area_attribute_connect (area, cell, editor->priv->name, col);
gtk_widget_set_sensitive (editor->priv->editor, col == -1);
notify_property (editor->priv->object, find_property (editor));
gtk_widget_queue_draw (gtk_cell_layout_get_widget (GTK_CELL_LAYOUT (layout)));
}
}
static guint
xsmp_get_unix_process_id (GsmClient *client)
{
SmProp *prop;
guint pid;
gboolean res;
g_debug ("GsmXSMPClient: getting pid");
prop = find_property (GSM_XSMP_CLIENT (client), SmProcessID, NULL);
if (!prop || strcmp (prop->type, SmARRAY8) != 0) {
return 0;
}
pid = 0;
res = _parse_value_as_uint ((char *)prop->vals[0].value, &pid);
if (! res) {
pid = 0;
}
return pid;
}
static void
constructed (GObject *object)
{
GtkInspectorPropEditor *editor = GTK_INSPECTOR_PROP_EDITOR (object);
GParamSpec *spec;
GtkWidget *label;
gboolean can_modify;
spec = find_property (editor);
label = gtk_label_new (g_param_spec_get_nick (spec));
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (editor), label);
can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
(spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
if (!can_modify)
return;
editor->priv->editor = property_editor (editor->priv->object, spec, editor);
gtk_widget_show (editor->priv->editor);
gtk_container_add (GTK_CONTAINER (editor), editor->priv->editor);
if (GTK_IS_CELL_RENDERER (editor->priv->object))
gtk_container_add (GTK_CONTAINER (editor),
attribute_editor (editor->priv->object, spec, editor));
if (GTK_IS_ACTIONABLE (editor->priv->object) &&
g_strcmp0 (editor->priv->name, "action-name") == 0)
gtk_container_add (GTK_CONTAINER (editor),
action_editor (editor->priv->object, editor));
add_binding_info (editor);
add_settings_info (editor);
add_gtk_settings_info (editor);
}
/******************************************************************************
* SetProperty : change input device properties
*/
HRESULT WINAPI JoystickWGenericImpl_SetProperty(LPDIRECTINPUTDEVICE8W iface, REFGUID rguid, LPCDIPROPHEADER ph)
{
JoystickGenericImpl *This = impl_from_IDirectInputDevice8W(iface);
DWORD i;
TRACE("(%p,%s,%p)\n",This,debugstr_guid(rguid),ph);
if (ph == NULL) {
WARN("invalid parameter: ph == NULL\n");
return DIERR_INVALIDPARAM;
}
if (TRACE_ON(dinput))
_dump_DIPROPHEADER(ph);
if (IS_DIPROP(rguid)) {
switch (LOWORD(rguid)) {
case (DWORD_PTR)DIPROP_RANGE: {
LPCDIPROPRANGE pr = (LPCDIPROPRANGE)ph;
if (ph->dwHow == DIPH_DEVICE) {
TRACE("proprange(%d,%d) all\n", pr->lMin, pr->lMax);
for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++) {
This->props[i].lMin = pr->lMin;
This->props[i].lMax = pr->lMax;
}
} else {
int obj = find_property(&This->base.data_format, ph);
TRACE("proprange(%d,%d) obj=%d\n", pr->lMin, pr->lMax, obj);
if (obj >= 0) {
This->props[obj].lMin = pr->lMin;
This->props[obj].lMax = pr->lMax;
return DI_OK;
}
}
break;
}
case (DWORD_PTR)DIPROP_DEADZONE: {
LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
if (ph->dwHow == DIPH_DEVICE) {
TRACE("deadzone(%d) all\n", pd->dwData);
for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
This->props[i].lDeadZone = pd->dwData;
} else {
int obj = find_property(&This->base.data_format, ph);
TRACE("deadzone(%d) obj=%d\n", pd->dwData, obj);
if (obj >= 0) {
This->props[obj].lDeadZone = pd->dwData;
return DI_OK;
}
}
break;
}
case (DWORD_PTR)DIPROP_SATURATION: {
LPCDIPROPDWORD pd = (LPCDIPROPDWORD)ph;
if (ph->dwHow == DIPH_DEVICE) {
TRACE("saturation(%d) all\n", pd->dwData);
for (i = 0; i < This->base.data_format.wine_df->dwNumObjs; i++)
This->props[i].lSaturation = pd->dwData;
} else {
int obj = find_property(&This->base.data_format, ph);
TRACE("saturation(%d) obj=%d\n", pd->dwData, obj);
if (obj >= 0) {
This->props[obj].lSaturation = pd->dwData;
return DI_OK;
}
}
break;
}
default:
return IDirectInputDevice2WImpl_SetProperty(iface, rguid, ph);
}
}
return DI_OK;
}
static DBusMessage *properties_set(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
DBusMessageIter iter, sub;
struct interface_data *iface;
const GDBusPropertyTable *property;
const char *name, *interface;
struct property_data *propdata;
gboolean valid_signature;
char *signature;
if (!dbus_message_iter_init(message, &iter))
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"No arguments given");
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"Invalid argument type: '%c'",
dbus_message_iter_get_arg_type(&iter));
dbus_message_iter_get_basic(&iter, &interface);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"Invalid argument type: '%c'",
dbus_message_iter_get_arg_type(&iter));
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"Invalid argument type: '%c'",
dbus_message_iter_get_arg_type(&iter));
dbus_message_iter_recurse(&iter, &sub);
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
"No such interface '%s'", interface);
property = find_property(iface->properties, name);
if (property == NULL)
return g_dbus_create_error(message,
DBUS_ERROR_UNKNOWN_PROPERTY,
"No such property '%s'", name);
if (property->set == NULL)
return g_dbus_create_error(message,
DBUS_ERROR_PROPERTY_READ_ONLY,
"Property '%s' is not writable", name);
if (property->exists != NULL &&
!property->exists(property, iface->user_data))
return g_dbus_create_error(message,
DBUS_ERROR_UNKNOWN_PROPERTY,
"No such property '%s'", name);
signature = dbus_message_iter_get_signature(&sub);
valid_signature = strcmp(signature, property->type) ? FALSE : TRUE;
dbus_free(signature);
if (!valid_signature)
return g_dbus_create_error(message,
DBUS_ERROR_INVALID_SIGNATURE,
"Invalid signature for '%s'", name);
propdata = g_new(struct property_data, 1);
propdata->id = next_pending_property++;
propdata->message = dbus_message_ref(message);
propdata->conn = connection;
pending_property_set = g_slist_prepend(pending_property_set, propdata);
property->set(property, &sub, propdata->id, iface->user_data);
return NULL;
}