1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <netinet/in.h>
32
33 #include <bluetooth/bluetooth.h>
34 #include <bluetooth/bnep.h>
35 #include <bluetooth/sdp.h>
36
37 #include <glib.h>
38 #include <gdbus.h>
39
40 #include "log.h"
41 #include "glib-helper.h"
42 #include "btio.h"
43 #include "dbus-common.h"
44 #include "adapter.h"
45 #include "device.h"
46
47 #include "error.h"
48 #include "common.h"
49 #include "connection.h"
50
51 #define NETWORK_PEER_INTERFACE "org.bluez.Network"
52
53 typedef enum {
54 CONNECTED,
55 CONNECTING,
56 DISCONNECTED
57 } conn_state;
58
59 struct network_peer {
60 bdaddr_t src;
61 bdaddr_t dst;
62 char *path; /* D-Bus path */
63 struct btd_device *device;
64 GSList *connections;
65 };
66
67 struct network_conn {
68 DBusMessage *msg;
69 char dev[16]; /* Interface name */
70 uint16_t id; /* Role: Service Class Identifier */
71 conn_state state;
72 GIOChannel *io;
73 guint watch; /* Disconnect watch */
74 guint dc_id;
75 struct network_peer *peer;
76 };
77
78 struct __service_16 {
79 uint16_t dst;
80 uint16_t src;
81 } __attribute__ ((packed));
82
83 static DBusConnection *connection = NULL;
84 static GSList *peers = NULL;
85
find_peer(GSList * list,const char * path)86 static struct network_peer *find_peer(GSList *list, const char *path)
87 {
88 for (; list; list = list->next) {
89 struct network_peer *peer = list->data;
90
91 if (!strcmp(peer->path, path))
92 return peer;
93 }
94
95 return NULL;
96 }
97
find_connection(GSList * list,uint16_t id)98 static struct network_conn *find_connection(GSList *list, uint16_t id)
99 {
100 for (; list; list = list->next) {
101 struct network_conn *nc = list->data;
102
103 if (nc->id == id)
104 return nc;
105 }
106
107 return NULL;
108 }
109
bnep_watchdog_cb(GIOChannel * chan,GIOCondition cond,gpointer data)110 static gboolean bnep_watchdog_cb(GIOChannel *chan, GIOCondition cond,
111 gpointer data)
112 {
113 struct network_conn *nc = data;
114
115 if (connection != NULL) {
116 gboolean connected = FALSE;
117 const char *property = "";
118 emit_property_changed(connection, nc->peer->path,
119 NETWORK_PEER_INTERFACE, "Connected",
120 DBUS_TYPE_BOOLEAN, &connected);
121 emit_property_changed(connection, nc->peer->path,
122 NETWORK_PEER_INTERFACE, "Interface",
123 DBUS_TYPE_STRING, &property);
124 emit_property_changed(connection, nc->peer->path,
125 NETWORK_PEER_INTERFACE, "UUID",
126 DBUS_TYPE_STRING, &property);
127 device_remove_disconnect_watch(nc->peer->device, nc->dc_id);
128 nc->dc_id = 0;
129 if (nc->watch) {
130 g_dbus_remove_watch(connection, nc->watch);
131 nc->watch = 0;
132 }
133 }
134
135 info("%s disconnected", nc->dev);
136
137 bnep_if_down(nc->dev);
138 nc->state = DISCONNECTED;
139 memset(nc->dev, 0, sizeof(nc->dev));
140 strcpy(nc->dev, "bnep%d");
141
142 return FALSE;
143 }
144
cancel_connection(struct network_conn * nc,const char * err_msg)145 static void cancel_connection(struct network_conn *nc, const char *err_msg)
146 {
147 DBusMessage *reply;
148
149 if (nc->watch) {
150 g_dbus_remove_watch(connection, nc->watch);
151 nc->watch = 0;
152 }
153
154 if (nc->msg && err_msg) {
155 reply = btd_error_failed(nc->msg, err_msg);
156 g_dbus_send_message(connection, reply);
157 }
158
159 g_io_channel_shutdown(nc->io, TRUE, NULL);
160 g_io_channel_unref(nc->io);
161 nc->io = NULL;
162
163 nc->state = DISCONNECTED;
164 }
165
connection_destroy(DBusConnection * conn,void * user_data)166 static void connection_destroy(DBusConnection *conn, void *user_data)
167 {
168 struct network_conn *nc = user_data;
169
170 if (nc->state == CONNECTED) {
171 bnep_if_down(nc->dev);
172 bnep_kill_connection(&nc->peer->dst);
173 } else if (nc->io)
174 cancel_connection(nc, NULL);
175 }
176
disconnect_cb(struct btd_device * device,gboolean removal,void * user_data)177 static void disconnect_cb(struct btd_device *device, gboolean removal,
178 void *user_data)
179 {
180 struct network_conn *nc = user_data;
181
182 info("Network: disconnect %s", nc->peer->path);
183
184 connection_destroy(NULL, user_data);
185 }
186
bnep_setup_cb(GIOChannel * chan,GIOCondition cond,gpointer data)187 static gboolean bnep_setup_cb(GIOChannel *chan, GIOCondition cond,
188 gpointer data)
189 {
190 struct network_conn *nc = data;
191 struct bnep_control_rsp *rsp;
192 struct timeval timeo;
193 char pkt[BNEP_MTU];
194 ssize_t r;
195 int sk;
196 const char *pdev, *uuid;
197 gboolean connected;
198
199 if (cond & G_IO_NVAL)
200 return FALSE;
201
202 if (cond & (G_IO_HUP | G_IO_ERR)) {
203 error("Hangup or error on l2cap server socket");
204 goto failed;
205 }
206
207 sk = g_io_channel_unix_get_fd(chan);
208
209 memset(pkt, 0, BNEP_MTU);
210 r = read(sk, pkt, sizeof(pkt) -1);
211 if (r < 0) {
212 error("IO Channel read error");
213 goto failed;
214 }
215
216 if (r == 0) {
217 error("No packet received on l2cap socket");
218 goto failed;
219 }
220
221 errno = EPROTO;
222
223 if ((size_t) r < sizeof(*rsp)) {
224 error("Packet received is not bnep type");
225 goto failed;
226 }
227
228 rsp = (void *) pkt;
229 if (rsp->type != BNEP_CONTROL) {
230 error("Packet received is not bnep type");
231 goto failed;
232 }
233
234 if (rsp->ctrl != BNEP_SETUP_CONN_RSP)
235 return TRUE;
236
237 r = ntohs(rsp->resp);
238
239 if (r != BNEP_SUCCESS) {
240 error("bnep failed");
241 goto failed;
242 }
243
244 memset(&timeo, 0, sizeof(timeo));
245 timeo.tv_sec = 0;
246
247 setsockopt(sk, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
248
249 if (bnep_connadd(sk, BNEP_SVC_PANU, nc->dev)) {
250 error("%s could not be added", nc->dev);
251 goto failed;
252 }
253
254 bnep_if_up(nc->dev);
255 pdev = nc->dev;
256 uuid = bnep_uuid(nc->id);
257
258 g_dbus_send_reply(connection, nc->msg,
259 DBUS_TYPE_STRING, &pdev,
260 DBUS_TYPE_INVALID);
261
262 connected = TRUE;
263 emit_property_changed(connection, nc->peer->path,
264 NETWORK_PEER_INTERFACE, "Connected",
265 DBUS_TYPE_BOOLEAN, &connected);
266 emit_property_changed(connection, nc->peer->path,
267 NETWORK_PEER_INTERFACE, "Interface",
268 DBUS_TYPE_STRING, &pdev);
269 emit_property_changed(connection, nc->peer->path,
270 NETWORK_PEER_INTERFACE, "UUID",
271 DBUS_TYPE_STRING, &uuid);
272
273 nc->state = CONNECTED;
274 nc->dc_id = device_add_disconnect_watch(nc->peer->device, disconnect_cb,
275 nc, NULL);
276
277 info("%s connected", nc->dev);
278 /* Start watchdog */
279 g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
280 (GIOFunc) bnep_watchdog_cb, nc);
281 g_io_channel_unref(nc->io);
282 nc->io = NULL;
283
284 return FALSE;
285
286 failed:
287 cancel_connection(nc, "bnep setup failed");
288
289 return FALSE;
290 }
291
bnep_connect(struct network_conn * nc)292 static int bnep_connect(struct network_conn *nc)
293 {
294 struct bnep_setup_conn_req *req;
295 struct __service_16 *s;
296 struct timeval timeo;
297 unsigned char pkt[BNEP_MTU];
298 int fd;
299
300 /* Send request */
301 req = (void *) pkt;
302 req->type = BNEP_CONTROL;
303 req->ctrl = BNEP_SETUP_CONN_REQ;
304 req->uuid_size = 2; /* 16bit UUID */
305 s = (void *) req->service;
306 s->dst = htons(nc->id);
307 s->src = htons(BNEP_SVC_PANU);
308
309 memset(&timeo, 0, sizeof(timeo));
310 timeo.tv_sec = 30;
311
312 fd = g_io_channel_unix_get_fd(nc->io);
313 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
314
315 if (send(fd, pkt, sizeof(*req) + sizeof(*s), 0) < 0)
316 return -errno;
317
318 g_io_add_watch(nc->io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
319 (GIOFunc) bnep_setup_cb, nc);
320
321 return 0;
322 }
323
connect_cb(GIOChannel * chan,GError * err,gpointer data)324 static void connect_cb(GIOChannel *chan, GError *err, gpointer data)
325 {
326 struct network_conn *nc = data;
327 const char *err_msg;
328 int perr;
329
330 if (err) {
331 error("%s", err->message);
332 err_msg = err->message;
333 goto failed;
334 }
335
336 perr = bnep_connect(nc);
337 if (perr < 0) {
338 err_msg = strerror(-perr);
339 error("bnep connect(): %s (%d)", err_msg, -perr);
340 goto failed;
341 }
342
343 return;
344
345 failed:
346 cancel_connection(nc, err_msg);
347 }
348
349 /* Connect and initiate BNEP session */
connection_connect(DBusConnection * conn,DBusMessage * msg,void * data)350 static DBusMessage *connection_connect(DBusConnection *conn,
351 DBusMessage *msg, void *data)
352 {
353 struct network_peer *peer = data;
354 struct network_conn *nc;
355 const char *svc;
356 uint16_t id;
357 GError *err = NULL;
358
359 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &svc,
360 DBUS_TYPE_INVALID) == FALSE)
361 return NULL;
362
363 id = bnep_service_id(svc);
364 nc = find_connection(peer->connections, id);
365 if (!nc)
366 return btd_error_not_supported(msg);
367
368 if (nc->state != DISCONNECTED)
369 return btd_error_already_connected(msg);
370
371 nc->io = bt_io_connect(BT_IO_L2CAP, connect_cb, nc,
372 NULL, &err,
373 BT_IO_OPT_SOURCE_BDADDR, &peer->src,
374 BT_IO_OPT_DEST_BDADDR, &peer->dst,
375 BT_IO_OPT_PSM, BNEP_PSM,
376 BT_IO_OPT_OMTU, BNEP_MTU,
377 BT_IO_OPT_IMTU, BNEP_MTU,
378 BT_IO_OPT_INVALID);
379 if (!nc->io) {
380 DBusMessage *reply;
381 error("%s", err->message);
382 reply = btd_error_failed(msg, err->message);
383 g_error_free(err);
384 return reply;
385 }
386
387 nc->state = CONNECTING;
388 nc->msg = dbus_message_ref(msg);
389 nc->watch = g_dbus_add_disconnect_watch(conn,
390 dbus_message_get_sender(msg),
391 connection_destroy,
392 nc, NULL);
393
394 return NULL;
395 }
396
connection_cancel(DBusConnection * conn,DBusMessage * msg,void * data)397 static DBusMessage *connection_cancel(DBusConnection *conn,
398 DBusMessage *msg, void *data)
399 {
400 struct network_conn *nc = data;
401 const char *owner = dbus_message_get_sender(nc->msg);
402 const char *caller = dbus_message_get_sender(msg);
403
404 if (!g_str_equal(owner, caller))
405 return btd_error_not_authorized(msg);
406
407 connection_destroy(conn, nc);
408
409 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
410 }
411
connection_disconnect(DBusConnection * conn,DBusMessage * msg,void * data)412 static DBusMessage *connection_disconnect(DBusConnection *conn,
413 DBusMessage *msg, void *data)
414 {
415 struct network_peer *peer = data;
416 GSList *l;
417
418 for (l = peer->connections; l; l = l->next) {
419 struct network_conn *nc = l->data;
420
421 if (nc->state == DISCONNECTED)
422 continue;
423
424 return connection_cancel(conn, msg, nc);
425 }
426
427 return btd_error_not_connected(msg);
428 }
429
connection_get_properties(DBusConnection * conn,DBusMessage * msg,void * data)430 static DBusMessage *connection_get_properties(DBusConnection *conn,
431 DBusMessage *msg, void *data)
432 {
433 struct network_peer *peer = data;
434 struct network_conn *nc = NULL;
435 DBusMessage *reply;
436 DBusMessageIter iter;
437 DBusMessageIter dict;
438 dbus_bool_t connected;
439 const char *property;
440 GSList *l;
441
442 reply = dbus_message_new_method_return(msg);
443 if (!reply)
444 return NULL;
445
446 dbus_message_iter_init_append(reply, &iter);
447
448 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
449 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
450 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
451 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
452
453 /* Connected */
454 for (l = peer->connections; l; l = l->next) {
455 struct network_conn *tmp = l->data;
456
457 if (tmp->state != CONNECTED)
458 continue;
459
460 nc = tmp;
461 break;
462 }
463
464 connected = nc ? TRUE : FALSE;
465 dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);
466
467 /* Interface */
468 property = nc ? nc->dev : "";
469 dict_append_entry(&dict, "Interface", DBUS_TYPE_STRING, &property);
470
471 /* UUID */
472 property = nc ? bnep_uuid(nc->id) : "";
473 dict_append_entry(&dict, "UUID", DBUS_TYPE_STRING, &property);
474
475 dbus_message_iter_close_container(&iter, &dict);
476
477 return reply;
478 }
479
connection_free(struct network_conn * nc)480 static void connection_free(struct network_conn *nc)
481 {
482 if (nc->dc_id)
483 device_remove_disconnect_watch(nc->peer->device, nc->dc_id);
484
485 connection_destroy(connection, nc);
486
487 g_free(nc);
488 nc = NULL;
489 }
490
peer_free(struct network_peer * peer)491 static void peer_free(struct network_peer *peer)
492 {
493 g_slist_foreach(peer->connections, (GFunc) connection_free, NULL);
494 g_slist_free(peer->connections);
495 btd_device_unref(peer->device);
496 g_free(peer->path);
497 g_free(peer);
498 }
499
path_unregister(void * data)500 static void path_unregister(void *data)
501 {
502 struct network_peer *peer = data;
503
504 DBG("Unregistered interface %s on path %s",
505 NETWORK_PEER_INTERFACE, peer->path);
506
507 peers = g_slist_remove(peers, peer);
508 peer_free(peer);
509 }
510
511 static GDBusMethodTable connection_methods[] = {
512 { "Connect", "s", "s", connection_connect,
513 G_DBUS_METHOD_FLAG_ASYNC },
514 { "Disconnect", "", "", connection_disconnect },
515 { "GetProperties", "", "a{sv}",connection_get_properties },
516 { }
517 };
518
519 static GDBusSignalTable connection_signals[] = {
520 { "PropertyChanged", "sv" },
521 { }
522 };
523
connection_unregister(const char * path,uint16_t id)524 void connection_unregister(const char *path, uint16_t id)
525 {
526 struct network_peer *peer;
527 struct network_conn *nc;
528
529 peer = find_peer(peers, path);
530 if (!peer)
531 return;
532
533 nc = find_connection(peer->connections, id);
534 if (!nc)
535 return;
536
537 peer->connections = g_slist_remove(peer->connections, nc);
538 connection_free(nc);
539 if (peer->connections)
540 return;
541
542 g_dbus_unregister_interface(connection, path, NETWORK_PEER_INTERFACE);
543 }
544
create_peer(struct btd_device * device,const char * path,bdaddr_t * src,bdaddr_t * dst)545 static struct network_peer *create_peer(struct btd_device *device,
546 const char *path, bdaddr_t *src,
547 bdaddr_t *dst)
548 {
549 struct network_peer *peer;
550
551 peer = g_new0(struct network_peer, 1);
552 peer->device = btd_device_ref(device);
553 peer->path = g_strdup(path);
554 bacpy(&peer->src, src);
555 bacpy(&peer->dst, dst);
556
557 if (g_dbus_register_interface(connection, path,
558 NETWORK_PEER_INTERFACE,
559 connection_methods,
560 connection_signals, NULL,
561 peer, path_unregister) == FALSE) {
562 error("D-Bus failed to register %s interface",
563 NETWORK_PEER_INTERFACE);
564 peer_free(peer);
565 return NULL;
566 }
567
568 DBG("Registered interface %s on path %s",
569 NETWORK_PEER_INTERFACE, path);
570
571 return peer;
572 }
573
connection_register(struct btd_device * device,const char * path,bdaddr_t * src,bdaddr_t * dst,uint16_t id)574 int connection_register(struct btd_device *device, const char *path,
575 bdaddr_t *src, bdaddr_t *dst, uint16_t id)
576 {
577 struct network_peer *peer;
578 struct network_conn *nc;
579
580 if (!path)
581 return -EINVAL;
582
583 peer = find_peer(peers, path);
584 if (!peer) {
585 peer = create_peer(device, path, src, dst);
586 if (!peer)
587 return -1;
588 peers = g_slist_append(peers, peer);
589 }
590
591 nc = find_connection(peer->connections, id);
592 if (nc)
593 return 0;
594
595 nc = g_new0(struct network_conn, 1);
596 nc->id = id;
597 memset(nc->dev, 0, sizeof(nc->dev));
598 strcpy(nc->dev, "bnep%d");
599 nc->state = DISCONNECTED;
600 nc->peer = peer;
601
602 peer->connections = g_slist_append(peer->connections, nc);
603
604 return 0;
605 }
606
connection_init(DBusConnection * conn)607 int connection_init(DBusConnection *conn)
608 {
609 connection = dbus_connection_ref(conn);
610
611 return 0;
612 }
613
connection_exit(void)614 void connection_exit(void)
615 {
616 dbus_connection_unref(connection);
617 connection = NULL;
618 }
619