source: source/ariba/utility/transport/rfcomm/rfcomm.cpp@ 5424

Last change on this file since 5424 was 5424, checked in by mies, 15 years ago
File size: 9.7 KB
Line 
1#include "rfcomm.hpp"
2
3#include "../asio/asio_io_service.h"
4#include "../asio/rfcomm.hpp"
5#include "../asio/bluetooth_endpoint.hpp"
6
7#include <boost/asio.hpp>
8#include <boost/thread.hpp>
9#include <boost/array.hpp>
10#include <memory.h>
11#include <deque>
12#include <cerrno>
13
14namespace ariba {
15namespace transport {
16
17use_logging_cpp(rfcomm)
18
19using namespace boost::asio;
20using namespace detail;
21using namespace std;
22
23using boost::system::error_code;
24
25class link_data {
26public:
27 uint8_t size_[4];
28 size_t size;
29 uint8_t* buffer;
30};
31
32class link_info {
33public:
34 link_info(io_service& io ) :
35 io(io), up(false), local(), remote(), socket(new bluetooth::rfcomm::socket(io)), connect_retries(0),
36 size(0), buffer(NULL), sending(false) {
37 }
38
39 ~link_info() {
40 delete socket;
41 }
42
43 void reinit() {
44 delete socket;
45 socket = new bluetooth::rfcomm::socket(io);
46 up = false;
47 }
48
49 io_service& io;
50
51 // state
52 bool up;
53 rfcomm_endpoint local, remote;
54 bluetooth::rfcomm::socket* socket;
55 int connect_retries;
56
57 // read buffer
58 uint8_t size_[4];
59 size_t size;
60 uint8_t* buffer;
61
62 // send buffer
63 bool sending;
64 boost::mutex mutex;
65 std::deque<link_data> send_buffer;
66};
67
68void rfcomm::shutdown(link_info* info) {
69 if (info != NULL && info->up) {
70 info->up = false;
71 info->socket->shutdown( bluetooth::rfcomm::socket::shutdown_both );
72 }
73}
74
75
76inline bluetooth::rfcomm::endpoint convert( const rfcomm_endpoint& endpoint ) {
77 return bluetooth::rfcomm::endpoint(
78 endpoint.mac().bluetooth(), endpoint.channel().value()
79 );
80}
81
82inline rfcomm_endpoint convert( const bluetooth::rfcomm::endpoint& endpoint ) {
83 mac_address mac;
84 mac.bluetooth( endpoint.address() );
85 rfcomm_channel_address channel;
86 channel.value( endpoint.channel() );
87 return rfcomm_endpoint( mac, channel );
88}
89
90
91rfcomm::rfcomm(uint16_t channel) :
92 channel(channel), io(asio_io_service::alloc()) {
93 accept_retries = 0;
94}
95
96rfcomm::~rfcomm() {
97 asio_io_service::free();
98}
99
100void rfcomm::start() {
101
102 // start io service
103 asio_io_service::start();
104
105 // create acceptor
106 logging_info( "Binding to channel " << channel );
107 acceptor = new bluetooth::rfcomm::acceptor(io,
108 bluetooth::rfcomm::endpoint(bluetooth::rfcomm::get(), channel )
109 );
110
111 send_data = new link_data();
112
113 // start accepting
114 start_accept();
115}
116
117void rfcomm::stop() {
118 logging_info( "Stopping asio rfcomm" );
119}
120
121void rfcomm::send(const address_v* remote, const uint8_t* data, size_t size) {
122
123 // get end-point
124 rfcomm_endpoint endpoint = *remote;
125 endpoint = convert(convert(endpoint));
126
127 // try to find established connector
128 logging_debug("Trying to find a already existing link.");
129 link_info* info = NULL;
130 for (size_t i = 0; i < links.size(); i++)
131 if (links[i]->remote.mac() == endpoint.mac()) {
132 logging_debug("Using already established link");
133 info = links[i];
134 break;
135 }
136
137 // not found, or not up? ->try to (re-)connect
138 if (info==NULL || !info->up || info->socket->is_open() ) {
139 logging_debug( "Connecting to " << endpoint.to_string() );
140 if (info != NULL && (!info->up || !info->socket->is_open())) {
141 logging_debug("Old link is down. Trying to re-establish link.");
142 info->reinit();
143 } else {
144 info = new link_info(io);
145 }
146 info->connect_retries = 0;
147 info->remote = endpoint;
148 info->socket->async_connect( convert(endpoint), boost::bind(
149 &rfcomm::handle_connect, this,
150 boost::asio::placeholders::error, info
151 ));
152 asio_io_service::start();
153 }
154
155 // copy message
156 link_data ldata;
157 ldata.size = size;
158 ldata.size_[0] = (size >> 24) & 0xFF;
159 ldata.size_[1] = (size >> 16) & 0xFF;
160 ldata.size_[2] = (size >> 8) & 0xFF;
161 ldata.size_[3] = (size >> 0) & 0xFF;
162 ldata.buffer = new uint8_t[size];
163 memcpy(ldata.buffer, data, size);
164
165 // enqueue message
166 info->mutex.lock();
167 info->send_buffer.push_back(ldata);
168 info->mutex.unlock();
169
170 // start writing
171 start_write(info);
172}
173
174void rfcomm::send(const endpoint_set& endpoints, const uint8_t* data, size_t size) {
175 // send a message to each combination of mac-address and channel
176 BOOST_FOREACH( const mac_address mac, endpoints.bluetooth ) {
177 BOOST_FOREACH( const rfcomm_channel_address channel, endpoints.rfcomm ) {
178 rfcomm_endpoint endpoint(mac, channel);
179 address_vf vf = endpoint;
180 send(vf,data,size);
181 }
182 }
183}
184
185void rfcomm::terminate(const address_v* local, const address_v* remote) {
186 // get end-point
187 rfcomm_endpoint endpoint = *remote;
188
189 for (size_t i = 0; i < links.size(); i++)
190 if (links[i]->remote.mac() == endpoint.mac()) {
191 // close socket
192 shutdown(links[i]);
193 break;
194 }
195}
196
197void rfcomm::register_listener(transport_listener* listener) {
198 this->listener = listener;
199}
200
201void rfcomm::start_accept() {
202
203 logging_info( "Waiting for connections ..." );
204
205 // start accepting a connection
206 link_info* info = new link_info(io);
207 acceptor->async_accept(*info->socket, boost::bind(
208 // bind parameters
209 &rfcomm::handle_accept, this,
210
211 // handler parameters
212 boost::asio::placeholders::error, info
213 ));
214 asio_io_service::start();
215}
216
217void rfcomm::handle_accept(const error_code& error, link_info* info) {
218 if (error) {
219 logging_error( "Error waiting for new connections. Error code: "<< error.message()
220 << ", trying to recover (attempt " << accept_retries << ")");
221
222 // restart accepting
223 if (accept_retries<3) {
224 accept_retries++;
225 start_accept();
226 } else
227 delete info;
228
229 return;
230 }
231
232 links_mutex.lock();
233
234 // convert endpoints
235 info->up = true;
236 info->local = convert( info->socket->local_endpoint() );
237 info->remote = convert( info->socket->remote_endpoint() );
238
239 logging_debug("Accepted incoming connection from "
240 << info->remote.to_string() );
241
242 // add to list
243 links.push_back(info);
244 links_mutex.unlock();
245
246 // start i/o
247 start_read(info);
248 start_write(info);
249
250 // restart accept
251 start_accept();
252}
253
254void rfcomm::handle_connect( const error_code& error, link_info* info ) {
255 if (error) {
256 logging_error( "Can not connect. Error code: "
257 << error.message() << " Retrying ... "
258 "(attempt " << info->connect_retries << ")" );
259
260 // do we retry this connection? yes->
261 if (info->connect_retries<3) {
262 // increase counter
263 info->connect_retries++;
264 info->reinit();
265
266 // retry connection attempt
267 info->socket->async_connect( convert(info->remote), boost::bind(
268 &rfcomm::handle_connect, this,
269 boost::asio::placeholders::error, info
270 ));
271
272 } else { // no-> delete link and stop
273 return;
274 }
275 }
276
277 // convert endpoints
278 info->up = true;
279 info->local = convert( info->socket->local_endpoint() );
280 info->remote = convert( info->socket->remote_endpoint() );
281
282 logging_debug( "Connected to " << info->remote.to_string() );
283
284 // add to list
285 links_mutex.lock();
286 links.push_back(info);
287 links_mutex.unlock();
288
289 // start i/o
290 start_read(info);
291 start_write(info);
292}
293
294void rfcomm::start_read(link_info* info) {
295 // start read
296 boost::asio::async_read(*info->socket,
297
298 // read size of packet
299 boost::asio::buffer(info->size_, 4),
300
301 // bind handler
302 boost::bind(
303
304 // bind parameters
305 &rfcomm::handle_read_header, this,
306
307 // handler parameters
308 placeholders::error, placeholders::bytes_transferred, info
309 )
310 );
311}
312
313void rfcomm::handle_read_header(const error_code& error, size_t bytes,
314 link_info* info) {
315
316 // handle error
317 if (error) {
318 logging_error("Failed to receive message payload. Error code: "
319 << error.message() );
320 shutdown(info);
321 return;
322 }
323
324 // ignore errors and wait for all data to be received
325 if (bytes != 4) return;
326
327 // get size
328 info->size = (info->size_[0]<<24) + (info->size_[1] << 16) +
329 (info->size_[2]<< 8) + (info->size_[3] << 0);
330
331 logging_debug( "Message header received -> receive message of size " << info->size );
332
333 // allocate buffer
334 info->buffer = new uint8_t[info->size];
335
336 // start read
337 boost::asio::async_read(*info->socket,
338 // read size of packet
339 boost::asio::buffer(info->buffer, info->size),
340 // bind handler
341 boost::bind(
342 // bind parameters
343 &rfcomm::handle_read_data, this,
344 // handler parameters
345 placeholders::error, placeholders::bytes_transferred, info
346 )
347 );
348}
349
350void rfcomm::handle_read_data(const error_code& error, size_t bytes,
351 link_info* info) {
352
353 // check error
354 if (error) {
355 logging_error("Failed to receive message payload. Error code: "
356 << error.message() );
357 shutdown(info);
358 return;
359 }
360
361 // wait for all data to be received
362 if (bytes != info->size)
363 return;
364
365 logging_debug( "Received message of size " << info->size );
366
367 // deliver data
368 listener->receive_message(this, info->local, info->remote, info->buffer, info->size );
369
370 // free buffers and reset size buffer
371 delete [] info->buffer;
372 for (size_t i=0; i<4; i++) info->size_[i] = 0;
373
374 start_read(info);
375}
376
377void rfcomm::start_write( link_info* info ) {
378 boost::mutex::scoped_lock(info->mutex);
379
380 // do not start writing if sending is in progress
381 if (info->sending || !info->up || info->send_buffer.size()==0) return;
382
383 logging_debug("Sending messages ...");
384
385 // safely remove data from deque
386 *send_data = info->send_buffer.front();
387 info->send_buffer.pop_front();
388
389 boost::array<boost::asio::mutable_buffer, 2> buffer;
390 buffer[0] = boost::asio::buffer(send_data->size_,4);
391 buffer[1] = boost::asio::buffer(send_data->buffer,send_data->size);
392
393 // start writing
394 boost::asio::async_write(*info->socket,
395 // read size of packet
396 buffer,
397 // bind handler
398 boost::bind(
399 // bind parameters
400 &rfcomm::handle_write_data, this,
401 // handler parameters
402 placeholders::error, placeholders::bytes_transferred,
403 info, send_data->size, send_data->buffer
404 )
405 );
406}
407
408void rfcomm::handle_write_data(const error_code& error, size_t bytes,
409 link_info* info, size_t size, uint8_t* buffer ) {
410
411 // handle error
412 if (error) {
413 logging_error( "Message sent error. Error code: "<< error.message() );
414 shutdown(info);
415 return;
416 }
417
418 // wait for all data to be sent
419 if (bytes != (size+4) )
420 return;
421
422 logging_debug( "Message sent" );
423
424 // free buffer
425 delete [] buffer;
426
427 // restart-write
428 start_write(info);
429}
430
431}} // namespace ariba::transport
Note: See TracBrowser for help on using the repository browser.