static DBusMessage *update_xml_record(DBusConnection *conn,
DBusMessage *msg,
struct service_adapter *serv_adapter)
{
struct record_data *user_record;
sdp_record_t *sdp_record;
const char *record;
dbus_uint32_t handle;
int len;
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_UINT32, &handle,
DBUS_TYPE_STRING, &record,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
len = (record ? strlen(record) : 0);
if (len == 0)
return btd_error_invalid_args(msg);
user_record = find_record(serv_adapter, handle,
dbus_message_get_sender(msg));
if (!user_record)
return btd_error_not_available(msg);
sdp_record = sdp_xml_parse_record(record, len);
if (!sdp_record) {
error("Parsing of XML service record failed");
return btd_error_failed(msg,
"Parsing of XML service record failed");
}
return update_record(conn, msg, serv_adapter, handle, sdp_record);
}
static int add_xml_record(DBusConnection *conn, const char *sender,
/*struct service_adapter *serv_adapter,*/
const char *record)
{
sdp_record_t * sdp_record;
uint16_t total_size = sizeof(tDTUN_HDR);
uint8_t * method_buf = NULL;
uint8_t * buf_ptr = NULL;
tDTUN_METHOD_DM_ADD_SDP_REC_EX * pmethod = NULL;
debug("%s", __FUNCTION__);
sdp_record = sdp_xml_parse_record(record, strlen(record));
if (!sdp_record) {
error("Parsing of XML service record failed");
return -EIO;
}
method_buf = create_sdp_method_buf(sdp_record, &total_size);
pmethod = (tDTUN_METHOD_DM_ADD_SDP_REC_EX *) method_buf;
pmethod->hdr.id = DTUN_METHOD_SDP_ADD_RECORD;
pmethod->hdr.len = total_size - sizeof(tDTUN_HDR);
sdp_hex_dump("***FINAL PACKET***", method_buf + sizeof(tDTUN_HDR),total_size - sizeof(tDTUN_HDR), 0 );
dtun_client_call_method((tDTUN_DEVICE_METHOD *)method_buf); //wait for the signal now.
//free method buf
free(method_buf);
return 0;
}
static int add_xml_record(DBusConnection *conn, const char *sender,
struct service_adapter *serv_adapter,
const char *record, dbus_uint32_t *handle)
{
struct record_data *user_record;
sdp_record_t *sdp_record;
bdaddr_t src;
sdp_record = sdp_xml_parse_record(record, strlen(record));
if (!sdp_record) {
error("Parsing of XML service record failed");
return -EIO;
}
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
if (add_record_to_server(&src, sdp_record) < 0) {
error("Failed to register service record");
sdp_record_free(sdp_record);
return -EIO;
}
user_record = g_new0(struct record_data, 1);
user_record->handle = sdp_record->handle;
user_record->sender = g_strdup(sender);
user_record->serv_adapter = serv_adapter;
user_record->listener_id = g_dbus_add_disconnect_watch(conn, sender,
exit_callback, user_record, NULL);
serv_adapter->records = g_slist_append(serv_adapter->records,
user_record);
DBG("listener_id %d", user_record->listener_id);
*handle = user_record->handle;
return 0;
}
static uint16_t ext_register_record(struct ext_profile *ext,
const bdaddr_t *src)
{
sdp_record_t *rec;
if (ext->record)
rec = sdp_xml_parse_record(ext->record, strlen(ext->record));
else
rec = ext_get_record(ext);
if (!rec)
return 0;
if (add_record_to_server(src, rec) < 0) {
error("Failed to register service record");
sdp_record_free(rec);
return 0;
}
return rec->handle;
}
static char *device_get_ieee1284_id(const char *adapter, const char *device)
{
DBusMessage *message, *reply;
DBusMessageIter iter, reply_iter;
DBusMessageIter reply_iter_entry;
const char *hcr_print = "00001126-0000-1000-8000-00805f9b34fb";
const char *xml;
char *id = NULL;
/* Look for the service handle of the HCRP service */
message = dbus_message_new_method_call("org.bluez", device,
"org.bluez.Device",
"DiscoverServices");
dbus_message_iter_init_append(message, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &hcr_print);
reply = dbus_connection_send_with_reply_and_block(conn,
message, -1, NULL);
dbus_message_unref(message);
if (!reply)
return NULL;
dbus_message_iter_init(reply, &reply_iter);
if (dbus_message_iter_get_arg_type(&reply_iter) != DBUS_TYPE_ARRAY) {
dbus_message_unref(reply);
return NULL;
}
dbus_message_iter_recurse(&reply_iter, &reply_iter_entry);
/* Hopefully we only get one handle, or take a punt */
while (dbus_message_iter_get_arg_type(&reply_iter_entry) == DBUS_TYPE_DICT_ENTRY) {
guint32 key;
DBusMessageIter dict_entry;
dbus_message_iter_recurse(&reply_iter_entry, &dict_entry);
/* Key ? */
dbus_message_iter_get_basic(&dict_entry, &key);
if (!key) {
dbus_message_iter_next(&reply_iter_entry);
continue;
}
/* Try to get the value */
if (!dbus_message_iter_next(&dict_entry)) {
dbus_message_iter_next(&reply_iter_entry);
continue;
}
dbus_message_iter_get_basic(&dict_entry, &xml);
id = sdp_xml_parse_record(xml);
if (id != NULL)
break;
dbus_message_iter_next(&reply_iter_entry);
}
dbus_message_unref(reply);
return id;
}
