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