An Overlay-based
Virtual Network Substrate
SpoVNet

source: source/ariba/utility/bootstrap/modules/bluetoothsdp/BluetoothSdp.cpp @ 5447

Last change on this file since 5447 was 5447, checked in by Christoph Mayer, 10 years ago
File size: 11.8 KB
Line 
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
41#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
42
43        // Attribute descriptors for SDP
44        // base was chosen randomly
45        #define SDP_SPOVNET_BASE                        0x4000
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 = "www.ariba-underlay.org";
57        const char *service_prov = "ITM Uni Karlsruhe";
58
59#endif // HAVE_BLUETOOTH_BLUETOOTH_H
60
61
62namespace ariba {
63namespace utility {
64use_logging_cpp(BluetoothSdp);
65
66BluetoothSdp::BluetoothSdp(BootstrapInformationCallback* _callback) :
67        BootstrapModule(_callback), scan_timer_(io_service_) {
68        srand( time(NULL) );
69#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
70
71        // This can be ignored, as the channel we really be saved in one
72        // of the info strings (as an attribute)
73        channel_ = 1;
74
75#endif // HAVE_BLUETOOTH_BLUETOOTH_H
76}
77
78BluetoothSdp::~BluetoothSdp() {
79}
80
81string BluetoothSdp::getName() {
82        return "BluetoothSdp";
83}
84
85string BluetoothSdp::getInformation() {
86        return "bootstrap module based on bluetooth service discovery protocol";
87}
88
89bool BluetoothSdp::isFunctional() {
90#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
91        return true;
92#else
93        return false;
94#endif
95}
96
97void BluetoothSdp::start() {
98#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
99
100        /*
101         * Initializes and forks the scanner.
102         */
103
104        io_service_.post(boost::bind(&BluetoothSdp::bt_scan, this));
105        t_ = boost::thread(boost::bind(&boost::asio::io_service::run, &io_service_));
106
107#endif // HAVE_BLUETOOTH_BLUETOOTH_H
108}
109
110void BluetoothSdp::stop() {
111#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
112
113        /*
114         * Stops the scanner.
115         */
116
117        // not sure if this is thread safe
118        io_service_.stop();
119        t_.join();
120
121        if(sdp_session_ != NULL)
122                sdp_close(sdp_session_);
123
124#endif // HAVE_BLUETOOTH_BLUETOOTH_H
125}
126
127void BluetoothSdp::publishService(string name, string info1, string info2,
128                string info3) {
129#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
130
131        /*
132         * Publishes an SpoVNet SDP Service and
133         * adds the arguments as info attributes.
134         */
135
136        logging_debug("registering SDP service");
137
138        uint8_t rfcomm_channel = channel_;
139
140        uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class_uuid;
141        sdp_list_t *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list =
142        0, *access_proto_list = 0, *svc_class_list = 0, *profile_list = 0;
143        sdp_data_t *channel = 0;
144        sdp_profile_desc_t profile;
145        sdp_record_t record = {0};
146        sdp_session_ = 0;
147
148        // prepare the info attribute buffers
149        //string namebuf, info1buf, info2buf, info3buf;
150        uint8_t namelen, info1len, info2len, info3len;
151
152        namelen = (uint8_t)name.length();
153        info1len = (uint8_t)info1.length();
154        info2len = (uint8_t)info2.length();
155        info3len = (uint8_t)info3.length();
156
157        if((namelen > 256) || (info1len > 256) || (info2len > 256) || (info3len > 256)) {
158                logging_error("string argument too long, max size is 256!");
159                return;
160        }
161
162        // set the general service ID
163        sdp_uuid128_create(&svc_uuid, &svc_uuid_int);
164        sdp_set_service_id(&record, svc_uuid);
165
166        // set the service class
167        sdp_uuid16_create(&svc_class_uuid, SERIAL_PORT_SVCLASS_ID);
168        svc_class_list = sdp_list_append(0, &svc_class_uuid);
169        sdp_set_service_classes(&record, svc_class_list);
170
171        // set the Bluetooth profile information
172        sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
173        profile.version = 0x0100;
174        profile_list = sdp_list_append(0, &profile);
175        sdp_set_profile_descs(&record, profile_list);
176
177        // make the service record publicly browsable
178        sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
179        root_list = sdp_list_append(0, &root_uuid);
180        sdp_set_browse_groups(&record, root_list);
181
182        // set l2cap informatiint argc, char* argv[]on
183        sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
184        l2cap_list = sdp_list_append(0, &l2cap_uuid);
185        proto_list = sdp_list_append(0, l2cap_list);
186
187        // register the RFCOMM channel for RFCOMM sockets
188        sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
189        channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
190        rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
191        sdp_list_append(rfcomm_list, channel);
192        sdp_list_append(proto_list, rfcomm_list);
193
194        access_proto_list = sdp_list_append(0, proto_list);
195        sdp_set_access_protos(&record, access_proto_list);
196
197        // set the name, provider, and description
198        sdp_set_info_attr(&record, service_name, service_prov, svc_dsc);
199
200        // add the spovnet attributes
201        sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_NAME, SDP_TEXT_STR8,
202                        name.data());
203
204        sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO1, SDP_TEXT_STR8,
205                        info1.data());
206
207        sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO2, SDP_TEXT_STR8,
208                        info2.data());
209
210        sdp_attr_add_new(&record, SDP_ATTR_SPOVNET_INFO3, SDP_TEXT_STR8,
211                        info3.data());
212
213        // connect to the local SDP server, register the service record
214        if( sdp_session_ == NULL ){
215                sdp_session_ = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
216        }
217
218        if (sdp_session_ == NULL) {
219                logging_error( "something is wrong with your SDP server, nothing registered: " << strerror(errno) );
220        } else {
221                int ret = sdp_record_register(sdp_session_, &record, 0);
222
223                if(ret < 0){
224                        logging_error("failed registering sdp record: " << strerror(errno));
225                }else{
226                        logging_debug("sdp record registered using session " << sdp_session_);
227                }
228        }
229
230        // cleanup
231        sdp_data_free(channel);
232        sdp_list_free(l2cap_list, 0);
233        sdp_list_free(rfcomm_list, 0);
234        sdp_list_free(root_list, 0);
235        sdp_list_free(access_proto_list, 0);
236        sdp_list_free(svc_class_list, 0);
237        sdp_list_free(profile_list, 0);
238
239#endif // HAVE_BLUETOOTH_BLUETOOTH_H
240}
241
242void BluetoothSdp::revokeService(string name) {
243#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
244
245        logging_debug("unregistering SDP service");
246        sdp_close(sdp_session_);
247
248#endif // HAVE_BLUETOOTH_BLUETOOTH_H
249}
250
251#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
252
253void BluetoothSdp::bt_scan() {
254        /*
255         * Scans for other bluetooth devices and starts a SDP search on them.
256         */
257
258        logging_debug("scanning for peers");
259
260        inquiry_info *ii = NULL;
261        int max_rsp, num_rsp;
262        int dev_id, sock, len, flags;
263        int i;
264
265        bdaddr_t address;
266        uint8_t channel;
267
268        dev_id = hci_get_route(NULL);
269        sock = hci_open_dev(dev_id);
270        if (dev_id < 0 || sock < 0) {
271                logging_error("opening socket for device "
272                                << dev_id << " failed. can not scan for peers: " << strerror(errno));
273                return;
274        }
275
276        len = 8;
277        max_rsp = 255;
278        flags = IREQ_CACHE_FLUSH;
279        ii = (inquiry_info*) malloc(max_rsp * sizeof(inquiry_info));
280
281        num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
282        if (num_rsp < 0)
283                logging_error("hci_inquiry failed with " << num_rsp << ": " << strerror(errno));
284
285        for (i = 0; i < num_rsp; i++) {
286                address = (ii + i)->bdaddr;
287
288                string saddress = ba2string(&address);
289                string sname = ba2name(&address, sock);
290
291                logging_debug("found peer [" << saddress << "] [" << sname << "]");
292                sdp_search( address, sname );
293        }
294
295        free(ii);
296        close(sock);
297
298        int nextscan = (rand() % 30) + 5;
299        logging_debug("next sdp scan in " << nextscan << " seconds");
300
301        scan_timer_.expires_from_now( boost::posix_time::seconds(nextscan) );
302        scan_timer_.async_wait( boost::bind(&BluetoothSdp::bt_scan, this) );
303}
304
305void BluetoothSdp::sdp_search(bdaddr_t target, string devicename) {
306
307        /*
308         * Searches target for SDP records with the SpoVnet uuid
309         * and extracts its info attributes.
310         */
311
312        int status;
313        uuid_t svc_uuid;
314        sdp_list_t *response_list, *search_list, *attrid_list;
315        sdp_session_t *session = NULL;
316        uint32_t range = 0x0000ffff;
317        uint8_t port = 0;
318
319        // connect to the SDP server running on the remote machine
320        logging_debug("querying services from bt device ["
321                        << ba2string(&target) << "] [" << devicename << "]");
322
323        // prepare the buffers for the attributes
324        char name[256], info1[256], info2[256], info3[256];
325
326        session = sdp_connect(BDADDR_ANY, &target, SDP_RETRY_IF_BUSY);
327
328        if (session == NULL) {
329                logging_error("failed to connect to SDP server at "
330                                << ba2string(&target) << ": " << strerror(errno));
331                return;
332        }
333
334        sdp_uuid128_create(&svc_uuid, &svc_uuid_int);
335        search_list = sdp_list_append(0, &svc_uuid);
336        attrid_list = sdp_list_append(0, &range);
337
338        // get a list of service records that have UUID uuid_
339        response_list = NULL;
340        status = sdp_service_search_attr_req(session, search_list,
341                        SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
342
343        if (status == 0) {
344                sdp_list_t *proto_list = NULL;
345                sdp_list_t *r = response_list;
346
347                // go through each of the service records
348                for ( ; r != NULL; r = r->next) {
349                        sdp_record_t *rec = (sdp_record_t*) r->data;
350
351                        // get a list of the protocol sequences
352                        if (sdp_get_access_protos(rec, &proto_list) == 0) {
353
354                                // get the RFCOMM port number
355                                port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
356
357                                sdp_list_free(proto_list, 0);
358
359                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_NAME, (char*)&name, 256);
360                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO1, (char*)&info1, 256);
361                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO2, (char*)&info2, 256);
362                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO3, (char*)&info3, 256);
363
364                                logging_info("Remote peer name is: " << name);
365                                logging_info("Remote peer info1 is: " << info1);
366                                logging_info("Remote peer info2 is: " << info2);
367                                logging_info("Remote peer info3 is: " << info3);
368
369                                // Callback
370                                callback->onBootstrapServiceFound(name, info1, info2, info3);
371                        }
372                        sdp_record_free(rec);
373                }
374        } else {
375                logging_error("sdp_service_search_attr_req failed with timeout: " << strerror(errno));
376        }
377
378        sdp_list_free(response_list, 0);
379        sdp_list_free(search_list, 0);
380        sdp_list_free(attrid_list, 0);
381        sdp_close(session);
382}
383
384string BluetoothSdp::ba2string(bdaddr_t* ba) {
385        /*
386         * Returns a string holding the bt adress in human readable form.
387         */
388        char addr[32] = { 0 };
389        char str[32] = { 0 };
390        ba2str(ba, str);
391        string result = str;
392        return result;
393}
394
395string BluetoothSdp::ba2name(bdaddr_t* ba, int sock){
396
397        char name[256] = {0};
398        memset(name, 0, sizeof(name));
399
400        if( hci_read_remote_name(sock, ba, sizeof(name), name, 0) < 0 )
401                strcpy(name, "unknown");
402
403        string result = name;
404        return result;
405}
406
407#endif // HAVE_BLUETOOTH_BLUETOOTH_H
408
409}} //namespace ariba, utility
Note: See TracBrowser for help on using the repository browser.