1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2009-2010 Marcel Holtmann <marcel@holtmann.org>
6 * Copyright (C) 2009-2010 Nokia Corporation
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #include <poll.h>
29 #include <sys/types.h>
30 #include <sys/socket.h>
31
32 #include <bluetooth/bluetooth.h>
33 #include <bluetooth/l2cap.h>
34 #include <bluetooth/rfcomm.h>
35 #include <bluetooth/sco.h>
36 #include <bluetooth/hci.h>
37 #include <bluetooth/hci_lib.h>
38
39 #include <glib.h>
40
41 #include "btio.h"
42
43 #define ERROR_FAILED(gerr, str, err) \
44 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_FAILED, \
45 str ": %s (%d)", strerror(err), err)
46
47 #define DEFAULT_DEFER_TIMEOUT 30
48
49 struct set_opts {
50 bdaddr_t src;
51 bdaddr_t dst;
52 int defer;
53 int sec_level;
54 uint8_t channel;
55 uint16_t psm;
56 uint16_t cid;
57 uint16_t mtu;
58 uint16_t imtu;
59 uint16_t omtu;
60 int master;
61 uint8_t mode;
62 int flushable;
63 uint8_t force_active;
64 };
65
66 struct connect {
67 BtIOConnect connect;
68 gpointer user_data;
69 GDestroyNotify destroy;
70 };
71
72 struct accept {
73 BtIOConnect connect;
74 gpointer user_data;
75 GDestroyNotify destroy;
76 };
77
78 struct server {
79 BtIOConnect connect;
80 BtIOConfirm confirm;
81 gpointer user_data;
82 GDestroyNotify destroy;
83 };
84
server_remove(struct server * server)85 static void server_remove(struct server *server)
86 {
87 if (server->destroy)
88 server->destroy(server->user_data);
89 g_free(server);
90 }
91
connect_remove(struct connect * conn)92 static void connect_remove(struct connect *conn)
93 {
94 if (conn->destroy)
95 conn->destroy(conn->user_data);
96 g_free(conn);
97 }
98
accept_remove(struct accept * accept)99 static void accept_remove(struct accept *accept)
100 {
101 if (accept->destroy)
102 accept->destroy(accept->user_data);
103 g_free(accept);
104 }
105
check_nval(GIOChannel * io)106 static gboolean check_nval(GIOChannel *io)
107 {
108 struct pollfd fds;
109
110 memset(&fds, 0, sizeof(fds));
111 fds.fd = g_io_channel_unix_get_fd(io);
112 fds.events = POLLNVAL;
113
114 if (poll(&fds, 1, 0) > 0 && (fds.revents & POLLNVAL))
115 return TRUE;
116
117 return FALSE;
118 }
119
accept_cb(GIOChannel * io,GIOCondition cond,gpointer user_data)120 static gboolean accept_cb(GIOChannel *io, GIOCondition cond,
121 gpointer user_data)
122 {
123 struct accept *accept = user_data;
124 GError *err = NULL;
125
126 /* If the user aborted this accept attempt */
127 if ((cond & G_IO_NVAL) || check_nval(io))
128 return FALSE;
129
130 if (cond & (G_IO_HUP | G_IO_ERR))
131 g_set_error(&err, BT_IO_ERROR, BT_IO_ERROR_DISCONNECTED,
132 "HUP or ERR on socket");
133
134 accept->connect(io, err, accept->user_data);
135
136 g_clear_error(&err);
137
138 return FALSE;
139 }
140
connect_cb(GIOChannel * io,GIOCondition cond,gpointer user_data)141 static gboolean connect_cb(GIOChannel *io, GIOCondition cond,
142 gpointer user_data)
143 {
144 struct connect *conn = user_data;
145 GError *gerr = NULL;
146
147 /* If the user aborted this connect attempt */
148 if ((cond & G_IO_NVAL) || check_nval(io))
149 return FALSE;
150
151 if (cond & G_IO_OUT) {
152 int err = 0, sock = g_io_channel_unix_get_fd(io);
153 socklen_t len = sizeof(err);
154
155 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
156 err = errno;
157
158 if (err)
159 g_set_error(&gerr, BT_IO_ERROR,
160 BT_IO_ERROR_CONNECT_FAILED, "%s (%d)",
161 strerror(err), err);
162 } else if (cond & (G_IO_HUP | G_IO_ERR))
163 g_set_error(&gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
164 "HUP or ERR on socket");
165
166 conn->connect(io, gerr, conn->user_data);
167
168 if (gerr)
169 g_error_free(gerr);
170
171 return FALSE;
172 }
173
server_cb(GIOChannel * io,GIOCondition cond,gpointer user_data)174 static gboolean server_cb(GIOChannel *io, GIOCondition cond,
175 gpointer user_data)
176 {
177 struct server *server = user_data;
178 int srv_sock, cli_sock;
179 GIOChannel *cli_io;
180
181 /* If the user closed the server */
182 if ((cond & G_IO_NVAL) || check_nval(io))
183 return FALSE;
184
185 srv_sock = g_io_channel_unix_get_fd(io);
186
187 cli_sock = accept(srv_sock, NULL, NULL);
188 if (cli_sock < 0)
189 return TRUE;
190
191 cli_io = g_io_channel_unix_new(cli_sock);
192
193 g_io_channel_set_close_on_unref(cli_io, TRUE);
194 g_io_channel_set_flags(cli_io, G_IO_FLAG_NONBLOCK, NULL);
195
196 if (server->confirm)
197 server->confirm(cli_io, server->user_data);
198 else
199 server->connect(cli_io, NULL, server->user_data);
200
201 g_io_channel_unref(cli_io);
202
203 return TRUE;
204 }
205
server_add(GIOChannel * io,BtIOConnect connect,BtIOConfirm confirm,gpointer user_data,GDestroyNotify destroy)206 static void server_add(GIOChannel *io, BtIOConnect connect,
207 BtIOConfirm confirm, gpointer user_data,
208 GDestroyNotify destroy)
209 {
210 struct server *server;
211 GIOCondition cond;
212
213 server = g_new0(struct server, 1);
214 server->connect = connect;
215 server->confirm = confirm;
216 server->user_data = user_data;
217 server->destroy = destroy;
218
219 cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
220 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, server_cb, server,
221 (GDestroyNotify) server_remove);
222 }
223
connect_add(GIOChannel * io,BtIOConnect connect,gpointer user_data,GDestroyNotify destroy)224 static void connect_add(GIOChannel *io, BtIOConnect connect,
225 gpointer user_data, GDestroyNotify destroy)
226 {
227 struct connect *conn;
228 GIOCondition cond;
229
230 conn = g_new0(struct connect, 1);
231 conn->connect = connect;
232 conn->user_data = user_data;
233 conn->destroy = destroy;
234
235 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
236 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, connect_cb, conn,
237 (GDestroyNotify) connect_remove);
238 }
239
accept_add(GIOChannel * io,BtIOConnect connect,gpointer user_data,GDestroyNotify destroy)240 static void accept_add(GIOChannel *io, BtIOConnect connect, gpointer user_data,
241 GDestroyNotify destroy)
242 {
243 struct accept *accept;
244 GIOCondition cond;
245
246 accept = g_new0(struct accept, 1);
247 accept->connect = connect;
248 accept->user_data = user_data;
249 accept->destroy = destroy;
250
251 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
252 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, accept_cb, accept,
253 (GDestroyNotify) accept_remove);
254 }
255
l2cap_bind(int sock,const bdaddr_t * src,uint16_t psm,uint16_t cid,GError ** err)256 static int l2cap_bind(int sock, const bdaddr_t *src, uint16_t psm,
257 uint16_t cid, GError **err)
258 {
259 struct sockaddr_l2 addr;
260
261 memset(&addr, 0, sizeof(addr));
262 addr.l2_family = AF_BLUETOOTH;
263 bacpy(&addr.l2_bdaddr, src);
264
265 if (cid)
266 addr.l2_cid = htobs(cid);
267 else
268 addr.l2_psm = htobs(psm);
269
270 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
271 ERROR_FAILED(err, "l2cap_bind", errno);
272 return -1;
273 }
274
275 return 0;
276 }
277
l2cap_connect(int sock,const bdaddr_t * dst,uint16_t psm,uint16_t cid)278 static int l2cap_connect(int sock, const bdaddr_t *dst,
279 uint16_t psm, uint16_t cid)
280 {
281 int err;
282 struct sockaddr_l2 addr;
283
284 memset(&addr, 0, sizeof(addr));
285 addr.l2_family = AF_BLUETOOTH;
286 bacpy(&addr.l2_bdaddr, dst);
287 if (cid)
288 addr.l2_cid = htobs(cid);
289 else
290 addr.l2_psm = htobs(psm);
291
292 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
293 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
294 return err;
295
296 return 0;
297 }
298
l2cap_set_master(int sock,int master)299 static int l2cap_set_master(int sock, int master)
300 {
301 int flags;
302 socklen_t len;
303
304 len = sizeof(flags);
305 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, &len) < 0)
306 return -errno;
307
308 if (master) {
309 if (flags & L2CAP_LM_MASTER)
310 return 0;
311 flags |= L2CAP_LM_MASTER;
312 } else {
313 if (!(flags & L2CAP_LM_MASTER))
314 return 0;
315 flags &= ~L2CAP_LM_MASTER;
316 }
317
318 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, sizeof(flags)) < 0)
319 return -errno;
320
321 return 0;
322 }
323
rfcomm_set_master(int sock,int master)324 static int rfcomm_set_master(int sock, int master)
325 {
326 int flags;
327 socklen_t len;
328
329 len = sizeof(flags);
330 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, &len) < 0)
331 return -errno;
332
333 if (master) {
334 if (flags & RFCOMM_LM_MASTER)
335 return 0;
336 flags |= RFCOMM_LM_MASTER;
337 } else {
338 if (!(flags & RFCOMM_LM_MASTER))
339 return 0;
340 flags &= ~RFCOMM_LM_MASTER;
341 }
342
343 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, sizeof(flags)) < 0)
344 return -errno;
345
346 return 0;
347 }
348
l2cap_set_lm(int sock,int level)349 static int l2cap_set_lm(int sock, int level)
350 {
351 int lm_map[] = {
352 0,
353 L2CAP_LM_AUTH,
354 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT,
355 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE,
356 }, opt = lm_map[level];
357
358 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0)
359 return -errno;
360
361 return 0;
362 }
363
rfcomm_set_lm(int sock,int level)364 static int rfcomm_set_lm(int sock, int level)
365 {
366 int lm_map[] = {
367 0,
368 RFCOMM_LM_AUTH,
369 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT,
370 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT | RFCOMM_LM_SECURE,
371 }, opt = lm_map[level];
372
373 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0)
374 return -errno;
375
376 return 0;
377 }
378
set_force_active(int sock,BtIOType type,uint8_t force_active,GError ** err)379 static gboolean set_force_active(int sock, BtIOType type, uint8_t force_active,
380 GError **err)
381 {
382 struct bt_power pwr;
383
384 memset(&pwr, 0, sizeof(struct bt_power));
385 pwr.force_active = force_active;
386
387 if (setsockopt(sock, SOL_BLUETOOTH, BT_POWER, &pwr,
388 sizeof(pwr)) == 0)
389 return TRUE;
390
391 if (errno != ENOPROTOOPT) {
392 ERROR_FAILED(err, "setsockopt(BT_POWER)", errno);
393 return FALSE;
394 }
395
396 return TRUE;
397 }
398
set_sec_level(int sock,BtIOType type,int level,GError ** err)399 static gboolean set_sec_level(int sock, BtIOType type, int level, GError **err)
400 {
401 struct bt_security sec;
402 int ret;
403
404 if (level < BT_SECURITY_LOW || level > BT_SECURITY_HIGH) {
405 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
406 "Valid security level range is %d-%d",
407 BT_SECURITY_LOW, BT_SECURITY_HIGH);
408 return FALSE;
409 }
410
411 memset(&sec, 0, sizeof(sec));
412 sec.level = level;
413
414 if (setsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec,
415 sizeof(sec)) == 0)
416 return TRUE;
417
418 if (errno != ENOPROTOOPT) {
419 ERROR_FAILED(err, "setsockopt(BT_SECURITY)", errno);
420 return FALSE;
421 }
422
423 if (type == BT_IO_L2CAP)
424 ret = l2cap_set_lm(sock, level);
425 else
426 ret = rfcomm_set_lm(sock, level);
427
428 if (ret < 0) {
429 ERROR_FAILED(err, "setsockopt(LM)", -ret);
430 return FALSE;
431 }
432
433 return TRUE;
434 }
435
l2cap_get_lm(int sock,int * sec_level)436 static int l2cap_get_lm(int sock, int *sec_level)
437 {
438 int opt;
439 socklen_t len;
440
441 len = sizeof(opt);
442 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, &len) < 0)
443 return -errno;
444
445 *sec_level = 0;
446
447 if (opt & L2CAP_LM_AUTH)
448 *sec_level = BT_SECURITY_LOW;
449 if (opt & L2CAP_LM_ENCRYPT)
450 *sec_level = BT_SECURITY_MEDIUM;
451 if (opt & L2CAP_LM_SECURE)
452 *sec_level = BT_SECURITY_HIGH;
453
454 return 0;
455 }
456
rfcomm_get_lm(int sock,int * sec_level)457 static int rfcomm_get_lm(int sock, int *sec_level)
458 {
459 int opt;
460 socklen_t len;
461
462 len = sizeof(opt);
463 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, &len) < 0)
464 return -errno;
465
466 *sec_level = 0;
467
468 if (opt & RFCOMM_LM_AUTH)
469 *sec_level = BT_SECURITY_LOW;
470 if (opt & RFCOMM_LM_ENCRYPT)
471 *sec_level = BT_SECURITY_MEDIUM;
472 if (opt & RFCOMM_LM_SECURE)
473 *sec_level = BT_SECURITY_HIGH;
474
475 return 0;
476 }
477
get_force_active(int sock,BtIOType type,uint8_t * force_active,GError ** err)478 static gboolean get_force_active(int sock, BtIOType type, uint8_t *force_active,
479 GError **err)
480 {
481 struct bt_power pwr;
482 socklen_t len;
483
484 memset(&pwr, 0, sizeof(pwr));
485 len = sizeof(pwr);
486 if (getsockopt(sock, SOL_BLUETOOTH, BT_POWER, &pwr, &len) == 0) {
487 *force_active = pwr.force_active;
488 return TRUE;
489 }
490
491 if (errno != ENOPROTOOPT) {
492 ERROR_FAILED(err, "getsockopt(BT_POWER)", errno);
493 return FALSE;
494 }
495
496 return TRUE;
497 }
498
get_sec_level(int sock,BtIOType type,int * level,GError ** err)499 static gboolean get_sec_level(int sock, BtIOType type, int *level,
500 GError **err)
501 {
502 struct bt_security sec;
503 socklen_t len;
504 int ret;
505
506 memset(&sec, 0, sizeof(sec));
507 len = sizeof(sec);
508 if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
509 *level = sec.level;
510 return TRUE;
511 }
512
513 if (errno != ENOPROTOOPT) {
514 ERROR_FAILED(err, "getsockopt(BT_SECURITY)", errno);
515 return FALSE;
516 }
517
518 if (type == BT_IO_L2CAP)
519 ret = l2cap_get_lm(sock, level);
520 else
521 ret = rfcomm_get_lm(sock, level);
522
523 if (ret < 0) {
524 ERROR_FAILED(err, "getsockopt(LM)", -ret);
525 return FALSE;
526 }
527
528 return TRUE;
529 }
530
l2cap_set_flushable(int sock,gboolean flushable)531 static int l2cap_set_flushable(int sock, gboolean flushable)
532 {
533 int f;
534
535 f = flushable;
536 if (setsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, sizeof(f)) < 0)
537 return -errno;
538
539 return 0;
540 }
541
l2cap_set(int sock,int sec_level,uint16_t imtu,uint16_t omtu,uint8_t mode,int master,int flushable,uint8_t force_active,GError ** err)542 static gboolean l2cap_set(int sock, int sec_level, uint16_t imtu,
543 uint16_t omtu, uint8_t mode, int master,
544 int flushable, uint8_t force_active, GError **err)
545 {
546 if (imtu || omtu || mode) {
547 struct l2cap_options l2o;
548 socklen_t len;
549
550 memset(&l2o, 0, sizeof(l2o));
551 len = sizeof(l2o);
552 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
553 &len) < 0) {
554 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
555 return FALSE;
556 }
557
558 if (imtu)
559 l2o.imtu = imtu;
560 if (omtu)
561 l2o.omtu = omtu;
562 if (mode)
563 l2o.mode = mode;
564
565 if (setsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
566 sizeof(l2o)) < 0) {
567 ERROR_FAILED(err, "setsockopt(L2CAP_OPTIONS)", errno);
568 return FALSE;
569 }
570 }
571
572 if (master >= 0 && l2cap_set_master(sock, master) < 0) {
573 ERROR_FAILED(err, "l2cap_set_master", errno);
574 return FALSE;
575 }
576
577 if (flushable >= 0 && l2cap_set_flushable(sock, flushable) < 0) {
578 ERROR_FAILED(err, "l2cap_set_flushable", errno);
579 return FALSE;
580 }
581
582 if (sec_level && !set_sec_level(sock, BT_IO_L2CAP, sec_level, err))
583 return FALSE;
584
585 if (!set_force_active(sock, BT_IO_L2CAP, force_active, err))
586 return FALSE;
587
588 return TRUE;
589 }
590
rfcomm_bind(int sock,const bdaddr_t * src,uint8_t channel,GError ** err)591 static int rfcomm_bind(int sock,
592 const bdaddr_t *src, uint8_t channel, GError **err)
593 {
594 struct sockaddr_rc addr;
595
596 memset(&addr, 0, sizeof(addr));
597 addr.rc_family = AF_BLUETOOTH;
598 bacpy(&addr.rc_bdaddr, src);
599 addr.rc_channel = channel;
600
601 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
602 ERROR_FAILED(err, "rfcomm_bind", errno);
603 return -1;
604 }
605
606 return 0;
607 }
608
rfcomm_connect(int sock,const bdaddr_t * dst,uint8_t channel)609 static int rfcomm_connect(int sock, const bdaddr_t *dst, uint8_t channel)
610 {
611 int err;
612 struct sockaddr_rc addr;
613
614 memset(&addr, 0, sizeof(addr));
615 addr.rc_family = AF_BLUETOOTH;
616 bacpy(&addr.rc_bdaddr, dst);
617 addr.rc_channel = channel;
618
619 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
620 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
621 return err;
622
623 return 0;
624 }
625
rfcomm_set(int sock,int sec_level,int master,uint8_t force_active,GError ** err)626 static gboolean rfcomm_set(int sock, int sec_level, int master,
627 uint8_t force_active, GError **err)
628 {
629 if (sec_level && !set_sec_level(sock, BT_IO_RFCOMM, sec_level, err))
630 return FALSE;
631
632 if (!set_force_active(sock, BT_IO_RFCOMM, force_active, err))
633 return FALSE;
634
635 if (master >= 0 && rfcomm_set_master(sock, master) < 0) {
636 ERROR_FAILED(err, "rfcomm_set_master", errno);
637 return FALSE;
638 }
639
640 return TRUE;
641 }
642
sco_bind(int sock,const bdaddr_t * src,GError ** err)643 static int sco_bind(int sock, const bdaddr_t *src, GError **err)
644 {
645 struct sockaddr_sco addr;
646
647 memset(&addr, 0, sizeof(addr));
648 addr.sco_family = AF_BLUETOOTH;
649 bacpy(&addr.sco_bdaddr, src);
650
651 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
652 ERROR_FAILED(err, "sco_bind", errno);
653 return -1;
654 }
655
656 return 0;
657 }
658
sco_connect(int sock,const bdaddr_t * dst)659 static int sco_connect(int sock, const bdaddr_t *dst)
660 {
661 struct sockaddr_sco addr;
662 int err;
663
664 memset(&addr, 0, sizeof(addr));
665 addr.sco_family = AF_BLUETOOTH;
666 bacpy(&addr.sco_bdaddr, dst);
667
668 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
669 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
670 return err;
671
672 return 0;
673 }
674
sco_set(int sock,uint16_t mtu,GError ** err)675 static gboolean sco_set(int sock, uint16_t mtu, GError **err)
676 {
677 struct sco_options sco_opt;
678 socklen_t len;
679
680 if (!mtu)
681 return TRUE;
682
683 len = sizeof(sco_opt);
684 memset(&sco_opt, 0, len);
685 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
686 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
687 return FALSE;
688 }
689
690 sco_opt.mtu = mtu;
691 if (setsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt,
692 sizeof(sco_opt)) < 0) {
693 ERROR_FAILED(err, "setsockopt(SCO_OPTIONS)", errno);
694 return FALSE;
695 }
696
697 return TRUE;
698 }
699
parse_set_opts(struct set_opts * opts,GError ** err,BtIOOption opt1,va_list args)700 static gboolean parse_set_opts(struct set_opts *opts, GError **err,
701 BtIOOption opt1, va_list args)
702 {
703 BtIOOption opt = opt1;
704 const char *str;
705
706 memset(opts, 0, sizeof(*opts));
707
708 /* Set defaults */
709 opts->defer = DEFAULT_DEFER_TIMEOUT;
710 opts->master = -1;
711 opts->sec_level = BT_IO_SEC_MEDIUM;
712 opts->mode = L2CAP_MODE_BASIC;
713 opts->flushable = -1;
714 opts->force_active = 1;
715
716 while (opt != BT_IO_OPT_INVALID) {
717 switch (opt) {
718 case BT_IO_OPT_SOURCE:
719 str = va_arg(args, const char *);
720 if (strncasecmp(str, "hci", 3) == 0)
721 hci_devba(atoi(str + 3), &opts->src);
722 else
723 str2ba(str, &opts->src);
724 break;
725 case BT_IO_OPT_SOURCE_BDADDR:
726 bacpy(&opts->src, va_arg(args, const bdaddr_t *));
727 break;
728 case BT_IO_OPT_DEST:
729 str2ba(va_arg(args, const char *), &opts->dst);
730 break;
731 case BT_IO_OPT_DEST_BDADDR:
732 bacpy(&opts->dst, va_arg(args, const bdaddr_t *));
733 break;
734 case BT_IO_OPT_DEFER_TIMEOUT:
735 opts->defer = va_arg(args, int);
736 break;
737 case BT_IO_OPT_SEC_LEVEL:
738 opts->sec_level = va_arg(args, int);
739 break;
740 case BT_IO_OPT_CHANNEL:
741 opts->channel = va_arg(args, int);
742 break;
743 case BT_IO_OPT_PSM:
744 opts->psm = va_arg(args, int);
745 break;
746 case BT_IO_OPT_CID:
747 opts->cid = va_arg(args, int);
748 break;
749 case BT_IO_OPT_MTU:
750 opts->mtu = va_arg(args, int);
751 opts->imtu = opts->mtu;
752 opts->omtu = opts->mtu;
753 break;
754 case BT_IO_OPT_OMTU:
755 opts->omtu = va_arg(args, int);
756 if (!opts->mtu)
757 opts->mtu = opts->omtu;
758 break;
759 case BT_IO_OPT_IMTU:
760 opts->imtu = va_arg(args, int);
761 if (!opts->mtu)
762 opts->mtu = opts->imtu;
763 break;
764 case BT_IO_OPT_MASTER:
765 opts->master = va_arg(args, gboolean);
766 break;
767 case BT_IO_OPT_MODE:
768 opts->mode = va_arg(args, int);
769 break;
770 case BT_IO_OPT_FLUSHABLE:
771 opts->flushable = va_arg(args, gboolean);
772 break;
773 case BT_IO_OPT_POWER_ACTIVE:
774 opts->force_active = va_arg(args, int);
775 break;
776 default:
777 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
778 "Unknown option %d", opt);
779 return FALSE;
780 }
781
782 opt = va_arg(args, int);
783 }
784
785 return TRUE;
786 }
787
get_peers(int sock,struct sockaddr * src,struct sockaddr * dst,socklen_t len,GError ** err)788 static gboolean get_peers(int sock, struct sockaddr *src, struct sockaddr *dst,
789 socklen_t len, GError **err)
790 {
791 socklen_t olen;
792
793 memset(src, 0, len);
794 olen = len;
795 if (getsockname(sock, src, &olen) < 0) {
796 ERROR_FAILED(err, "getsockname", errno);
797 return FALSE;
798 }
799
800 memset(dst, 0, len);
801 olen = len;
802 if (getpeername(sock, dst, &olen) < 0) {
803 ERROR_FAILED(err, "getpeername", errno);
804 return FALSE;
805 }
806
807 return TRUE;
808 }
809
l2cap_get_info(int sock,uint16_t * handle,uint8_t * dev_class)810 static int l2cap_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
811 {
812 struct l2cap_conninfo info;
813 socklen_t len;
814
815 len = sizeof(info);
816 if (getsockopt(sock, SOL_L2CAP, L2CAP_CONNINFO, &info, &len) < 0)
817 return -errno;
818
819 if (handle)
820 *handle = info.hci_handle;
821
822 if (dev_class)
823 memcpy(dev_class, info.dev_class, 3);
824
825 return 0;
826 }
827
l2cap_get_flushable(int sock,gboolean * flushable)828 static int l2cap_get_flushable(int sock, gboolean *flushable)
829 {
830 int f;
831 socklen_t len;
832
833 f = 0;
834 len = sizeof(f);
835 if (getsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, &len) < 0)
836 return -errno;
837
838 if (f)
839 *flushable = TRUE;
840 else
841 *flushable = FALSE;
842
843 return 0;
844 }
845
l2cap_get(int sock,GError ** err,BtIOOption opt1,va_list args)846 static gboolean l2cap_get(int sock, GError **err, BtIOOption opt1,
847 va_list args)
848 {
849 BtIOOption opt = opt1;
850 struct sockaddr_l2 src, dst;
851 struct l2cap_options l2o;
852 int flags;
853 uint8_t dev_class[3];
854 uint16_t handle;
855 socklen_t len;
856 gboolean flushable = FALSE;
857
858 len = sizeof(l2o);
859 memset(&l2o, 0, len);
860 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
861 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
862 return FALSE;
863 }
864
865 if (!get_peers(sock, (struct sockaddr *) &src,
866 (struct sockaddr *) &dst, sizeof(src), err))
867 return FALSE;
868
869 while (opt != BT_IO_OPT_INVALID) {
870 switch (opt) {
871 case BT_IO_OPT_SOURCE:
872 ba2str(&src.l2_bdaddr, va_arg(args, char *));
873 break;
874 case BT_IO_OPT_SOURCE_BDADDR:
875 bacpy(va_arg(args, bdaddr_t *), &src.l2_bdaddr);
876 break;
877 case BT_IO_OPT_DEST:
878 ba2str(&dst.l2_bdaddr, va_arg(args, char *));
879 break;
880 case BT_IO_OPT_DEST_BDADDR:
881 bacpy(va_arg(args, bdaddr_t *), &dst.l2_bdaddr);
882 break;
883 case BT_IO_OPT_DEFER_TIMEOUT:
884 len = sizeof(int);
885 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
886 va_arg(args, int *), &len) < 0) {
887 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
888 errno);
889 return FALSE;
890 }
891 break;
892 case BT_IO_OPT_SEC_LEVEL:
893 if (!get_sec_level(sock, BT_IO_L2CAP,
894 va_arg(args, int *), err))
895 return FALSE;
896 break;
897 case BT_IO_OPT_PSM:
898 *(va_arg(args, uint16_t *)) = src.l2_psm ?
899 src.l2_psm : dst.l2_psm;
900 break;
901 case BT_IO_OPT_CID:
902 *(va_arg(args, uint16_t *)) = src.l2_cid ?
903 src.l2_cid : dst.l2_cid;
904 break;
905 case BT_IO_OPT_OMTU:
906 *(va_arg(args, uint16_t *)) = l2o.omtu;
907 break;
908 case BT_IO_OPT_IMTU:
909 *(va_arg(args, uint16_t *)) = l2o.imtu;
910 break;
911 case BT_IO_OPT_MASTER:
912 len = sizeof(flags);
913 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags,
914 &len) < 0) {
915 ERROR_FAILED(err, "getsockopt(L2CAP_LM)",
916 errno);
917 return FALSE;
918 }
919 *(va_arg(args, gboolean *)) =
920 (flags & L2CAP_LM_MASTER) ? TRUE : FALSE;
921 break;
922 case BT_IO_OPT_HANDLE:
923 if (l2cap_get_info(sock, &handle, dev_class) < 0) {
924 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
925 return FALSE;
926 }
927 *(va_arg(args, uint16_t *)) = handle;
928 break;
929 case BT_IO_OPT_CLASS:
930 if (l2cap_get_info(sock, &handle, dev_class) < 0) {
931 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
932 return FALSE;
933 }
934 memcpy(va_arg(args, uint8_t *), dev_class, 3);
935 break;
936 case BT_IO_OPT_MODE:
937 *(va_arg(args, uint8_t *)) = l2o.mode;
938 break;
939 case BT_IO_OPT_FLUSHABLE:
940 if (l2cap_get_flushable(sock, &flushable) < 0) {
941 ERROR_FAILED(err, "get_flushable", errno);
942 return FALSE;
943 }
944 *(va_arg(args, gboolean *)) = flushable;
945 break;
946 case BT_IO_OPT_POWER_ACTIVE:
947 if (!get_force_active(sock, BT_IO_L2CAP,
948 va_arg(args, uint8_t *), err))
949 return FALSE;
950 break;
951 default:
952 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
953 "Unknown option %d", opt);
954 return FALSE;
955 }
956
957 opt = va_arg(args, int);
958 }
959
960 return TRUE;
961 }
962
rfcomm_get_info(int sock,uint16_t * handle,uint8_t * dev_class)963 static int rfcomm_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
964 {
965 struct rfcomm_conninfo info;
966 socklen_t len;
967
968 len = sizeof(info);
969 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_CONNINFO, &info, &len) < 0)
970 return -errno;
971
972 if (handle)
973 *handle = info.hci_handle;
974
975 if (dev_class)
976 memcpy(dev_class, info.dev_class, 3);
977
978 return 0;
979 }
980
rfcomm_get(int sock,GError ** err,BtIOOption opt1,va_list args)981 static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1,
982 va_list args)
983 {
984 BtIOOption opt = opt1;
985 struct sockaddr_rc src, dst;
986 int flags;
987 socklen_t len;
988 uint8_t dev_class[3];
989 uint16_t handle;
990
991 if (!get_peers(sock, (struct sockaddr *) &src,
992 (struct sockaddr *) &dst, sizeof(src), err))
993 return FALSE;
994
995 while (opt != BT_IO_OPT_INVALID) {
996 switch (opt) {
997 case BT_IO_OPT_SOURCE:
998 ba2str(&src.rc_bdaddr, va_arg(args, char *));
999 break;
1000 case BT_IO_OPT_SOURCE_BDADDR:
1001 bacpy(va_arg(args, bdaddr_t *), &src.rc_bdaddr);
1002 break;
1003 case BT_IO_OPT_DEST:
1004 ba2str(&dst.rc_bdaddr, va_arg(args, char *));
1005 break;
1006 case BT_IO_OPT_DEST_BDADDR:
1007 bacpy(va_arg(args, bdaddr_t *), &dst.rc_bdaddr);
1008 break;
1009 case BT_IO_OPT_DEFER_TIMEOUT:
1010 len = sizeof(int);
1011 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
1012 va_arg(args, int *), &len) < 0) {
1013 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
1014 errno);
1015 return FALSE;
1016 }
1017 break;
1018 case BT_IO_OPT_SEC_LEVEL:
1019 if (!get_sec_level(sock, BT_IO_RFCOMM,
1020 va_arg(args, int *), err))
1021 return FALSE;
1022 break;
1023 case BT_IO_OPT_CHANNEL:
1024 *(va_arg(args, uint8_t *)) = src.rc_channel ?
1025 src.rc_channel : dst.rc_channel;
1026 break;
1027 case BT_IO_OPT_SOURCE_CHANNEL:
1028 *(va_arg(args, uint8_t *)) = src.rc_channel;
1029 break;
1030 case BT_IO_OPT_DEST_CHANNEL:
1031 *(va_arg(args, uint8_t *)) = dst.rc_channel;
1032 break;
1033 case BT_IO_OPT_MASTER:
1034 len = sizeof(flags);
1035 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags,
1036 &len) < 0) {
1037 ERROR_FAILED(err, "getsockopt(RFCOMM_LM)",
1038 errno);
1039 return FALSE;
1040 }
1041 *(va_arg(args, gboolean *)) =
1042 (flags & RFCOMM_LM_MASTER) ? TRUE : FALSE;
1043 break;
1044 case BT_IO_OPT_HANDLE:
1045 if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1046 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1047 return FALSE;
1048 }
1049 *(va_arg(args, uint16_t *)) = handle;
1050 break;
1051 case BT_IO_OPT_CLASS:
1052 if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1053 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1054 return FALSE;
1055 }
1056 memcpy(va_arg(args, uint8_t *), dev_class, 3);
1057 break;
1058 case BT_IO_OPT_POWER_ACTIVE:
1059 if (!get_force_active(sock, BT_IO_RFCOMM,
1060 va_arg(args, uint8_t *), err))
1061 return FALSE;
1062 break;
1063 default:
1064 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1065 "Unknown option %d", opt);
1066 return FALSE;
1067 }
1068
1069 opt = va_arg(args, int);
1070 }
1071
1072 return TRUE;
1073 }
1074
sco_get_info(int sock,uint16_t * handle,uint8_t * dev_class)1075 static int sco_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
1076 {
1077 struct sco_conninfo info;
1078 socklen_t len;
1079
1080 len = sizeof(info);
1081 if (getsockopt(sock, SOL_SCO, SCO_CONNINFO, &info, &len) < 0)
1082 return -errno;
1083
1084 if (handle)
1085 *handle = info.hci_handle;
1086
1087 if (dev_class)
1088 memcpy(dev_class, info.dev_class, 3);
1089
1090 return 0;
1091 }
1092
sco_get(int sock,GError ** err,BtIOOption opt1,va_list args)1093 static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args)
1094 {
1095 BtIOOption opt = opt1;
1096 struct sockaddr_sco src, dst;
1097 struct sco_options sco_opt;
1098 socklen_t len;
1099 uint8_t dev_class[3];
1100 uint16_t handle;
1101
1102 len = sizeof(sco_opt);
1103 memset(&sco_opt, 0, len);
1104 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
1105 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
1106 return FALSE;
1107 }
1108
1109 if (!get_peers(sock, (struct sockaddr *) &src,
1110 (struct sockaddr *) &dst, sizeof(src), err))
1111 return FALSE;
1112
1113 while (opt != BT_IO_OPT_INVALID) {
1114 switch (opt) {
1115 case BT_IO_OPT_SOURCE:
1116 ba2str(&src.sco_bdaddr, va_arg(args, char *));
1117 break;
1118 case BT_IO_OPT_SOURCE_BDADDR:
1119 bacpy(va_arg(args, bdaddr_t *), &src.sco_bdaddr);
1120 break;
1121 case BT_IO_OPT_DEST:
1122 ba2str(&dst.sco_bdaddr, va_arg(args, char *));
1123 break;
1124 case BT_IO_OPT_DEST_BDADDR:
1125 bacpy(va_arg(args, bdaddr_t *), &dst.sco_bdaddr);
1126 break;
1127 case BT_IO_OPT_MTU:
1128 case BT_IO_OPT_IMTU:
1129 case BT_IO_OPT_OMTU:
1130 *(va_arg(args, uint16_t *)) = sco_opt.mtu;
1131 break;
1132 case BT_IO_OPT_HANDLE:
1133 if (sco_get_info(sock, &handle, dev_class) < 0) {
1134 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1135 return FALSE;
1136 }
1137 *(va_arg(args, uint16_t *)) = handle;
1138 break;
1139 case BT_IO_OPT_CLASS:
1140 if (sco_get_info(sock, &handle, dev_class) < 0) {
1141 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1142 return FALSE;
1143 }
1144 memcpy(va_arg(args, uint8_t *), dev_class, 3);
1145 break;
1146 default:
1147 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1148 "Unknown option %d", opt);
1149 return FALSE;
1150 }
1151
1152 opt = va_arg(args, int);
1153 }
1154
1155 return TRUE;
1156 }
1157
get_valist(GIOChannel * io,BtIOType type,GError ** err,BtIOOption opt1,va_list args)1158 static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err,
1159 BtIOOption opt1, va_list args)
1160 {
1161 int sock;
1162
1163 sock = g_io_channel_unix_get_fd(io);
1164
1165 switch (type) {
1166 case BT_IO_L2RAW:
1167 case BT_IO_L2CAP:
1168 return l2cap_get(sock, err, opt1, args);
1169 case BT_IO_RFCOMM:
1170 return rfcomm_get(sock, err, opt1, args);
1171 case BT_IO_SCO:
1172 return sco_get(sock, err, opt1, args);
1173 }
1174
1175 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1176 "Unknown BtIO type %d", type);
1177 return FALSE;
1178 }
1179
bt_io_accept(GIOChannel * io,BtIOConnect connect,gpointer user_data,GDestroyNotify destroy,GError ** err)1180 gboolean bt_io_accept(GIOChannel *io, BtIOConnect connect, gpointer user_data,
1181 GDestroyNotify destroy, GError **err)
1182 {
1183 int sock;
1184 char c;
1185 struct pollfd pfd;
1186
1187 sock = g_io_channel_unix_get_fd(io);
1188
1189 memset(&pfd, 0, sizeof(pfd));
1190 pfd.fd = sock;
1191 pfd.events = POLLOUT;
1192
1193 if (poll(&pfd, 1, 0) < 0) {
1194 ERROR_FAILED(err, "poll", errno);
1195 return FALSE;
1196 }
1197
1198 if (!(pfd.revents & POLLOUT)) {
1199 if (read(sock, &c, 1) < 0) {
1200 ERROR_FAILED(err, "read", errno);
1201 return FALSE;
1202 }
1203 }
1204
1205 accept_add(io, connect, user_data, destroy);
1206
1207 return TRUE;
1208 }
1209
bt_io_set(GIOChannel * io,BtIOType type,GError ** err,BtIOOption opt1,...)1210 gboolean bt_io_set(GIOChannel *io, BtIOType type, GError **err,
1211 BtIOOption opt1, ...)
1212 {
1213 va_list args;
1214 gboolean ret;
1215 struct set_opts opts;
1216 int sock;
1217
1218 va_start(args, opt1);
1219 ret = parse_set_opts(&opts, err, opt1, args);
1220 va_end(args);
1221
1222 if (!ret)
1223 return ret;
1224
1225 sock = g_io_channel_unix_get_fd(io);
1226
1227 switch (type) {
1228 case BT_IO_L2RAW:
1229 case BT_IO_L2CAP:
1230 return l2cap_set(sock, opts.sec_level, opts.imtu, opts.omtu,
1231 opts.mode, opts.master, opts.flushable,
1232 opts.force_active, err);
1233 case BT_IO_RFCOMM:
1234 return rfcomm_set(sock, opts.sec_level, opts.master, opts.force_active,
1235 err);
1236 case BT_IO_SCO:
1237 return sco_set(sock, opts.mtu, err);
1238 }
1239
1240 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1241 "Unknown BtIO type %d", type);
1242 return FALSE;
1243 }
1244
bt_io_get(GIOChannel * io,BtIOType type,GError ** err,BtIOOption opt1,...)1245 gboolean bt_io_get(GIOChannel *io, BtIOType type, GError **err,
1246 BtIOOption opt1, ...)
1247 {
1248 va_list args;
1249 gboolean ret;
1250
1251 va_start(args, opt1);
1252 ret = get_valist(io, type, err, opt1, args);
1253 va_end(args);
1254
1255 return ret;
1256 }
1257
create_io(BtIOType type,gboolean server,struct set_opts * opts,GError ** err)1258 static GIOChannel *create_io(BtIOType type, gboolean server,
1259 struct set_opts *opts, GError **err)
1260 {
1261 int sock;
1262 GIOChannel *io;
1263
1264 switch (type) {
1265 case BT_IO_L2RAW:
1266 sock = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1267 if (sock < 0) {
1268 ERROR_FAILED(err, "socket(RAW, L2CAP)", errno);
1269 return NULL;
1270 }
1271 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0,
1272 opts->cid, err) < 0)
1273 goto failed;
1274 if (!l2cap_set(sock, opts->sec_level, 0, 0, 0, -1, -1, opts->force_active,
1275 err))
1276 goto failed;
1277 break;
1278 case BT_IO_L2CAP:
1279 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
1280 if (sock < 0) {
1281 ERROR_FAILED(err, "socket(SEQPACKET, L2CAP)", errno);
1282 return NULL;
1283 }
1284 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0,
1285 opts->cid, err) < 0)
1286 goto failed;
1287 if (!l2cap_set(sock, opts->sec_level, opts->imtu, opts->omtu,
1288 opts->mode, opts->master, opts->flushable,
1289 opts->force_active, err))
1290 goto failed;
1291 break;
1292 case BT_IO_RFCOMM:
1293 sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1294 if (sock < 0) {
1295 ERROR_FAILED(err, "socket(STREAM, RFCOMM)", errno);
1296 return NULL;
1297 }
1298 if (rfcomm_bind(sock, &opts->src,
1299 server ? opts->channel : 0, err) < 0)
1300 goto failed;
1301 if (!rfcomm_set(sock, opts->sec_level, opts->master,
1302 opts->force_active, err))
1303 goto failed;
1304 break;
1305 case BT_IO_SCO:
1306 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
1307 if (sock < 0) {
1308 ERROR_FAILED(err, "socket(SEQPACKET, SCO)", errno);
1309 return NULL;
1310 }
1311 if (sco_bind(sock, &opts->src, err) < 0)
1312 goto failed;
1313 if (!sco_set(sock, opts->mtu, err))
1314 goto failed;
1315 break;
1316 default:
1317 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1318 "Unknown BtIO type %d", type);
1319 return NULL;
1320 }
1321
1322 io = g_io_channel_unix_new(sock);
1323
1324 g_io_channel_set_close_on_unref(io, TRUE);
1325 g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
1326
1327 return io;
1328
1329 failed:
1330 close(sock);
1331
1332 return NULL;
1333 }
1334
bt_io_connect(BtIOType type,BtIOConnect connect,gpointer user_data,GDestroyNotify destroy,GError ** gerr,BtIOOption opt1,...)1335 GIOChannel *bt_io_connect(BtIOType type, BtIOConnect connect,
1336 gpointer user_data, GDestroyNotify destroy,
1337 GError **gerr, BtIOOption opt1, ...)
1338 {
1339 GIOChannel *io;
1340 va_list args;
1341 struct set_opts opts;
1342 int err, sock;
1343 gboolean ret;
1344
1345 va_start(args, opt1);
1346 ret = parse_set_opts(&opts, gerr, opt1, args);
1347 va_end(args);
1348
1349 if (ret == FALSE)
1350 return NULL;
1351
1352 io = create_io(type, FALSE, &opts, gerr);
1353 if (io == NULL)
1354 return NULL;
1355
1356 sock = g_io_channel_unix_get_fd(io);
1357
1358 switch (type) {
1359 case BT_IO_L2RAW:
1360 err = l2cap_connect(sock, &opts.dst, 0, opts.cid);
1361 break;
1362 case BT_IO_L2CAP:
1363 err = l2cap_connect(sock, &opts.dst, opts.psm, opts.cid);
1364 break;
1365 case BT_IO_RFCOMM:
1366 err = rfcomm_connect(sock, &opts.dst, opts.channel);
1367 break;
1368 case BT_IO_SCO:
1369 err = sco_connect(sock, &opts.dst);
1370 break;
1371 default:
1372 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1373 "Unknown BtIO type %d", type);
1374 return NULL;
1375 }
1376
1377 if (err < 0) {
1378 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
1379 "connect: %s (%d)", strerror(-err), -err);
1380 g_io_channel_unref(io);
1381 return NULL;
1382 }
1383
1384 connect_add(io, connect, user_data, destroy);
1385
1386 return io;
1387 }
1388
bt_io_listen(BtIOType type,BtIOConnect connect,BtIOConfirm confirm,gpointer user_data,GDestroyNotify destroy,GError ** err,BtIOOption opt1,...)1389 GIOChannel *bt_io_listen(BtIOType type, BtIOConnect connect,
1390 BtIOConfirm confirm, gpointer user_data,
1391 GDestroyNotify destroy, GError **err,
1392 BtIOOption opt1, ...)
1393 {
1394 GIOChannel *io;
1395 va_list args;
1396 struct set_opts opts;
1397 int sock;
1398 gboolean ret;
1399
1400 if (type == BT_IO_L2RAW) {
1401 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1402 "Server L2CAP RAW sockets not supported");
1403 return NULL;
1404 }
1405
1406 va_start(args, opt1);
1407 ret = parse_set_opts(&opts, err, opt1, args);
1408 va_end(args);
1409
1410 if (ret == FALSE)
1411 return NULL;
1412
1413 io = create_io(type, TRUE, &opts, err);
1414 if (io == NULL)
1415 return NULL;
1416
1417 sock = g_io_channel_unix_get_fd(io);
1418
1419 if (confirm)
1420 setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &opts.defer,
1421 sizeof(opts.defer));
1422
1423 if (listen(sock, 5) < 0) {
1424 ERROR_FAILED(err, "listen", errno);
1425 g_io_channel_unref(io);
1426 return NULL;
1427 }
1428
1429 server_add(io, connect, confirm, user_data, destroy);
1430
1431 return io;
1432 }
1433
bt_io_error_quark(void)1434 GQuark bt_io_error_quark(void)
1435 {
1436 return g_quark_from_static_string("bt-io-error-quark");
1437 }
1438