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; }