btio/btio.c

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