static int parse_request_oob_params(DBusMessage *message, const uint8_t **tlv_msg, int *length) { DBusMessageIter iter; DBusMessageIter array; DBusMessageIter dict_entry; const char *key; int arg_type; if (!tlv_msg || !length) return -EINVAL; dbus_message_iter_init(message, &iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) return -EINVAL; dbus_message_iter_recurse(&iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); if (arg_type != DBUS_TYPE_DICT_ENTRY) return -EINVAL; while (arg_type != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&array, &dict_entry); if (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_STRING) return -EINVAL; dbus_message_iter_get_basic(&dict_entry, &key); if (g_strcmp0(key, "WSC") == 0) { DBusMessageIter value; DBusMessageIter fixed_array; dbus_message_iter_next(&dict_entry); dbus_message_iter_recurse(&dict_entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_ARRAY) return -EINVAL; dbus_message_iter_recurse(&value, &fixed_array); dbus_message_iter_get_fixed_array(&fixed_array, tlv_msg, length); return 0; } dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } return -EINVAL; }
static void extract_wpsie(DBusMessageIter *value, struct supplicant_result *result) { DBusMessageIter array; unsigned char *ie; int ie_len; dbus_message_iter_recurse(value, &array); dbus_message_iter_get_fixed_array(&array, &ie, &ie_len); if (ie_len > 0) result->has_wps = TRUE; }
static bool parse_advertising_manufacturer_data(GDBusProxy *proxy, struct bt_ad *data) { DBusMessageIter iter, entries; if (!g_dbus_proxy_get_property(proxy, "ManufacturerData", &iter)) return true; if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) return false; dbus_message_iter_recurse(&iter, &entries); bt_ad_clear_manufacturer_data(data); while (dbus_message_iter_get_arg_type(&entries) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter value, entry; uint16_t manuf_id; uint8_t *manuf_data; int len; dbus_message_iter_recurse(&entries, &entry); dbus_message_iter_get_basic(&entry, &manuf_id); dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_ARRAY) goto fail; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_BYTE) goto fail; dbus_message_iter_get_fixed_array(&value, &manuf_data, &len); DBG("Adding ManufacturerData for %04x", manuf_id); if (!bt_ad_add_manufacturer_data(data, manuf_id, manuf_data, len)) goto fail; dbus_message_iter_next(&entries); } return true; fail: bt_ad_clear_manufacturer_data(data); return false; }
static int bus_manager_create_machine(Manager *manager, DBusMessage *message) { const char *name, *service, *class, *root_directory; DBusMessageIter iter, sub; MachineClass c; uint32_t leader; sd_id128_t id; Machine *m; int n, r; void *v; assert(manager); assert(message); if (!dbus_message_iter_init(message, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return -EINVAL; dbus_message_iter_get_basic(&iter, &name); if (!valid_machine_name(name) || !dbus_message_iter_next(&iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) return -EINVAL; dbus_message_iter_recurse(&iter, &sub); dbus_message_iter_get_fixed_array(&sub, &v, &n); if (n == 0) id = SD_ID128_NULL; else if (n == 16) memcpy(&id, v, n); else return -EINVAL; if (!dbus_message_iter_next(&iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return -EINVAL; dbus_message_iter_get_basic(&iter, &service); if (!dbus_message_iter_next(&iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return -EINVAL; dbus_message_iter_get_basic(&iter, &class); if (isempty(class)) c = _MACHINE_CLASS_INVALID; else {
static int parse_properties(DBusMessageIter *props, const char **uuid, gboolean *delay_reporting, uint8_t *codec, uint8_t **capabilities, int *size) { gboolean has_uuid = FALSE; gboolean has_codec = FALSE; while (dbus_message_iter_get_arg_type(props) == DBUS_TYPE_DICT_ENTRY) { const char *key; DBusMessageIter value, entry; int var; dbus_message_iter_recurse(props, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); var = dbus_message_iter_get_arg_type(&value); if (strcasecmp(key, "UUID") == 0) { if (var != DBUS_TYPE_STRING) return -EINVAL; dbus_message_iter_get_basic(&value, uuid); has_uuid = TRUE; } else if (strcasecmp(key, "Codec") == 0) { if (var != DBUS_TYPE_BYTE) return -EINVAL; dbus_message_iter_get_basic(&value, codec); has_codec = TRUE; } else if (strcasecmp(key, "DelayReporting") == 0) { if (var != DBUS_TYPE_BOOLEAN) return -EINVAL; dbus_message_iter_get_basic(&value, delay_reporting); } else if (strcasecmp(key, "Capabilities") == 0) { DBusMessageIter array; if (var != DBUS_TYPE_ARRAY) return -EINVAL; dbus_message_iter_recurse(&value, &array); dbus_message_iter_get_fixed_array(&array, capabilities, size); } dbus_message_iter_next(props); } return (has_uuid && has_codec) ? 0 : -EINVAL; }
static void chr_write(struct characteristic *chr, DBusMessageIter *iter) { DBusMessageIter array; uint8_t *value; int len; dbus_message_iter_recurse(iter, &array); dbus_message_iter_get_fixed_array(&array, &value, &len); g_free(chr->value); chr->value = g_memdup(value, len); chr->vlen = len; g_dbus_emit_property_changed(connection, chr->path, GATT_CHR_IFACE, "Value"); }
static void desc_write(struct descriptor *desc, DBusMessageIter *iter) { DBusMessageIter array; const uint8_t *value; int vlen; dbus_message_iter_recurse(iter, &array); dbus_message_iter_get_fixed_array(&array, &value, &vlen); g_free(desc->value); desc->value = g_memdup(value, vlen); desc->vlen = vlen; g_dbus_emit_property_changed(connection, desc->path, GATT_DESCRIPTOR_IFACE, "Value"); }
pa_proplist *pa_dbus_get_proplist_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter) { DBusMessageIter dict_iter; DBusMessageIter dict_entry_iter; pa_proplist *proplist = NULL; const char *key = NULL; const uint8_t *value = NULL; int value_length = 0; pa_assert(c); pa_assert(msg); pa_assert(iter); pa_assert(pa_streq(dbus_message_iter_get_signature(iter), "a{say}")); proplist = pa_proplist_new(); dbus_message_iter_recurse(iter, &dict_iter); while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&dict_iter, &dict_entry_iter); dbus_message_iter_get_basic(&dict_entry_iter, &key); dbus_message_iter_next(&dict_entry_iter); if (strlen(key) <= 0 || !pa_ascii_valid(key)) { pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Invalid property list key: '%s'.", key); goto fail; } dbus_message_iter_get_fixed_array(&dict_entry_iter, &value, &value_length); pa_assert(value_length >= 0); pa_assert_se(pa_proplist_set(proplist, key, value, value_length) >= 0); dbus_message_iter_next(&dict_iter); } dbus_message_iter_next(iter); return proplist; fail: if (proplist) pa_proplist_free(proplist); return NULL; }
static DBusMessage *oem_raw_make_request(DBusConnection *conn, DBusMessage *msg, void *data) { char *array; /* Byte array containing client request*/ int array_len; /* Length of request byte array */ DBusMessageIter iter; DBusMessageIter subiter; struct ofono_oem_raw_request *req; struct ofono_oem_raw *raw; raw = data; req = 0; if (raw && raw->driver->request == NULL) return __ofono_error_not_implemented(msg); dbus_message_iter_init(msg, &iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) goto error_arg; if (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) { DBG("Ignoring request because dbus request element type=%c", dbus_message_iter_get_element_type(&iter)); goto error_arg; } dbus_message_iter_recurse(&iter, &subiter); dbus_message_iter_get_fixed_array(&subiter, &array, &array_len); req = g_new0(struct ofono_oem_raw_request, 1); req->data = array; req->length = array_len; /* Store msg to request struct to allow multiple parallel requests */ req->pending = dbus_message_ref(msg); raw->driver->request(raw, req, ofono_oem_raw_query_cb, req); return NULL; error_arg: DBG("DBus arg type=%c, msg signature: %s", dbus_message_iter_get_arg_type(&iter), dbus_message_get_signature(msg)); return __ofono_error_invalid_args(msg); }
static void proxy_read_cb(struct btd_attribute *attr, btd_attr_read_result_t result, void *user_data) { DBusMessageIter iter, array; GDBusProxy *proxy; uint8_t *value; int len; /* * Remote device is trying to read the informed attribute, * "Value" should be read from the proxy. GDBusProxy tracks * properties changes automatically, it is not necessary to * get the value directly from the GATT server. */ proxy = g_hash_table_lookup(proxy_hash, attr); if (!proxy) { result(-ENOENT, NULL, 0, user_data); return; } if (!g_dbus_proxy_get_property(proxy, "Value", &iter)) { /* Unusual situation, read property will checked earlier */ result(-EPERM, NULL, 0, user_data); return; } if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { DBG("External service inconsistent!"); result(-EPERM, NULL, 0, user_data); return; } dbus_message_iter_recurse(&iter, &array); dbus_message_iter_get_fixed_array(&array, &value, &len); DBG("attribute: %p read %d bytes", attr, len); result(0, value, len, user_data); }
EAPI Eina_Bool eldbus_message_iter_fixed_array_get(Eldbus_Message_Iter *iter, int signature, void *value, int *n_elements) { int iter_type; ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(iter->writable, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(n_elements, EINA_FALSE); iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator); if (iter_type == DBUS_TYPE_INVALID) { *n_elements = 0; return EINA_TRUE; } EINA_SAFETY_ON_FALSE_RETURN_VAL( (dbus_message_iter_get_arg_type(&iter->dbus_iterator) == signature), EINA_FALSE); dbus_message_iter_get_fixed_array(&iter->dbus_iterator, value, n_elements); return EINA_TRUE; }
static void desc_set_value(const GDBusPropertyTable *property, DBusMessageIter *iter, GDBusPendingPropertySet id, void *user_data) { struct descriptor *desc = user_data; DBusMessageIter array; const uint8_t *value; int vlen; printf("Descriptor(%s): Set(\"Value\", ...)\n", desc->uuid); dbus_message_iter_recurse(iter, &array); dbus_message_iter_get_fixed_array(&array, &value, &vlen); g_free(desc->value); desc->value = g_memdup(value, vlen); desc->vlen = vlen; g_dbus_pending_property_success(id); g_dbus_emit_property_changed(connection, desc->path, GATT_DESCRIPTOR_IFACE, "Value"); }
static struct carrier_data *parse_reply(DBusMessage *reply) { DBusMessageIter args; DBusMessageIter data; struct carrier_data *c_data; c_data = g_try_new0(struct carrier_data, 1); if (!c_data) return NULL; c_data->state = CPS_UNKNOWN; dbus_message_iter_init(reply, &args); dbus_message_iter_recurse(&args, &data); while (dbus_message_iter_get_arg_type(&data) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter value; DBusMessageIter entry; DBusMessageIter array; const char *key; int var; dbus_message_iter_recurse(&data, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); var = dbus_message_iter_get_arg_type(&value); if (strcasecmp(key, "State") == 0) { const char *state; if (var != DBUS_TYPE_STRING) goto failed; dbus_message_iter_get_basic(&value, &state); c_data->state = string2cps(state); if (c_data->state == CPS_UNKNOWN) goto failed; } else if (strcasecmp(key, "EIR") == 0) { int size; void *oob_data; if (var != DBUS_TYPE_ARRAY) goto failed; dbus_message_iter_recurse(&value, &array); dbus_message_iter_get_fixed_array(&array, &oob_data, &size); if (size > UINT8_MAX || size < 8) goto failed; memcpy(c_data->data, oob_data, size); c_data->size = size; c_data->type = BT_MIME_V2_1; } else if (strcasecmp(key, "nokia.com:bt") == 0) { int size; void *oob_data; /* prefer EIR over nokia.com:bt */ if (c_data->type == BT_MIME_V2_1) continue; dbus_message_iter_recurse(&value, &array); dbus_message_iter_get_fixed_array(&array, &oob_data, &size); if (size > UINT8_MAX || size < 8) goto failed; memcpy(c_data->data, oob_data, size); c_data->size = size; c_data->type = BT_MIME_V2_1; } else if (strcasecmp(key, "WSC") == 0) { int size; void *oob_data; if (var != DBUS_TYPE_ARRAY) goto failed; dbus_message_iter_recurse(&value, &array); dbus_message_iter_get_fixed_array(&array, &oob_data, &size); memcpy(c_data->data, oob_data, size); c_data->size = size; c_data->type = WIFI_WSC_MIME; } dbus_message_iter_next(&data); } /* State can be present only if EIR or nokia.com:bt is also present */ if (c_data->state != CPS_UNKNOWN && c_data->size == 0) goto failed; return c_data; failed: g_free(c_data); return NULL; }
CICallerInfo * ci_tracker_get_info (CITracker *cit, const char *system_bus_unique_name) { CICallerInfo *ci; DBusError error; #ifdef HAVE_CONKIT DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter sub_iter; char *dbus_session_name; char *str; int num_elems; #endif /* HAVE_CONKIT */ ci = NULL; if (system_bus_unique_name == NULL) goto error; if (!validate_bus_name (system_bus_unique_name)) goto error; /*HAL_INFO (("=========================")); HAL_INFO (("Looking up CICallerInfo for system_bus_unique_name = %s", system_bus_unique_name));*/ ci = g_hash_table_lookup (cit->connection_name_to_caller_info, system_bus_unique_name); if (ci != NULL) { /*HAL_INFO (("(using cached information)"));*/ goto got_caller_info; } /*HAL_INFO (("(retrieving info from system bus and ConsoleKit)"));*/ ci = caller_info_new (); ci->system_bus_unique_name = g_strdup (system_bus_unique_name); dbus_error_init (&error); ci->uid = dbus_bus_get_unix_user (cit->dbus_connection, system_bus_unique_name, &error); if (ci->uid == ((unsigned long) -1) || dbus_error_is_set (&error)) { HAL_WARNING (("Could not get uid for connection: %s %s", error.name, error.message)); dbus_error_free (&error); goto error; } #ifdef HAVE_CONKIT message = dbus_message_new_method_call ("org.freedesktop.DBus", "/org/freedesktop/DBus/Bus", "org.freedesktop.DBus", "GetConnectionUnixProcessID"); dbus_message_iter_init_append (message, &iter); dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &system_bus_unique_name); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (cit->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_WARNING (("Error doing GetConnectionUnixProcessID on Bus: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); dbus_error_free (&error); goto error; } dbus_message_iter_init (reply, &iter); dbus_message_iter_get_basic (&iter, &ci->pid); dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.DBus", "/org/freedesktop/DBus/Bus", "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext"); dbus_message_iter_init_append (message, &iter); dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &system_bus_unique_name); reply = dbus_connection_send_with_reply_and_block (cit->dbus_connection, message, -1, &error); /* SELinux might not be enabled */ if (dbus_error_is_set (&error) && strcmp (error.name, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown") == 0) { dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); dbus_error_init (&error); } else if (reply == NULL || dbus_error_is_set (&error)) { g_warning ("Error doing GetConnectionSELinuxSecurityContext on Bus: %s: %s", error.name, error.message); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); dbus_error_free (&error); goto error; } else { /* TODO: verify signature */ dbus_message_iter_init (reply, &iter); dbus_message_iter_recurse (&iter, &sub_iter); dbus_message_iter_get_fixed_array (&sub_iter, (void *) &str, &num_elems); if (str != NULL && num_elems > 0) ci->selinux_context = g_strndup (str, num_elems); dbus_message_unref (message); dbus_message_unref (reply); } message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "GetSessionForUnixProcess"); dbus_message_iter_init_append (message, &iter); dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &ci->pid); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (cit->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_WARNING (("Error doing GetSessionForUnixProcess on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); /* OK, this is not a catastrophe; just means the caller is not a member of any session.. */ dbus_error_free (&error); goto store_caller_info; } dbus_message_iter_init (reply, &iter); dbus_message_iter_get_basic (&iter, &dbus_session_name); ci->session_objpath = g_strdup (dbus_session_name); dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", ci->session_objpath, "org.freedesktop.ConsoleKit.Session", "IsActive"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (cit->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_WARNING (("Error doing IsActive on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); dbus_error_free (&error); goto error; } dbus_message_iter_init (reply, &iter); dbus_message_iter_get_basic (&iter, &ci->in_active_session); dbus_message_unref (message); dbus_message_unref (reply); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", ci->session_objpath, "org.freedesktop.ConsoleKit.Session", "IsLocal"); dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (cit->dbus_connection, message, -1, &error); if (reply == NULL || dbus_error_is_set (&error)) { HAL_WARNING (("Error doing IsLocal on ConsoleKit: %s: %s", error.name, error.message)); dbus_message_unref (message); if (reply != NULL) dbus_message_unref (reply); dbus_error_free (&error); goto error; } dbus_message_iter_init (reply, &iter); dbus_message_iter_get_basic (&iter, &ci->is_local); dbus_message_unref (message); dbus_message_unref (reply); store_caller_info: #endif /* HAVE_CONKIT */ g_hash_table_insert (cit->connection_name_to_caller_info, ci->system_bus_unique_name, ci); got_caller_info: /*HAL_INFO (("system_bus_unique_name = %s", ci->system_bus_unique_name)); HAL_INFO (("uid = %d", ci->uid)); HAL_INFO (("pid = %d", ci->pid)); if (ci->session_objpath != NULL) { HAL_INFO (("session_objpath = %s", ci->session_objpath)); HAL_INFO (("in_active_session = %d", ci->in_active_session)); } else { HAL_INFO ((" (Caller is not in any session)")); } HAL_INFO ((" (keeping CICallerInfo for %d connections)", g_hash_table_size (cit->connection_name_to_caller_info))); HAL_INFO (("========================="));*/ return ci; error: /*HAL_INFO (("========================="));*/ if (ci != NULL) caller_info_free (ci); return NULL; }
static DBusMessage *dbus_add_lease(DBusMessage* message) { struct dhcp_lease *lease; const char *ipaddr, *hwaddr, *hostname, *tmp; const unsigned char* clid; int clid_len, hostname_len, hw_len, hw_type; dbus_uint32_t expires, ia_id; dbus_bool_t is_temporary; struct all_addr addr; time_t now = dnsmasq_time(); unsigned char dhcp_chaddr[DHCP_CHADDR_MAX]; DBusMessageIter iter, array_iter; if (!dbus_message_iter_init(message, &iter)) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Failed to initialize dbus message iter"); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected string as first argument"); dbus_message_iter_get_basic(&iter, &ipaddr); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected string as second argument"); dbus_message_iter_get_basic(&iter, &hwaddr); dbus_message_iter_next(&iter); if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) || (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE)) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected byte array as third argument"); dbus_message_iter_recurse(&iter, &array_iter); dbus_message_iter_get_fixed_array(&array_iter, &hostname, &hostname_len); tmp = memchr(hostname, '\0', hostname_len); if (tmp) { if (tmp == &hostname[hostname_len - 1]) hostname_len--; else return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Hostname contains an embedded NUL character"); } dbus_message_iter_next(&iter); if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) || (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE)) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected byte array as fourth argument"); dbus_message_iter_recurse(&iter, &array_iter); dbus_message_iter_get_fixed_array(&array_iter, &clid, &clid_len); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected uint32 as fifth argument"); dbus_message_iter_get_basic(&iter, &expires); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected uint32 as sixth argument"); dbus_message_iter_get_basic(&iter, &ia_id); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "Expected uint32 as sixth argument"); dbus_message_iter_get_basic(&iter, &is_temporary); if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4)) { if (ia_id != 0 || is_temporary) return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "ia_id and is_temporary must be zero for IPv4 lease"); if (!(lease = lease_find_by_addr(addr.addr.addr4))) lease = lease4_allocate(addr.addr.addr4); } #ifdef HAVE_DHCP6 else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6)) { if (!(lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0))) lease = lease6_allocate(&addr.addr.addr6, is_temporary ? LEASE_TA : LEASE_NA); lease_set_iaid(lease, ia_id); } #endif else return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS, "Invalid IP address '%s'", ipaddr); hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL, &hw_type); if (hw_type == 0 && hw_len != 0) hw_type = ARPHRD_ETHER; lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type, clid_len, now, 0); lease_set_expires(lease, expires, now); if (hostname_len != 0) lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL); lease_update_file(now); lease_update_dns(0); return NULL; }
static void endpoint_reply(DBusPendingCall *call, void *user_data) { struct endpoint_request *request = user_data; struct media_endpoint *endpoint = request->endpoint; DBusMessage *reply; DBusError err; gboolean value; void *ret = NULL; int size = -1; /* steal_reply will always return non-NULL since the callback * is only called after a reply has been received */ reply = dbus_pending_call_steal_reply(call); dbus_error_init(&err); if (dbus_set_error_from_message(&err, reply)) { error("Endpoint replied with an error: %s", err.name); /* Clear endpoint configuration in case of NO_REPLY error */ if (dbus_error_has_name(&err, DBUS_ERROR_NO_REPLY)) { if (request->cb) request->cb(endpoint, NULL, size, request->user_data); clear_endpoint(endpoint); dbus_message_unref(reply); dbus_error_free(&err); return; } dbus_error_free(&err); goto done; } if (dbus_message_is_method_call(request->msg, MEDIA_ENDPOINT_INTERFACE, "SelectConfiguration")) { DBusMessageIter args, array; uint8_t *configuration; dbus_message_iter_init(reply, &args); dbus_message_iter_recurse(&args, &array); dbus_message_iter_get_fixed_array(&array, &configuration, &size); ret = configuration; goto done; } else if (!dbus_message_get_args(reply, &err, DBUS_TYPE_INVALID)) { error("Wrong reply signature: %s", err.message); dbus_error_free(&err); goto done; } size = 1; value = TRUE; ret = &value; done: dbus_message_unref(reply); if (request->cb) request->cb(endpoint, ret, size, request->user_data); endpoint->requests = g_slist_remove(endpoint->requests, request); endpoint_request_free(request); }
char* resolve_service(int interface, int protocol, char *name, char *type, char *domain) { DBusMessage* msg; DBusMessageIter args; DBusConnection* conn; DBusError err; dbus_error_init(&err); DBusPendingCall* pending; //dbus_int32_t interface = 2; //dbus_int32_t protocol = 1; //char *name = "TestService"; //char *type = "_http._tcp"; //char *domain = "local"; dbus_int32_t aprotocol = -1; dbus_uint32_t flags = 0; printf ("parameter for ResolvesService:%d, %d, %s, %s, %s, %d, %d.\n", interface, protocol, name, type, domain, aprotocol, flags); // initialiset the errors printf("Calling remote method: %s\n", "org.freedesktop.Avahi"); // connect to the system bus and check for errors conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Connection Error (%s)\n", err.message); dbus_error_free(&err); } if (NULL == conn) { exit(1); } msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call "/", // object to call on "org.freedesktop.Avahi.Server", // interface to call on "ResolveService"); // method nameResolveHostName if (NULL == msg) { fprintf(stderr, "Message Null\n"); exit(1); } // append arguments dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &interface)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &protocol)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &name)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &domain)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &aprotocol)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &flags)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } // 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); } dbus_connection_flush(conn); printf("Request Sent\n"); // free message dbus_message_unref(msg); // block until we recieve a reply dbus_pending_call_block(pending); // get the reply message msg = dbus_pending_call_steal_reply(pending); if (NULL == msg) { fprintf(stderr, "Reply Null\n"); exit(1); } // free the pending message handle dbus_pending_call_unref(pending); char *address; char *host; dbus_uint16_t port;//gint16 GPtrArray *byte_arraies; dbus_uint32_t m_flags; if (!dbus_message_iter_init(msg, &args)) g_message("dbus_message_iter_init fail\n"); else { //g_message("signature of container args: %s", dbus_message_iter_get_signature(&args)); //g_message("first type: %d", dbus_message_iter_get_arg_type(&args)); //g_message("DBUS_TYPE_INT32: %d", DBUS_TYPE_INT32); //g_message("DBUS_TYPE_STRING: %d", DBUS_TYPE_STRING); //char *value; //dbus_message_iter_get_basic(&args, &value); //g_message("DBUS_TYPE_STRING: %s", value); if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args)) g_message( "Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &interface); printf("interface : %d\n", interface); } if (!dbus_message_iter_next(&args)) g_message( "Message has too few arguments!\n"); else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &protocol); printf("protocol : %d\n", protocol); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &name); printf("name : %s\n", name); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &type); printf("type : %s\n", type); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &domain); printf("domain : %s\n", domain); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &host); printf("host : %s\n", host); } if (!dbus_message_iter_next(&args)) g_message( "Message has too few arguments!\n"); else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &aprotocol); printf("aprotocol : %d\n", aprotocol); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &address); printf("address : %s\n", address); } if (!dbus_message_iter_next(&args)) g_message( "Message has too few arguments!\n"); else if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &port); printf("port : %d\n", port); } if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (strcmp("aay", dbus_message_iter_get_signature(&args))) g_message("Argument is not error!\n"); else{ DBusMessageIter container_ay, container_y; unsigned char *values;int size; //dbus_message_iter_get_basic(&args, &flags); //dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &container_ay); //dbus_message_iter_open_container(&container_ay, DBUS_TYPE_BYTE, "y", &container_y); dbus_message_iter_recurse(&args, &container_ay); dbus_message_iter_recurse(&container_ay, &container_y); dbus_message_iter_get_fixed_array(&container_y, &values, &size); g_message("size: %d, %s", size, values); /* g_message("container args: %s", dbus_message_iter_get_signature(&args)); g_message("container_ay: %s", dbus_message_iter_get_signature(&container_ay)); g_message("container_y: %s", dbus_message_iter_get_signature(&container_y)); g_message("type of container_y: %d", dbus_message_iter_get_arg_type(&container_y)); g_message("value of DBUS_TYPE_BYTE: %d", DBUS_TYPE_BYTE); */ // && strcmp("ay", dbus_message_iter_get_signature(&container_ay)) while(dbus_message_iter_next(&container_ay)){ dbus_message_iter_recurse(&container_ay, &container_y); dbus_message_iter_get_fixed_array(&container_y, &values, &size); g_message("size: %d, %s", size, values); } } if (!dbus_message_iter_next(&args)) g_message( "Message has too few arguments!\n"); else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else{ dbus_message_iter_get_basic(&args, &m_flags); printf("m_flags : %d\n", m_flags); } /* dbus_message_iter_next(&args); g_message("g_message_iter_get_signature: %s", dbus_message_iter_get_signature(&args)); */ /* if (!dbus_message_iter_next(&args)) g_message("Message has too few arguments!\n"); else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)) g_message("Argument is not error!\n"); else dbus_message_iter_get_basic(&args, &flags); */ // printf("discovered:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, type, domain, flags); } dbus_message_unref(msg); }
bool dp_unpack_pam_response(DBusMessage *msg, struct pam_data *pd, DBusError *dbus_error) { DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter struct_iter; DBusMessageIter sub_iter; int type; int len; const uint8_t *data; if (!dbus_message_iter_init(msg, &iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has no arguments.\n"); return false; } if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&iter, &(pd->pam_status)); if (!dbus_message_iter_next(&iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n"); return false; } if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&iter, &(pd->account_locked)); if (!dbus_message_iter_next(&iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n"); return false; } /* After this point will be an array of pam data */ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); DEBUG(SSSDBG_CRIT_FAILURE, "Type was %c\n", (char)dbus_message_iter_get_arg_type(&iter)); return false; } if (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&iter, &array_iter); while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID) { /* Read in a pam data struct */ if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&array_iter, &struct_iter); /* PAM data struct contains a type and a byte-array of data */ /* Get the pam data type */ if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&struct_iter, &type); if (!dbus_message_iter_next(&struct_iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } /* Get the byte array */ if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&struct_iter) != DBUS_TYPE_BYTE) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&struct_iter, &sub_iter); dbus_message_iter_get_fixed_array(&sub_iter, &data, &len); if (pam_add_response(pd, type, len, data) != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed.\n"); return false; } dbus_message_iter_next(&array_iter); } return true; }
static void request_input_passphrase_reply(DBusMessage *reply, void *user_data) { struct request_input_reply *passphrase_reply = user_data; bool values_received = false; bool wps = false; const char *error = NULL; char *identity = NULL; char *passphrase = NULL; char *wpspin = NULL; char *key; char *name = NULL; int name_len = 0; DBusMessageIter iter, dict; if (!reply) goto out; if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { error = dbus_message_get_error_name(reply); goto done; } if (!check_reply_has_dict(reply)) goto done; values_received = true; dbus_message_iter_init(reply, &iter); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &key); if (g_str_equal(key, "Identity")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &identity); } else if (g_str_equal(key, "Passphrase")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &passphrase); } else if (g_str_equal(key, "WPS")) { wps = true; dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &wpspin); break; } else if (g_str_equal(key, "Name")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &name); name_len = strlen(name); } else if (g_str_equal(key, "SSID")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_VARIANT) break; if (dbus_message_iter_get_element_type(&value) != DBUS_TYPE_VARIANT) break; dbus_message_iter_get_fixed_array(&value, &name, &name_len); } dbus_message_iter_next(&dict); } done: passphrase_reply->callback(passphrase_reply->service, values_received, name, name_len, identity, passphrase, wps, wpspin, error, passphrase_reply->user_data); out: g_free(passphrase_reply); }
DBusHandlerResult avahi_service_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) { AvahiServiceResolver *r = NULL; DBusError error; const char *path; AvahiStringList *strlst = NULL; assert(client); assert(message); dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (r = client->service_resolvers; r; r = r->service_resolvers_next) if (strcmp (r->path, path) == 0) break; if (!r) goto fail; switch (event) { case AVAHI_RESOLVER_FOUND: { int j; int32_t interface, protocol, aprotocol; uint32_t flags; char *name, *type, *domain, *host, *address; uint16_t port; DBusMessageIter iter, sub; AvahiAddress a; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_STRING, &host, DBUS_TYPE_INT32, &aprotocol, DBUS_TYPE_STRING, &address, DBUS_TYPE_UINT16, &port, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_init(message, &iter); for (j = 0; j < 9; j++) dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } strlst = NULL; dbus_message_iter_recurse(&iter, &sub); for (;;) { DBusMessageIter sub2; int at; const uint8_t *k; int n; if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) break; assert(at == DBUS_TYPE_ARRAY); if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } dbus_message_iter_recurse(&sub, &sub2); k = NULL; n = 0; dbus_message_iter_get_fixed_array(&sub2, &k, &n); if (k && n > 0) strlst = avahi_string_list_add_arbitrary(strlst, k, n); dbus_message_iter_next(&sub); } dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_get_basic(&iter, &flags); assert(address); if (address[0] == 0) address = NULL; else avahi_address_parse(address, (AvahiProtocol) aprotocol, &a); r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, type, domain, host, address ? &a : NULL, port, strlst, (AvahiLookupResultFlags) flags, r->userdata); avahi_string_list_free(strlst); break; } case AVAHI_RESOLVER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt)); r->callback(r, r->interface, r->protocol, event, r->name, r->type, r->domain, NULL, NULL, 0, NULL, 0, r->userdata); break; } } return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); avahi_string_list_free(strlst); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
DBusHandlerResult avahi_record_browser_event(AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message) { AvahiRecordBrowser *b = NULL; DBusError error; const char *path; char *name; int32_t interface, protocol; uint32_t flags = 0; uint16_t clazz, type; void *rdata = NULL; int rdata_size = 0; dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (b = client->record_browsers; b; b = b->record_browsers_next) if (strcmp (b->path, path) == 0) break; if (!b) goto fail; interface = b->interface; protocol = b->protocol; clazz = b->clazz; type = b->type; name = b->name; switch (event) { case AVAHI_BROWSER_NEW: case AVAHI_BROWSER_REMOVE: { DBusMessageIter iter, sub; int j; if (!dbus_message_get_args ( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_UINT16, &clazz, DBUS_TYPE_UINT16, &type, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } dbus_message_iter_init(message, &iter); for (j = 0; j < 5; j++) dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) goto fail; dbus_message_iter_recurse(&iter, &sub); dbus_message_iter_get_fixed_array(&sub, &rdata, &rdata_size); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) goto fail; dbus_message_iter_get_basic(&iter, &flags); break; } case AVAHI_BROWSER_CACHE_EXHAUSTED: case AVAHI_BROWSER_ALL_FOR_NOW: break; case AVAHI_BROWSER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse browser event.\n"); goto fail; } avahi_client_set_errno(b->client, avahi_error_dbus_to_number(etxt)); break; } } b->callback(b, (AvahiIfIndex) interface, (AvahiProtocol) protocol, event, name, clazz, type, rdata, (size_t) rdata_size, (AvahiLookupResultFlags) flags, b->userdata); return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
void cras_bt_transport_update_properties( struct cras_bt_transport *transport, DBusMessageIter *properties_array_iter, DBusMessageIter *invalidated_array_iter) { while (dbus_message_iter_get_arg_type(properties_array_iter) != DBUS_TYPE_INVALID) { DBusMessageIter properties_dict_iter, variant_iter; const char *key; int type; dbus_message_iter_recurse(properties_array_iter, &properties_dict_iter); dbus_message_iter_get_basic(&properties_dict_iter, &key); dbus_message_iter_next(&properties_dict_iter); dbus_message_iter_recurse(&properties_dict_iter, &variant_iter); type = dbus_message_iter_get_arg_type(&variant_iter); if (type == DBUS_TYPE_STRING) { const char *value; dbus_message_iter_get_basic(&variant_iter, &value); if (strcmp(key, "UUID") == 0) { transport->profile = cras_bt_device_profile_from_uuid(value); } else if (strcmp(key, "State") == 0) { enum cras_bt_transport_state old_state = transport->state; transport->state = cras_bt_transport_state_from_string( value); if (transport->state != old_state) cras_bt_transport_state_changed( transport); } } else if (type == DBUS_TYPE_BYTE) { int value; dbus_message_iter_get_basic(&variant_iter, &value); if (strcmp(key, "Codec") == 0) transport->codec = value; } else if (type == DBUS_TYPE_OBJECT_PATH) { const char *obj_path; /* Property: object Device [readonly] */ dbus_message_iter_get_basic(&variant_iter, &obj_path); transport->device = cras_bt_device_get(obj_path); if (!transport->device) { syslog(LOG_ERR, "Device %s not found at update" "transport properties", obj_path); transport->device = cras_bt_device_create(transport->conn, obj_path); cras_bt_transport_update_device(transport); } } else if (strcmp( dbus_message_iter_get_signature(&variant_iter), "ay") == 0 && strcmp(key, "Configuration") == 0) { DBusMessageIter value_iter; char *value; int len; dbus_message_iter_recurse(&variant_iter, &value_iter); dbus_message_iter_get_fixed_array(&value_iter, &value, &len); free(transport->configuration); transport->configuration_len = 0; transport->configuration = malloc(len); if (transport->configuration) { memcpy(transport->configuration, value, len); transport->configuration_len = len; } } else if (strcmp(key, "Volume") == 0) { uint16_t volume; dbus_message_iter_get_basic(&variant_iter, &volume); transport->volume = volume; cras_bt_transport_update_device(transport); } dbus_message_iter_next(properties_array_iter); } while (invalidated_array_iter && dbus_message_iter_get_arg_type(invalidated_array_iter) != DBUS_TYPE_INVALID) { const char *key; dbus_message_iter_get_basic(invalidated_array_iter, &key); if (strcmp(key, "Device") == 0) { transport->device = NULL; } else if (strcmp(key, "UUID") == 0) { transport->profile = 0; } else if (strcmp(key, "State") == 0) { transport->state = CRAS_BT_TRANSPORT_STATE_IDLE; } else if (strcmp(key, "Codec") == 0) { transport->codec = 0; } else if (strcmp(key, "Configuration") == 0) { free(transport->configuration); transport->configuration = NULL; transport->configuration_len = 0; } dbus_message_iter_next(invalidated_array_iter); } }
static QVariant qFetchParameter(DBusMessageIter *it) { switch (dbus_message_iter_get_arg_type(it)) { case DBUS_TYPE_BYTE: return qVariantFromValue(qIterGet<unsigned char>(it)); case DBUS_TYPE_INT16: return qVariantFromValue(qIterGet<dbus_int16_t>(it)); case DBUS_TYPE_UINT16: return qVariantFromValue(qIterGet<dbus_uint16_t>(it)); case DBUS_TYPE_INT32: return qIterGet<dbus_int32_t>(it); case DBUS_TYPE_UINT32: return qIterGet<dbus_uint32_t>(it); case DBUS_TYPE_DOUBLE: return qIterGet<double>(it); case DBUS_TYPE_BOOLEAN: return bool(qIterGet<dbus_bool_t>(it)); case DBUS_TYPE_INT64: return static_cast<qlonglong>(qIterGet<dbus_int64_t>(it)); case DBUS_TYPE_UINT64: return static_cast<qulonglong>(qIterGet<dbus_uint64_t>(it)); case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: return QString::fromUtf8(qIterGet<char *>(it)); case DBUS_TYPE_VARIANT: return qIterGet<QVariant>(it); case DBUS_TYPE_ARRAY: { int arrayType = dbus_message_iter_get_element_type(it); switch (arrayType) { case DBUS_TYPE_BYTE: { // QByteArray DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); int len = dbus_message_iter_get_array_len(&sub); char* data; dbus_message_iter_get_fixed_array(&sub,&data,&len); return QByteArray(data,len); } case DBUS_TYPE_INT16: return qFetchList<dbus_int16_t, short>(it); case DBUS_TYPE_UINT16: return qFetchList<dbus_uint16_t, ushort>(it); case DBUS_TYPE_INT32: return qFetchList<dbus_int32_t, int>(it); case DBUS_TYPE_UINT32: return qFetchList<dbus_uint32_t, uint>(it); case DBUS_TYPE_BOOLEAN: return qFetchList<dbus_bool_t, bool>(it); case DBUS_TYPE_DOUBLE: return qFetchList<double, double>(it); case DBUS_TYPE_INT64: return qFetchList<dbus_int64_t, qlonglong>(it); case DBUS_TYPE_UINT64: return qFetchList<dbus_uint64_t, qulonglong>(it); case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: return qFetchStringList(it); case DBUS_TYPE_VARIANT: return qFetchList<QVariant, QVariant>(it); case DBUS_TYPE_DICT_ENTRY: { // ### support other types of maps? QMap<QString, QVariant> map; DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); if (dbus_message_iter_get_array_len(&sub) == 0) // empty map return map; do { DBusMessageIter itemIter; dbus_message_iter_recurse(&sub, &itemIter); Q_ASSERT(dbus_message_iter_has_next(&itemIter)); QString key = qFetchParameter(&itemIter).toString(); dbus_message_iter_next(&itemIter); map.insertMulti(key, qFetchParameter(&itemIter)); } while (dbus_message_iter_next(&sub)); return map; } } } // fall through // common handling for structs and lists of lists (for now) case DBUS_TYPE_STRUCT: { QList<QVariant> list; DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); if (dbus_message_iter_get_array_len(&sub) == 0) return list; do { list.append(qFetchParameter(&sub)); } while (dbus_message_iter_next(&sub)); return list; } default: qWarning("Don't know how to handle type %d '%c'", dbus_message_iter_get_arg_type(it), dbus_message_iter_get_arg_type(it)); return QVariant(); break; } }
int lassi_server_get_clipboard(LassiServer *ls, gboolean primary, const char *t, int *f, gpointer *p, int *l) { DBusMessage *n, *reply; DBusConnection *c; DBusError e; int ret = -1; DBusMessageIter iter, sub; gboolean b; g_assert(ls); dbus_error_init(&e); if (primary) { if (ls->primary_empty || !ls->primary_connection) return -1; c = ls->primary_connection->dbus_connection; } else { if (ls->clipboard_empty || !ls->clipboard_connection) return -1; c = ls->clipboard_connection->dbus_connection; } n = dbus_message_new_method_call(NULL, "/", LASSI_INTERFACE, "GetClipboard"); g_assert(n); b = dbus_message_append_args(n, DBUS_TYPE_BOOLEAN, &primary, DBUS_TYPE_STRING, &t, DBUS_TYPE_INVALID); g_assert(b); if (!(reply = dbus_connection_send_with_reply_and_block(c, n, -1, &e))) { g_debug("Getting clipboard failed: %s", e.message); goto finish; } dbus_message_iter_init(reply, &iter); dbus_message_iter_get_basic(&iter, f); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) { g_debug("Invalid clipboard data"); goto finish; } dbus_message_iter_recurse(&iter, &sub); dbus_message_iter_get_fixed_array(&sub, p, l); *p = g_memdup(*p, *l); ret = 0; finish: dbus_message_unref(n); if (reply) dbus_message_unref(reply); dbus_error_free(&e); return ret; }