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;
}
static int create_search_context(struct search_context **ctxt,
const bdaddr_t *src,
const bdaddr_t *dst,
uuid_t *uuid)
{
sdp_session_t *s;
GIOChannel *chan;
if (!ctxt)
return -EINVAL;
s = get_sdp_session(src, dst);
if (!s)
return -errno;
*ctxt = g_try_malloc0(sizeof(struct search_context));
if (!*ctxt) {
sdp_close(s);
return -ENOMEM;
}
bacpy(&(*ctxt)->src, src);
bacpy(&(*ctxt)->dst, dst);
(*ctxt)->session = s;
(*ctxt)->uuid = *uuid;
chan = g_io_channel_unix_new(sdp_get_socket(s));
(*ctxt)->io_id = g_io_add_watch(chan,
G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
connect_watch, *ctxt);
g_io_channel_unref(chan);
return 0;
}
int bt_cancel_discovery(const bdaddr_t *src, const bdaddr_t *dst)
{
struct search_context search, *ctxt;
GSList *match;
memset(&search, 0, sizeof(search));
bacpy(&search.src, src);
bacpy(&search.dst, dst);
/* Ongoing SDP Discovery */
match = g_slist_find_custom(context_list, &search, find_by_bdaddr);
if (!match)
return -ENODATA;
ctxt = match->data;
if (!ctxt->session)
return -ENOTCONN;
if (ctxt->io_id)
g_source_remove(ctxt->io_id);
if (ctxt->session)
sdp_close(ctxt->session);
search_context_cleanup(ctxt);
return 0;
}
int bt_cancel_discovery(const bdaddr_t *src, const bdaddr_t *dst)
{
struct search_context match, *ctxt;
GSList *l;
memset(&match, 0, sizeof(match));
bacpy(&match.src, src);
bacpy(&match.dst, dst);
/* Ongoing SDP Discovery */
l = g_slist_find_custom(context_list, &match, find_by_bdaddr);
if (l == NULL)
return -ENOENT;
ctxt = l->data;
if (!ctxt->session)
return -ENOTCONN;
delete_cached_session(ctxt->session);
if (ctxt->io_id)
g_source_remove(ctxt->io_id);
ctxt->io_id = 0;
if (ctxt->session)
sdp_close(ctxt->session);
ctxt->session = NULL;
search_context_cleanup(ctxt);
return 0;
}
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;
}
prop_dictionary_t
cfg_query(bdaddr_t *laddr, bdaddr_t *raddr, const char *service)
{
prop_dictionary_t dict;
sdp_session_t ss;
size_t i;
dict = prop_dictionary_create();
if (dict == NULL)
err(EXIT_FAILURE, "prop_dictionary_create()");
for (i = 0; i < __arraycount(cfgtype); i++) {
if (strcasecmp(service, cfgtype[i].name) == 0) {
ss = sdp_open(laddr, raddr);
if (ss == NULL)
err(EXIT_FAILURE, "SDP connection failed");
if (!cfg_search(ss, i, dict))
errx(EXIT_FAILURE, "service %s not found", service);
sdp_close(ss);
return dict;
}
}
printf("Known config types:\n");
for (i = 0; i < __arraycount(cfgtype); i++)
printf("\t%s\t%s\n", cfgtype[i].name, cfgtype[i].description);
exit(EXIT_FAILURE);
}
static gboolean search_process_cb(GIOChannel *chan, GIOCondition cond,
gpointer user_data)
{
struct search_context *ctxt = user_data;
int err = 0;
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
err = EIO;
goto failed;
}
if (sdp_process(ctxt->session) < 0)
goto failed;
return TRUE;
failed:
if (err) {
sdp_close(ctxt->session);
ctxt->session = NULL;
if (ctxt->cb)
ctxt->cb(NULL, err, ctxt->user_data);
search_context_cleanup(ctxt);
}
return FALSE;
}
void bt_clear_cached_session(const bdaddr_t *src, const bdaddr_t *dst)
{
sdp_session_t *session;
session = get_cached_sdp_session(src, dst);
if (session)
sdp_close(session);
}
void sdpreg_cleanup(void)
{
if (srvHandle < 0)
return;
sdp_close(srvHandle);
sdp_cleanup();
srvHandle = -1;
}
void sdp_remove()
{
if (sdp_record && sdp_record_unregister(sdp_session, sdp_record)) {
printf("%s: HID Device (Keyboard) Service Record unregistration failed\n", (char*)__func__);
}
sdp_close(sdp_session);
}
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;
}
static void
sess_dealloc(PySDPSessionObject *s)
{
if(s->session != NULL) {
sdp_close( s->session );
s->session = NULL;
}
s->ob_type->tp_free((PyObject *)s);
}
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 gboolean connect_watch(GIOChannel *chan, GIOCondition cond,
gpointer user_data)
{
struct search_context *ctxt = user_data;
sdp_list_t *search, *attrids;
uint32_t range = 0x0000ffff;
socklen_t len;
int sk, err = 0;
sk = g_io_channel_unix_get_fd(chan);
ctxt->io_id = 0;
len = sizeof(err);
if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &len) < 0) {
err = errno;
goto failed;
}
if (err != 0)
goto failed;
if (sdp_set_notify(ctxt->session, search_completed_cb, ctxt) < 0) {
err = EIO;
goto failed;
}
search = sdp_list_append(NULL, &ctxt->uuid);
attrids = sdp_list_append(NULL, &range);
if (sdp_service_search_attr_async(ctxt->session,
search, SDP_ATTR_REQ_RANGE, attrids) < 0) {
sdp_list_free(attrids, NULL);
sdp_list_free(search, NULL);
err = EIO;
goto failed;
}
sdp_list_free(attrids, NULL);
sdp_list_free(search, NULL);
/* Set callback responsible for update the internal SDP transaction */
ctxt->io_id = g_io_add_watch(chan,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
search_process_cb, ctxt);
return FALSE;
failed:
sdp_close(ctxt->session);
ctxt->session = NULL;
if (ctxt->cb)
ctxt->cb(NULL, -err, ctxt->user_data);
search_context_cleanup(ctxt);
return FALSE;
}
int main(int argc, char **argv)
{
struct sockaddr_rc loc_addr = {0}, rem_addr = {0};
char buff[1024] = {0};
int s = 0, client = 0, bytes_read = 1;
unsigned int opt = sizeof(rem_addr);
sdp_session_t * session = register_service();
int leftToRead = 0;
/* creamos el socket */
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
/* cargamos loc_addr para luego hacer el bind */
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = 11;
/* hacemos el bind NOTE: error check falta*/
if(bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr)) < 0)
printf("Error al hacer el bind\n");
else
printf("Hicimos el bind correctamente\n");
/* listening con tamaño cola 1 */
if (listen(s, 1) < 0)
printf("Error al hacer el listen\n");
else
printf("Hicimos el listen correctamente\n");
/* aceptamos conecciones */
printf("Esperando clientes.... \n");
client = accept(s, (struct sockaddr *)&rem_addr, &opt);
ba2str(&rem_addr.rc_bdaddr,buff);
printf("Aceptamos conexion de: %s\n", buff);
memset(buff, 0, sizeof(buff));
bytes_read = recv(client, buff, sizeof(buff), 0);
leftToRead = (int)buff[0];
printf("nos van a mandar %d bytes\n",leftToRead);
while (leftToRead > 0) {
memset(buff, 0, sizeof(buff));
bytes_read = recv(client, buff, sizeof(buff), 0);
leftToRead -= bytes_read;
if (bytes_read > 0)
printf("Recibimos %d\nDatos:%s\n", bytes_read, buff);
}
printf ("enviando...\n");
send(client, "maraca", 6, 0);
close(client);
close(s);
sdp_close(session);
return 0;
}
int main(int argc, char **argv){
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
char buf[1] = { 0 };
int s, client, bytes_read;
socklen_t opt = sizeof(rem_addr);
sdp_session_t *sdp_session;
//register the service an acquire the session
sdp_session = register_service();
for(;;){
// allocate socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// bind socket to port 1 of the first available
// local bluetooth adapter
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) SVC_CHANNEL;
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
// put socket into listening mode
fprintf(stderr, "listening\n");
listen(s, 1);
// accept one connection
fprintf(stderr, "accepting\n");
client = accept(s, (struct sockaddr *)&rem_addr, &opt);
ba2str( &rem_addr.rc_bdaddr, buf );
fprintf(stderr, "accepted connection from %s\n", buf);
memset(buf, 0, sizeof(buf));
// read data from the client
initInput();
bytes_read = 1;
while(bytes_read > 0){
bytes_read = read(client, buf, sizeof(buf));
scroll(buf[0]);
printf("received %d\n", buf[0]);
}
deinitInput();
// close connection
close(client);
close(s);
}
//close sdp session
sdp_close(sdp_session);
return 0;
}
/*
* 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 gboolean cached_session_expired(gpointer user_data)
{
struct cached_sdp_session *cached = user_data;
cached_sdp_sessions = g_slist_remove(cached_sdp_sessions, cached);
sdp_close(cached->session);
g_free(cached);
return FALSE;
}
int main(int argc, char **argv)
{
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
char buf[1024] = { 0 };
char str[1024] = { 0 };
int s, client, bytes_read;
sdp_session_t *session;
socklen_t opt = sizeof(rem_addr);
int fd = open("/sys/kernel/debug/gpio_debug/gpio40/current_value", O_RDWR);
if (fd < 0) {
printf("Error opening gpio fd %d\n", fd);
goto out;
}
session = register_service();
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) 11;
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
listen(s, 1);
do {
client = accept(s, (struct sockaddr *)&rem_addr, &opt);
ba2str( &rem_addr.rc_bdaddr, buf );
fprintf(stderr, "accepted connection from %s\n", buf);
memset(buf, 0, sizeof(buf));
while (read(client, buf, sizeof(buf)) > 0 ) {
//printf("received [%s]\n", buf);
if (*buf == '0')
write(fd, "low", 3);
else if (*buf == '1')
write(fd, "high", 4);
else
break;
}
close(client);
} while (*buf);
close(s);
sdp_close(session);
out:
return 0;
}
int add_hid(int hid_mode) {
int handle = 0x0;
int ret = sdp_open();
if (ret == 0) {
if ((handle = is_hid_sdp_record_registered()) == 0) {
sdp_record = sdp_register_hid(hid_mode);
if (sdp_record == NULL) {
LOGE("Error register sdp record: %d\n", ret);
sdp_close(sdp_session);
return ret;
}
} else {
LOGD("Nothing done; already registered\n");
sdp_close(sdp_session);
return handle;
}
sdp_close(sdp_session);
}
return sdp_record->handle;
}
int deinitBluetooth(bluetoothtoken_t *bt)
{
if (recordHandle != 0) {
del_service(sdpSession, recordHandle);
}
del_service(sdpSession, recordHandle);
sdp_close(sdpSession);
close(bt->s);
pthread_cancel(bt->thread);
//not used yet:
// pthread_mutex_destroy(&bt->mutex);
// pthread_cond_destroy(&bt->condition);
return 0;
}
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;
}
raises _bluetooth.error if something goes wrong\n\
");
// close
static PyObject *
sess_close(PySDPSessionObject *s)
{
if( s->session != NULL ) {
Py_BEGIN_ALLOW_THREADS
sdp_close( s->session );
Py_END_ALLOW_THREADS
s->session = NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
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;
}
static gboolean service_callback(GIOChannel *io, GIOCondition cond,
gpointer user_data)
{
struct callback_data *callback = user_data;
sdp_list_t *search, *attrid;
uint32_t range = 0x0000ffff;
GError *gerr = NULL;
if (cond & (G_IO_NVAL | G_IO_ERR))
goto failed;
if (sdp_set_notify(callback->sdp, search_callback, callback) < 0)
goto failed;
search = sdp_list_append(NULL, &callback->session->uuid);
attrid = sdp_list_append(NULL, &range);
if (sdp_service_search_attr_async(callback->sdp,
search, SDP_ATTR_REQ_RANGE, attrid) < 0) {
sdp_list_free(attrid, NULL);
sdp_list_free(search, NULL);
goto failed;
}
sdp_list_free(attrid, NULL);
sdp_list_free(search, NULL);
g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
process_callback, callback);
return FALSE;
failed:
sdp_close(callback->sdp);
g_set_error(&gerr, OBEX_IO_ERROR, -EIO,
"Unable to find service record");
callback->func(callback->session, gerr, callback->data);
g_clear_error(&gerr);
session_unref(callback->session);
g_free(callback);
return FALSE;
}
static int
bt_query(struct l2cap_info *info, uint16_t service_class)
{
sdp_attr_t values[BT_NUM_VALUES];
uint8_t buffer[BT_NUM_VALUES][BT_BUF_SIZE];
void *ss;
int psm = -1;
int n;
memset(buffer, 0, sizeof(buffer));
memset(values, 0, sizeof(values));
ss = sdp_open(&info->laddr, &info->raddr);
if (ss == NULL || sdp_error(ss) != 0) {
DPRINTF("Could not open SDP\n");
return (psm);
}
/* Initialize attribute values array */
for (n = 0; n != BT_NUM_VALUES; n++) {
values[n].flags = SDP_ATTR_INVALID;
values[n].vlen = BT_BUF_SIZE;
values[n].value = buffer[n];
}
/* Do SDP Service Search Attribute Request */
n = sdp_search(ss, 1, &service_class, 1, bt_attrs, BT_NUM_VALUES, values);
if (n != 0) {
DPRINTF("SDP search failed\n");
goto done;
}
/* Print attributes values */
for (n = 0; n != BT_NUM_VALUES; n++) {
if (values[n].flags != SDP_ATTR_OK)
break;
if (values[n].attr != SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST)
continue;
psm = bt_find_psm(values[n].value, values[n].value + values[n].vlen);
if (psm > -1)
break;
}
done:
sdp_close(ss);
return (psm);
}
/*
* 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 int create_search_context(struct search_context **ctxt,
const bdaddr_t *src,
const bdaddr_t *dst,
uuid_t *uuid)
{
sdp_session_t *s;
GIOChannel *chan;
uint32_t prio = 1;
int sk;
if (!ctxt)
return -EINVAL;
s = get_sdp_session(src, dst);
if (!s)
return -errno;
*ctxt = g_try_malloc0(sizeof(struct search_context));
if (!*ctxt) {
sdp_close(s);
return -ENOMEM;
}
bacpy(&(*ctxt)->src, src);
bacpy(&(*ctxt)->dst, dst);
(*ctxt)->session = s;
(*ctxt)->uuid = *uuid;
sk = sdp_get_socket(s);
/* Set low priority for the SDP connection not to interfere with
* other potential traffic.
*/
if (setsockopt(sk, SOL_SOCKET, SO_PRIORITY, &prio, sizeof(prio)) < 0)
warn("Setting SDP priority failed: %s (%d)",
strerror(errno), errno);
chan = g_io_channel_unix_new(sk);
(*ctxt)->io_id = g_io_add_watch(chan,
G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
connect_watch, *ctxt);
g_io_channel_unref(chan);
return 0;
}
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;
}
void connection_cleanup(){
if (btServerSocket != INVALID_SOCKET){
close(btServerSocket);
btServerSocket = INVALID_SOCKET;
}
if(sdpRecord != NULL)
{
sdp_record_unregister(sdpSession, sdpRecord);
sdpRecord = NULL;
}
if(sdpSession != NULL)
{
sdp_close(sdpSession);
sdpSession = NULL;
}
if (wifiServerSocket != INVALID_SOCKET)
close(wifiServerSocket);
}
