[4840] | 1 | // [License] |
---|
| 2 | // The Ariba-Underlay Copyright |
---|
| 3 | // |
---|
| 4 | // Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH) |
---|
| 5 | // |
---|
| 6 | // Institute of Telematics |
---|
| 7 | // UniversitÀt Karlsruhe (TH) |
---|
| 8 | // Zirkel 2, 76128 Karlsruhe |
---|
| 9 | // Germany |
---|
| 10 | // |
---|
| 11 | // Redistribution and use in source and binary forms, with or without |
---|
| 12 | // modification, are permitted provided that the following conditions are |
---|
| 13 | // met: |
---|
| 14 | // |
---|
| 15 | // 1. Redistributions of source code must retain the above copyright |
---|
| 16 | // notice, this list of conditions and the following disclaimer. |
---|
| 17 | // 2. Redistributions in binary form must reproduce the above copyright |
---|
| 18 | // notice, this list of conditions and the following disclaimer in the |
---|
| 19 | // documentation and/or other materials provided with the distribution. |
---|
| 20 | // |
---|
| 21 | // THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND |
---|
| 22 | // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
| 23 | // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
---|
| 24 | // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR |
---|
| 25 | // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
---|
| 26 | // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
---|
| 27 | // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
---|
| 28 | // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
---|
| 29 | // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
---|
| 30 | // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
---|
| 31 | // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
---|
| 32 | // |
---|
| 33 | // The views and conclusions contained in the software and documentation |
---|
| 34 | // are those of the authors and should not be interpreted as representing |
---|
| 35 | // official policies, either expressed or implied, of the Institute of |
---|
| 36 | // Telematics. |
---|
| 37 | // [License] |
---|
| 38 | |
---|
| 39 | #include "BluetoothSdp.h" |
---|
| 40 | |
---|
[4870] | 41 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 42 | |
---|
| 43 | // Attribute descriptors for SDP |
---|
| 44 | // base was chosen randomly |
---|
[4879] | 45 | #define SDP_SPOVNET_BASE 0x4000 |
---|
[4870] | 46 | #define SDP_ATTR_SPOVNET_NAME 0x0000 + SDP_SPOVNET_BASE |
---|
| 47 | #define SDP_ATTR_SPOVNET_INFO1 0x0001 + SDP_SPOVNET_BASE |
---|
| 48 | #define SDP_ATTR_SPOVNET_INFO2 0x0002 + SDP_SPOVNET_BASE |
---|
| 49 | #define SDP_ATTR_SPOVNET_INFO3 0x0003 + SDP_SPOVNET_BASE |
---|
| 50 | |
---|
| 51 | // The SpoVNet unique identifier, this should be the same for all SpoVNet implementations |
---|
| 52 | const uint8_t svc_uuid_int[] = {0x59, 0x29, 0x24, 0x34, 0x69, 0x42, 0x11, 0xde, 0x94, |
---|
| 53 | 0x3e, 0x00, 0x21, 0x5d, 0xb4, 0xd8, 0x54}; |
---|
| 54 | |
---|
| 55 | const char *service_name = "SpoVNet"; |
---|
| 56 | const char *svc_dsc = "Spontaneous Virtual Network"; |
---|
| 57 | const char *service_prov = "ITM Uni Karlsruhe"; |
---|
| 58 | |
---|
| 59 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 60 | |
---|
| 61 | |
---|
[4840] | 62 | namespace ariba { |
---|
| 63 | namespace utility { |
---|
[4970] | 64 | use_logging_cpp(BluetoothSdp); |
---|
[4840] | 65 | |
---|
[4870] | 66 | BluetoothSdp::BluetoothSdp(BootstrapInformationCallback* _callback) : |
---|
| 67 | BootstrapModule(_callback), scan_timer_(io_service_) { |
---|
| 68 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 69 | |
---|
[4970] | 70 | // This can be ignored, as the channel we really be saved in one |
---|
| 71 | // of the info strings (as an attribute) |
---|
| 72 | channel_ = 1; |
---|
[4870] | 73 | |
---|
| 74 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4840] | 75 | } |
---|
| 76 | |
---|
[4870] | 77 | BluetoothSdp::~BluetoothSdp() { |
---|
[4840] | 78 | } |
---|
| 79 | |
---|
[4870] | 80 | string BluetoothSdp::getName() { |
---|
[4840] | 81 | return "BluetoothSdp"; |
---|
| 82 | } |
---|
| 83 | |
---|
[4870] | 84 | string BluetoothSdp::getInformation() { |
---|
[4840] | 85 | return "bootstrap module based on bluetooth service discovery protocol"; |
---|
| 86 | } |
---|
| 87 | |
---|
[4870] | 88 | bool BluetoothSdp::isFunctional() { |
---|
| 89 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4903] | 90 | return true; // Not tested yet :) |
---|
[4870] | 91 | #else |
---|
[4840] | 92 | return false; |
---|
[4870] | 93 | #endif |
---|
[4840] | 94 | } |
---|
| 95 | |
---|
[4870] | 96 | void BluetoothSdp::start() { |
---|
| 97 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 98 | |
---|
| 99 | /* |
---|
| 100 | * Initializes and forks the scanner. |
---|
| 101 | */ |
---|
| 102 | |
---|
| 103 | io_service_.post(boost::bind(&BluetoothSdp::bt_scan, this)); |
---|
| 104 | t_ = boost::thread(boost::bind(&boost::asio::io_service::run, &io_service_)); |
---|
| 105 | |
---|
| 106 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4840] | 107 | } |
---|
| 108 | |
---|
[4870] | 109 | void BluetoothSdp::stop() { |
---|
| 110 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 111 | |
---|
| 112 | /* |
---|
| 113 | * Stops the scanner. |
---|
| 114 | */ |
---|
| 115 | |
---|
| 116 | // not sure if this is thread safe |
---|
| 117 | io_service_.stop(); |
---|
| 118 | t_.join(); |
---|
| 119 | |
---|
| 120 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4840] | 121 | } |
---|
| 122 | |
---|
[4870] | 123 | void BluetoothSdp::publishService(string name, string info1, string info2, |
---|
| 124 | string info3) { |
---|
| 125 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 126 | |
---|
| 127 | /* |
---|
| 128 | * Publishes an SpoVNet SDP Service and |
---|
| 129 | * adds the arguments as info attributes. |
---|
| 130 | */ |
---|
| 131 | |
---|
[4879] | 132 | logging_info("Registering SDP service"); |
---|
[4870] | 133 | |
---|
| 134 | uint8_t rfcomm_channel = channel_; |
---|
| 135 | |
---|
| 136 | uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class_uuid; |
---|
| 137 | sdp_list_t *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = |
---|
| 138 | 0, *access_proto_list = 0, *svc_class_list = 0, *profile_list = 0; |
---|
| 139 | sdp_data_t *channel = 0; |
---|
| 140 | sdp_profile_desc_t profile; |
---|
| 141 | sdp_record_t record = {0}; |
---|
| 142 | sdp_session_ = 0; |
---|
| 143 | |
---|
| 144 | bdaddr_t bdaddr_any = (bdaddr_t) { {0, 0, 0, 0, 0, 0}}; |
---|
| 145 | bdaddr_t bdaddr_local = (bdaddr_t) { {0, 0, 0, 0xff, 0xff, 0xff}}; |
---|
| 146 | |
---|
| 147 | // prepare the info attribute buffers |
---|
[4970] | 148 | //string namebuf, info1buf, info2buf, info3buf; |
---|
[4894] | 149 | uint8_t namelen, info1len, info2len, info3len; |
---|
| 150 | |
---|
[4870] | 151 | namelen = (uint8_t)name.length(); |
---|
| 152 | info1len = (uint8_t)info1.length(); |
---|
| 153 | info2len = (uint8_t)info2.length(); |
---|
| 154 | info3len = (uint8_t)info3.length(); |
---|
| 155 | |
---|
| 156 | if((namelen > 256) || (info1len > 256) || (info2len > 256) || (info3len > 256)) { |
---|
| 157 | logging_error("String Argument too long, max size is 256!"); |
---|
| 158 | return; |
---|
| 159 | } |
---|
| 160 | |
---|
[4970] | 161 | // we need to save the string len for sdp; do we? |
---|
| 162 | /* |
---|
[4870] | 163 | namebuf = (char)namelen; |
---|
| 164 | namebuf.append(name); |
---|
| 165 | info1buf = (char)info1len; |
---|
| 166 | info1buf.append(info1); |
---|
| 167 | info2buf = (char)info2len; |
---|
| 168 | info2buf.append(info2); |
---|
| 169 | info3buf = (char)info3len; |
---|
| 170 | info3buf.append(info3); |
---|
[4970] | 171 | */ |
---|
[4870] | 172 | |
---|
| 173 | // set the general service ID |
---|
| 174 | sdp_uuid128_create(&svc_uuid, &svc_uuid_int); |
---|
| 175 | sdp_set_service_id(&record, svc_uuid); |
---|
| 176 | |
---|
| 177 | // set the service class |
---|
| 178 | sdp_uuid16_create(&svc_class_uuid, SERIAL_PORT_SVCLASS_ID); |
---|
| 179 | svc_class_list = sdp_list_append(0, &svc_class_uuid); |
---|
| 180 | sdp_set_service_classes(&record, svc_class_list); |
---|
| 181 | |
---|
| 182 | // set the Bluetooth profile information |
---|
| 183 | sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID); |
---|
| 184 | profile.version = 0x0100; |
---|
| 185 | profile_list = sdp_list_append(0, &profile); |
---|
| 186 | sdp_set_profile_descs(&record, profile_list); |
---|
| 187 | |
---|
| 188 | // make the service record publicly browsable |
---|
| 189 | sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); |
---|
| 190 | root_list = sdp_list_append(0, &root_uuid); |
---|
| 191 | sdp_set_browse_groups(&record, root_list); |
---|
| 192 | |
---|
| 193 | // set l2cap informatiint argc, char* argv[]on |
---|
| 194 | sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); |
---|
| 195 | l2cap_list = sdp_list_append(0, &l2cap_uuid); |
---|
| 196 | proto_list = sdp_list_append(0, l2cap_list); |
---|
| 197 | |
---|
| 198 | // register the RFCOMM channel for RFCOMM sockets |
---|
| 199 | sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); |
---|
| 200 | channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel); |
---|
| 201 | rfcomm_list = sdp_list_append(0, &rfcomm_uuid); |
---|
| 202 | sdp_list_append(rfcomm_list, channel); |
---|
| 203 | sdp_list_append(proto_list, rfcomm_list); |
---|
| 204 | |
---|
| 205 | access_proto_list = sdp_list_append(0, proto_list); |
---|
| 206 | sdp_set_access_protos(&record, access_proto_list); |
---|
| 207 | |
---|
| 208 | // set the name, provider, and description |
---|
| 209 | sdp_set_info_attr(&record, service_name, service_prov, svc_dsc); |
---|
| 210 | |
---|
[4904] | 211 | // add the spovnet attributes |
---|
| 212 | sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_NAME, SDP_TEXT_STR8, |
---|
[4970] | 213 | name.data()); |
---|
[4870] | 214 | |
---|
[4904] | 215 | sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO1, SDP_TEXT_STR8, |
---|
[4970] | 216 | info1.data()); |
---|
[4870] | 217 | |
---|
[4904] | 218 | sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO2, SDP_TEXT_STR8, |
---|
[4970] | 219 | info2.data()); |
---|
[4870] | 220 | |
---|
[4904] | 221 | sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO3, SDP_TEXT_STR8, |
---|
[4970] | 222 | info3.data()); |
---|
[4870] | 223 | |
---|
| 224 | // connect to the local SDP server, register the service record, |
---|
| 225 | // and disconnect |
---|
| 226 | sdp_session_ = sdp_connect(&bdaddr_any, &bdaddr_local, SDP_RETRY_IF_BUSY); |
---|
| 227 | |
---|
| 228 | if (sdp_session_ == 0) { |
---|
[4879] | 229 | logging_error( "Something is wrong with your SDP server, nothing registered" ); |
---|
[4870] | 230 | } else { |
---|
| 231 | sdp_record_register(sdp_session_, &record, 0); |
---|
| 232 | } |
---|
| 233 | |
---|
| 234 | // cleanup |
---|
| 235 | sdp_data_free(channel); |
---|
| 236 | sdp_list_free(l2cap_list, 0); |
---|
| 237 | sdp_list_free(rfcomm_list, 0); |
---|
| 238 | sdp_list_free(root_list, 0); |
---|
| 239 | sdp_list_free(access_proto_list, 0); |
---|
| 240 | sdp_list_free(svc_class_list, 0); |
---|
| 241 | sdp_list_free(profile_list, 0); |
---|
| 242 | |
---|
| 243 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4840] | 244 | } |
---|
| 245 | |
---|
[4870] | 246 | void BluetoothSdp::revokeService(string name) { |
---|
| 247 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 248 | |
---|
[4879] | 249 | logging_info("Unregistering SDP service"); |
---|
[4870] | 250 | sdp_close(sdp_session_); |
---|
| 251 | |
---|
| 252 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
[4840] | 253 | } |
---|
| 254 | |
---|
[4870] | 255 | #ifdef HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 256 | |
---|
| 257 | void BluetoothSdp::bt_scan() { |
---|
| 258 | |
---|
| 259 | |
---|
| 260 | /* |
---|
| 261 | * Scans for other bluetooth devices and starts a SDP search on them. |
---|
| 262 | * Repeats 20 seconds after the end of the scan. |
---|
| 263 | */ |
---|
| 264 | |
---|
[4879] | 265 | logging_info("Scanning for peers"); |
---|
[4870] | 266 | |
---|
| 267 | inquiry_info *ii = NULL; |
---|
| 268 | int max_rsp, num_rsp; |
---|
| 269 | int dev_id, sock, len, flags; |
---|
| 270 | int i; |
---|
| 271 | |
---|
| 272 | bdaddr_t address; |
---|
| 273 | uint8_t channel; |
---|
| 274 | |
---|
| 275 | dev_id = hci_get_route(NULL); |
---|
| 276 | sock = hci_open_dev(dev_id); |
---|
| 277 | if (dev_id < 0 || sock < 0) { |
---|
[4879] | 278 | logging_error("opening socket"); |
---|
[4870] | 279 | exit(1); |
---|
| 280 | } |
---|
| 281 | |
---|
| 282 | len = 8; |
---|
| 283 | max_rsp = 255; |
---|
| 284 | flags = IREQ_CACHE_FLUSH; |
---|
| 285 | ii = (inquiry_info*) malloc(max_rsp * sizeof(inquiry_info)); |
---|
| 286 | |
---|
| 287 | num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags); |
---|
| 288 | if (num_rsp < 0) |
---|
[4879] | 289 | logging_error("hci_inquiry"); |
---|
[4870] | 290 | |
---|
| 291 | for (i = 0; i < num_rsp; i++) { |
---|
| 292 | /* |
---|
| 293 | ba2str(&(ii + i)->bdaddr, addr); |
---|
| 294 | memset(name, 0, sizeof(name)); |
---|
| 295 | if (hci_read_remote_name(sock, &(ii + i)->bdaddr, sizeof(name), |
---|
| 296 | name, 0) < 0) |
---|
| 297 | strcpy(name, "[unknown]"); |
---|
| 298 | printf("%s %s\n", addr, name); |
---|
| 299 | */ |
---|
| 300 | |
---|
| 301 | address = (ii + i)->bdaddr; |
---|
[4905] | 302 | |
---|
[4970] | 303 | logging_info("Found peer " << ba2string(&address) << ", querying SDP.") |
---|
[4905] | 304 | |
---|
[4870] | 305 | // TODO: sdp_search can be very slow, fork it! |
---|
| 306 | sdp_search(address); |
---|
| 307 | } |
---|
| 308 | |
---|
| 309 | free(ii); |
---|
| 310 | close(sock); |
---|
| 311 | |
---|
[4879] | 312 | logging_info("Next scan in 20 seconds"); |
---|
[4870] | 313 | |
---|
| 314 | scan_timer_.expires_from_now(boost::posix_time::seconds(20)); |
---|
| 315 | scan_timer_.async_wait(boost::bind(&BluetoothSdp::bt_scan, this)); |
---|
| 316 | } |
---|
| 317 | |
---|
| 318 | void BluetoothSdp::sdp_search(bdaddr_t target) { |
---|
| 319 | |
---|
| 320 | /* |
---|
| 321 | * Searches target for SDP records with the SpoVnet uuid |
---|
| 322 | * and extracts its info attributes. |
---|
| 323 | */ |
---|
| 324 | |
---|
| 325 | int status; |
---|
| 326 | uuid_t svc_uuid; |
---|
| 327 | sdp_list_t *response_list, *search_list, *attrid_list; |
---|
| 328 | sdp_session_t *session = 0; |
---|
| 329 | uint32_t range = 0x0000ffff; |
---|
| 330 | uint8_t port = 0; |
---|
| 331 | bdaddr_t any_addr = (bdaddr_t) { {0, 0, 0, 0, 0, 0}}; |
---|
| 332 | |
---|
| 333 | // prepare the buffers for the attributes |
---|
[4905] | 334 | char name[256], info1[256], info2[256], info3[256]; |
---|
[4870] | 335 | |
---|
| 336 | // connect to the SDP server running on the remote machine |
---|
| 337 | session = sdp_connect(&any_addr, &target, 0); |
---|
| 338 | |
---|
| 339 | if (session == 0) { |
---|
[4970] | 340 | logging_error("Failed to connect to SDP server at " << ba2string(&target) <<"."); |
---|
[4870] | 341 | return; |
---|
| 342 | } |
---|
| 343 | |
---|
| 344 | sdp_uuid128_create(&svc_uuid, &svc_uuid_int); |
---|
| 345 | search_list = sdp_list_append(0, &svc_uuid); |
---|
| 346 | attrid_list = sdp_list_append(0, &range); |
---|
| 347 | |
---|
| 348 | // get a list of service records that have UUID uuid_ |
---|
| 349 | response_list = NULL; |
---|
| 350 | status = sdp_service_search_attr_req(session, search_list, |
---|
| 351 | SDP_ATTR_REQ_RANGE, attrid_list, &response_list); |
---|
| 352 | |
---|
| 353 | if (status == 0) { |
---|
| 354 | sdp_list_t *proto_list = NULL; |
---|
| 355 | sdp_list_t *r = response_list; |
---|
| 356 | |
---|
| 357 | // go through each of the service records |
---|
| 358 | for (; r; r = r->next) { |
---|
| 359 | sdp_record_t *rec = (sdp_record_t*) r->data; |
---|
| 360 | |
---|
| 361 | // get a list of the protocol sequences |
---|
| 362 | if (sdp_get_access_protos(rec, &proto_list) == 0) { |
---|
| 363 | |
---|
| 364 | // get the RFCOMM port number |
---|
| 365 | port = sdp_get_proto_port(proto_list, RFCOMM_UUID); |
---|
| 366 | |
---|
| 367 | sdp_list_free(proto_list, 0); |
---|
| 368 | |
---|
[4905] | 369 | sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_NAME, (char*)&name, 256); |
---|
| 370 | sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO1, (char*)&name, 256); |
---|
| 371 | sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO2, (char*)&name, 256); |
---|
| 372 | sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO3, (char*)&name, 256); |
---|
[4900] | 373 | |
---|
[4905] | 374 | logging_info("Remote peer name is: " << name); |
---|
| 375 | logging_info("Remote peer info1 is: " << info1); |
---|
| 376 | logging_info("Remote peer info2 is: " << info2); |
---|
| 377 | logging_info("Remote peer info3 is: " << info3); |
---|
[4970] | 378 | |
---|
| 379 | // Callback |
---|
| 380 | callback->onBootstrapServiceFound(name, info1, info2, info3); |
---|
| 381 | |
---|
[4870] | 382 | } |
---|
| 383 | sdp_record_free(rec); |
---|
| 384 | } |
---|
| 385 | } |
---|
| 386 | sdp_list_free(response_list, 0); |
---|
| 387 | sdp_list_free(search_list, 0); |
---|
| 388 | sdp_list_free(attrid_list, 0); |
---|
| 389 | sdp_close(session); |
---|
| 390 | |
---|
| 391 | } |
---|
| 392 | |
---|
[4970] | 393 | string BluetoothSdp::ba2string(bdaddr_t *ba) { |
---|
| 394 | /* |
---|
| 395 | * Returns a string holding the bt adress in human readable form. |
---|
| 396 | */ |
---|
| 397 | char *str; |
---|
| 398 | ba2str(ba, str); |
---|
| 399 | string result = str; |
---|
| 400 | return result; |
---|
| 401 | } |
---|
| 402 | |
---|
[4870] | 403 | #endif // HAVE_BLUETOOTH_BLUETOOTH_H |
---|
| 404 | |
---|
[4879] | 405 | }} //namespace ariba, utility |
---|