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