static gboolean set_sdp_services_uuid(sdp_record_t *record, HdpRole role)
{
uuid_t svc_uuid_source, svc_uuid_sink;
sdp_list_t *svc_list = NULL;
sdp_uuid16_create(&svc_uuid_sink, HDP_SINK_SVCLASS_ID);
sdp_uuid16_create(&svc_uuid_source, HDP_SOURCE_SVCLASS_ID);
sdp_get_service_classes(record, &svc_list);
if (role == HDP_SOURCE) {
if (!sdp_list_find(svc_list, &svc_uuid_source, sdp_uuid_cmp))
svc_list = sdp_list_append(svc_list, &svc_uuid_source);
} else if (role == HDP_SINK) {
if (!sdp_list_find(svc_list, &svc_uuid_sink, sdp_uuid_cmp))
svc_list = sdp_list_append(svc_list, &svc_uuid_sink);
}
if (sdp_set_service_classes(record, svc_list) < 0) {
sdp_list_free(svc_list, NULL);
return FALSE;
}
sdp_list_free(svc_list, NULL);
return TRUE;
}
static sdp_record_t *a2dp_record(void)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, l2cap_uuid, avdtp_uuid, a2dp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[2];
sdp_record_t *record;
sdp_data_t *psm, *version, *features;
uint16_t lp = AVDTP_UUID;
uint16_t a2dp_ver = 0x0103, avdtp_ver = 0x0103, feat = 0x000f;
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&a2dp_uuid, AUDIO_SOURCE_SVCLASS_ID);
svclass_id = sdp_list_append(NULL, &a2dp_uuid);
sdp_set_service_classes(record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, ADVANCED_AUDIO_PROFILE_ID);
profile[0].version = a2dp_ver;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap_uuid);
psm = sdp_data_alloc(SDP_UINT16, &lp);
proto[0] = sdp_list_append(proto[0], psm);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&avdtp_uuid, AVDTP_UUID);
proto[1] = sdp_list_append(NULL, &avdtp_uuid);
version = sdp_data_alloc(SDP_UINT16, &avdtp_ver);
proto[1] = sdp_list_append(proto[1], version);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
features = sdp_data_alloc(SDP_UINT16, &feat);
sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
sdp_set_info_attr(record, "Audio Source", NULL, NULL);
sdp_data_free(psm);
sdp_data_free(version);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(apseq, NULL);
sdp_list_free(pfseq, NULL);
sdp_list_free(aproto, NULL);
sdp_list_free(root, NULL);
sdp_list_free(svclass_id, NULL);
return record;
}
static int set_sdp_services_uuid(sdp_record_t *rec, uint8_t role)
{
uuid_t source, sink;
sdp_list_t *list = NULL;
sdp_uuid16_create(&sink, HDP_SINK_SVCLASS_ID);
sdp_uuid16_create(&source, HDP_SOURCE_SVCLASS_ID);
sdp_get_service_classes(rec, &list);
switch (role) {
case HAL_HEALTH_MDEP_ROLE_SOURCE:
if (!sdp_list_find(list, &source, sdp_uuid_cmp))
list = sdp_list_append(list, &source);
break;
case HAL_HEALTH_MDEP_ROLE_SINK:
if (!sdp_list_find(list, &sink, sdp_uuid_cmp))
list = sdp_list_append(list, &sink);
break;
}
if (sdp_set_service_classes(rec, list) < 0) {
sdp_list_free(list, NULL);
return -1;
}
sdp_list_free(list, NULL);
return 0;
}
void register_device_id(const uint16_t vendor, const uint16_t product,
const uint16_t version)
{
const uint16_t spec = 0x0102, source = 0x0002;
const uint8_t primary = 1;
sdp_list_t *class_list, *group_list, *profile_list;
uuid_t class_uuid, group_uuid;
sdp_data_t *sdp_data, *primary_data, *source_data;
sdp_data_t *spec_data, *vendor_data, *product_data, *version_data;
sdp_profile_desc_t profile;
sdp_record_t *record = sdp_record_alloc();
info("Adding device id record for %04x:%04x", vendor, product);
btd_manager_set_did(vendor, product, version);
record->handle = sdp_next_handle();
sdp_record_add(BDADDR_ANY, record);
sdp_data = sdp_data_alloc(SDP_UINT32, &record->handle);
sdp_attr_add(record, SDP_ATTR_RECORD_HANDLE, sdp_data);
sdp_uuid16_create(&class_uuid, PNP_INFO_SVCLASS_ID);
class_list = sdp_list_append(0, &class_uuid);
sdp_set_service_classes(record, class_list);
sdp_list_free(class_list, NULL);
sdp_uuid16_create(&group_uuid, PUBLIC_BROWSE_GROUP);
group_list = sdp_list_append(NULL, &group_uuid);
sdp_set_browse_groups(record, group_list);
sdp_list_free(group_list, NULL);
sdp_uuid16_create(&profile.uuid, PNP_INFO_PROFILE_ID);
profile.version = spec;
profile_list = sdp_list_append(NULL, &profile);
sdp_set_profile_descs(record, profile_list);
sdp_list_free(profile_list, NULL);
spec_data = sdp_data_alloc(SDP_UINT16, &spec);
sdp_attr_add(record, 0x0200, spec_data);
vendor_data = sdp_data_alloc(SDP_UINT16, &vendor);
sdp_attr_add(record, 0x0201, vendor_data);
product_data = sdp_data_alloc(SDP_UINT16, &product);
sdp_attr_add(record, 0x0202, product_data);
version_data = sdp_data_alloc(SDP_UINT16, &version);
sdp_attr_add(record, 0x0203, version_data);
primary_data = sdp_data_alloc(SDP_BOOL, &primary);
sdp_attr_add(record, 0x0204, primary_data);
source_data = sdp_data_alloc(SDP_UINT16, &source);
sdp_attr_add(record, 0x0205, source_data);
update_db_timestamp();
}
static sdp_record_t *create_rfcomm_record(uint8_t chan, uuid_t *uuid,
const char *svc_name,
bool has_obex)
{
sdp_list_t *svclass_id;
sdp_list_t *seq, *proto_seq, *pbg_seq;
sdp_list_t *proto[3];
uuid_t l2cap_uuid, rfcomm_uuid, obex_uuid, pbg_uuid;
sdp_data_t *channel;
sdp_record_t *record;
record = sdp_record_alloc();
if (!record)
return NULL;
record->handle = sdp_next_handle();
svclass_id = sdp_list_append(NULL, uuid);
sdp_set_service_classes(record, svclass_id);
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap_uuid);
seq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
proto[1] = sdp_list_append(NULL, &rfcomm_uuid);
channel = sdp_data_alloc(SDP_UINT8, &chan);
proto[1] = sdp_list_append(proto[1], channel);
seq = sdp_list_append(seq, proto[1]);
if (has_obex) {
sdp_uuid16_create(&obex_uuid, OBEX_UUID);
proto[2] = sdp_list_append(NULL, &obex_uuid);
seq = sdp_list_append(seq, proto[2]);
}
proto_seq = sdp_list_append(NULL, seq);
sdp_set_access_protos(record, proto_seq);
sdp_uuid16_create(&pbg_uuid, PUBLIC_BROWSE_GROUP);
pbg_seq = sdp_list_append(NULL, &pbg_uuid);
sdp_set_browse_groups(record, pbg_seq);
if (svc_name)
sdp_set_info_attr(record, svc_name, NULL, NULL);
sdp_data_free(channel);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
if (has_obex)
sdp_list_free(proto[2], NULL);
sdp_list_free(seq, NULL);
sdp_list_free(proto_seq, NULL);
sdp_list_free(pbg_seq, NULL);
sdp_list_free(svclass_id, NULL);
return record;
}
static sdp_record_t *hfp_hs_record(uint8_t ch)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, svclass_uuid, ga_svclass_uuid;
uuid_t l2cap_uuid, rfcomm_uuid;
sdp_profile_desc_t profile;
sdp_record_t *record;
sdp_list_t *aproto, *proto[2];
sdp_data_t *channel;
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&svclass_uuid, HANDSFREE_SVCLASS_ID);
svclass_id = sdp_list_append(0, &svclass_uuid);
sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
sdp_set_service_classes(record, svclass_id);
sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID);
profile.version = 0x0105;
pfseq = sdp_list_append(0, &profile);
sdp_set_profile_descs(record, pfseq);
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append(0, &l2cap_uuid);
apseq = sdp_list_append(0, proto[0]);
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
proto[1] = sdp_list_append(0, &rfcomm_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ch);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(record, aproto);
sdp_set_info_attr(record, "Hands-Free", 0, 0);
sdp_data_free(channel);
sdp_list_free(proto[0], 0);
sdp_list_free(proto[1], 0);
sdp_list_free(apseq, 0);
sdp_list_free(pfseq, 0);
sdp_list_free(aproto, 0);
sdp_list_free(root, 0);
sdp_list_free(svclass_id, 0);
return record;
}
static sdp_record_t *create_sap_record(uint8_t channel)
{
sdp_list_t *apseq, *aproto, *profiles, *proto[2], *root, *svclass_id;
uuid_t sap_uuid, gt_uuid, root_uuid, l2cap, rfcomm;
sdp_profile_desc_t profile;
sdp_record_t *record;
sdp_data_t *ch;
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_list_free(root, NULL);
sdp_uuid16_create(&sap_uuid, SAP_SVCLASS_ID);
svclass_id = sdp_list_append(NULL, &sap_uuid);
sdp_uuid16_create(>_uuid, GENERIC_TELEPHONY_SVCLASS_ID);
svclass_id = sdp_list_append(svclass_id, >_uuid);
sdp_set_service_classes(record, svclass_id);
sdp_list_free(svclass_id, NULL);
sdp_uuid16_create(&profile.uuid, SAP_PROFILE_ID);
profile.version = SAP_VERSION;
profiles = sdp_list_append(NULL, &profile);
sdp_set_profile_descs(record, profiles);
sdp_list_free(profiles, NULL);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&rfcomm, RFCOMM_UUID);
proto[1] = sdp_list_append(NULL, &rfcomm);
ch = sdp_data_alloc(SDP_UINT8, &channel);
proto[1] = sdp_list_append(proto[1], ch);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
sdp_set_info_attr(record, "SIM Access Server",
NULL, NULL);
sdp_data_free(ch);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(apseq, NULL);
sdp_list_free(aproto, NULL);
return record;
}
static sdp_record_t *dun_record(uint8_t ch)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root, *aproto;
uuid_t root_uuid, dun, gn, l2cap, rfcomm;
sdp_profile_desc_t profile;
sdp_list_t *proto[2];
sdp_record_t *record;
sdp_data_t *channel;
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&dun, DIALUP_NET_SVCLASS_ID);
svclass_id = sdp_list_append(NULL, &dun);
sdp_uuid16_create(&gn, GENERIC_NETWORKING_SVCLASS_ID);
svclass_id = sdp_list_append(svclass_id, &gn);
sdp_set_service_classes(record, svclass_id);
sdp_uuid16_create(&profile.uuid, DIALUP_NET_PROFILE_ID);
profile.version = 0x0100;
pfseq = sdp_list_append(NULL, &profile);
sdp_set_profile_descs(record, pfseq);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&rfcomm, RFCOMM_UUID);
proto[1] = sdp_list_append(NULL, &rfcomm);
channel = sdp_data_alloc(SDP_UINT8, &ch);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(record, aproto);
sdp_set_info_attr(record, "Dial-Up Networking", 0, 0);
sdp_data_free(channel);
sdp_list_free(root, NULL);
sdp_list_free(svclass_id, NULL);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(pfseq, NULL);
sdp_list_free(apseq, NULL);
sdp_list_free(aproto, NULL);
return record;
}
static sdp_record_t *proxy_record_new(const char *uuid128, uint8_t channel)
{
sdp_list_t *apseq, *aproto, *profiles, *proto[2], *root, *svclass_id;
uuid_t uuid, root_uuid, l2cap, rfcomm;
sdp_profile_desc_t profile;
sdp_record_t *record;
sdp_data_t *ch;
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_list_free(root, NULL);
bt_string2uuid(&uuid, uuid128);
svclass_id = sdp_list_append(NULL, &uuid);
sdp_set_service_classes(record, svclass_id);
sdp_list_free(svclass_id, NULL);
sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
profile.version = 0x0100;
profiles = sdp_list_append(NULL, &profile);
sdp_set_profile_descs(record, profiles);
sdp_list_free(profiles, NULL);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&rfcomm, RFCOMM_UUID);
proto[1] = sdp_list_append(NULL, &rfcomm);
ch = sdp_data_alloc(SDP_UINT8, &channel);
proto[1] = sdp_list_append(proto[1], ch);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
add_lang_attr(record);
sdp_set_info_attr(record, "Port Proxy Entity",
NULL, "Port Proxy Entity");
sdp_data_free(ch);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(apseq, NULL);
sdp_list_free(aproto, NULL);
return record;
}
/*
* The SDP server must present its own service record to
* the service repository. This can be accessed by service
* discovery clients. This method constructs a service record
* and stores it in the repository
*/
void register_server_service(void)
{
sdp_list_t *classIDList;
uuid_t classID;
void **versions, **versionDTDs;
uint8_t dtd;
sdp_data_t *pData;
int i;
server = sdp_record_alloc();
server->pattern = NULL;
/* Force the record to be SDP_SERVER_RECORD_HANDLE */
server->handle = SDP_SERVER_RECORD_HANDLE;
sdp_record_add(BDADDR_ANY, server);
sdp_attr_add(server, SDP_ATTR_RECORD_HANDLE,
sdp_data_alloc(SDP_UINT32, &server->handle));
sdp_uuid16_create(&classID, SDP_SERVER_SVCLASS_ID);
classIDList = sdp_list_append(0, &classID);
sdp_set_service_classes(server, classIDList);
sdp_list_free(classIDList, 0);
/*
* Set the version numbers supported, these are passed as arguments
* to the server on command line. Now defaults to 1.0
* Build the version number sequence first
*/
versions = malloc(sdpServerVnumEntries * sizeof(void *));
versionDTDs = malloc(sdpServerVnumEntries * sizeof(void *));
dtd = SDP_UINT16;
for (i = 0; i < sdpServerVnumEntries; i++) {
uint16_t *version = malloc(sizeof(uint16_t));
*version = sdpVnumArray[i].major;
*version = (*version << 8);
*version |= sdpVnumArray[i].minor;
versions[i] = version;
versionDTDs[i] = &dtd;
}
pData = sdp_seq_alloc(versionDTDs, versions, sdpServerVnumEntries);
for (i = 0; i < sdpServerVnumEntries; i++)
free(versions[i]);
free(versions);
free(versionDTDs);
sdp_attr_add(server, SDP_ATTR_VERSION_NUM_LIST, pData);
update_db_timestamp();
}
void register_public_browse_group(void)
{
sdp_list_t *browselist;
uuid_t bgscid, pbgid;
sdp_data_t *sdpdata;
sdp_record_t *browse = sdp_record_alloc();
browse->handle = SDP_SERVER_RECORD_HANDLE + 1;
sdp_record_add(BDADDR_ANY, browse);
sdpdata = sdp_data_alloc(SDP_UINT32, &browse->handle);
sdp_attr_add(browse, SDP_ATTR_RECORD_HANDLE, sdpdata);
sdp_uuid16_create(&bgscid, BROWSE_GRP_DESC_SVCLASS_ID);
browselist = sdp_list_append(0, &bgscid);
sdp_set_service_classes(browse, browselist);
sdp_list_free(browselist, 0);
sdp_uuid16_create(&pbgid, PUBLIC_BROWSE_GROUP);
sdp_attr_add_new(browse, SDP_ATTR_GROUP_ID,
SDP_UUID16, &pbgid.value.uuid16);
}
sdp_session_t *register_service()
{
uint32_t svc_uuid_int[] = { 0x00000000,0x00000000,0x00000000,0x0001 };
uint8_t rfcomm_channel = 1;
const char *service_name = "Remote Host";
const char *service_dsc = "What the remote should be connecting to.";
const char *service_prov = "Your mother";
uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid;
sdp_list_t *l2cap_list = 0,
*rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0;
sdp_data_t *channel = 0, *psm = 0;
sdp_record_t *record = sdp_record_alloc();
// set the general service ID
sdp_uuid128_create( &svc_uuid, &svc_uuid_int );
sdp_set_service_id( record, svc_uuid );
sdp_list_t service_class = {NULL, &svc_uuid};
sdp_set_service_classes( record, &service_class);
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( record, root_list );
// set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append( 0, &l2cap_uuid );
proto_list = sdp_list_append( 0, l2cap_list );
// set rfcomm information
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
rfcomm_list = sdp_list_append( 0, &rfcomm_uuid );
sdp_list_append( rfcomm_list, channel );
sdp_list_append( proto_list, rfcomm_list );
// attach protocol information to service record
access_proto_list = sdp_list_append( 0, proto_list );
sdp_set_access_protos( record, access_proto_list );
// set the name, provider, and description
sdp_set_info_attr(record, service_name, service_prov, service_dsc);
int err = 0;
sdp_session_t *session = 0;
// connect to the local SDP server, register the service record, and
// disconnect
session = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
err = sdp_record_register(session, record, 0);
// cleanup
//sdp_data_free( channel );
sdp_list_free( l2cap_list, 0 );
sdp_list_free( rfcomm_list, 0 );
sdp_list_free( root_list, 0 );
sdp_list_free( access_proto_list, 0 );
return session;
}
sdp_session_t *register_service(int chnel, int l2_chnel)
{
uint32_t service_uuid_int[] = { 0, 0, 0, 0xABCD };
uint8_t rfcomm_channel = chnel;
uint16_t l2cap_channel = l2_chnel;
const char *service_name = "Roto-Rooter Data Router";
const char *service_dsc = "An experimental plumbing router";
const char *service_prov = "Roto-Rooter";
uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid;
sdp_list_t *l2cap_list = 0,
*rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0,
*class_id_list = 0;
sdp_data_t *channel = 0, *psm = 0, *l2cap_port = 0;
sdp_record_t *record = sdp_record_alloc();
// set the general service ID
sdp_uuid128_create( &svc_uuid, &service_uuid_int );
class_id_list = sdp_list_append(0, &svc_uuid);
//sdp_set_service_id( record, svc_uuid );
sdp_set_service_classes( record, class_id_list);
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( record, root_list );
// set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append( 0, &l2cap_uuid );
l2cap_port = sdp_data_alloc(SDP_UINT16, &l2cap_channel);
sdp_list_append( l2cap_list, l2cap_port);
proto_list = sdp_list_append( 0, l2cap_list );
// set rfcomm information
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
rfcomm_list = sdp_list_append( 0, &rfcomm_uuid );
sdp_list_append( rfcomm_list, channel );
sdp_list_append( proto_list, rfcomm_list );
// attach protocol information to service record
access_proto_list = sdp_list_append( 0, proto_list );
sdp_set_access_protos( record, access_proto_list );
// set the name, provider, and description
sdp_set_info_attr(record, service_name, service_prov, service_dsc);
int err = 0;
sdp_session_t *session = 0;
// connect to the local SDP server, register the service record, and
// disconnect
session = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
err = sdp_record_register(session, record, 0);
// cleanup
sdp_data_free( channel );
sdp_list_free( l2cap_list, 0 );
sdp_list_free( rfcomm_list, 0 );
sdp_list_free( root_list, 0 );
sdp_list_free( access_proto_list, 0 );
return session;
}
sdp_session_t* io_rfcomm_advertise(uint8_t ch, const char *name, const char *desc, const uint32_t *uuid128) {
uuid_t root_uuid, rfcomm_uuid, svc_uuid, svc_class_uuid, l2cap_uuid;
sdp_list_t *rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0,
*svc_class_list = 0,
*profile_list = 0,
*l2cap_list = 0; //*l2cap_list
sdp_data_t *channel = 0;
sdp_profile_desc_t profile;
sdp_record_t record = { 0 };
sdp_session_t *session = 0;
//set general service ID
sdp_uuid128_create(&svc_uuid, &uuid128);
sdp_set_service_id(&record, svc_uuid);
// set the service class
sdp_uuid16_create(&svc_class_uuid, SERIAL_PORT_SVCLASS_ID);
svc_class_list = sdp_list_append(0, &svc_class_uuid);
sdp_set_service_classes(&record, svc_class_list);
// set the Bluetooth profile information
sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
profile.version = 0x0100;
profile_list = sdp_list_append(0, &profile);
sdp_set_profile_descs(&record, profile_list);
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( &record, root_list );
//set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append( 0, &l2cap_uuid );
proto_list = sdp_list_append( 0, l2cap_list );
// register rfcomm channel for rfcomm sockets
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &ch);
rfcomm_list = sdp_list_append( 0, &rfcomm_uuid );
sdp_list_append( rfcomm_list, channel );
sdp_list_append( proto_list, rfcomm_list );
access_proto_list = sdp_list_append(0, proto_list);
sdp_set_access_protos(&record, access_proto_list);
//set name, provider, description
sdp_set_info_attr(&record, name, "", desc);
//connect to local SDP server, register service record, and disconnect
session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, 0);
sdp_record_register(session, &record, 0);
//cleanup
sdp_data_free(channel);
sdp_list_free(l2cap_list, 0);
sdp_list_free( rfcomm_list, 0 );
sdp_list_free( root_list, 0 );
sdp_list_free( access_proto_list, 0 );
return session;
}
int register_service(sdp_session_t *session)
{
uint8_t rfcomm_channel = 11;
const char *service_name = "Atmel Simple Test Service";
const char *svc_dsc = "Simple Test for SDP Register";
const char *service_prov = "Tony";
int ret = 0;
uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid,
svc_class_uuid;
sdp_list_t *l2cap_list = 0,
*rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0,
*svc_class_list = 0,
*profile_list = 0;
sdp_data_t *channel = 0;
sdp_profile_desc_t profile;
sdp_record_t record = { 0 };
/* set the general service ID */
sdp_uuid128_create( &svc_uuid, &uuid128 );
sdp_set_service_id( &record, svc_uuid );
/* set the service class */
sdp_uuid16_create(&svc_class_uuid, SERIAL_PORT_SVCLASS_ID);
svc_class_list = sdp_list_append(0, &svc_class_uuid);
sdp_set_service_classes(&record, svc_class_list);
/* set the Bluetooth profile information */
sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
profile.version = 0x0100;
profile_list = sdp_list_append(0, &profile);
sdp_set_profile_descs(&record, profile_list);
/* make the service record publicly browsable */
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( &record, root_list );
/* set l2cap information */
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append( 0, &l2cap_uuid );
proto_list = sdp_list_append( 0, l2cap_list );
/* register the RFCOMM channel for RFCOMM sockets */
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
rfcomm_list = sdp_list_append( 0, &rfcomm_uuid );
sdp_list_append( rfcomm_list, channel );
sdp_list_append( proto_list, rfcomm_list );
access_proto_list = sdp_list_append( 0, proto_list );
sdp_set_access_protos( &record, access_proto_list );
/* set the name, provider, and description */
sdp_set_info_attr(&record, service_name, service_prov, svc_dsc);
/* register the service record, */
if(sdp_record_register(session, &record, SDP_RECORD_PERSIST) < 0) {
printf("Service Record registration failed\n");
ret = -1;
goto end;
}
end:
// cleanup
sdp_data_free(channel);
sdp_list_free(l2cap_list, 0);
sdp_list_free(rfcomm_list, 0);
sdp_list_free(root_list, 0);
sdp_list_free(access_proto_list, 0);
sdp_list_free(svc_class_list, 0);
sdp_list_free(profile_list, 0);
return ret;
}
static sdp_record_t *avrcp_tg_record()
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, l2cap, avctp, avrtg;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[2];
sdp_record_t *record;
sdp_data_t *psm, *version, *features;
uint16_t lp = AVCTP_PSM;
uint16_t avrcp_ver = 0x0100, avctp_ver = 0x0103, feat = 0x000f;
#ifdef ANDROID
feat = 0x0001;
#endif
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(record, root);
/* Service Class ID List */
sdp_uuid16_create(&avrtg, AV_REMOTE_TARGET_SVCLASS_ID);
svclass_id = sdp_list_append(0, &avrtg);
sdp_set_service_classes(record, svclass_id);
/* Protocol Descriptor List */
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(0, &l2cap);
psm = sdp_data_alloc(SDP_UINT16, &lp);
proto[0] = sdp_list_append(proto[0], psm);
apseq = sdp_list_append(0, proto[0]);
sdp_uuid16_create(&avctp, AVCTP_UUID);
proto[1] = sdp_list_append(0, &avctp);
version = sdp_data_alloc(SDP_UINT16, &avctp_ver);
proto[1] = sdp_list_append(proto[1], version);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(record, aproto);
/* Bluetooth Profile Descriptor List */
sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
profile[0].version = avrcp_ver;
pfseq = sdp_list_append(0, &profile[0]);
sdp_set_profile_descs(record, pfseq);
features = sdp_data_alloc(SDP_UINT16, &feat);
sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
sdp_set_info_attr(record, "AVRCP TG", 0, 0);
free(psm);
free(version);
sdp_list_free(proto[0], 0);
sdp_list_free(proto[1], 0);
sdp_list_free(apseq, 0);
sdp_list_free(aproto, 0);
sdp_list_free(pfseq, 0);
sdp_list_free(root, 0);
sdp_list_free(svclass_id, 0);
return record;
}
static sdp_record_t *hfp_ag_record(uint8_t ch, uint32_t feat)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, svclass_uuid, ga_svclass_uuid;
uuid_t l2cap_uuid, rfcomm_uuid;
sdp_profile_desc_t profile;
sdp_list_t *aproto, *proto[2];
sdp_record_t *record;
sdp_data_t *channel, *features;
uint8_t netid = 0x01;
uint16_t sdpfeat;
sdp_data_t *network;
record = sdp_record_alloc();
if (!record)
return NULL;
network = sdp_data_alloc(SDP_UINT8, &netid);
if (!network) {
sdp_record_free(record);
return NULL;
}
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&svclass_uuid, HANDSFREE_AGW_SVCLASS_ID);
svclass_id = sdp_list_append(0, &svclass_uuid);
sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
sdp_set_service_classes(record, svclass_id);
sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID);
profile.version = 0x0105;
pfseq = sdp_list_append(0, &profile);
sdp_set_profile_descs(record, pfseq);
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append(0, &l2cap_uuid);
apseq = sdp_list_append(0, proto[0]);
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
proto[1] = sdp_list_append(0, &rfcomm_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ch);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(apseq, proto[1]);
sdpfeat = (uint16_t) feat & 0xF;
features = sdp_data_alloc(SDP_UINT16, &sdpfeat);
sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(record, aproto);
sdp_set_info_attr(record, "Hands-Free Audio Gateway", 0, 0);
sdp_attr_add(record, SDP_ATTR_EXTERNAL_NETWORK, network);
sdp_data_free(channel);
sdp_list_free(proto[0], 0);
sdp_list_free(proto[1], 0);
sdp_list_free(apseq, 0);
sdp_list_free(pfseq, 0);
sdp_list_free(aproto, 0);
sdp_list_free(root, 0);
sdp_list_free(svclass_id, 0);
return record;
}
/*
* add keyboard descriptor
*/
void sdp_add_keyboard()
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, hidkb_uuid, l2cap_uuid, hidp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_data_t *channel, *lang_lst, *lang_lst2, *hid_spec_lst, *hid_spec_lst2;
int i;
uint8_t dtd = SDP_UINT16;
uint8_t dtd2 = SDP_UINT8;
uint8_t dtd_data = SDP_TEXT_STR8;
sdp_session_t *session;
void *dtds[2];
void *values[2];
void *dtds2[2];
void *values2[2];
int leng[2];
uint8_t hid_spec_type = 0x22;
uint16_t hid_attr_lang[] = {0x409,0x100};
static const uint8_t ctrl = 0x11;
static const uint8_t intr = 0x13;
static const uint16_t hid_attr[] = {0x100,0x111,0x40,0x0d,0x01,0x01};
static const uint16_t hid_attr2[] = {0x0,0x01,0x100,0x1f40,0x01,0x01};
// taken from Apple Wireless Keyboard
const uint8_t hid_spec[] = {
0x05, 0x01, // usage page
0x09, 0x06, // keyboard
0xa1, 0x01, // key codes
0x85, 0x01, // minimum
0x05, 0x07, // max
0x19, 0xe0, // logical min
0x29, 0xe7, // logical max
0x15, 0x00, // report size
0x25, 0x01, // report count
0x75, 0x01, // input data variable absolute
0x95, 0x08, // report count
0x81, 0x02, // report size
0x75, 0x08,
0x95, 0x01,
0x81, 0x01,
0x75, 0x01,
0x95, 0x05,
0x05, 0x08,
0x19, 0x01,
0x29, 0x05,
0x91, 0x02,
0x75, 0x03,
0x95, 0x01,
0x91, 0x01,
0x75, 0x08,
0x95, 0x06,
0x15, 0x00,
0x26, 0xff,
0x00, 0x05,
0x07, 0x19,
0x00, 0x2a,
0xff, 0x00,
0x81, 0x00,
0x75, 0x01,
0x95, 0x01,
0x15, 0x00,
0x25, 0x01,
0x05, 0x0c,
0x09, 0xb8,
0x81, 0x06,
0x09, 0xe2,
0x81, 0x06,
0x09, 0xe9,
0x81, 0x02,
0x09, 0xea,
0x81, 0x02,
0x75, 0x01,
0x95, 0x04,
0x81, 0x01,
0xc0 // end tag
};
if (!sdp_session) {
printf("%s: sdp_session invalid\n", (char*)__func__);
exit(-1);
}
session = sdp_session;
sdp_record = sdp_record_alloc();
if (!sdp_record) {
perror("add_keyboard sdp_record_alloc: ");
exit(-1);
}
memset((void*)sdp_record, 0, sizeof(sdp_record_t));
sdp_record->handle = 0xffffffff;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(sdp_record, root);
add_lang_attr(sdp_record);
sdp_uuid16_create(&hidkb_uuid, HID_SVCLASS_ID);
svclass_id = sdp_list_append(0, &hidkb_uuid);
sdp_set_service_classes(sdp_record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, HID_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(sdp_record, pfseq);
// PROTO
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ctrl);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(sdp_record, aproto);
// ATTR_ADD_PROTO
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &intr);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_add_access_protos(sdp_record, aproto);
sdp_set_info_attr(sdp_record, "Collin's Fake Bluetooth Keyboard",
"MUlliNER.ORG", "http://www.mulliner.org/bluetooth/");
for (i = 0; i < sizeof(hid_attr)/2; i++) {
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_RELEASE_NUMBER+i, SDP_UINT16, &hid_attr[i]);
}
dtds[0] = &dtd2;
values[0] = &hid_spec_type;
dtds[1] = &dtd_data;
values[1] = (uint8_t*)hid_spec;
leng[0] = 0;
leng[1] = sizeof(hid_spec);
hid_spec_lst = sdp_seq_alloc_with_length(dtds, values, leng, 2);
hid_spec_lst2 = sdp_data_alloc(SDP_SEQ8, hid_spec_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_spec_lst2);
for (i = 0; i < sizeof(hid_attr_lang)/2; i++) {
dtds2[i] = &dtd;
values2[i] = &hid_attr_lang[i];
}
lang_lst = sdp_seq_alloc(dtds2, values2, sizeof(hid_attr_lang)/2);
lang_lst2 = sdp_data_alloc(SDP_SEQ8, lang_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_LANG_ID_BASE_LIST, lang_lst2);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SDP_DISABLE, SDP_UINT16, &hid_attr2[0]);
for (i = 0; i < sizeof(hid_attr2)/2-1; i++) {
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_REMOTE_WAKEUP+i, SDP_UINT16, &hid_attr2[i+1]);
}
if (sdp_record_register(session, sdp_record, 0) < 0) {
printf("%s: HID Device (Keyboard) Service Record registration failed\n", (char*)__func__);
exit(-1);
}
}
static int add_service(sdp_session_t *session, uint32_t *handle, uint8_t rfcomm_channel)
{
int ret = 0;
unsigned char service_uuid_int[] = CARBOT_BLUETOOTH_SDP_UUID;
const char *service_name = "Carbot Soul";
const char *service_dsc = "General Purpose Android-Auto Interface";
const char *service_prov = "Ubergrund.com";
uuid_t root_uuid;
uuid_t rfcomm_uuid, l2cap_uuid, svc_uuid;
sdp_list_t *root_list;
sdp_list_t *rfcomm_list = 0, *l2cap_list = 0, *proto_list = 0, *access_proto_list = 0, *service_list = 0;
sdp_data_t *channel = 0;
sdp_record_t *rec;
// connect to the local SDP server, register the service record, and
// disconnect
if (!session) {
logDebug("Bad local SDP session\n");
return -1;
}
rec = sdp_record_alloc();
// set the general service ID
sdp_uuid128_create(&svc_uuid, &service_uuid_int);
service_list = sdp_list_append(0, &svc_uuid);
sdp_set_service_classes(rec, service_list);
sdp_set_service_id(rec, svc_uuid);
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(rec, root_list);
// set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append(0, &l2cap_uuid);
proto_list = sdp_list_append(0, l2cap_list);
// set rfcomm information
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
sdp_list_append(rfcomm_list, channel);
sdp_list_append(proto_list, rfcomm_list);
// attach protocol information to service record
access_proto_list = sdp_list_append(0, proto_list);
sdp_set_access_protos(rec, access_proto_list);
// set the name, provider, and description
sdp_set_info_attr(rec, service_name, service_prov, service_dsc);
ret = sdp_record_register(session, rec, 0);
if (ret < 0) {
logError("Service registration failed\n");
} else {
*handle = rec->handle;
}
// cleanup
sdp_data_free(channel);
sdp_list_free(l2cap_list, 0);
sdp_list_free(rfcomm_list, 0);
sdp_list_free(root_list, 0);
sdp_list_free(proto_list, 0);
sdp_list_free(access_proto_list, 0);
sdp_list_free(service_list, 0);
sdp_record_free(rec);
return ret;
}
static sdp_record_t *avrcp_record(void)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, l2cap, avctp, avrtg;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto_control, *proto_control[2];
sdp_record_t *record;
sdp_data_t *psm, *version, *features;
uint16_t lp = L2CAP_PSM_AVCTP;
uint16_t avrcp_ver = 0x0105, avctp_ver = 0x0104;
uint16_t feat = (AVRCP_FEATURE_CATEGORY_1 |
AVRCP_FEATURE_CATEGORY_2 |
AVRCP_FEATURE_CATEGORY_3 |
AVRCP_FEATURE_CATEGORY_4);
record = sdp_record_alloc();
if (!record)
return NULL;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
/* Service Class ID List */
sdp_uuid16_create(&avrtg, AV_REMOTE_TARGET_SVCLASS_ID);
svclass_id = sdp_list_append(NULL, &avrtg);
sdp_set_service_classes(record, svclass_id);
/* Protocol Descriptor List */
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto_control[0] = sdp_list_append(NULL, &l2cap);
psm = sdp_data_alloc(SDP_UINT16, &lp);
proto_control[0] = sdp_list_append(proto_control[0], psm);
apseq = sdp_list_append(NULL, proto_control[0]);
sdp_uuid16_create(&avctp, AVCTP_UUID);
proto_control[1] = sdp_list_append(NULL, &avctp);
version = sdp_data_alloc(SDP_UINT16, &avctp_ver);
proto_control[1] = sdp_list_append(proto_control[1], version);
apseq = sdp_list_append(apseq, proto_control[1]);
aproto_control = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto_control);
/* Bluetooth Profile Descriptor List */
sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
profile[0].version = avrcp_ver;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
features = sdp_data_alloc(SDP_UINT16, &feat);
sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
sdp_set_info_attr(record, "AVRCP TG", NULL, NULL);
sdp_data_free(psm);
sdp_data_free(version);
sdp_list_free(proto_control[0], NULL);
sdp_list_free(proto_control[1], NULL);
sdp_list_free(apseq, NULL);
sdp_list_free(aproto_control, NULL);
sdp_list_free(pfseq, NULL);
sdp_list_free(root, NULL);
sdp_list_free(svclass_id, NULL);
return record;
}
int register_record(int descriptor_is_relative){
// Connect to to local SDP-Servicer on localhost, to publish
// the new service record.
// Session will be established.
sdp_session_t *session;
session = sdp_connect ( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
if ( ! session )
{
// LOGCAT:
__android_log_print(ANDROID_LOG_DEBUG, TAG, "SDP: Connection to SDP failed.");
return CODE_SDP_SESSION_FAILED;
}
// LOGCAT:
__android_log_print(ANDROID_LOG_DEBUG, TAG, "SDP: Connection to SDP established.");
// Service record, to be included in the registry of the SDP-Server
sdp_record_t record;
// To create the record, several lists must be put together
sdp_list_t *languages, *service_class_id, *profile_sequence, *access_protocol_sequence, *root_list, *access_protocol, *protocol_list[3];
// The uuid_t data type is used to represent the 128-bit UUID that
// is used as un universal unique identifier. SEE THE THESIS, SUBSECTION 2.2.2
uuid_t root_uuid, hid_uuid, l2cap_uuid, hidp_uuid;
// BluetoothProfileDescriptorList. SEE THE THESIS, SUBSECTION 4.2.6
sdp_profile_desc_t sdp_profile[1];
// LanguageBaseAttributeIDList, SEE THE THESIS, SUBSECTION 4.2.4
sdp_lang_attr_t base_language;
// The sdp_data_t structure stores information in a service record
sdp_data_t *psm, *hid_descriptor_list, *hid_descriptor_formatted_list, *language_base_list, *language_base_formatted_list;
// SDP-specific types: 8- and 16- bit unsigned integers and a 8-bit string
uint8_t data_type_uint8 = SDP_UINT8;
uint8_t data_type_uint16 = SDP_UINT16;
uint8_t data_type_str8 = SDP_TEXT_STR8;
int length[2];
// arrays used to form the sdp specific strcuture of sequence attribites: descriptor and language base
void *data_types[2] , *descriptor_array[2], *language_base_array[2];
memset(&record, 0, sizeof(sdp_record_t));
// Assigning the Record Handle, SEE THE THESIS, SUBSECTION 4.2.2
record.handle = handle;
// Putting together attributes, common to all services.
// SEE THE THESIS, SECTION 4.2
// Setting the Browse Group and making
// the service record publicly available.
// SEE THE THESIS, SUBSECTION 4.2.3
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( &record, root_list );
// The LanguageBaseAttributeIDList
// SEE THE THESIS, SUBSECTION 4.2.4
base_language.code_ISO639 = (0x65 << 8) | 0x6e;
base_language.base_offset = SDP_PRIMARY_LANG_BASE;
base_language.encoding = 106;
languages = sdp_list_append(0, &base_language);
sdp_set_lang_attr(&record, languages);
sdp_list_free(languages, 0);
// The ServiceClassIDList
// SEE THE THESIS, SUBSECTION 4.2.1
sdp_uuid16_create(&hid_uuid, HID_SVCLASS_ID);
service_class_id = sdp_list_append(0, &hid_uuid);
sdp_set_service_classes(&record, service_class_id);
// The BluetoothProfileDescriptorList
// SEE THE THESIS, SUBSECTION 4.2.6
sdp_uuid16_create(&sdp_profile[0].uuid, HID_PROFILE_ID);
sdp_profile[0].version = 0x0100;
profile_sequence = sdp_list_append(0, sdp_profile);
sdp_set_profile_descs(&record, profile_sequence);
// The ProtocolDescriptorList
// SEE THE THESIS, SUBSECTION 4.2.5
// We set information about:
// A) Control Channel ->
// B) Interruption Channel
// We use the protocol_list to bind information
// about L2CAP and HID stack level
// A) Control Channel (PSM: 0x11)
// 1) Set info on L2CAP
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
protocol_list[1] = sdp_list_append(0, &l2cap_uuid);
psm = sdp_data_alloc(SDP_UINT16, &control_channel_psm);
protocol_list[1] = sdp_list_append(protocol_list[1], psm);
access_protocol_sequence = sdp_list_append(0, protocol_list[1]);
// 2) Set info on HID
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
protocol_list[2] = sdp_list_append(0, &hidp_uuid);
access_protocol_sequence = sdp_list_append(access_protocol_sequence, protocol_list[2]);
// bind to DecriptorList
access_protocol = sdp_list_append(0, access_protocol_sequence);
sdp_set_access_protos(&record, access_protocol);
// B) Interruption Channel (PSM: 0x13)
// 1) Set info on L2CAP
protocol_list[1] = sdp_list_append(0, &l2cap_uuid);
psm = sdp_data_alloc(SDP_UINT16, &interruption_channel_psm);
protocol_list[1] = sdp_list_append(protocol_list[1], psm);
access_protocol_sequence = sdp_list_append(0, protocol_list[1]);
// 2) Set info on HID
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
protocol_list[2] = sdp_list_append(0, &hidp_uuid);
access_protocol_sequence = sdp_list_append(access_protocol_sequence, protocol_list[2]);
access_protocol = sdp_list_append(0, access_protocol_sequence);
sdp_set_add_access_protos(&record, access_protocol);
// Setting the information on device, author and service,
// throuth the human-readable attributes
// SEE THE THESIS, SUBSECTION 4.2.4
sdp_set_info_attr(&record, SERVICE_NAME, SERVICE_INFO, AUTHOR_INFO);
// After putting together the attributes, common to all services,
// we bind the attributes that are specific to the HID service.
// SEE THE THESIS, SECTION 4.3
// Adding all HID attributes (mandatory or optional)
// explained in the THESIS (4.3.1 - 4.3.13)
// SEE THE THESIS, SUBSECTION 4.3.1
if(descriptor_is_relative){
sdp_attr_add_new( &record,
SDP_ATTR_HID_DEVICE_RELEASE_NUMBER,
SDP_UINT16,
&attr_release_number_mouse_keyboard);
}else{
sdp_attr_add_new( &record,
SDP_ATTR_HID_DEVICE_RELEASE_NUMBER,
SDP_UINT16,
&attr_release_number_pointer_keyboard);
}
// SEE THE THESIS, SUBSECTION 4.3.2
sdp_attr_add_new( &record,
SDP_ATTR_HID_PARSER_VERSION,
SDP_UINT16,
&attr_parser_version);
// SEE THE THESIS, SUBSECTION 4.3.3
sdp_attr_add_new( &record,
SDP_ATTR_HID_DEVICE_SUBCLASS,
SDP_UINT8,
&attr_device_subclass);
// SEE THE THESIS, SUBSECTION 4.3.4
sdp_attr_add_new( &record,
SDP_ATTR_HID_COUNTRY_CODE,
SDP_UINT8,
&attr_country_code);
// SEE THE THESIS, SUBSECTION 4.3.5
sdp_attr_add_new( &record,
SDP_ATTR_HID_VIRTUAL_CABLE,
SDP_BOOL,
&attr_virtual_cable);
// SEE THE THESIS, SUBSECTION 4.3.6
sdp_attr_add_new( &record,
SDP_ATTR_HID_RECONNECT_INITIATE,
SDP_BOOL,
&attr_reconnect_initiate);
// SEE THE THESIS, SUBSECTION 4.3.13
// Adding the HIDDescriptorList attribute is more complex,
// thus it is data sequence.
//
// The attribute contains two things:
// A) The descriptor type as unsigned integer (In our case it is a report descriptor)
// B) The two descriptors as string sequence (keyboard + mouse or keyboard + pointer)
data_types[0] = &data_type_uint8;
data_types[1] = &data_type_str8;
// We check the descriptor_is_realtive value to
// find out, if the keyboard + mouse or keyboard + pointer
// service description is to be added.
if(descriptor_is_relative){
descriptor_array[0] = &hid_descriptor_type;
descriptor_array[1] =(uint8_t *) attr_hid_descriptor_relative;
length[0] = 0;
length[1] = sizeof(attr_hid_descriptor_relative);
}else{
descriptor_array[0] = &hid_descriptor_type;
descriptor_array[1] =(uint8_t *) attr_hid_descriptor_absolute;
length[0] = 0;
length[1] = sizeof(attr_hid_descriptor_absolute);
}
// We bind the array containing the type and the array containing the values
// with the sdp_seq_alloc_with_length function
hid_descriptor_list = sdp_seq_alloc_with_length( data_types, descriptor_array, length, 2 );
// The newly created array contains all information, so it is used to create
// the list from the right SDP-specific type (SDP_SEQ8)
hid_descriptor_formatted_list = sdp_data_alloc( SDP_SEQ8, hid_descriptor_list );
// Finally the list is added as un SDP-attribute
sdp_attr_add( &record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_descriptor_formatted_list );
// Done!
// The same is also done with the HIDLANGIDBaseList
// SEE THE THESIS, SUBSECTION 4.3.12
data_types[0] = &data_type_uint16;
data_types[1] = &data_type_uint16;
language_base_array[0] = &attr_language_base[0];
language_base_array[1] = &attr_language_base[1];
//sizeof(attr_language_base) is devided by two, since values are 16-bit integers (not 8-bit like with the HIDDecriptorList)
language_base_list = sdp_seq_alloc(data_types, language_base_array, sizeof(attr_language_base) / 2);
language_base_formatted_list = sdp_data_alloc(SDP_SEQ8, language_base_list);
sdp_attr_add(&record, SDP_ATTR_HID_LANG_ID_BASE_LIST, language_base_formatted_list);
// Done!
// SEE THE THESIS, SUBSECTION 4.3.7
sdp_attr_add_new( &record,
SDP_ATTR_HID_SDP_DISABLE,
SDP_BOOL,
&attr_sdp_disable);
// SEE THE THESIS, SUBSECTION 4.3.8
sdp_attr_add_new( &record,
SDP_ATTR_HID_BATTERY_POWER,
SDP_BOOL,
&attr_battery_power);
// SEE THE THESIS, SUBSECTION 4.3.9
sdp_attr_add_new( &record,
SDP_ATTR_HID_REMOTE_WAKEUP,
SDP_BOOL,
&attr_remote_wake);
// SEE THE THESIS, SUBSECTION 4.3.10
sdp_attr_add_new( &record,
SDP_ATTR_HID_PROFILE_VERSION,
SDP_UINT16,
&attr_profile_version);
// sdp_attr_add_new( &record,
// SDP_ATTR_HID_SUPERVISION_TIMEOUT,
// SDP_UINT16,
// &attr_supervision_timeout);
// SEE THE THESIS, SUBSECTION 4.3.6
sdp_attr_add_new( &record,
SDP_ATTR_HID_NORMALLY_CONNECTABLE,
SDP_BOOL,
&attr_normally_connectable);
// SEE THE THESIS, SUBSECTION 4.3.11
sdp_attr_add_new( &record,
SDP_ATTR_HID_BOOT_DEVICE,
SDP_BOOL,
&attr_boot_device);
// At last the record is good to go and could be added to the sdp registry!
if (sdp_record_register(session, &record, SDP_RECORD_PERSIST) < 0) {
// LOGCAT:
__android_log_print(ANDROID_LOG_DEBUG, TAG, "SDP: Registration of new record failed.");
return CODE_RECORD_REGISTRATION_FAILED;
}
// LOGCAT:
__android_log_print(ANDROID_LOG_DEBUG, TAG, "SDP: Registration of new record successful.");
sdp_close(session);
return CODE_RECORD_REGISTERED;
}
static sdp_record_t *server_record_new(const char *name, uint16_t id)
{
sdp_list_t *svclass, *pfseq, *apseq, *root, *aproto;
uuid_t root_uuid, pan, l2cap, bnep;
sdp_profile_desc_t profile[1];
sdp_list_t *proto[2];
sdp_data_t *v, *p;
uint16_t psm = BNEP_PSM, version = 0x0100;
uint16_t security_desc = (security ? 0x0001 : 0x0000);
uint16_t net_access_type = 0xfffe;
uint32_t max_net_access_rate = 0;
const char *desc = "Network service";
sdp_record_t *record;
record = sdp_record_alloc();
if (!record)
return NULL;
record->attrlist = NULL;
record->pattern = NULL;
switch (id) {
case BNEP_SVC_NAP:
sdp_uuid16_create(&pan, NAP_SVCLASS_ID);
svclass = sdp_list_append(NULL, &pan);
sdp_set_service_classes(record, svclass);
sdp_uuid16_create(&profile[0].uuid, NAP_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
sdp_set_info_attr(record, name, NULL, desc);
sdp_attr_add_new(record, SDP_ATTR_NET_ACCESS_TYPE,
SDP_UINT16, &net_access_type);
sdp_attr_add_new(record, SDP_ATTR_MAX_NET_ACCESSRATE,
SDP_UINT32, &max_net_access_rate);
break;
case BNEP_SVC_GN:
sdp_uuid16_create(&pan, GN_SVCLASS_ID);
svclass = sdp_list_append(NULL, &pan);
sdp_set_service_classes(record, svclass);
sdp_uuid16_create(&profile[0].uuid, GN_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
sdp_set_info_attr(record, name, NULL, desc);
break;
case BNEP_SVC_PANU:
sdp_uuid16_create(&pan, PANU_SVCLASS_ID);
svclass = sdp_list_append(NULL, &pan);
sdp_set_service_classes(record, svclass);
sdp_uuid16_create(&profile[0].uuid, PANU_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
sdp_set_info_attr(record, name, NULL, desc);
break;
default:
sdp_record_free(record);
return NULL;
}
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
p = sdp_data_alloc(SDP_UINT16, &psm);
proto[0] = sdp_list_append(proto[0], p);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&bnep, BNEP_UUID);
proto[1] = sdp_list_append(NULL, &bnep);
v = sdp_data_alloc(SDP_UINT16, &version);
proto[1] = sdp_list_append(proto[1], v);
/* Supported protocols */
{
uint16_t ptype[] = {
0x0800, /* IPv4 */
0x0806, /* ARP */
};
sdp_data_t *head, *pseq;
int p;
for (p = 0, head = NULL; p < 2; p++) {
sdp_data_t *data = sdp_data_alloc(SDP_UINT16, &ptype[p]);
if (head)
sdp_seq_append(head, data);
else
head = data;
}
pseq = sdp_data_alloc(SDP_SEQ16, head);
proto[1] = sdp_list_append(proto[1], pseq);
}
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
add_lang_attr(record);
sdp_attr_add_new(record, SDP_ATTR_SECURITY_DESC,
SDP_UINT16, &security_desc);
sdp_data_free(p);
sdp_data_free(v);
sdp_list_free(apseq, NULL);
sdp_list_free(root, NULL);
sdp_list_free(aproto, NULL);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(svclass, NULL);
sdp_list_free(pfseq, NULL);
return record;
}
/*
* dosdpregistration - Care for the proper SDP record sent to the "sdpd"
* so that other BT devices can discover the HID service
* Parameters: none; Return value: 0 = OK, >0 = failure
*/
int dosdpregistration ( void )
{
sdp_record_t record;
sdp_session_t *session;
sdp_list_t *svclass_id,
*pfseq,
*apseq,
*root;
uuid_t root_uuid,
hidkb_uuid,
l2cap_uuid,
hidp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto,
*proto[3];
sdp_data_t *psm,
*lang_lst,
*lang_lst2,
*hid_spec_lst,
*hid_spec_lst2;
void *dtds[2],
*values[2],
*dtds2[2],
*values2[2];
int i,
leng[2];
uint8_t dtd=SDP_UINT16,
dtd2=SDP_UINT8,
dtd_data=SDP_TEXT_STR8,
hid_spec_type=0x22;
uint16_t hid_attr_lang[]={0x409, 0x100},
ctrl=PSMHIDCTL,
intr=PSMHIDINT,
hid_attr[]={0x100, 0x111, 0x40, 0x00, 0x01, 0x01},
// Assigned to SDP 0x200...0x205 - see HID SPEC for
// details. Those values seem to work fine...
// "it\'s a kind of magic" numbers.
hid_attr2[]={0x100, 0x0};
// Connect to SDP server on localhost, to publish service information
session = sdp_connect ( BDADDR_ANY, BDADDR_LOCAL, 0 );
if ( ! session )
{
fprintf ( stderr, "Failed to connect to SDP server: %s\n",
strerror ( errno ) );
return 1;
}
memset(&record, 0, sizeof(sdp_record_t));
record.handle = 0xffffffff;
// With 0xffffffff, we get assigned the first free record >= 0x10000
// Make HID service visible (add to PUBLIC BROWSE GROUP)
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(&record, root);
// Language Information to be added
add_lang_attr(&record);
// The descriptor for the keyboard
sdp_uuid16_create(&hidkb_uuid, HID_SVCLASS_ID);
svclass_id = sdp_list_append(0, &hidkb_uuid);
sdp_set_service_classes(&record, svclass_id);
// And information about the HID profile used
sdp_uuid16_create(&profile[0].uuid, HIDP_UUID /*HID_PROFILE_ID*/);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(&record, pfseq);
// We are using L2CAP, so add an info about that
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[1] = sdp_list_append(0, &l2cap_uuid);
psm = sdp_data_alloc(SDP_UINT16, &ctrl);
proto[1] = sdp_list_append(proto[1], psm);
apseq = sdp_list_append(0, proto[1]);
// And about our purpose, the HID protocol data transfer
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(&record, aproto);
proto[1] = sdp_list_append(0, &l2cap_uuid);
psm = sdp_data_alloc(SDP_UINT16, &intr);
proto[1] = sdp_list_append(proto[1], psm);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_add_access_protos(&record, aproto);
// Set service name, description
sdp_set_info_attr(&record, HIDINFO_NAME, HIDINFO_PROV, HIDINFO_DESC);
// Add a few HID-specifid pieces of information
// See the HID spec for details what those codes 0x200+something
// are good for... we send a fixed set of info that seems to work
sdp_attr_add_new(&record, SDP_ATTR_HID_DEVICE_RELEASE_NUMBER,
SDP_UINT16, &hid_attr[0]); /* Opt */
sdp_attr_add_new(&record, SDP_ATTR_HID_PARSER_VERSION,
SDP_UINT16, &hid_attr[1]); /* Mand */
sdp_attr_add_new(&record, SDP_ATTR_HID_DEVICE_SUBCLASS,
SDP_UINT8, &hid_attr[2]); /* Mand */
sdp_attr_add_new(&record, SDP_ATTR_HID_COUNTRY_CODE,
SDP_UINT8, &hid_attr[3]); /* Mand */
sdp_attr_add_new(&record, SDP_ATTR_HID_VIRTUAL_CABLE,
SDP_BOOL, &hid_attr[4]); /* Mand */
sdp_attr_add_new(&record, SDP_ATTR_HID_RECONNECT_INITIATE,
SDP_BOOL, &hid_attr[5]); /* Mand */
// Add the HID descriptor (describing the virtual device) as code
// SDP_ATTR_HID_DESCRIPTOR_LIST (0x206 IIRC)
dtds[0] = &dtd2;
values[0] = &hid_spec_type;
dtd_data= SDPRECORD_BYTES <= 255 ? SDP_TEXT_STR8 : SDP_TEXT_STR16 ;
dtds[1] = &dtd_data;
values[1] = (uint8_t *) SDPRECORD;
leng[0] = 0;
leng[1] = SDPRECORD_BYTES;
hid_spec_lst = sdp_seq_alloc_with_length(dtds, values, leng, 2);
hid_spec_lst2 = sdp_data_alloc(SDP_SEQ8, hid_spec_lst);
sdp_attr_add(&record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_spec_lst2);
// and continue adding further data bytes for 0x206+x values
for (i = 0; i < sizeof(hid_attr_lang) / 2; i++) {
dtds2[i] = &dtd;
values2[i] = &hid_attr_lang[i];
}
lang_lst = sdp_seq_alloc(dtds2, values2, sizeof(hid_attr_lang) / 2);
lang_lst2 = sdp_data_alloc(SDP_SEQ8, lang_lst);
sdp_attr_add(&record, SDP_ATTR_HID_LANG_ID_BASE_LIST, lang_lst2);
sdp_attr_add_new ( &record, SDP_ATTR_HID_PROFILE_VERSION,
SDP_UINT16, &hid_attr2[0] );
sdp_attr_add_new ( &record, SDP_ATTR_HID_BOOT_DEVICE,
SDP_UINT16, &hid_attr2[1] );
// Submit our IDEA of a SDP record to the "sdpd"
if (sdp_record_register(session, &record, SDP_RECORD_PERSIST) < 0) {
fprintf ( stderr, "Service Record registration failed\n" );
return -1;
}
// Store the service handle retrieved from there for reference (i.e.,
// deleting the service info when this program terminates)
sdphandle = record.handle;
fprintf ( stdout, "HID keyboard/mouse service registered\n" );
return 0;
}
/**
* Creates the SDP record for PS3 keypad HID emulation. Works well with many different
* clients: windows, linux (ubuntu), PS3, and motorola android devices.
*/
static sdp_record_t *create_hid_ps3_keypad_record()
{
sdp_record_t *sdp_record;
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, hidkb_uuid, l2cap_uuid, hidp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_data_t *channel, *lang_lst, *lang_lst2, *hid_spec_lst, *hid_spec_lst2;
int i;
uint8_t dtd = SDP_UINT16;
uint8_t dtd2 = SDP_UINT8;
uint8_t dtd_data = SDP_TEXT_STR8;
void *dtds[2];
void *values[2];
void *dtds2[2];
void *values2[2];
int leng[2];
uint8_t hid_spec_type = 0x22;
uint16_t hid_attr_lang[] = {0x409,0x100};
uint16_t value_int = 0;
static const uint16_t ctrl = 0x11;
static const uint16_t intr = 0x13;
static const uint16_t hid_release_num = 0x100;
static const uint16_t hid_parser_version = 0x111;
static const uint8_t hid_dev_subclass = 0x40;
static const uint8_t hid_country_code = 0x4;
static const uint8_t hid_virtual_cable = 0x0;
static const uint8_t hid_reconn_initiate = 0x1;
static const uint8_t hid_sdp_disable = 0x0;
static const uint8_t hid_batt_power = 0x1;
static const uint8_t hid_remote_wake = 0x0;
static const uint16_t hid_profile_version = 0x100;
static const uint16_t hid_superv_timeout = 0x1f40;
static const uint8_t hid_normally_connectable = 0x0;
static const uint8_t hid_boot_device = 0x1;
static const uint8_t hid_spec[] = {
/* Pointer (mouse) */
0x05, 0x01, /* Usage Page (Desktop), */
0x09, 0x02, /* Usage (Mouse), */
0xA1, 0x01, /* Collection (Application), */
0x85, 0x02, /* Report ID (2), */
0x09, 0x01, /* Usage (Pointer), */
0xA1, 0x00, /* Collection (Physical), */
0x05, 0x09, /* Usage Page (Button), */
0x19, 0x01, /* Usage Minimum (01h), */
0x29, 0x02, /* Usage Maximum (02h), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x95, 0x02, /* Report Count (2), */
0x75, 0x01, /* Report Size (1), */
0x81, 0x02, /* Input (Variable), */
0x95, 0x01, /* Report Count (1), */
0x75, 0x06, /* Report Size (6), */
0x81, 0x03, /* Input (Constant, Variable), */
0x05, 0x01, /* Usage Page (Desktop), */
0x09, 0x30, /* Usage (X), */
0x09, 0x31, /* Usage (Y), */
0x15, 0x81, /* Logical Minimum (-127), */
0x25, 0x7F, /* Logical Maximum (127), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x02, /* Report Count (2), */
0x81, 0x06, /* Input (Variable, Relative), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x01, /* Report Count (1), */
0x81, 0x01, /* Input (Constant), */
0x06, 0x00, 0xFF, /* Usage Page (FF00h), */
0x09, 0x20, /* Usage (20h), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x0F, /* Logical Maximum (4095), */
0x75, 0x0C, /* Report Size (12), */
0x95, 0x02, /* Report Count (2), */
0x81, 0x02, /* Input (Variable), */
0x09, 0x21, /* Usage (21h), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x01, /* Report Count (1), */
0x81, 0x02, /* Input (Variable), */
0xC0, /* End Collection, */
0xC0, /* End Collection, */
/* Keyboard */
0x05, 0x01, /* Usage Page (Desktop), */
0x09, 0x06, /* Usage (Keyboard), */
0xA1, 0x01, /* Collection (Application), */
0x85, 0x01, /* Report ID (1), */
0x05, 0x07, /* Usage Page (Keyboard), */
0x19, 0xE0, /* Usage Minimum (KB Leftcontrol), */
0x29, 0xE7, /* Usage Maximum (KB Right GUI), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x75, 0x01, /* Report Size (1), */
0x95, 0x08, /* Report Count (8), */
0x81, 0x02, /* Input (Variable), */
0x95, 0x01, /* Report Count (1), */
0x75, 0x08, /* Report Size (8), */
0x81, 0x01, /* Input (Constant), */
0x95, 0x05, /* Report Count (5), */
0x75, 0x01, /* Report Size (1), */
0x05, 0x08, /* Usage Page (LED), */
0x19, 0x01, /* Usage Minimum (01h), */
0x29, 0x05, /* Usage Maximum (05h), */
0x91, 0x02, /* Output (Variable), */
0x95, 0x01, /* Report Count (1), */
0x75, 0x03, /* Report Size (3), */
0x91, 0x01, /* Output (Constant), */
0x95, 0x06, /* Report Count (6), */
0x75, 0x08, /* Report Size (8), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x05, 0x07, /* Usage Page (Keyboard), */
0x19, 0x00, /* Usage Minimum (None), */
0x29, 0xE7, /* Usage Maximum (KB Right GUI), */
0x81, 0x00, /* Input, */
0xC0, /* End Collection, */
0x06, 0x01, 0xFF, /* Usage Page (FF01h), */
0x09, 0x20, /* Usage (20h), */
0xA1, 0x01, /* Collection (Application), */
0x09, 0x21, /* Usage (21h), */
0x85, 0x03, /* Report ID (3), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x01, /* Report Count (1), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x09, 0x22, /* Usage (22h), */
0x81, 0x02, /* Input (Variable), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x01, /* Report Count (1), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x09, 0x23, /* Usage (23h), */
0x81, 0x02, /* Input (Variable), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x06, /* Report Count (6), */
0x81, 0x01, /* Input (Constant), */
0x09, 0x24, /* Usage (24h), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x01, /* Report Count (1), */
0x91, 0x02, /* Output (Variable), */
0xC0, /* End Collection, */
/* ?? PS3 proprietary? */
0x06, 0x02, 0xFF, /* Usage Page (FF02h), */
0x09, 0x20, /* Usage (20h), */
0xA1, 0x01, /* Collection (Application), */
0x09, 0x21, /* Usage (21h), */
0x85, 0x04, /* Report ID (4), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x0F, /* Report Count (15), */
0xB1, 0x02, /* Feature (Variable), */
0x09, 0x22, /* Usage (22h), */
0x85, 0x05, /* Report ID (5), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x75, 0x08, /* Report Size (8), */
0x95, 0x16, /* Report Count (22), */
0xB1, 0x02, /* Feature (Variable), */
0xC0 /* End Collection */
};
sdp_record = sdp_record_alloc();
if (!sdp_record) {
return NULL;
}
memset((void*)sdp_record, 0, sizeof(sdp_record_t));
sdp_record->handle = 0xffffffff;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(sdp_record, root);
add_lang_attr(sdp_record);
sdp_uuid16_create(&hidkb_uuid, HID_SVCLASS_ID);
svclass_id = sdp_list_append(0, &hidkb_uuid);
sdp_set_service_classes(sdp_record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, HID_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(sdp_record, pfseq);
/* PROTO */
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ctrl);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(sdp_record, aproto);
/* ATTR_ADD_PROTO */
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &intr);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_add_access_protos(sdp_record, aproto);
sdp_set_info_attr(sdp_record, "Android PS3 Bluetooth Keypad",
"", "PS3 compatible HID device over Bluetooth for Android");
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_RELEASE_NUMBER, SDP_UINT16, &hid_release_num);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PARSER_VERSION, SDP_UINT16, &hid_parser_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_SUBCLASS, SDP_UINT8, &hid_dev_subclass);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_COUNTRY_CODE, SDP_UINT8, &hid_country_code);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_VIRTUAL_CABLE, SDP_BOOL, &hid_virtual_cable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_RECONNECT_INITIATE, SDP_BOOL, &hid_reconn_initiate);
dtds[0] = &dtd2;
values[0] = &hid_spec_type;
dtds[1] = &dtd_data;
values[1] = (uint8_t*)hid_spec;
leng[0] = 0;
leng[1] = sizeof(hid_spec);
hid_spec_lst = sdp_seq_alloc_with_length(dtds, values, leng, 2);
hid_spec_lst2 = sdp_data_alloc(SDP_SEQ8, hid_spec_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_spec_lst2);
for (i = 0; i < sizeof(hid_attr_lang)/2; i++) {
dtds2[i] = &dtd;
values2[i] = &hid_attr_lang[i];
}
lang_lst = sdp_seq_alloc(dtds2, values2, sizeof(hid_attr_lang)/2);
lang_lst2 = sdp_data_alloc(SDP_SEQ8, lang_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_LANG_ID_BASE_LIST, lang_lst2);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SDP_DISABLE, SDP_BOOL, &hid_sdp_disable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BATTERY_POWER, SDP_BOOL, &hid_batt_power);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_REMOTE_WAKEUP, SDP_BOOL, &hid_remote_wake);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PROFILE_VERSION, SDP_UINT16, &hid_profile_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SUPERVISION_TIMEOUT, SDP_UINT16, &hid_superv_timeout);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_NORMALLY_CONNECTABLE, SDP_BOOL, &hid_normally_connectable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BOOT_DEVICE, SDP_BOOL, &hid_boot_device);
return sdp_record;
}
/**
* Creates the SDP record for HID emulation. Works well with many different
* clients: windows, linux (ubuntu), PS3, and motorola android devices.
*/
static sdp_record_t *create_hid_generic_record()
{
sdp_record_t *sdp_record;
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, hidkb_uuid, l2cap_uuid, hidp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_data_t *channel, *lang_lst, *lang_lst2, *hid_spec_lst, *hid_spec_lst2;
int i;
uint8_t dtd = SDP_UINT16;
uint8_t dtd2 = SDP_UINT8;
uint8_t dtd_data = SDP_TEXT_STR8;
void *dtds[2];
void *values[2];
void *dtds2[2];
void *values2[2];
int leng[2];
uint8_t hid_spec_type = 0x22;
uint16_t hid_attr_lang[] = {0x409,0x100};
uint16_t value_int = 0;
static const uint16_t ctrl = 0x11;
static const uint16_t intr = 0x13;
static const uint16_t hid_release_num = 0x100;
static const uint16_t hid_parser_version = 0x111;
static const uint8_t hid_dev_subclass = 0x40;
static const uint8_t hid_country_code = 0x4;
static const uint8_t hid_virtual_cable = 0x0;
static const uint8_t hid_reconn_initiate = 0x1;
static const uint8_t hid_sdp_disable = 0x0;
static const uint8_t hid_batt_power = 0x1;
static const uint8_t hid_remote_wake = 0x0;
static const uint16_t hid_profile_version = 0x100;
static const uint16_t hid_superv_timeout = 0x1f40;
static const uint8_t hid_normally_connectable = 0x0;
static const uint8_t hid_boot_device = 0x1;
static const uint8_t hid_spec[] = {
/* Generic keyboard */
0x05, 0x01, /* Usage Page (Desktop), */
0x09, 0x06, /* Usage (Keyboard), */
0xA1, 0x01, /* Collection (Application), */
0x85, 0x01, /* Report ID (1), */
0x05, 0x07, /* Usage Page (Keyboard), */
0x19, 0xE0, /* Usage Minimum (KB Leftcontrol), */
0x29, 0xE7, /* Usage Maximum (KB Right GUI), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x75, 0x01, /* Report Size (1), */
0x95, 0x08, /* Report Count (8), */
0x81, 0x02, /* Input (Variable), */
0x95, 0x01, /* Report Count (1), */
0x75, 0x08, /* Report Size (8), */
0x81, 0x01, /* Input (Constant), */
0x95, 0x05, /* Report Count (5), */
0x75, 0x01, /* Report Size (1), */
0x05, 0x08, /* Usage Page (LED), */
0x19, 0x01, /* Usage Minimum (01h), */
0x29, 0x05, /* Usage Maximum (05h), */
0x91, 0x02, /* Output (Variable), */
0x95, 0x01, /* Report Count (1), */
0x75, 0x03, /* Report Size (3), */
0x91, 0x01, /* Output (Constant), */
0x95, 0x06, /* Report Count (6), */
0x75, 0x08, /* Report Size (8), */
0x15, 0x00, /* Logical Minimum (0), */
0x26, 0xFF, 0x00, /* Logical Maximum (255), */
0x05, 0x07, /* Usage Page (Keyboard), */
0x19, 0x00, /* Usage Minimum (None), */
0x29, 0xE7, /* Usage Maximum (KB Right GUI), */
0x81, 0x00, /* Input, */
/* Consumer specific - volume / mute */
0xC0, /* End Collection, */
0x05, 0x0C, /* Usage Page (Consumer), */
0x09, 0x01, /* Usage (Consumer Control), */
0xA1, 0x01, /* Collection (Application), */
0x85, 0x01, /* Report ID (1), */
0x09, 0xE0, /* Usage (Volume), */
0x15, 0xE8, /* Logical Minimum (-24), */
0x25, 0x18, /* Logical Maximum (24), */
0x75, 0x07, /* Report Size (7), */
0x95, 0x01, /* Report Count (1), */
0x81, 0x06, /* Input (Variable, Relative), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x75, 0x01, /* Report Size (1), */
0x09, 0xE2, /* Usage (Mute), */
0x81, 0x06, /* Input (Variable, Relative), */
0xC0, /* End Collection, */
/* Consumer specific - media controls */
0x05, 0x0C, /* Usage Page (Consumer), */
0x09, 0x01, /* Usage (Consumer Control), */
0xA1, 0x01, /* Collection (Application), */
0x85, 0x03, /* Report ID (3), */
0x15, 0x00, /* Logical Minimum (0), */
0x25, 0x01, /* Logical Maximum (1), */
0x75, 0x01, /* Report Size (1), */
0x95, 0x01, /* Report Count (1), */
0x0A, 0x27, 0x02, /* Usage (AC Refresh), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x94, 0x01, /* Usage (AL Local Machine Brwsr), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x23, 0x02, /* Usage (AC Home), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x8A, 0x01, /* Usage (AL Email Reader), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x92, 0x01, /* Usage (AL Calculator), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x26, 0x02, /* Usage (AC Stop), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x25, 0x02, /* Usage (AC Forward), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x24, 0x02, /* Usage (AC Back), */
0x81, 0x06, /* Input (Variable, Relative), */
0x09, 0xB5, /* Usage (Scan Next Track), */
0x81, 0x06, /* Input (Variable, Relative), */
0x09, 0xB6, /* Usage (Scan Previous Track), */
0x81, 0x06, /* Input (Variable, Relative), */
0x09, 0xCD, /* Usage (Play Pause), */
0x81, 0x06, /* Input (Variable, Relative), */
0x09, 0xB7, /* Usage (Stop), */
0x81, 0x06, /* Input (Variable, Relative), */
0x0A, 0x83, 0x01, /* Usage (AL Consumer Control Config), */
0x81, 0x06, /* Input (Variable, Relative), */
0x95, 0x0B, /* Report Count (11), */
0x81, 0x01, /* Input (Constant), */
0xC0, /* End Collection */
/* Generic mouse pointer */
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
0x09, 0x02, /* USAGE (Mouse) */
0xa1, 0x01, /* COLLECTION (Application) */
0x85, 0x02, /* Report ID (2), */
0x09, 0x01, /* USAGE (Pointer) */
0xa1, 0x00, /* COLLECTION (Physical) */
0x05, 0x09, /* USAGE_PAGE (Button) */
0x19, 0x01, /* USAGE_MINIMUM (Button 1) */
0x29, 0x03, /* USAGE_MAXIMUM (Button 3) */
0x15, 0x00, /* LOGICAL_MINIMUM (0) */
0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
0x95, 0x03, /* REPORT_COUNT (3) */
0x75, 0x01, /* REPORT_SIZE (1) */
0x81, 0x02, /* INPUT (Data,Var,Abs) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x75, 0x05, /* REPORT_SIZE (5) */
0x81, 0x03, /* INPUT (Cnst,Var,Abs) */
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
0x09, 0x30, /* USAGE (X) */
0x09, 0x31, /* USAGE (Y) */
0x15, 0x81, /* LOGICAL_MINIMUM (-127) */
0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */
0x75, 0x08, /* REPORT_SIZE (8) */
0x95, 0x02, /* REPORT_COUNT (2) */
0x81, 0x06, /* INPUT (Data,Var,Rel) */
0xc0, /* END_COLLECTION */
0xc0 /* END_COLLECTION */
};
sdp_record = sdp_record_alloc();
if (!sdp_record) {
return NULL;
}
memset((void*)sdp_record, 0, sizeof(sdp_record_t));
sdp_record->handle = 0xffffffff;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(sdp_record, root);
add_lang_attr(sdp_record);
sdp_uuid16_create(&hidkb_uuid, HID_SVCLASS_ID);
svclass_id = sdp_list_append(0, &hidkb_uuid);
sdp_set_service_classes(sdp_record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, HID_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(sdp_record, pfseq);
/* PROTO */
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ctrl);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(sdp_record, aproto);
/* ATTR_ADD_PROTO */
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &intr);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_add_access_protos(sdp_record, aproto);
sdp_set_info_attr(sdp_record, "Android Bluetooth Keyboard",
"", "HID device over Bluetooth for Android");
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_RELEASE_NUMBER, SDP_UINT16, &hid_release_num);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PARSER_VERSION, SDP_UINT16, &hid_parser_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_SUBCLASS, SDP_UINT8, &hid_dev_subclass);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_COUNTRY_CODE, SDP_UINT8, &hid_country_code);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_VIRTUAL_CABLE, SDP_BOOL, &hid_virtual_cable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_RECONNECT_INITIATE, SDP_BOOL, &hid_reconn_initiate);
dtds[0] = &dtd2;
values[0] = &hid_spec_type;
dtds[1] = &dtd_data;
values[1] = (uint8_t*)hid_spec;
leng[0] = 0;
leng[1] = sizeof(hid_spec);
hid_spec_lst = sdp_seq_alloc_with_length(dtds, values, leng, 2);
hid_spec_lst2 = sdp_data_alloc(SDP_SEQ8, hid_spec_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_spec_lst2);
for (i = 0; i < sizeof(hid_attr_lang)/2; i++) {
dtds2[i] = &dtd;
values2[i] = &hid_attr_lang[i];
}
lang_lst = sdp_seq_alloc(dtds2, values2, sizeof(hid_attr_lang)/2);
lang_lst2 = sdp_data_alloc(SDP_SEQ8, lang_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_LANG_ID_BASE_LIST, lang_lst2);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SDP_DISABLE, SDP_BOOL, &hid_sdp_disable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BATTERY_POWER, SDP_BOOL, &hid_batt_power);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_REMOTE_WAKEUP, SDP_BOOL, &hid_remote_wake);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PROFILE_VERSION, SDP_UINT16, &hid_profile_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SUPERVISION_TIMEOUT, SDP_UINT16, &hid_superv_timeout);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_NORMALLY_CONNECTABLE, SDP_BOOL, &hid_normally_connectable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BOOT_DEVICE, SDP_BOOL, &hid_boot_device);
return sdp_record;
}
/**
* Creates the SDP record for BD remtoe HID emulation. Probably works with PS3 only (experimental)
*/
static sdp_record_t *create_hid_bdremote_record()
{
sdp_record_t *sdp_record;
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, hidkb_uuid, l2cap_uuid, hidp_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_data_t *channel, *lang_lst, *lang_lst2, *hid_spec_lst, *hid_spec_lst2;
int i;
uint8_t dtd = SDP_UINT16;
uint8_t dtd2 = SDP_UINT8;
uint8_t dtd_data = SDP_TEXT_STR8;
void *dtds[2];
void *values[2];
void *dtds2[2];
void *values2[2];
int leng[2];
uint8_t hid_spec_type = 0x22;
uint16_t hid_attr_lang[] = {0x409,0x100};
uint16_t value_int = 0;
static const uint16_t ctrl = 0x11;
static const uint16_t intr = 0x13;
static const uint16_t hid_release_num = 0x100;
static const uint16_t hid_parser_version = 0x111;
static const uint8_t hid_dev_subclass = 0x0c;
static const uint8_t hid_country_code = 0x21;
static const uint8_t hid_virtual_cable = 0x1;
static const uint8_t hid_reconn_initiate = 0x1;
static const uint8_t hid_sdp_disable = 0x0;
static const uint8_t hid_batt_power = 0x1;
static const uint8_t hid_remote_wake = 0x1;
static const uint16_t hid_profile_version = 0x100;
static const uint16_t hid_superv_timeout = 0x1f40;
static const uint8_t hid_normally_connectable = 0x0;
static const uint8_t hid_boot_device = 0x10;
const uint8_t hid_spec[] = {
/* PS3 blu-ray remote */
0x05, 0x01, /* Usage Page (Generic Desktop) */
0x09, 0x05, /* Usage ID (Game Pad) */
0xa1, 0x01, /* Collection (Application) */
0x85, 0x01, /* Report ID (1) */
0x15, 0x00, /* Logical Minimum (0) */
0x26, 0xff, 0x00, /* Logical Maximum (255) */
0x75, 0x08, /* Report Size (8) */
0x95, 0x0b, /* Report Count (11) */
0x06, 0x00, 0xff, /* Usage Page (Vendor Defined Page 1) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0x81, 0x00, /* Input (Data,Array,Absolute) */
0x85, 0x01, /* Report ID (1) */
0x95, 0x0b, /* Report Count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0x85, 0x02, /* Report ID (2) */
0x95, 0x0b, /* Report Count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0x85, 0x03, /* Report ID (3) */
0x95, 0x0b, /* Report Count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0x85, 0x04, /* Report ID (4) */
0x95, 0x0b, /* Report Count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0x85, 0x05, /* Report ID (5) */
0x95, 0x0b, /* Report count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0x85, 0x06, /* Report ID (6) */
0x95, 0x0b, /* Report count (11) */
0x09, 0x01, /* Usage (Vendor Usage 1) */
0xb1, 0x00, /* Feature (Data,Array,Absolute) */
0xc0 /* End Collection */
};
sdp_record = sdp_record_alloc();
if (!sdp_record) {
return NULL;
}
memset((void*)sdp_record, 0, sizeof(sdp_record_t));
sdp_record->handle = 0xffffffff;
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(sdp_record, root);
add_lang_attr(sdp_record);
sdp_uuid16_create(&hidkb_uuid, HID_SVCLASS_ID);
svclass_id = sdp_list_append(0, &hidkb_uuid);
sdp_set_service_classes(sdp_record, svclass_id);
sdp_uuid16_create(&profile[0].uuid, HID_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(0, profile);
sdp_set_profile_descs(sdp_record, pfseq);
/* PROTO */
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &ctrl);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_access_protos(sdp_record, aproto);
/* ATTR_ADD_PROTO */
proto[1] = sdp_list_append(0, &l2cap_uuid);
channel = sdp_data_alloc(SDP_UINT8, &intr);
proto[1] = sdp_list_append(proto[1], channel);
apseq = sdp_list_append(0, proto[1]);
sdp_uuid16_create(&hidp_uuid, HIDP_UUID);
proto[2] = sdp_list_append(0, &hidp_uuid);
apseq = sdp_list_append(apseq, proto[2]);
aproto = sdp_list_append(0, apseq);
sdp_set_add_access_protos(sdp_record, aproto);
sdp_set_info_attr(sdp_record, "Android Bluetooth Keyboard",
"", "HID device over Bluetooth for Android");
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_RELEASE_NUMBER, SDP_UINT16, &hid_release_num);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PARSER_VERSION, SDP_UINT16, &hid_parser_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_DEVICE_SUBCLASS, SDP_UINT8, &hid_dev_subclass);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_COUNTRY_CODE, SDP_UINT8, &hid_country_code);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_VIRTUAL_CABLE, SDP_BOOL, &hid_virtual_cable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_RECONNECT_INITIATE, SDP_BOOL, &hid_reconn_initiate);
dtds[0] = &dtd2;
values[0] = &hid_spec_type;
dtds[1] = &dtd_data;
values[1] = (uint8_t*)hid_spec;
leng[0] = 0;
leng[1] = sizeof(hid_spec);
hid_spec_lst = sdp_seq_alloc_with_length(dtds, values, leng, 2);
hid_spec_lst2 = sdp_data_alloc(SDP_SEQ8, hid_spec_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_DESCRIPTOR_LIST, hid_spec_lst2);
for (i = 0; i < sizeof(hid_attr_lang)/2; i++) {
dtds2[i] = &dtd;
values2[i] = &hid_attr_lang[i];
}
lang_lst = sdp_seq_alloc(dtds2, values2, sizeof(hid_attr_lang)/2);
lang_lst2 = sdp_data_alloc(SDP_SEQ8, lang_lst);
sdp_attr_add(sdp_record, SDP_ATTR_HID_LANG_ID_BASE_LIST, lang_lst2);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SDP_DISABLE, SDP_BOOL, &hid_sdp_disable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BATTERY_POWER, SDP_BOOL, &hid_batt_power);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_REMOTE_WAKEUP, SDP_BOOL, &hid_remote_wake);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_PROFILE_VERSION, SDP_UINT16, &hid_profile_version);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_SUPERVISION_TIMEOUT, SDP_UINT16, &hid_superv_timeout);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_NORMALLY_CONNECTABLE, SDP_BOOL, &hid_normally_connectable);
sdp_attr_add_new(sdp_record, SDP_ATTR_HID_BOOT_DEVICE, SDP_BOOL, &hid_boot_device);
return sdp_record;
}
sdp_session_t *register_service(){
//4e:65:78:75:73:2d:43:6f:6d:70:75:74:69:6e:67 ~ Nexus-Computing :)4e65 7875 732d 436f 6d70 7574 696e 6700
//uint32_t service_uuid_int[] = {0x4e65,0x7875,0x732d,0x436f,0x6d70,0x7574,0x696e,0x6700};
uint8_t service_uuid_int[] = {0x07,0x29,0x3d,0xb4,0xa3, 0x23, 0x4e, 0x07,0x8b, 0x8b,0x25,0x0b,0x34,0x0e, 0x42, 0xa4};
uint8_t rfcomm_channel = SVC_CHANNEL;
uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid;
sdp_list_t *l2cap_list = 0,
*rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0,
*class_id_list;
sdp_data_t *channel = 0, *psm = 0;
sdp_record_t *record = sdp_record_alloc();
// set the general service ID
sdp_uuid128_create( &svc_uuid, &service_uuid_int );
sdp_set_service_id( record, svc_uuid );
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups( record, root_list );
// set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append( 0, &l2cap_uuid );
proto_list = sdp_list_append( 0, l2cap_list );
// set rfcomm information
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
rfcomm_list = sdp_list_append( 0, &rfcomm_uuid );
sdp_list_append( rfcomm_list, channel );
sdp_list_append( proto_list, rfcomm_list );
// attach protocol information to service record
access_proto_list = sdp_list_append( 0, proto_list );
sdp_set_access_protos( record, access_proto_list );
//service classes IMPORTANT FOR ANDROID!
class_id_list = sdp_list_append( 0, &svc_uuid);
sdp_set_service_classes( record, class_id_list );
// set the name, provider, and description
sdp_set_info_attr(record, SVC_NAME, SVC_PROV, SVC_DESC);
int err = 0;
sdp_session_t *session = 0;
// connect to the local SDP server, register the service record, and
// disconnect
session = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
err = sdp_record_register(session, record, 0);
if(err != 0)
perror("Error registring record");
// cleanup
sdp_data_free( channel );
sdp_list_free( l2cap_list, 0 );
sdp_list_free( rfcomm_list, 0 );
sdp_list_free( root_list, 0 );
sdp_list_free( access_proto_list, 0 );
return session;
}
int dun_sdp_register(bdaddr_t *device, uint8_t channel, int type)
{
sdp_list_t *svclass, *pfseq, *apseq, *root, *aproto;
uuid_t root_uuid, l2cap, rfcomm, dun;
sdp_profile_desc_t profile[1];
sdp_list_t *proto[2];
int status;
session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, 0);
if (!session) {
syslog(LOG_ERR, "Failed to connect to the local SDP server. %s(%d)",
strerror(errno), errno);
return -1;
}
record = sdp_record_alloc();
if (!record) {
syslog(LOG_ERR, "Failed to alloc service record");
return -1;
}
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&rfcomm, RFCOMM_UUID);
proto[1] = sdp_list_append(NULL, &rfcomm);
proto[1] = sdp_list_append(proto[1], sdp_data_alloc(SDP_UINT8, &channel));
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
switch (type) {
case MROUTER:
sdp_uuid16_create(&dun, SERIAL_PORT_SVCLASS_ID);
break;
case ACTIVESYNC:
sdp_uuid128_create(&dun, (void *) async_uuid);
break;
case DIALUP:
sdp_uuid16_create(&dun, DIALUP_NET_SVCLASS_ID);
break;
default:
sdp_uuid16_create(&dun, LAN_ACCESS_SVCLASS_ID);
break;
}
svclass = sdp_list_append(NULL, &dun);
sdp_set_service_classes(record, svclass);
switch (type) {
case LANACCESS:
sdp_uuid16_create(&profile[0].uuid, LAN_ACCESS_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
break;
case DIALUP:
sdp_uuid16_create(&profile[0].uuid, DIALUP_NET_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
break;
}
switch (type) {
case MROUTER:
sdp_set_info_attr(record, "mRouter", NULL, NULL);
break;
case ACTIVESYNC:
sdp_set_info_attr(record, "ActiveSync", NULL, NULL);
break;
case DIALUP:
sdp_set_info_attr(record, "Dialup Networking", NULL, NULL);
break;
default:
sdp_set_info_attr(record, "LAN Access Point", NULL, NULL);
break;
}
status = sdp_device_record_register(session, device, record, 0);
if (status) {
syslog(LOG_ERR, "SDP registration failed.");
sdp_record_free(record);
record = NULL;
return -1;
}
return 0;
}
/* Allows this service to be discovered when running sdptool. For example, you can find this service
* after starting it by running
*
* $ sdptool browse local
*
* (Adapted from http://www.btessentials.com/examples/bluez/sdp-register.c)
* */
sdp_session_t *register_service(uint8_t rfcomm_channel) {
/* A 128-bit number used to identify this service. The words are ordered from most to least
* significant, but within each word, the octets are ordered from least to most significant.
* For example, the UUID represneted by this array is 00001101-0000-1000-8000-00805F9B34FB. (The
* hyphenation is a convention specified by the Service Discovery Protocol of the Bluetooth Core
* Specification, but is not particularly important for this program.)
*
* This UUID is the Bluetooth Base UUID and is commonly used for simple Bluetooth applications.
* Regardless of the UUID used, it must match the one that the Armatus Android app is searching
* for.
*/
uint32_t svc_uuid_int[] = { 0x01110000, 0x00100000, 0x80000080, 0xFB349B5F };
const char *service_name = "Armatus Bluetooth server";
const char *svc_dsc = "A HERMIT server that interfaces with the Armatus Android app";
const char *service_prov = "Armatus";
uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid,
svc_class_uuid;
sdp_list_t *l2cap_list = 0,
*rfcomm_list = 0,
*root_list = 0,
*proto_list = 0,
*access_proto_list = 0,
*svc_class_list = 0,
*profile_list = 0;
sdp_data_t *channel = 0;
sdp_profile_desc_t profile;
sdp_record_t record = { 0 };
sdp_session_t *session = 0;
// set the general service ID
sdp_uuid128_create(&svc_uuid, &svc_uuid_int);
sdp_set_service_id(&record, svc_uuid);
char str[256] = "";
sdp_uuid2strn(&svc_uuid, str, 256);
printf("Registering UUID %s\n", str);
// set the service class
sdp_uuid16_create(&svc_class_uuid, SERIAL_PORT_SVCLASS_ID);
svc_class_list = sdp_list_append(0, &svc_class_uuid);
sdp_set_service_classes(&record, svc_class_list);
// set the Bluetooth profile information
sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
profile.version = 0x0100;
profile_list = sdp_list_append(0, &profile);
sdp_set_profile_descs(&record, profile_list);
// make the service record publicly browsable
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root_list = sdp_list_append(0, &root_uuid);
sdp_set_browse_groups(&record, root_list);
// set l2cap information
sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
l2cap_list = sdp_list_append(0, &l2cap_uuid);
proto_list = sdp_list_append(0, l2cap_list);
// register the RFCOMM channel for RFCOMM sockets
sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
sdp_list_append(rfcomm_list, channel);
sdp_list_append(proto_list, rfcomm_list);
access_proto_list = sdp_list_append(0, proto_list);
sdp_set_access_protos(&record, access_proto_list);
// set the name, provider, and description
sdp_set_info_attr(&record, service_name, service_prov, svc_dsc);
// connect to the local SDP server, register the service record,
// and disconnect
session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
sdp_record_register(session, &record, 0);
// cleanup
sdp_data_free(channel);
sdp_list_free(l2cap_list, 0);
sdp_list_free(rfcomm_list, 0);
sdp_list_free(root_list, 0);
sdp_list_free(access_proto_list, 0);
sdp_list_free(svc_class_list, 0);
sdp_list_free(profile_list, 0);
return session;
}
static sdp_record_t *panu_record(void)
{
sdp_list_t *svclass, *pfseq, *apseq, *root, *aproto;
uuid_t root_uuid, panu, l2cap, bnep;
sdp_profile_desc_t profile[1];
sdp_list_t *proto[2];
sdp_data_t *v, *p;
uint16_t psm = BNEP_PSM, version = 0x0100;
uint16_t security = 0x0001, type = 0xfffe;
uint32_t rate = 0;
const char *desc = "PAN User", *name = "Network Service";
sdp_record_t *record;
uint16_t ptype[] = { 0x0800, /* IPv4 */ 0x0806, /* ARP */ };
sdp_data_t *head, *pseq, *data;
record = sdp_record_alloc();
if (!record)
return NULL;
record->attrlist = NULL;
record->pattern = NULL;
sdp_uuid16_create(&panu, PANU_SVCLASS_ID);
svclass = sdp_list_append(NULL, &panu);
sdp_set_service_classes(record, svclass);
sdp_uuid16_create(&profile[0].uuid, PANU_PROFILE_ID);
profile[0].version = 0x0100;
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_set_profile_descs(record, pfseq);
sdp_set_info_attr(record, name, NULL, desc);
sdp_attr_add_new(record, SDP_ATTR_NET_ACCESS_TYPE, SDP_UINT16, &type);
sdp_attr_add_new(record, SDP_ATTR_MAX_NET_ACCESSRATE,
SDP_UINT32, &rate);
sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append(NULL, &root_uuid);
sdp_set_browse_groups(record, root);
sdp_uuid16_create(&l2cap, L2CAP_UUID);
proto[0] = sdp_list_append(NULL, &l2cap);
p = sdp_data_alloc(SDP_UINT16, &psm);
proto[0] = sdp_list_append(proto[0], p);
apseq = sdp_list_append(NULL, proto[0]);
sdp_uuid16_create(&bnep, BNEP_UUID);
proto[1] = sdp_list_append(NULL, &bnep);
v = sdp_data_alloc(SDP_UINT16, &version);
proto[1] = sdp_list_append(proto[1], v);
head = sdp_data_alloc(SDP_UINT16, &ptype[0]);
data = sdp_data_alloc(SDP_UINT16, &ptype[1]);
sdp_seq_append(head, data);
pseq = sdp_data_alloc(SDP_SEQ16, head);
proto[1] = sdp_list_append(proto[1], pseq);
apseq = sdp_list_append(apseq, proto[1]);
aproto = sdp_list_append(NULL, apseq);
sdp_set_access_protos(record, aproto);
sdp_add_lang_attr(record);
sdp_attr_add_new(record, SDP_ATTR_SECURITY_DESC, SDP_UINT16, &security);
sdp_data_free(p);
sdp_data_free(v);
sdp_list_free(apseq, NULL);
sdp_list_free(root, NULL);
sdp_list_free(aproto, NULL);
sdp_list_free(proto[0], NULL);
sdp_list_free(proto[1], NULL);
sdp_list_free(svclass, NULL);
sdp_list_free(pfseq, NULL);
return record;
}
