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