static sdp_session_t *service_connect(const bdaddr_t *src, const bdaddr_t *dst,
GIOFunc function, gpointer user_data)
{
struct bluetooth_session *session = user_data;
sdp_session_t *sdp;
GIOChannel *io;
DBG("");
sdp = sdp_connect(src, dst, SDP_NON_BLOCKING);
if (sdp == NULL)
return NULL;
io = g_io_channel_unix_new(sdp_get_socket(sdp));
if (io == NULL) {
sdp_close(sdp);
return NULL;
}
g_io_add_watch(io, G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
function, user_data);
session->io = io;
return sdp;
}
int __sdp_connect(char *target)
{
int status;
struct sockaddr_affix sa;
status = sdp_init(0);
if (status < 0)
return status;
sa.family = PF_AFFIX;
sa.devnum = hci_devnum(btdev);//HCIDEV_ANY;
if (strcmp(target, "local") == 0) {
printf("Opening local connection\n");
srvHandle = sdp_connect_local();
} else {
status = btdev_get_bda(&sa.bda, target);
if (status) {
printf("Incorrect address given\n");
return -1;
}
printf("Connecting to host %s ...\n", bda2str(&sa.bda));
srvHandle = sdp_connect(&sa);
}
if (srvHandle < 0)
return -1;
return 0;
}
int dun_sdp_search(bdaddr_t *src, bdaddr_t *dst, int *channel, int type)
{
sdp_session_t *s;
sdp_list_t *srch, *attrs, *rsp;
uuid_t svclass;
uint16_t attr;
int err;
s = sdp_connect(src, dst, 0);
if (!s) {
syslog(LOG_ERR, "Failed to connect to the SDP server. %s(%d)",
strerror(errno), errno);
return -1;
}
switch (type) {
case MROUTER:
sdp_uuid16_create(&svclass, SERIAL_PORT_SVCLASS_ID);
break;
case ACTIVESYNC:
sdp_uuid128_create(&svclass, (void *) async_uuid);
break;
case DIALUP:
sdp_uuid16_create(&svclass, DIALUP_NET_SVCLASS_ID);
break;
default:
sdp_uuid16_create(&svclass, LAN_ACCESS_SVCLASS_ID);
break;
}
srch = sdp_list_append(NULL, &svclass);
attr = SDP_ATTR_PROTO_DESC_LIST;
attrs = sdp_list_append(NULL, &attr);
err = sdp_service_search_attr_req(s, srch, SDP_ATTR_REQ_INDIVIDUAL, attrs, &rsp);
sdp_close(s);
if (err)
return 0;
for(; rsp; rsp = rsp->next) {
sdp_record_t *rec = (sdp_record_t *) rsp->data;
sdp_list_t *protos;
if (!sdp_get_access_protos(rec, &protos)) {
int ch = sdp_get_proto_port(protos, RFCOMM_UUID);
if (ch > 0) {
*channel = ch;
return 1;
}
}
}
return 0;
}
int main(int argc, char const *argv[])
{
uint32_t svc_uuid_int[] = {0, 0, 0, 0xABCD};
int status;
bdaddr_t target, source;
uuid_t svc_uuid;
sdp_list_t *response_list, *search_list, *attrid_list;
sdp_session_t *session = 0;
uint32_t range = 0x0000ffff;
uint8_t port = 0;
//connect to the SDP server running on the remote machine
str2ba(dest, &target);
str2ba(src, &source);
session = sdp_connect(&source, &target, 0);
if (session == NULL) {
perror("sdp_connect");
exit(1);
}
sdp_uuid128_create(&svc_uuid, &svc_uuid_int);
search_list = sdp_list_append(0, &svc_uuid);
attrid_list = sdp_list_append(0, &range);
//get a list of service records that have UUID 0xabcd
response_list = NULL;
status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
if (status == 0) {
sdp_list_t *proto_list = NULL;
sdp_list_t *r = response_list;
//go through each of the service records
for (; r; r = r->next) {
sdp_record_t *rec = (sdp_record_t *)r->data;
//get a list of the protocol sequences
if (sdp_get_access_protos(rec, &proto_list) == 0) {
// get the RFCOMM port number
port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
sdp_list_free(proto_list, 0);
}
sdp_record_free(rec);
}
}
sdp_list_free(response_list, 0);
sdp_list_free(search_list, 0);
sdp_list_free(attrid_list, 0);
sdp_close(session);
if (port != 0) {
printf("found service running on RFCOMM Port %d\n", port);
}
return 0;
}
static sdp_session_t *get_sdp_session(const bdaddr_t *src, const bdaddr_t *dst)
{
sdp_session_t *session;
session = get_cached_sdp_session(src, dst);
if (session)
return session;
return sdp_connect(src, dst, SDP_NON_BLOCKING);
}
void sdp_open()
{
if (!sdp_session) {
sdp_session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, 0);
}
if (!sdp_session) {
printf("%s: sdp_session invalid\n", (char*)__func__);
exit(-1);
}
}
/**
* Opens sdp_session. Note: sdp_session has global scope
*/
int sdp_open()
{
if (!sdp_session) {
sdp_session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_NON_BLOCKING);
}
if (!sdp_session) {
LOGE("%s: sdp_session invalid: %s (%d)\n", (char*)__func__, strerror(errno), errno);
return -1;
}
return 0;
}
static int detect_channel(bdaddr_t * bdaddr)
{
uuid_t group;
bdaddr_t interface;
sdp_list_t *attrid, *search, *seq, *next;
uint32_t range = 0x0000ffff;
sdp_session_t *sess;
int channel = 2;
int searchresult;
bacpy(&interface, BDADDR_ANY);
sdp_uuid16_create(&group, 0x1108);
sess = sdp_connect(&interface, bdaddr, SDP_RETRY_IF_BUSY);
if (!sess) {
fprintf(stderr, "Failed to connect to SDP server: %s\nAssuming channel %d\n",
strerror(errno), channel);
return channel;
}
attrid = sdp_list_append(0, &range);
search = sdp_list_append(0, &group);
searchresult = sdp_service_search_attr_req(sess, search,
SDP_ATTR_REQ_RANGE, attrid, &seq);
sdp_list_free(attrid, 0);
sdp_list_free(search, 0);
if (searchresult) {
fprintf(stderr, "Service Search failed: %s\nAssuming channel %d\n",
strerror(errno), channel);
sdp_close(sess);
return channel;
}
for (; seq; seq = next) {
sdp_record_t *rec = (sdp_record_t *) seq->data;
sdp_list_t *list = 0;
if (sdp_get_access_protos(rec, &list) == 0) {
channel = sdp_get_proto_port(list, RFCOMM_UUID);
}
next = seq->next;
free(seq);
sdp_record_free(rec);
}
sdp_close(sess);
return channel;
}
bluetoothtoken_t * initBluetooth(const char *h, const int p)
{
hostname = h;
portno = p;
int s;
uuid_t svc_uuid;
struct sockaddr_rc rem_addr = { 0 };
socklen_t opt = sizeof(rem_addr);
// allocate socket
if((s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) <= 0) {
logError("failed to bind bluetooth socket: %d", s);
return NULL;
}
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) 10;
if((bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr))) == -1) {
logError("failed to bind bluetooth socket");
close(s);
return NULL;
}
logDebug("BT bound to channel %d", loc_addr.rc_channel);
// put socket into listening mode
if(listen(s, 1) == -1) {
logError("failed to setup listening mode");
close(s);
return NULL;
}
sdpSession = sdp_connect( BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY );
if(add_service(sdpSession, &recordHandle, loc_addr.rc_channel) < 0) {
logError("failed to register service @ SDP");
recordHandle = 0;
}
// sdpSession = register_service(loc_addr.rc_channel);
bluetoothtoken_t* btp = (bluetoothtoken_t*)malloc(sizeof(bluetoothtoken_t));
btp->s = s;
//not used yet:
// pthread_mutex_init(&btp->mutex, NULL);
// pthread_cond_init(&btp->condition, NULL);
return btp;
}
JNIEXPORT jboolean JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZ_populateServiceRecordAttributeValuesImpl
(JNIEnv *env, jobject peer, jlong localDeviceBTAddress, jlong remoteDeviceAddressLong, jlong sdpSession, jlong handle, jintArray attrIDs, jobject serviceRecord) {
sdp_session_t* session = (sdp_session_t*)jlong2ptr(sdpSession);
sdp_session_t* close_session_on_return = NULL;
if (session != NULL) {
debug("populateServiceRecordAttributeValuesImpl connected %p, recordHandle %li", session, handle);
} else {
debug("populateServiceRecordAttributeValuesImpl connects, recordHandle %li", handle);
bdaddr_t localAddr;
longToDeviceAddr(localDeviceBTAddress, &localAddr);
bdaddr_t remoteAddress;
longToDeviceAddr(remoteDeviceAddressLong, &remoteAddress);
session = sdp_connect(&localAddr, &remoteAddress, SDP_RETRY_IF_BUSY);
if (session == NULL) {
debug("populateServiceRecordAttributeValuesImpl can't connect");
return JNI_FALSE;
}
// Close session on exit
close_session_on_return = session;
}
sdp_list_t *attr_list = NULL;
jboolean isCopy = JNI_FALSE;
jint* ids = (*env)->GetIntArrayElements(env, attrIDs, &isCopy);
int i;
for(i = 0; i < (*env)->GetArrayLength(env, attrIDs); i++) {
uint16_t* id = (uint16_t*)malloc(sizeof(uint16_t));
*id=(uint16_t)ids[i];
attr_list = sdp_list_append(attr_list,id);
}
jboolean rc = JNI_FALSE;
sdp_record_t *sdpRecord = sdp_service_attr_req(session, (uint32_t)handle, SDP_ATTR_REQ_INDIVIDUAL, attr_list);
if (!sdpRecord) {
debug("sdp_service_attr_req return error");
rc = JNI_FALSE;
} else {
populateServiceRecord(env, serviceRecord, sdpRecord, attr_list);
sdp_record_free(sdpRecord);
rc = JNI_TRUE;
}
sdp_list_free(attr_list, free);
if (close_session_on_return != NULL) {
sdp_close(close_session_on_return);
}
return rc;
}
int main(int argc, char **argv)
{
sdp_session_t* session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
if(!session) {
printf("fail to SDP connect\n");
exit(1);
}
if(register_service(session) < 0) {
printf("fail to register service\n");
exit(1);
}
sdp_close(session);
printf("done...\n");
return 0;
}
/*
* Determine whether the given device supports Serial or Dial-Up Networking,
* and if so what the RFCOMM channel number for the service is.
*/
static int find_service_channel(bdaddr_t *adapter, bdaddr_t *device, int only_gnapplet, uint16_t svclass_id)
{
sdp_session_t *sdp = NULL;
sdp_list_t *search = NULL, *attrs = NULL, *recs = NULL, *tmp;
uuid_t browse_uuid, service_id;
uint32_t range = 0x0000ffff;
int channel = -1;
sdp = sdp_connect(adapter, device, SDP_RETRY_IF_BUSY);
if (!sdp)
goto end;
sdp_uuid16_create(&browse_uuid, PUBLIC_BROWSE_GROUP);
sdp_uuid16_create(&service_id, svclass_id);
search = sdp_list_append(NULL, &browse_uuid);
search = sdp_list_append(search, &service_id);
attrs = sdp_list_append(NULL, &range);
if (sdp_service_search_attr_req(sdp, search,
SDP_ATTR_REQ_RANGE, attrs,
&recs))
goto end;
for (tmp = recs; tmp != NULL; tmp = tmp->next) {
sdp_record_t *rec = tmp->data;
/*
* If this service is better than what we've
* previously seen, try and get the channel number.
*/
channel = get_rfcomm_channel(rec, only_gnapplet);
if (channel > 0)
goto end;
}
end:
sdp_list_free(recs, (sdp_free_func_t)sdp_record_free);
sdp_list_free(search, NULL);
sdp_list_free(attrs, NULL);
sdp_close(sdp);
return channel;
}
static uint8_t get_channel(const char *svr, uint16_t uuid)
{
sdp_session_t *sdp;
sdp_list_t *srch, *attrs, *rsp;
uuid_t svclass;
uint16_t attr;
bdaddr_t dst;
uint8_t channel = 0;
int err;
str2ba(svr, &dst);
sdp = sdp_connect(&bdaddr, &dst, SDP_RETRY_IF_BUSY);
if (!sdp)
return 0;
sdp_uuid16_create(&svclass, uuid);
srch = sdp_list_append(NULL, &svclass);
attr = SDP_ATTR_PROTO_DESC_LIST;
attrs = sdp_list_append(NULL, &attr);
err = sdp_service_search_attr_req(sdp, srch,
SDP_ATTR_REQ_INDIVIDUAL, attrs, &rsp);
if (err)
goto done;
for (; rsp; rsp = rsp->next) {
sdp_record_t *rec = (sdp_record_t *) rsp->data;
sdp_list_t *protos;
if (!sdp_get_access_protos(rec, &protos)) {
channel = sdp_get_proto_port(protos, RFCOMM_UUID);
if (channel > 0)
break;
}
}
done:
sdp_close(sdp);
return channel;
}
/*
* sdpunregister - Remove SDP entry for HID service on program termination
* Parameters: SDP handle (typically 0x10004 or similar)
*/
void sdpunregister ( uint32_t handle )
{
uint32_t range=0x0000ffff;
sdp_list_t * attr;
sdp_session_t * sess;
sdp_record_t * rec;
// Connect to the local SDP server
sess = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, 0);
if ( !sess ) return;
attr = sdp_list_append(0, &range);
rec = sdp_service_attr_req(sess, handle, SDP_ATTR_REQ_RANGE, attr);
sdp_list_free(attr, 0);
if ( !rec ) {
sdp_close(sess);
return;
}
sdp_device_record_unregister(sess, BDADDR_ANY, rec);
sdp_close(sess);
// We do not care wether unregister fails. If it does, we cannot help it.
return;
}
static sdp_session_t *get_sdp_session(const bdaddr_t *src, const bdaddr_t *dst)
{
GSList *l;
for (l = cached_sdp_sessions; l != NULL; l = l->next) {
struct cached_sdp_session *c = l->data;
sdp_session_t *session;
if (bacmp(&c->src, src) || bacmp(&c->dst, dst))
continue;
g_source_remove(c->timer);
session = c->session;
cached_sdp_sessions = g_slist_remove(cached_sdp_sessions, c);
g_free(c);
return session;
}
return sdp_connect(src, dst, SDP_NON_BLOCKING);
}
// connect
static PyObject *
sess_connect(PySDPSessionObject *s, PyObject *args, PyObject *kwds)
{
bdaddr_t src;
bdaddr_t dst;
char *dst_buf = "localhost";
uint32_t flags = SDP_RETRY_IF_BUSY;
static char *keywords[] = {"target", 0};
bacpy( &src, BDADDR_ANY );
bacpy( &dst, BDADDR_LOCAL );
if( s->session != NULL ) {
sdp_close( s->session );
}
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"|s", keywords,
&dst_buf))
return NULL;
if( strncmp( dst_buf, "localhost", 18 ) != 0 ) {
str2ba( dst_buf, &dst );
} else {
// XXX
}
Py_BEGIN_ALLOW_THREADS
s->session = sdp_connect( &src, &dst, flags );
Py_END_ALLOW_THREADS
if( s->session == NULL )
return PyErr_SetFromErrno( bluetooth_error );
Py_INCREF(Py_None);
return Py_None;
}
/* 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;
}
int discover_sdp(char* remote) {
int channel = 0;
// returns rfcomm channel
uuid_t svc_uuid;
int err;
bdaddr_t target;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
sdp_session_t *session = 0;
str2ba( remote , &target );
// connect to the SDP server running on the remote machine
if (D) printf("connecting..\n");
session = sdp_connect( BDADDR_ANY, &target, SDP_RETRY_IF_BUSY );
// specify the UUID of the application we're searching for
if (D) printf("uuid\n");
sdp_uuid128_create( &svc_uuid, &service_uuid_int );
search_list = sdp_list_append( NULL, &svc_uuid );
// specify that we want a list of all the matching applications' attributes
uint32_t range = 0x0000ffff;
attrid_list = sdp_list_append( NULL, &range );
// get a list of service records that have UUID 0xabcd
err = sdp_service_search_attr_req( session, search_list, \
SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
sdp_list_t *r = response_list;
// go through each of the service records
for (; r; r = r->next ) {
sdp_record_t *rec = (sdp_record_t*) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if( sdp_get_access_protos( rec, &proto_list ) == 0 ) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for( ; p ; p = p->next ) {
sdp_list_t *pds = (sdp_list_t*)p->data;
// go through each protocol list of the protocol sequence
for( ; pds ; pds = pds->next ) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t*)pds->data;
int proto = 0;
for( ; d; d = d->next ) {
switch( d->dtd ) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto( &d->val.uuid );
break;
case SDP_UINT8:
if( proto == RFCOMM_UUID ) {
printf("rfcomm channel: %d\n",d->val.int8);
channel = (int)d->val.int8;
}
break;
}
}
}
sdp_list_free( (sdp_list_t*)p->data, 0 );
}
sdp_list_free( proto_list, 0 );
}
printf("found service record 0x%x\n", rec->handle);
sdp_record_free( rec );
}
sdp_close(session);
return channel;
}
int main(void) {
int i, j, err, sock, dev_id = -1;
struct hci_dev_info dev_info;
inquiry_info *info = NULL;
bdaddr_t target;
char addr[19] = { 0 };
char name[248] = { 0 };
uuid_t uuid = { 0 };
//Change this to your apps UUID
char *uuid_str="4e5d48e0-75df-11e3-981f-0800200c9a66";
uint32_t range = 0x0000ffff;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
int s, loco_channel = -1, status;
struct sockaddr_rc loc_addr = { 0 };
pthread_t blueThread;
FILE *fp_Setting;
char message_Buffer[64];
char mode[30], language[16], topic[16], topicLen[16];
size_t len = 16;
(void) signal(SIGINT, SIG_DFL);
changeTopic_flag = 1;
///////////////////////////MRAA/////////////////////////////
//Initialize MRAA
mraa_init();
//Initialize MRAA Pin 8 == IO8 == GP49
mraa_gpio_context BearButton = mraa_gpio_init(8);
//Check for successful initialization or else return
if (BearButton == NULL){
printf("Error initializing Push to Talk Pin, IO2\n");
return -1;
}
//Set pin to an input
mraa_gpio_dir(BearButton, MRAA_GPIO_IN);
printf("Set Pin to an input\n");
int curr_pin = mraa_gpio_get_pin(BearButton);
printf("The current pin number is %d\n", curr_pin);
int curr_raw = mraa_gpio_get_pin_raw(BearButton);
printf("The raw pin number is %d\n", curr_raw);
printf("Going to start reading the button via polling\n");
//////////////////////AWS///////////////////////////////////
aws_flag = 0;
IoT_Error_t rc = NONE_ERROR;
char HostAddress[255] = AWS_IOT_MQTT_HOST;
char certDirectory[PATH_MAX + 1] = "/AWS/SDK/certs/";
uint32_t port = AWS_IOT_MQTT_PORT;
MQTTMessageParams Msg = MQTTMessageParamsDefault;
Msg.qos = QOS_0;
char cPayload[100];
Msg.pPayload = (void *) cPayload;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char cafileName[] = AWS_IOT_ROOT_CA_FILENAME;
char clientCRTName[] = AWS_IOT_CERTIFICATE_FILENAME;
char clientKeyName[] = AWS_IOT_PRIVATE_KEY_FILENAME;
sprintf(rootCA, "/%s/%s", certDirectory, cafileName);
sprintf(clientCRT, "/%s/%s", certDirectory, clientCRTName);
sprintf(clientKey, "/%s/%s", certDirectory, clientKeyName);
MQTTConnectParams connectParams = MQTTConnectParamsDefault;
connectParams.KeepAliveInterval_sec = 14000;
connectParams.isCleansession = true;
connectParams.MQTTVersion = MQTT_3_1_1;
connectParams.pClientID = "TED";
connectParams.pHostURL = HostAddress;
connectParams.port = port;
connectParams.isWillMsgPresent = false;
connectParams.pRootCALocation = rootCA;
connectParams.pDeviceCertLocation = clientCRT;
connectParams.pDevicePrivateKeyLocation = clientKey;
connectParams.mqttCommandTimeout_ms = 2000;
connectParams.tlsHandshakeTimeout_ms = 5000;
connectParams.isSSLHostnameVerify = true;// ensure this is set to true for production
connectParams.disconnectHandler = disconnectCallbackHandler;
MQTTPublishParams CurriculumParams = MQTTPublishParamsDefault;
CurriculumParams.pTopic = "Bear/Curriculum/Request";
MQTTPublishParams MetricsParams = MQTTPublishParamsDefault;
MetricsParams.pTopic = "Bear/Curriculum/Metrics";
///////////////////////////////////////////////////////////////////////////////////////
dev_id = hci_get_route(NULL);
if (dev_id < 0) {
perror("No Bluetooth Adapter Available");
exit(1);
}
if (hci_devinfo(dev_id, &dev_info) < 0) {
perror("Can't get device info");
exit(1);
}
sock = hci_open_dev( dev_id );
if (sock < 0) {
perror("HCI device open failed");
free(info);
exit(1);
}
if( !str2uuid( uuid_str, &uuid ) ) {
perror("Invalid UUID");
free(info);
exit(1);
}
do {
printf("Scanning ...\n");
sdp_session_t *session;
int retries;
int foundit, responses;
str2ba(TABLET_ADDRESS,&target);
memset(name, 0, sizeof(name));
if (hci_read_remote_name(sock, &target, sizeof(name), name, 0) < 0){
strcpy(name, "[unknown]");
}
printf("Found %s %s, searching for the the desired service on it now\n", addr, name);
// connect to the SDP server running on the remote machine
sdpconnect:
session = 0; retries = 0;
while(!session) {
session = sdp_connect( BDADDR_ANY, &target, SDP_RETRY_IF_BUSY );
if(session) break;
if(errno == EALREADY && retries < 5) {
perror("Retrying");
retries++;
sleep(1);
continue;
}
break;
}
if ( session == NULL ) {
perror("Can't open session with the device");
continue;
}
search_list = sdp_list_append( 0, &uuid );
attrid_list = sdp_list_append( 0, &range );
err = 0;
err = sdp_service_search_attr_req( session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
sdp_list_t *r = response_list;
sdp_record_t *rec;
// go through each of the service records
foundit = 0;
responses = 0;
for (; r; r = r->next ) {
responses++;
rec = (sdp_record_t*) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if( sdp_get_access_protos( rec, &proto_list ) == 0 ) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for( ; p ; p = p->next ) {
sdp_list_t *pds = (sdp_list_t*)p->data;
// go through each protocol list of the protocol sequence
for( ; pds ; pds = pds->next ) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t*)pds->data;
int proto = 0;
for( ; d; d = d->next ) {
switch( d->dtd ) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto( &d->val.uuid );
break;
case SDP_UINT8:
if( proto == RFCOMM_UUID ) {
printf("rfcomm channel: %d\n",d->val.int8);
loco_channel = d->val.int8;
foundit = 1;
}
break;
}
}
}
sdp_list_free( (sdp_list_t*)p->data, 0 );
}
sdp_list_free( proto_list, 0 );
}
if (loco_channel > 0)
break;
}
printf("No of Responses %d\n", responses);
if ( loco_channel > 0 && foundit == 1 ) {
printf("Found service on this device, now gonna blast it with dummy data\n");
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_channel = loco_channel;
loc_addr.rc_bdaddr = *(&target);
status = connect(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
if( status < 0 ) {
perror("uh oh");
}
rc = pthread_create(&blueThread, NULL, threadListen, (void *)s);
if (rc){
printf("ERROR: %d\n", rc);
exit(1);
}
MQTTSubscribeParams subParams = MQTTSubscribeParamsDefault;
//Loop through trying to subscribe to AWS incase the first attempt fails, so will keep trying until the app sends the edison proper network info.
do{
INFO("Connecting...");
rc = aws_iot_mqtt_connect(&connectParams);
if (NONE_ERROR != rc) {
ERROR("Error(%d) connecting to %s:%d", rc, connectParams.pHostURL, connectParams.port);
}
subParams.mHandler = MQTTcallbackHandler;
subParams.pTopic = "Bear/Curriculum/Response";
subParams.qos = QOS_0;
if (NONE_ERROR == rc) {
INFO("Subscribing...");
rc = aws_iot_mqtt_subscribe(&subParams);
if (NONE_ERROR != rc) {
ERROR("Error subscribing");
}
}
sleep(1);
}while(NONE_ERROR != rc);
aws_flag = 1;
//////////////////////////Start of teaching stuff//////////////////////////////////////////
do {
if(changeTopic_flag){
sprintf(cPayload, "{\"BearID\":\"%s\"}",BEARID);
Msg.PayloadLen = strlen(cPayload) + 1;
CurriculumParams.MessageParams = Msg;
rc = aws_iot_mqtt_publish(&CurriculumParams);
while(rc == NONE_ERROR && changeTopic_flag){
rc = aws_iot_mqtt_yield(100);
INFO("-->sleep");
sleep(1);
}
changeTopic_flag = 0;
}
fp_Setting = fopen("/Curriculum/BearSettings.txt", "r");
fgets(language, sizeof(language), fp_Setting);
fgets(mode, sizeof(mode), fp_Setting);
fgets(topic, sizeof(topic), fp_Setting);
fgets(topicLen, sizeof(topicLen), fp_Setting);
language[strlen(language)-1] = 0;
mode[strlen(mode)-1] = 0;
topic[strlen(topic)-1] = 0;
topicLen[strlen(topicLen)-1] = 0;
fclose(fp_Setting);
//Wait for the tablet to tell the edison to start the lesson
while(strcmp(threadMessage, "learning")){
printf("Waiting for learning, got: %s\n", threadMessage);
if(!strcmp(threadMessage, "crash")){
memset(threadMessage, 0, sizeof(threadMessage));
goto CRASHED;
}
memset(threadMessage, 0, sizeof(threadMessage));
sleep(1);
}
printf("Current Mode: %s\n", mode);
printf("Current Language: %s\n", language);
printf("Current topic: %s\n", topic);
//Call a different function depending on what teaching mode it is, also write to the tablet based on the topic info and lesson
if(!strcmp(mode, "Repeat After Me")){
sprintf(message_Buffer,"%s,1,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
if(!strcmp(language, "English")){
status = repeat_after_me_english(s, topic, MetricsParams, BearButton);
}
else{
status = repeat_after_me_foreign(s, language, topic, MetricsParams, BearButton);
}
}
else if(!strcmp(mode, "English to Foreign")){
sprintf(message_Buffer,"%s,3,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
status = english_to_foreign(s, language, topic, MetricsParams, BearButton);
}
else if(!strcmp(mode, "Foreign to English")){
sprintf(message_Buffer,"%s,2,%s",language, topicLen);
status = write(s,message_Buffer,sizeof(message_Buffer));
status = foreign_to_english(s, language, topic, MetricsParams, BearButton);
}
changeTopic_flag = 1;
printf("Changing Topic");
sleep(5);
} while (status > 0);
CRASHED:
printf("\nBluetooth Disconnected\n");
close(s);
sdp_record_free( rec );
}
sdp_close(session);
if (loco_channel > 0) {
goto sdpconnect;
//break;
}
sleep(1);
} while (1);
printf("Exiting...\n");
}
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;
}
// Detect whether A2DP Sink is present at the destination or not
static int detect_a2dp(bdaddr_t *src, bdaddr_t *dst, unsigned short *psm, unsigned long *flags)
{
sdp_session_t *sess;
sdp_list_t *attrid, *search, *seq, *next;
sdp_data_t *pdlist;
uuid_t group;
uint32_t range = 0x0000ffff;
int err;
int tries;
tries = 0;
while(!(sess = sdp_connect(src, dst, SDP_RETRY_IF_BUSY))) {
DBG("retrying sdp connect: %s", strerror(errno));
sleep(1);
if(++tries > 10) {
break;
}
}
if (!sess) {
DBG( "Warning: failed to connect to SDP server: %s", strerror(errno));
if(psm) *psm = 25;
if(flags) *flags = 0;
return 0;
}
/* 0x1108->all? 0x1101->rf sink 0x111e->handsfree 0x1108->headset */
sdp_uuid16_create(&group, 0x110d);
search = sdp_list_append(0, &group);
attrid = sdp_list_append(0, &range);
err = sdp_service_search_attr_req(sess, search,
SDP_ATTR_REQ_RANGE, attrid, &seq);
sdp_list_free(search, 0);
sdp_list_free(attrid, 0);
if (err) {
DBG( "Service Search failed: %s", strerror(errno));
sdp_close(sess);
return -1;
}
for (; seq; seq = next) {
sdp_record_t *rec = (sdp_record_t *) seq->data;
DBG( "Found A2DP Sink");
if (psm)
*psm = 25;
next = seq->next;
free(seq);
sdp_record_free(rec);
}
sdp_uuid16_create(&group, PNP_INFO_SVCLASS_ID);
search = sdp_list_append(0, &group);
attrid = sdp_list_append(0, &range);
err = sdp_service_search_attr_req(sess, search,
SDP_ATTR_REQ_RANGE, attrid, &seq);
sdp_list_free(search, 0);
sdp_list_free(attrid, 0);
if (err)
goto done;
if (flags)
*flags = 0;
for (; seq; seq = next) {
sdp_record_t *rec = (sdp_record_t *) seq->data;
uint16_t vendor, product, version;
pdlist = sdp_data_get(rec, 0x0201);
vendor = pdlist ? pdlist->val.uint16 : 0x0000;
pdlist = sdp_data_get(rec, 0x0202);
product = pdlist ? pdlist->val.uint16 : 0x0000;
pdlist = sdp_data_get(rec, 0x0203);
version = pdlist ? pdlist->val.uint16 : 0x0000;
DBG( "Product ID %04x:%04x:%04x", vendor, product, version);
if (vendor == 0x1310 && product == 0x0100 && version == 0x0104) {
DBG( "Enabling GCT media payload workaround");
if (flags)
*flags |= NONSPECAUDIO;
}
next = seq->next;
free(seq);
sdp_record_free(rec);
}
done:
sdp_close(sess);
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;
}
/*
* 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()
{
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 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;
}
int main(int argc, char **argv)
{
/* on Samsung Galaxy S3
Service Name: LIVIO_CONNECT
Service RecHandle: 0x1000a
Service Class ID List:
UUID 128: fbe4be12-374a-486b-a473-24e39408a24d
Protocol Descriptor List:
"L2CAP" (0x0100)
"RFCOMM" (0x0003)
*/
uint8_t svc_uuid_int[] = { 0xfb, 0xe4, 0xbe, 0x12, 0x37, 0x4a, 0x48, 0x6b,
0xa4, 0x73, 0x24, 0xe3, 0x94, 0x08, 0xa2, 0x4d};
uuid_t svc_uuid;
int err;
bdaddr_t target;
sdp_list_t *response_list = NULL, *search_list, *attrid_list;
sdp_session_t *session = 0;
if(argc < 2)
{
printf("usage: %s <bt-addr> \n",argv[0]);
exit(1);
}
str2ba( argv[1], &target );
// connect to the SDP server running on the remote machine
session = sdp_connect( BDADDR_ANY, &target, SDP_RETRY_IF_BUSY );
// specify the UUID of the application we're searching for
sdp_uuid128_create( &svc_uuid, &svc_uuid_int );
search_list = sdp_list_append( NULL, &svc_uuid );
// specify that we want a list of all the matching applications' attributes
uint32_t range = 0x0000ffff;
attrid_list = sdp_list_append( NULL, &range );
printf("starting search...\n");
// get a list of service records that have UUID 0xabcd
err = sdp_service_search_attr_req( session, search_list, \
SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
sdp_list_t *r = response_list;
printf("search completed\n");
// go through each of the service records
for (; r; r = r->next ) {
sdp_record_t *rec = (sdp_record_t*) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if( sdp_get_access_protos( rec, &proto_list ) == 0 ) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for( ; p ; p = p->next ) {
sdp_list_t *pds = (sdp_list_t*)p->data;
// go through each protocol list of the protocol sequence
for( ; pds ; pds = pds->next ) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t*)pds->data;
int proto = 0;
for( ; d; d = d->next ) {
switch( d->dtd ) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto( &d->val.uuid );
printf("\tproto: 0x%x\n", proto);
break;
case SDP_UINT8:
if( proto == RFCOMM_UUID ) {
printf("rfcomm channel: %d\n",d->val.int8);
}
break;
}
}
}
sdp_list_free( (sdp_list_t*)p->data, 0 );
}
sdp_list_free( proto_list, 0 );
}
printf("found service record 0x%x\n", rec->handle);
sdp_record_free( rec );
}
sdp_close(session);
}
int get_sdp_device_info(const bdaddr_t *src, const bdaddr_t *dst, struct hidp_connadd_req *req)
{
struct sockaddr_l2 addr;
socklen_t addrlen;
bdaddr_t bdaddr;
uint32_t range = 0x0000ffff;
sdp_session_t *s;
sdp_list_t *search, *attrid, *pnp_rsp;
sdp_record_t *rec;
sdp_data_t *pdlist;
uuid_t svclass;
int err;
s = sdp_connect(src, dst, SDP_RETRY_IF_BUSY | SDP_WAIT_ON_CLOSE);
if (!s)
return -1;
sdp_uuid16_create(&svclass, PNP_INFO_SVCLASS_ID);
search = sdp_list_append(NULL, &svclass);
attrid = sdp_list_append(NULL, &range);
err = sdp_service_search_attr_req(s, search,
SDP_ATTR_REQ_RANGE, attrid, &pnp_rsp);
sdp_list_free(search, NULL);
sdp_list_free(attrid, NULL);
memset(&addr, 0, sizeof(addr));
addrlen = sizeof(addr);
if (getsockname(s->sock, (struct sockaddr *) &addr, &addrlen) < 0)
bacpy(&bdaddr, src);
else
bacpy(&bdaddr, &addr.l2_bdaddr);
sdp_close(s);
if (err)
return -1;
if (pnp_rsp) {
rec = (sdp_record_t *) pnp_rsp->data;
pdlist = sdp_data_get(rec, 0x0201);
req->vendor = pdlist ? pdlist->val.uint16 : 0x0000;
pdlist = sdp_data_get(rec, 0x0202);
req->product = pdlist ? pdlist->val.uint16 : 0x0000;
pdlist = sdp_data_get(rec, 0x0203);
req->version = pdlist ? pdlist->val.uint16 : 0x0000;
sdp_record_free(rec);
}
req->parser = 0x0100;
req->subclass = 0xc0;
req->country = 0;
if (bacmp(&bdaddr, BDADDR_ANY))
store_device_info(&bdaddr, dst, req);
return 0;
}
uint8_t sdp_lookup_uuid_rfcomm_channel(bdaddr_t *addr, uint16_t wanted_uuid)
{
uuid_t uuid;
sdp_list_t *sdp_res, *sdp_search, *sdp_wanted_attr;
sdp_session_t *sdp_session;
uint32_t wanted_attr_range = 0xFFFF;
bdaddr_t bdaddr = *addr;
uint8_t rfcomm_channel = 0;
int err;
sdp_session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY);
if (NULL != sdp_session)
printf("Connected to target SDP server\n");
sdp_uuid16_create(&uuid, wanted_uuid);
sdp_search = sdp_list_append( NULL, &uuid );
sdp_wanted_attr = sdp_list_append( NULL, &wanted_attr_range );
// get a list of service records that have UUID 0xabcd
err = sdp_service_search_attr_req(sdp_session, sdp_search, SDP_ATTR_REQ_RANGE, sdp_wanted_attr, &sdp_res);
printf("SDP service search result: %p\n", sdp_res);
sdp_list_t *r = sdp_res;
// go through each of the service records
for (; r; r = r->next )
{
sdp_record_t *rec = (sdp_record_t*) r->data;
sdp_list_t *proto_list;
// get a list of the protocol sequences
if( sdp_get_access_protos( rec, &proto_list ) == 0 ) {
sdp_list_t *p = proto_list;
// go through each protocol sequence
for( ; p ; p = p->next ) {
sdp_list_t *pds = (sdp_list_t*)p->data;
// go through each protocol list of the protocol sequence
for( ; pds ; pds = pds->next ) {
// check the protocol attributes
sdp_data_t *d = (sdp_data_t*)pds->data;
int proto = 0;
for( ; d; d = d->next ) {
switch( d->dtd ) {
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
proto = sdp_uuid_to_proto( &d->val.uuid );
printf("Proto: %d\n", proto);
break;
case SDP_UINT8:
if( proto == RFCOMM_UUID )
{
rfcomm_channel = d->val.int8;
printf("Found RFCOMM channel: %d\n",d->val.int8);
}
break;
}
}
}
sdp_list_free( (sdp_list_t*)p->data, 0 );
}
sdp_list_free( proto_list, 0 );
}
sdp_record_free( rec );
}
sdp_close(sdp_session);
return rfcomm_channel;
}
