3 * BlueZ - Bluetooth protocol stack for Linux
5 * Copyright (C) 2009-2010 Marcel Holtmann <marcel@holtmann.org>
6 * Copyright (C) 2009-2010 Nokia Corporation
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.
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.
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
29 #include <sys/types.h>
30 #include <sys/socket.h>
32 #include <bluetooth/bluetooth.h>
33 #include <bluetooth/l2cap.h>
34 #include <bluetooth/rfcomm.h>
35 #include <bluetooth/sco.h>
42 #define BT_FLUSHABLE 8
45 #define ERROR_FAILED(gerr, str, err) \
46 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_FAILED, \
47 str ": %s (%d)", strerror(err), err)
49 #define DEFAULT_DEFER_TIMEOUT 30
72 GDestroyNotify destroy;
78 GDestroyNotify destroy;
85 GDestroyNotify destroy;
88 static void server_remove(struct server *server)
91 server->destroy(server->user_data);
95 static void connect_remove(struct connect *conn)
98 conn->destroy(conn->user_data);
102 static void accept_remove(struct accept *accept)
105 accept->destroy(accept->user_data);
109 static gboolean check_nval(GIOChannel *io)
113 memset(&fds, 0, sizeof(fds));
114 fds.fd = g_io_channel_unix_get_fd(io);
115 fds.events = POLLNVAL;
117 if (poll(&fds, 1, 0) > 0 && (fds.revents & POLLNVAL))
123 static gboolean accept_cb(GIOChannel *io, GIOCondition cond,
126 struct accept *accept = user_data;
129 /* If the user aborted this accept attempt */
130 if ((cond & G_IO_NVAL) || check_nval(io))
133 if (cond & (G_IO_HUP | G_IO_ERR))
134 g_set_error(&err, BT_IO_ERROR, BT_IO_ERROR_DISCONNECTED,
135 "HUP or ERR on socket");
137 accept->connect(io, err, accept->user_data);
144 static gboolean connect_cb(GIOChannel *io, GIOCondition cond,
147 struct connect *conn = user_data;
150 /* If the user aborted this connect attempt */
151 if ((cond & G_IO_NVAL) || check_nval(io))
154 if (cond & G_IO_OUT) {
155 int err, sk_err = 0, sock = g_io_channel_unix_get_fd(io);
156 socklen_t len = sizeof(sk_err);
158 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)
164 g_set_error(&gerr, BT_IO_ERROR,
165 BT_IO_ERROR_CONNECT_FAILED, "%s (%d)",
166 strerror(-err), -err);
167 } else if (cond & (G_IO_HUP | G_IO_ERR))
168 g_set_error(&gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
169 "HUP or ERR on socket");
171 conn->connect(io, gerr, conn->user_data);
179 static gboolean server_cb(GIOChannel *io, GIOCondition cond,
182 struct server *server = user_data;
183 int srv_sock, cli_sock;
186 /* If the user closed the server */
187 if ((cond & G_IO_NVAL) || check_nval(io))
190 srv_sock = g_io_channel_unix_get_fd(io);
192 cli_sock = accept(srv_sock, NULL, NULL);
196 cli_io = g_io_channel_unix_new(cli_sock);
198 g_io_channel_set_close_on_unref(cli_io, TRUE);
199 g_io_channel_set_flags(cli_io, G_IO_FLAG_NONBLOCK, NULL);
202 server->confirm(cli_io, server->user_data);
204 server->connect(cli_io, NULL, server->user_data);
206 g_io_channel_unref(cli_io);
211 static void server_add(GIOChannel *io, BtIOConnect connect,
212 BtIOConfirm confirm, gpointer user_data,
213 GDestroyNotify destroy)
215 struct server *server;
218 server = g_new0(struct server, 1);
219 server->connect = connect;
220 server->confirm = confirm;
221 server->user_data = user_data;
222 server->destroy = destroy;
224 cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
225 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, server_cb, server,
226 (GDestroyNotify) server_remove);
229 static void connect_add(GIOChannel *io, BtIOConnect connect,
230 gpointer user_data, GDestroyNotify destroy)
232 struct connect *conn;
235 conn = g_new0(struct connect, 1);
236 conn->connect = connect;
237 conn->user_data = user_data;
238 conn->destroy = destroy;
240 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
241 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, connect_cb, conn,
242 (GDestroyNotify) connect_remove);
245 static void accept_add(GIOChannel *io, BtIOConnect connect, gpointer user_data,
246 GDestroyNotify destroy)
248 struct accept *accept;
251 accept = g_new0(struct accept, 1);
252 accept->connect = connect;
253 accept->user_data = user_data;
254 accept->destroy = destroy;
256 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
257 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, accept_cb, accept,
258 (GDestroyNotify) accept_remove);
261 static int l2cap_bind(int sock, const bdaddr_t *src, uint16_t psm,
262 uint16_t cid, GError **err)
264 struct sockaddr_l2 addr;
266 memset(&addr, 0, sizeof(addr));
267 addr.l2_family = AF_BLUETOOTH;
268 bacpy(&addr.l2_bdaddr, src);
271 addr.l2_cid = htobs(cid);
273 addr.l2_psm = htobs(psm);
275 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
277 ERROR_FAILED(err, "l2cap_bind", errno);
284 static int l2cap_connect(int sock, const bdaddr_t *dst, uint8_t dst_type,
285 uint16_t psm, uint16_t cid)
288 struct sockaddr_l2 addr;
290 memset(&addr, 0, sizeof(addr));
291 addr.l2_family = AF_BLUETOOTH;
292 bacpy(&addr.l2_bdaddr, dst);
294 addr.l2_cid = htobs(cid);
296 addr.l2_psm = htobs(psm);
298 addr.l2_bdaddr_type = dst_type;
300 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
301 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
307 static int l2cap_set_master(int sock, int master)
313 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, &len) < 0)
317 if (flags & L2CAP_LM_MASTER)
319 flags |= L2CAP_LM_MASTER;
321 if (!(flags & L2CAP_LM_MASTER))
323 flags &= ~L2CAP_LM_MASTER;
326 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, sizeof(flags)) < 0)
332 static int rfcomm_set_master(int sock, int master)
338 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, &len) < 0)
342 if (flags & RFCOMM_LM_MASTER)
344 flags |= RFCOMM_LM_MASTER;
346 if (!(flags & RFCOMM_LM_MASTER))
348 flags &= ~RFCOMM_LM_MASTER;
351 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, sizeof(flags)) < 0)
357 static int l2cap_set_lm(int sock, int level)
362 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT,
363 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE,
364 }, opt = lm_map[level];
366 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0)
372 static int rfcomm_set_lm(int sock, int level)
377 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT,
378 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT | RFCOMM_LM_SECURE,
379 }, opt = lm_map[level];
381 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0)
387 static gboolean set_sec_level(int sock, BtIOType type, int level, GError **err)
389 struct bt_security sec;
392 if (level < BT_SECURITY_LOW || level > BT_SECURITY_HIGH) {
393 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
394 "Valid security level range is %d-%d",
395 BT_SECURITY_LOW, BT_SECURITY_HIGH);
399 memset(&sec, 0, sizeof(sec));
402 if (setsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec,
406 if (errno != ENOPROTOOPT) {
407 ERROR_FAILED(err, "setsockopt(BT_SECURITY)", errno);
411 if (type == BT_IO_L2CAP)
412 ret = l2cap_set_lm(sock, level);
414 ret = rfcomm_set_lm(sock, level);
417 ERROR_FAILED(err, "setsockopt(LM)", -ret);
424 static int l2cap_get_lm(int sock, int *sec_level)
430 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, &len) < 0)
435 if (opt & L2CAP_LM_AUTH)
436 *sec_level = BT_SECURITY_LOW;
437 if (opt & L2CAP_LM_ENCRYPT)
438 *sec_level = BT_SECURITY_MEDIUM;
439 if (opt & L2CAP_LM_SECURE)
440 *sec_level = BT_SECURITY_HIGH;
445 static int rfcomm_get_lm(int sock, int *sec_level)
451 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, &len) < 0)
456 if (opt & RFCOMM_LM_AUTH)
457 *sec_level = BT_SECURITY_LOW;
458 if (opt & RFCOMM_LM_ENCRYPT)
459 *sec_level = BT_SECURITY_MEDIUM;
460 if (opt & RFCOMM_LM_SECURE)
461 *sec_level = BT_SECURITY_HIGH;
466 static gboolean get_sec_level(int sock, BtIOType type, int *level,
469 struct bt_security sec;
473 memset(&sec, 0, sizeof(sec));
475 if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
480 if (errno != ENOPROTOOPT) {
481 ERROR_FAILED(err, "getsockopt(BT_SECURITY)", errno);
485 if (type == BT_IO_L2CAP)
486 ret = l2cap_get_lm(sock, level);
488 ret = rfcomm_get_lm(sock, level);
491 ERROR_FAILED(err, "getsockopt(LM)", -ret);
498 static int l2cap_set_flushable(int sock, gboolean flushable)
503 if (setsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, sizeof(f)) < 0)
509 static int set_priority(int sock, uint32_t prio)
511 if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, &prio, sizeof(prio)) < 0)
517 static gboolean get_key_size(int sock, int *size, GError **err)
519 struct bt_security sec;
522 memset(&sec, 0, sizeof(sec));
524 if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
525 *size = sec.key_size;
532 static gboolean l2cap_set(int sock, int sec_level, uint16_t imtu,
533 uint16_t omtu, uint8_t mode, int master,
534 int flushable, uint32_t priority, GError **err)
536 if (imtu || omtu || mode) {
537 struct l2cap_options l2o;
540 memset(&l2o, 0, sizeof(l2o));
542 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
544 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
555 if (setsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
557 ERROR_FAILED(err, "setsockopt(L2CAP_OPTIONS)", errno);
562 if (master >= 0 && l2cap_set_master(sock, master) < 0) {
563 ERROR_FAILED(err, "l2cap_set_master", errno);
567 if (flushable >= 0 && l2cap_set_flushable(sock, flushable) < 0) {
568 ERROR_FAILED(err, "l2cap_set_flushable", errno);
572 if (priority > 0 && set_priority(sock, priority) < 0) {
573 ERROR_FAILED(err, "set_priority", errno);
577 if (sec_level && !set_sec_level(sock, BT_IO_L2CAP, sec_level, err))
583 static int rfcomm_bind(int sock,
584 const bdaddr_t *src, uint8_t channel, GError **err)
586 struct sockaddr_rc addr;
588 memset(&addr, 0, sizeof(addr));
589 addr.rc_family = AF_BLUETOOTH;
590 bacpy(&addr.rc_bdaddr, src);
591 addr.rc_channel = channel;
593 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
595 ERROR_FAILED(err, "rfcomm_bind", errno);
602 static int rfcomm_connect(int sock, const bdaddr_t *dst, uint8_t channel)
605 struct sockaddr_rc addr;
607 memset(&addr, 0, sizeof(addr));
608 addr.rc_family = AF_BLUETOOTH;
609 bacpy(&addr.rc_bdaddr, dst);
610 addr.rc_channel = channel;
612 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
613 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
619 static gboolean rfcomm_set(int sock, int sec_level, int master, GError **err)
621 if (sec_level && !set_sec_level(sock, BT_IO_RFCOMM, sec_level, err))
624 if (master >= 0 && rfcomm_set_master(sock, master) < 0) {
625 ERROR_FAILED(err, "rfcomm_set_master", errno);
632 static int sco_bind(int sock, const bdaddr_t *src, GError **err)
634 struct sockaddr_sco addr;
636 memset(&addr, 0, sizeof(addr));
637 addr.sco_family = AF_BLUETOOTH;
638 bacpy(&addr.sco_bdaddr, src);
640 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
642 ERROR_FAILED(err, "sco_bind", errno);
649 static int sco_connect(int sock, const bdaddr_t *dst)
651 struct sockaddr_sco addr;
654 memset(&addr, 0, sizeof(addr));
655 addr.sco_family = AF_BLUETOOTH;
656 bacpy(&addr.sco_bdaddr, dst);
658 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
659 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
665 static gboolean sco_set(int sock, uint16_t mtu, GError **err)
667 struct sco_options sco_opt;
673 len = sizeof(sco_opt);
674 memset(&sco_opt, 0, len);
675 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
676 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
681 if (setsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt,
682 sizeof(sco_opt)) < 0) {
683 ERROR_FAILED(err, "setsockopt(SCO_OPTIONS)", errno);
690 static gboolean parse_set_opts(struct set_opts *opts, GError **err,
691 BtIOOption opt1, va_list args)
693 BtIOOption opt = opt1;
696 memset(opts, 0, sizeof(*opts));
699 opts->defer = DEFAULT_DEFER_TIMEOUT;
701 opts->mode = L2CAP_MODE_BASIC;
702 opts->flushable = -1;
704 opts->dst_type = BDADDR_BREDR;
706 while (opt != BT_IO_OPT_INVALID) {
708 case BT_IO_OPT_SOURCE:
709 str = va_arg(args, const char *);
710 str2ba(str, &opts->src);
712 case BT_IO_OPT_SOURCE_BDADDR:
713 bacpy(&opts->src, va_arg(args, const bdaddr_t *));
716 str2ba(va_arg(args, const char *), &opts->dst);
718 case BT_IO_OPT_DEST_BDADDR:
719 bacpy(&opts->dst, va_arg(args, const bdaddr_t *));
721 case BT_IO_OPT_DEST_TYPE:
722 opts->dst_type = va_arg(args, int);
724 case BT_IO_OPT_DEFER_TIMEOUT:
725 opts->defer = va_arg(args, int);
727 case BT_IO_OPT_SEC_LEVEL:
728 opts->sec_level = va_arg(args, int);
730 case BT_IO_OPT_CHANNEL:
731 opts->channel = va_arg(args, int);
734 opts->psm = va_arg(args, int);
737 opts->cid = va_arg(args, int);
740 opts->mtu = va_arg(args, int);
741 opts->imtu = opts->mtu;
742 opts->omtu = opts->mtu;
745 opts->omtu = va_arg(args, int);
747 opts->mtu = opts->omtu;
750 opts->imtu = va_arg(args, int);
752 opts->mtu = opts->imtu;
754 case BT_IO_OPT_MASTER:
755 opts->master = va_arg(args, gboolean);
758 opts->mode = va_arg(args, int);
760 case BT_IO_OPT_FLUSHABLE:
761 opts->flushable = va_arg(args, gboolean);
763 case BT_IO_OPT_PRIORITY:
764 opts->priority = va_arg(args, int);
767 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
768 "Unknown option %d", opt);
772 opt = va_arg(args, int);
778 static gboolean get_peers(int sock, struct sockaddr *src, struct sockaddr *dst,
779 socklen_t len, GError **err)
785 if (getsockname(sock, src, &olen) < 0) {
786 ERROR_FAILED(err, "getsockname", errno);
792 if (getpeername(sock, dst, &olen) < 0) {
793 ERROR_FAILED(err, "getpeername", errno);
800 static int l2cap_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
802 struct l2cap_conninfo info;
806 if (getsockopt(sock, SOL_L2CAP, L2CAP_CONNINFO, &info, &len) < 0)
810 *handle = info.hci_handle;
813 memcpy(dev_class, info.dev_class, 3);
818 static int l2cap_get_flushable(int sock, gboolean *flushable)
825 if (getsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, &len) < 0)
836 static int get_priority(int sock, uint32_t *prio)
841 if (getsockopt(sock, SOL_SOCKET, SO_PRIORITY, prio, &len) < 0)
847 static gboolean l2cap_get(int sock, GError **err, BtIOOption opt1,
850 BtIOOption opt = opt1;
851 struct sockaddr_l2 src, dst;
852 struct l2cap_options l2o;
854 uint8_t dev_class[3];
857 gboolean flushable = FALSE;
861 memset(&l2o, 0, len);
862 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
863 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
867 if (!get_peers(sock, (struct sockaddr *) &src,
868 (struct sockaddr *) &dst, sizeof(src), err))
871 while (opt != BT_IO_OPT_INVALID) {
873 case BT_IO_OPT_SOURCE:
874 ba2str(&src.l2_bdaddr, va_arg(args, char *));
876 case BT_IO_OPT_SOURCE_BDADDR:
877 bacpy(va_arg(args, bdaddr_t *), &src.l2_bdaddr);
880 ba2str(&dst.l2_bdaddr, va_arg(args, char *));
882 case BT_IO_OPT_DEST_BDADDR:
883 bacpy(va_arg(args, bdaddr_t *), &dst.l2_bdaddr);
885 case BT_IO_OPT_DEST_TYPE:
886 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
889 case BT_IO_OPT_DEFER_TIMEOUT:
891 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
892 va_arg(args, int *), &len) < 0) {
893 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
898 case BT_IO_OPT_SEC_LEVEL:
899 if (!get_sec_level(sock, BT_IO_L2CAP,
900 va_arg(args, int *), err))
903 case BT_IO_OPT_KEY_SIZE:
904 if (!get_key_size(sock, va_arg(args, int *), err))
908 *(va_arg(args, uint16_t *)) = src.l2_psm ?
909 btohs(src.l2_psm) : btohs(dst.l2_psm);
912 *(va_arg(args, uint16_t *)) = src.l2_cid ?
913 btohs(src.l2_cid) : btohs(dst.l2_cid);
916 *(va_arg(args, uint16_t *)) = l2o.omtu;
919 *(va_arg(args, uint16_t *)) = l2o.imtu;
921 case BT_IO_OPT_MASTER:
923 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags,
925 ERROR_FAILED(err, "getsockopt(L2CAP_LM)",
929 *(va_arg(args, gboolean *)) =
930 (flags & L2CAP_LM_MASTER) ? TRUE : FALSE;
932 case BT_IO_OPT_HANDLE:
933 if (l2cap_get_info(sock, &handle, dev_class) < 0) {
934 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
937 *(va_arg(args, uint16_t *)) = handle;
939 case BT_IO_OPT_CLASS:
940 if (l2cap_get_info(sock, &handle, dev_class) < 0) {
941 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
944 memcpy(va_arg(args, uint8_t *), dev_class, 3);
947 *(va_arg(args, uint8_t *)) = l2o.mode;
949 case BT_IO_OPT_FLUSHABLE:
950 if (l2cap_get_flushable(sock, &flushable) < 0) {
951 ERROR_FAILED(err, "get_flushable", errno);
954 *(va_arg(args, gboolean *)) = flushable;
956 case BT_IO_OPT_PRIORITY:
957 if (get_priority(sock, &priority) < 0) {
958 ERROR_FAILED(err, "get_priority", errno);
961 *(va_arg(args, uint32_t *)) = priority;
964 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
965 "Unknown option %d", opt);
969 opt = va_arg(args, int);
975 static int rfcomm_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
977 struct rfcomm_conninfo info;
981 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_CONNINFO, &info, &len) < 0)
985 *handle = info.hci_handle;
988 memcpy(dev_class, info.dev_class, 3);
993 static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1,
996 BtIOOption opt = opt1;
997 struct sockaddr_rc src, dst;
1000 uint8_t dev_class[3];
1003 if (!get_peers(sock, (struct sockaddr *) &src,
1004 (struct sockaddr *) &dst, sizeof(src), err))
1007 while (opt != BT_IO_OPT_INVALID) {
1009 case BT_IO_OPT_SOURCE:
1010 ba2str(&src.rc_bdaddr, va_arg(args, char *));
1012 case BT_IO_OPT_SOURCE_BDADDR:
1013 bacpy(va_arg(args, bdaddr_t *), &src.rc_bdaddr);
1015 case BT_IO_OPT_DEST:
1016 ba2str(&dst.rc_bdaddr, va_arg(args, char *));
1018 case BT_IO_OPT_DEST_BDADDR:
1019 bacpy(va_arg(args, bdaddr_t *), &dst.rc_bdaddr);
1021 case BT_IO_OPT_DEFER_TIMEOUT:
1023 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
1024 va_arg(args, int *), &len) < 0) {
1025 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
1030 case BT_IO_OPT_SEC_LEVEL:
1031 if (!get_sec_level(sock, BT_IO_RFCOMM,
1032 va_arg(args, int *), err))
1035 case BT_IO_OPT_CHANNEL:
1036 *(va_arg(args, uint8_t *)) = src.rc_channel ?
1037 src.rc_channel : dst.rc_channel;
1039 case BT_IO_OPT_SOURCE_CHANNEL:
1040 *(va_arg(args, uint8_t *)) = src.rc_channel;
1042 case BT_IO_OPT_DEST_CHANNEL:
1043 *(va_arg(args, uint8_t *)) = dst.rc_channel;
1045 case BT_IO_OPT_MASTER:
1046 len = sizeof(flags);
1047 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags,
1049 ERROR_FAILED(err, "getsockopt(RFCOMM_LM)",
1053 *(va_arg(args, gboolean *)) =
1054 (flags & RFCOMM_LM_MASTER) ? TRUE : FALSE;
1056 case BT_IO_OPT_HANDLE:
1057 if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1058 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1061 *(va_arg(args, uint16_t *)) = handle;
1063 case BT_IO_OPT_CLASS:
1064 if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1065 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1068 memcpy(va_arg(args, uint8_t *), dev_class, 3);
1071 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1072 "Unknown option %d", opt);
1076 opt = va_arg(args, int);
1082 static int sco_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
1084 struct sco_conninfo info;
1088 if (getsockopt(sock, SOL_SCO, SCO_CONNINFO, &info, &len) < 0)
1092 *handle = info.hci_handle;
1095 memcpy(dev_class, info.dev_class, 3);
1100 static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args)
1102 BtIOOption opt = opt1;
1103 struct sockaddr_sco src, dst;
1104 struct sco_options sco_opt;
1106 uint8_t dev_class[3];
1109 len = sizeof(sco_opt);
1110 memset(&sco_opt, 0, len);
1111 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
1112 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
1116 if (!get_peers(sock, (struct sockaddr *) &src,
1117 (struct sockaddr *) &dst, sizeof(src), err))
1120 while (opt != BT_IO_OPT_INVALID) {
1122 case BT_IO_OPT_SOURCE:
1123 ba2str(&src.sco_bdaddr, va_arg(args, char *));
1125 case BT_IO_OPT_SOURCE_BDADDR:
1126 bacpy(va_arg(args, bdaddr_t *), &src.sco_bdaddr);
1128 case BT_IO_OPT_DEST:
1129 ba2str(&dst.sco_bdaddr, va_arg(args, char *));
1131 case BT_IO_OPT_DEST_BDADDR:
1132 bacpy(va_arg(args, bdaddr_t *), &dst.sco_bdaddr);
1135 case BT_IO_OPT_IMTU:
1136 case BT_IO_OPT_OMTU:
1137 *(va_arg(args, uint16_t *)) = sco_opt.mtu;
1139 case BT_IO_OPT_HANDLE:
1140 if (sco_get_info(sock, &handle, dev_class) < 0) {
1141 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1144 *(va_arg(args, uint16_t *)) = handle;
1146 case BT_IO_OPT_CLASS:
1147 if (sco_get_info(sock, &handle, dev_class) < 0) {
1148 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1151 memcpy(va_arg(args, uint8_t *), dev_class, 3);
1154 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1155 "Unknown option %d", opt);
1159 opt = va_arg(args, int);
1165 static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err,
1166 BtIOOption opt1, va_list args)
1170 sock = g_io_channel_unix_get_fd(io);
1176 return l2cap_get(sock, err, opt1, args);
1178 return rfcomm_get(sock, err, opt1, args);
1180 return sco_get(sock, err, opt1, args);
1183 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1184 "Unknown BtIO type %d", type);
1188 gboolean bt_io_accept(GIOChannel *io, BtIOConnect connect, gpointer user_data,
1189 GDestroyNotify destroy, GError **err)
1195 sock = g_io_channel_unix_get_fd(io);
1197 memset(&pfd, 0, sizeof(pfd));
1199 pfd.events = POLLOUT;
1201 if (poll(&pfd, 1, 0) < 0) {
1202 ERROR_FAILED(err, "poll", errno);
1206 if (!(pfd.revents & POLLOUT)) {
1207 if (read(sock, &c, 1) < 0) {
1208 ERROR_FAILED(err, "read", errno);
1213 accept_add(io, connect, user_data, destroy);
1218 gboolean bt_io_set(GIOChannel *io, BtIOType type, GError **err,
1219 BtIOOption opt1, ...)
1223 struct set_opts opts;
1226 va_start(args, opt1);
1227 ret = parse_set_opts(&opts, err, opt1, args);
1233 sock = g_io_channel_unix_get_fd(io);
1239 return l2cap_set(sock, opts.sec_level, opts.imtu, opts.omtu,
1240 opts.mode, opts.master, opts.flushable,
1241 opts.priority, err);
1243 return rfcomm_set(sock, opts.sec_level, opts.master, err);
1245 return sco_set(sock, opts.mtu, err);
1248 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1249 "Unknown BtIO type %d", type);
1253 gboolean bt_io_get(GIOChannel *io, BtIOType type, GError **err,
1254 BtIOOption opt1, ...)
1259 va_start(args, opt1);
1260 ret = get_valist(io, type, err, opt1, args);
1266 static GIOChannel *create_io(BtIOType type, gboolean server,
1267 struct set_opts *opts, GError **err)
1274 sock = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1276 ERROR_FAILED(err, "socket(RAW, L2CAP)", errno);
1279 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0,
1280 opts->cid, err) < 0)
1282 if (!l2cap_set(sock, opts->sec_level, 0, 0, 0, -1, -1, 0, err))
1286 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
1288 ERROR_FAILED(err, "socket(SEQPACKET, L2CAP)", errno);
1291 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0,
1292 opts->cid, err) < 0)
1294 if (!l2cap_set(sock, opts->sec_level, opts->imtu, opts->omtu,
1295 opts->mode, opts->master, opts->flushable,
1296 opts->priority, err))
1300 sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_L2CAP);
1302 ERROR_FAILED(err, "socket(STREAM, L2CAP)", errno);
1305 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0,
1306 opts->cid, err) < 0)
1308 if (!l2cap_set(sock, opts->sec_level, opts->imtu, opts->omtu,
1309 opts->mode, opts->master, opts->flushable,
1310 opts->priority, err))
1314 sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1316 ERROR_FAILED(err, "socket(STREAM, RFCOMM)", errno);
1319 if (rfcomm_bind(sock, &opts->src,
1320 server ? opts->channel : 0, err) < 0)
1322 if (!rfcomm_set(sock, opts->sec_level, opts->master, err))
1326 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
1328 ERROR_FAILED(err, "socket(SEQPACKET, SCO)", errno);
1331 if (sco_bind(sock, &opts->src, err) < 0)
1333 if (!sco_set(sock, opts->mtu, err))
1337 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1338 "Unknown BtIO type %d", type);
1342 io = g_io_channel_unix_new(sock);
1344 g_io_channel_set_close_on_unref(io, TRUE);
1345 g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
1355 GIOChannel *bt_io_connect(BtIOType type, BtIOConnect connect,
1356 gpointer user_data, GDestroyNotify destroy,
1357 GError **gerr, BtIOOption opt1, ...)
1361 struct set_opts opts;
1365 va_start(args, opt1);
1366 ret = parse_set_opts(&opts, gerr, opt1, args);
1372 io = create_io(type, FALSE, &opts, gerr);
1376 sock = g_io_channel_unix_get_fd(io);
1380 err = l2cap_connect(sock, &opts.dst, opts.dst_type, 0,
1385 err = l2cap_connect(sock, &opts.dst, opts.dst_type,
1386 opts.psm, opts.cid);
1389 err = rfcomm_connect(sock, &opts.dst, opts.channel);
1392 err = sco_connect(sock, &opts.dst);
1395 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1396 "Unknown BtIO type %d", type);
1401 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED,
1402 "connect: %s (%d)", strerror(-err), -err);
1403 g_io_channel_unref(io);
1407 connect_add(io, connect, user_data, destroy);
1412 GIOChannel *bt_io_listen(BtIOType type, BtIOConnect connect,
1413 BtIOConfirm confirm, gpointer user_data,
1414 GDestroyNotify destroy, GError **err,
1415 BtIOOption opt1, ...)
1419 struct set_opts opts;
1423 if (type == BT_IO_L2RAW) {
1424 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS,
1425 "Server L2CAP RAW sockets not supported");
1429 va_start(args, opt1);
1430 ret = parse_set_opts(&opts, err, opt1, args);
1436 io = create_io(type, TRUE, &opts, err);
1440 sock = g_io_channel_unix_get_fd(io);
1443 setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &opts.defer,
1444 sizeof(opts.defer));
1446 if (listen(sock, 5) < 0) {
1447 ERROR_FAILED(err, "listen", errno);
1448 g_io_channel_unref(io);
1452 server_add(io, connect, confirm, user_data, destroy);
1457 GQuark bt_io_error_quark(void)
1459 return g_quark_from_static_string("bt-io-error-quark");