/**
* Registers the new SDP record for HID, and returns the sdp_record_t *.
*/
sdp_record_t *sdp_register_hid(int hid_mode) {
sdp_record_t *rec = NULL;
switch (hid_mode) {
case HID_MODE_GENERIC:
rec = create_hid_generic_record();
break;
case HID_MODE_BDREMOTE:
rec = create_hid_bdremote_record();
break;
case HID_MODE_PS3KEYPAD:
rec = create_hid_ps3_keypad_record();
break;
}
int ret = -1;
if ((ret = sdp_record_register(sdp_session, rec, SDP_RECORD_PERSIST)) < 0) {
LOGE("%s: HID Device (Keyboard) Service Record registration failed\n", (char*)__func__);
return NULL;
}
return rec;
}
/* 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;
}
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;
}
static int RegisterSdp(uint8_t port)
{
int ret = 1;
// {6A841273-4A97-4eed-A299-C23D571A54E7}
// {00001101-0000-1000-8000-00805F9B34FB}
uint8_t svc_uuid_int[] = {0x00, 0x00, 0x11, 0x01, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb};
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;
sdpRecord = sdp_record_alloc();
// set the general service ID
sdp_uuid128_create(&svc_uuid, &svc_uuid_int);
sdp_set_service_id(sdpRecord, 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(sdpRecord, 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, &port);
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(sdpRecord, access_proto_list);
// set the name, provider, and description
sdp_set_info_attr(sdpRecord, "DroidCam", "", "Android Webcam");
// connect to the local SDP server, register the service record
sdpSession = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
if(sdp_record_register(sdpSession, sdpRecord, 0))
{
MSG_ERROR("Could not register Bluetooth service");
ret = 0;
}
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 ret;
}
sdp_session_t *register_service()
{
uint32_t service_uuid_int[] = { 0, 0, 0, 0xABCD };
uint8_t rfcomm_channel = 11;
const char *service_name = "Edison Test";
const char *service_dsc = "Edison Experimental";
const char *service_prov = "glfernando";
sdp_session_t *session = 0;
bdaddr_t bdaddr_local = {{0, 0, 0, 0xff, 0xff, 0xff}};
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, &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 );
// set the name, provider, and description
sdp_set_info_attr(record, service_name, service_prov, service_dsc);
// connect to the local SDP server, register the service record, and disconnect
session = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
if (!session) {
printf("session NULL , err %s\n", strerror(errno));
}
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;
}
/*
* 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;
}
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 *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;
}
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;
}
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 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;
}
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;
}
/*
* 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);
}
}
