/****************************************************************************** * 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; }