audio/unix.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   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
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <fcntl.h>
  31 #include <sys/socket.h>
  32 #include <sys/un.h>
  33 #include <stdlib.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <stdint.h>
  37
  38 #include <bluetooth/bluetooth.h>
  39 #include <bluetooth/sdp.h>
  40 #include <dbus/dbus.h>
  41 #include <glib.h>
  42
  43 #include "log.h"
  44 #include "ipc.h"
  45 #include "device.h"
  46 #include "manager.h"
  47 #include "avdtp.h"
  48 #include "media.h"
  49 #include "a2dp.h"
  50 #include "headset.h"
  51 #include "sink.h"
  52 #include "source.h"
  53 #include "gateway.h"
  54 #include "unix.h"
  55
  56 #define check_nul(str) (str[sizeof(str) - 1] == '\0')
  57
  58 typedef enum {
  59         TYPE_NONE,
  60         TYPE_HEADSET,
  61         TYPE_GATEWAY,
  62         TYPE_SINK,
  63         TYPE_SOURCE
  64 } service_type_t;
  65
  66 typedef void (*notify_cb_t) (struct audio_device *dev, void *data);
  67
  68 struct a2dp_data {
  69         struct avdtp *session;
  70         struct avdtp_stream *stream;
  71         struct a2dp_sep *sep;
  72 };
  73
  74 struct headset_data {
  75         gboolean locked;
  76 };
  77
  78 struct unix_client {
  79         struct audio_device *dev;
  80         GSList *caps;
  81         service_type_t type;
  82         char *interface;
  83         uint8_t seid;
  84         union {
  85                 struct a2dp_data a2dp;
  86                 struct headset_data hs;
  87         } d;
  88         int sock;
  89         int lock;
  90         int data_fd; /* To be deleted once two phase configuration is fully implemented */
  91         unsigned int req_id;
  92         unsigned int cb_id;
  93         gboolean (*cancel) (struct audio_device *dev, unsigned int id);
  94 };
  95
  96 static GSList *clients = NULL;
  97
  98 static int unix_sock = -1;
  99
 100 static void client_free(void *data)
 101 {
 102         struct unix_client *client = data;
 103
 104         DBG("client_free(%p)", client);
 105
 106         if (client->cancel && client->dev && client->req_id > 0)
 107                 client->cancel(client->dev, client->req_id);
 108
 109         if (client->sock >= 0)
 110                 close(client->sock);
 111
 112         g_slist_free_full(client->caps, g_free);
 113
 114         g_free(client->interface);
 115         g_free(client);
 116 }
 117
 118 static int set_nonblocking(int fd)
 119 {
 120         long arg;
 121
 122         arg = fcntl(fd, F_GETFL);
 123         if (arg < 0)
 124                 return -errno;
 125
 126         /* Return if already nonblocking */
 127         if (arg & O_NONBLOCK)
 128                 return 0;
 129
 130         arg |= O_NONBLOCK;
 131         if (fcntl(fd, F_SETFL, arg) < 0)
 132                 return -errno;
 133
 134         return 0;
 135 }
 136
 137 /* Pass file descriptor through local domain sockets (AF_LOCAL, formerly
 138  * AF_UNIX) and the sendmsg() system call with the cmsg_type field of a "struct
 139  * cmsghdr" set to SCM_RIGHTS and the data being an integer value equal to the
 140  * handle of the file descriptor to be passed. */
 141 static int unix_sendmsg_fd(int sock, int fd)
 142 {
 143         char cmsg_b[CMSG_SPACE(sizeof(int))], m = 'm';
 144         struct cmsghdr *cmsg;
 145         struct iovec iov = { &m, sizeof(m) };
 146         struct msghdr msgh;
 147
 148         memset(&msgh, 0, sizeof(msgh));
 149         msgh.msg_iov = &iov;
 150         msgh.msg_iovlen = 1;
 151         msgh.msg_control = &cmsg_b;
 152         msgh.msg_controllen = CMSG_LEN(sizeof(int));
 153
 154         cmsg = CMSG_FIRSTHDR(&msgh);
 155         cmsg->cmsg_level = SOL_SOCKET;
 156         cmsg->cmsg_type = SCM_RIGHTS;
 157         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 158         /* Initialize the payload */
 159         memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
 160
 161         return sendmsg(sock, &msgh, MSG_NOSIGNAL);
 162 }
 163
 164 static void unix_ipc_sendmsg(struct unix_client *client,
 165                                         const bt_audio_msg_header_t *msg)
 166 {
 167         const char *type = bt_audio_strtype(msg->type);
 168         const char *name = bt_audio_strname(msg->name);
 169
 170         DBG("Audio API: %s -> %s", type, name);
 171
 172         if (send(client->sock, msg, msg->length, 0) < 0)
 173                 error("Error %s(%d)", strerror(errno), errno);
 174 }
 175
 176 static void unix_ipc_error(struct unix_client *client, uint8_t name, int err)
 177 {
 178         char buf[BT_SUGGESTED_BUFFER_SIZE];
 179         bt_audio_error_t *rsp = (void *) buf;
 180
 181         if (!g_slist_find(clients, client))
 182                 return;
 183
 184         memset(buf, 0, sizeof(buf));
 185         rsp->h.type = BT_ERROR;
 186         rsp->h.name = name;
 187         rsp->h.length = sizeof(*rsp);
 188
 189         rsp->posix_errno = err;
 190
 191         DBG("sending error %s(%d)", strerror(err), err);
 192         unix_ipc_sendmsg(client, &rsp->h);
 193 }
 194
 195 static service_type_t select_service(struct audio_device *dev, const char *interface)
 196 {
 197         if (!interface) {
 198                 if (dev->sink && avdtp_is_connected(&dev->src, &dev->dst))
 199                         return TYPE_SINK;
 200                 else if (dev->source && avdtp_is_connected(&dev->src,
 201                                                                 &dev->dst))
 202                         return TYPE_SOURCE;
 203                 else if (dev->headset && headset_is_active(dev))
 204                         return TYPE_HEADSET;
 205                 else if (dev->sink)
 206                         return TYPE_SINK;
 207                 else if (dev->source)
 208                         return TYPE_SOURCE;
 209                 else if (dev->headset)
 210                         return TYPE_HEADSET;
 211         } else if (!strcmp(interface, AUDIO_SOURCE_INTERFACE) && dev->source)
 212                 return TYPE_SOURCE;
 213         else if (!strcmp(interface, AUDIO_SINK_INTERFACE) && dev->sink)
 214                 return TYPE_SINK;
 215         else if (!strcmp(interface, AUDIO_HEADSET_INTERFACE) && dev->headset)
 216                 return TYPE_HEADSET;
 217         else if (!strcmp(interface, AUDIO_GATEWAY_INTERFACE) && dev->gateway)
 218                 return TYPE_GATEWAY;
 219
 220         return TYPE_NONE;
 221 }
 222
 223 static void stream_state_changed(struct avdtp_stream *stream,
 224                                         avdtp_state_t old_state,
 225                                         avdtp_state_t new_state,
 226                                         struct avdtp_error *err,
 227                                         void *user_data)
 228 {
 229         struct unix_client *client = user_data;
 230         struct a2dp_data *a2dp = &client->d.a2dp;
 231
 232         switch (new_state) {
 233         case AVDTP_STATE_IDLE:
 234                 if (a2dp->sep) {
 235                         a2dp_sep_unlock(a2dp->sep, a2dp->session);
 236                         a2dp->sep = NULL;
 237                 }
 238                 if (a2dp->session) {
 239                         avdtp_unref(a2dp->session);
 240                         a2dp->session = NULL;
 241                 }
 242                 a2dp->stream = NULL;
 243                 client->cb_id = 0;
 244                 break;
 245         default:
 246                 break;
 247         }
 248 }
 249
 250 static uint8_t headset_generate_capability(struct audio_device *dev,
 251                                                 codec_capabilities_t *codec)
 252 {
 253         pcm_capabilities_t *pcm;
 254
 255         codec->seid = BT_A2DP_SEID_RANGE + 1;
 256         codec->transport = BT_CAPABILITIES_TRANSPORT_SCO;
 257         codec->type = BT_HFP_CODEC_PCM;
 258         codec->length = sizeof(*pcm);
 259
 260         pcm = (void *) codec;
 261         pcm->sampling_rate = 8000;
 262         if (dev->headset) {
 263                 if (headset_get_nrec(dev))
 264                         pcm->flags |= BT_PCM_FLAG_NREC;
 265                 if (!headset_get_sco_hci(dev))
 266                         pcm->flags |= BT_PCM_FLAG_PCM_ROUTING;
 267                 codec->configured = headset_is_active(dev);
 268                 codec->lock = headset_get_lock(dev);
 269         } else {
 270                 pcm->flags |= BT_PCM_FLAG_NREC;
 271                 codec->configured = TRUE;
 272                 codec->lock = 0;
 273         }
 274
 275         return codec->length;
 276 }
 277
 278 static void headset_discovery_complete(struct audio_device *dev, void *user_data)
 279 {
 280         struct unix_client *client = user_data;
 281         char buf[BT_SUGGESTED_BUFFER_SIZE];
 282         struct bt_get_capabilities_rsp *rsp = (void *) buf;
 283         uint8_t length;
 284
 285         client->req_id = 0;
 286
 287         if (!dev)
 288                 goto failed;
 289
 290         memset(buf, 0, sizeof(buf));
 291
 292         length = headset_generate_capability(dev, (void *) rsp->data);
 293
 294         rsp->h.type = BT_RESPONSE;
 295         rsp->h.name = BT_GET_CAPABILITIES;
 296         rsp->h.length = sizeof(*rsp) + length;
 297
 298         ba2str(&dev->src, rsp->source);
 299         ba2str(&dev->dst, rsp->destination);
 300         strncpy(rsp->object, dev->path, sizeof(rsp->object));
 301
 302         unix_ipc_sendmsg(client, &rsp->h);
 303
 304         return;
 305
 306 failed:
 307         error("discovery failed");
 308         unix_ipc_error(client, BT_SET_CONFIGURATION, EIO);
 309 }
 310
 311 static void headset_setup_complete(struct audio_device *dev, void *user_data)
 312 {
 313         struct unix_client *client = user_data;
 314         char buf[BT_SUGGESTED_BUFFER_SIZE];
 315         struct bt_set_configuration_rsp *rsp = (void *) buf;
 316
 317         client->req_id = 0;
 318
 319         if (!dev)
 320                 goto failed;
 321
 322         memset(buf, 0, sizeof(buf));
 323
 324         rsp->h.type = BT_RESPONSE;
 325         rsp->h.name = BT_SET_CONFIGURATION;
 326         rsp->h.length = sizeof(*rsp);
 327
 328         rsp->link_mtu = 48;
 329
 330         client->data_fd = headset_get_sco_fd(dev);
 331
 332         unix_ipc_sendmsg(client, &rsp->h);
 333
 334         return;
 335
 336 failed:
 337         error("config failed");
 338         unix_ipc_error(client, BT_SET_CONFIGURATION, EIO);
 339 }
 340
 341 static void gateway_setup_complete(struct audio_device *dev, GError *err, void *user_data)
 342 {
 343         struct unix_client *client = user_data;
 344         char buf[BT_SUGGESTED_BUFFER_SIZE];
 345         struct bt_set_configuration_rsp *rsp = (void *) buf;
 346
 347         if (err) {
 348                 unix_ipc_error(client, BT_SET_CONFIGURATION, err->code);
 349                 return;
 350         }
 351
 352         client->req_id = 0;
 353
 354         memset(buf, 0, sizeof(buf));
 355
 356         rsp->h.type = BT_RESPONSE;
 357         rsp->h.name = BT_SET_CONFIGURATION;
 358         rsp->h.length = sizeof(*rsp);
 359
 360         rsp->link_mtu = 48;
 361
 362         client->data_fd = gateway_get_sco_fd(dev);
 363
 364         unix_ipc_sendmsg(client, &rsp->h);
 365 }
 366
 367 static void headset_resume_complete(struct audio_device *dev, void *user_data)
 368 {
 369         struct unix_client *client = user_data;
 370         char buf[BT_SUGGESTED_BUFFER_SIZE];
 371         struct bt_start_stream_rsp *rsp = (void *) buf;
 372         struct bt_new_stream_ind *ind = (void *) buf;
 373
 374         client->req_id = 0;
 375
 376         if (!dev)
 377                 goto failed;
 378
 379         client->data_fd = headset_get_sco_fd(dev);
 380         if (client->data_fd < 0) {
 381                 error("Unable to get a SCO fd");
 382                 goto failed;
 383         }
 384
 385         memset(buf, 0, sizeof(buf));
 386         rsp->h.type = BT_RESPONSE;
 387         rsp->h.name = BT_START_STREAM;
 388         rsp->h.length = sizeof(*rsp);
 389
 390         unix_ipc_sendmsg(client, &rsp->h);
 391
 392         memset(buf, 0, sizeof(buf));
 393         ind->h.type = BT_INDICATION;
 394         ind->h.name = BT_NEW_STREAM;
 395         ind->h.length = sizeof(*ind);
 396
 397         unix_ipc_sendmsg(client, &ind->h);
 398
 399         if (unix_sendmsg_fd(client->sock, client->data_fd) < 0) {
 400                 error("unix_sendmsg_fd: %s(%d)", strerror(errno), errno);
 401                 goto failed;
 402         }
 403
 404         return;
 405
 406 failed:
 407         error("headset_resume_complete: resume failed");
 408         unix_ipc_error(client, BT_START_STREAM, EIO);
 409 }
 410
 411 static void gateway_resume_complete(struct audio_device *dev, GError *err, void *user_data)
 412 {
 413         struct unix_client *client = user_data;
 414         char buf[BT_SUGGESTED_BUFFER_SIZE];
 415         struct bt_start_stream_rsp *rsp = (void *) buf;
 416         struct bt_new_stream_ind *ind = (void *) buf;
 417
 418         if (err) {
 419                 unix_ipc_error(client, BT_START_STREAM, err->code);
 420                 return;
 421         }
 422
 423         memset(buf, 0, sizeof(buf));
 424         rsp->h.type = BT_RESPONSE;
 425         rsp->h.name = BT_START_STREAM;
 426         rsp->h.length = sizeof(*rsp);
 427
 428         unix_ipc_sendmsg(client, &rsp->h);
 429
 430         memset(buf, 0, sizeof(buf));
 431         ind->h.type = BT_INDICATION;
 432         ind->h.name = BT_NEW_STREAM;
 433         ind->h.length = sizeof(*ind);
 434
 435         unix_ipc_sendmsg(client, &ind->h);
 436
 437         client->data_fd = gateway_get_sco_fd(dev);
 438         if (unix_sendmsg_fd(client->sock, client->data_fd) < 0) {
 439                 error("unix_sendmsg_fd: %s(%d)", strerror(errno), errno);
 440                 unix_ipc_error(client, BT_START_STREAM, EIO);
 441         }
 442
 443         client->req_id = 0;
 444 }
 445
 446 static void headset_suspend_complete(struct audio_device *dev, void *user_data)
 447 {
 448         struct unix_client *client = user_data;
 449         char buf[BT_SUGGESTED_BUFFER_SIZE];
 450         struct bt_stop_stream_rsp *rsp = (void *) buf;
 451
 452         if (!dev)
 453                 goto failed;
 454
 455         memset(buf, 0, sizeof(buf));
 456         rsp->h.type = BT_RESPONSE;
 457         rsp->h.name = BT_STOP_STREAM;
 458         rsp->h.length = sizeof(*rsp);
 459
 460         unix_ipc_sendmsg(client, &rsp->h);
 461
 462         return;
 463
 464 failed:
 465         error("suspend failed");
 466         unix_ipc_error(client, BT_STOP_STREAM, EIO);
 467 }
 468
 469 static void print_mpeg12(struct mpeg_codec_cap *mpeg)
 470 {
 471         DBG("Media Codec: MPEG12"
 472                 " Channel Modes: %s%s%s%s"
 473                 " Frequencies: %s%s%s%s%s%s"
 474                 " Layers: %s%s%s"
 475                 " CRC: %s",
 476                 mpeg->channel_mode & MPEG_CHANNEL_MODE_MONO ? "Mono " : "",
 477                 mpeg->channel_mode & MPEG_CHANNEL_MODE_DUAL_CHANNEL ?
 478                 "DualChannel " : "",
 479                 mpeg->channel_mode & MPEG_CHANNEL_MODE_STEREO ? "Stereo " : "",
 480                 mpeg->channel_mode & MPEG_CHANNEL_MODE_JOINT_STEREO ?
 481                 "JointStereo " : "",
 482                 mpeg->frequency & MPEG_SAMPLING_FREQ_16000 ? "16Khz " : "",
 483                 mpeg->frequency & MPEG_SAMPLING_FREQ_22050 ? "22.05Khz " : "",
 484                 mpeg->frequency & MPEG_SAMPLING_FREQ_24000 ? "24Khz " : "",
 485                 mpeg->frequency & MPEG_SAMPLING_FREQ_32000 ? "32Khz " : "",
 486                 mpeg->frequency & MPEG_SAMPLING_FREQ_44100 ? "44.1Khz " : "",
 487                 mpeg->frequency & MPEG_SAMPLING_FREQ_48000 ? "48Khz " : "",
 488                 mpeg->layer & MPEG_LAYER_MP1 ? "1 " : "",
 489                 mpeg->layer & MPEG_LAYER_MP2 ? "2 " : "",
 490                 mpeg->layer & MPEG_LAYER_MP3 ? "3 " : "",
 491                 mpeg->crc ? "Yes" : "No");
 492 }
 493
 494 static void print_sbc(struct sbc_codec_cap *sbc)
 495 {
 496         DBG("Media Codec: SBC"
 497                 " Channel Modes: %s%s%s%s"
 498                 " Frequencies: %s%s%s%s"
 499                 " Subbands: %s%s"
 500                 " Blocks: %s%s%s%s"
 501                 " Bitpool: %d-%d",
 502                 sbc->channel_mode & SBC_CHANNEL_MODE_MONO ? "Mono " : "",
 503                 sbc->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL ?
 504                 "DualChannel " : "",
 505                 sbc->channel_mode & SBC_CHANNEL_MODE_STEREO ? "Stereo " : "",
 506                 sbc->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO ? "JointStereo" : "",
 507                 sbc->frequency & SBC_SAMPLING_FREQ_16000 ? "16Khz " : "",
 508                 sbc->frequency & SBC_SAMPLING_FREQ_32000 ? "32Khz " : "",
 509                 sbc->frequency & SBC_SAMPLING_FREQ_44100 ? "44.1Khz " : "",
 510                 sbc->frequency & SBC_SAMPLING_FREQ_48000 ? "48Khz " : "",
 511                 sbc->subbands & SBC_SUBBANDS_4 ? "4 " : "",
 512                 sbc->subbands & SBC_SUBBANDS_8 ? "8 " : "",
 513                 sbc->block_length & SBC_BLOCK_LENGTH_4 ? "4 " : "",
 514                 sbc->block_length & SBC_BLOCK_LENGTH_8 ? "8 " : "",
 515                 sbc->block_length & SBC_BLOCK_LENGTH_12 ? "12 " : "",
 516                 sbc->block_length & SBC_BLOCK_LENGTH_16 ? "16 " : "",
 517                 sbc->min_bitpool, sbc->max_bitpool);
 518 }
 519
 520 static int a2dp_append_codec(struct bt_get_capabilities_rsp *rsp,
 521                                 struct avdtp_service_capability *cap,
 522                                 uint8_t seid,
 523                                 uint8_t type,
 524                                 uint8_t configured,
 525                                 uint8_t lock)
 526 {
 527         struct avdtp_media_codec_capability *codec_cap = (void *) cap->data;
 528         codec_capabilities_t *codec = (void *) rsp + rsp->h.length;
 529         size_t space_left;
 530
 531         if (rsp->h.length > BT_SUGGESTED_BUFFER_SIZE)
 532                 return -ENOMEM;
 533
 534         space_left = BT_SUGGESTED_BUFFER_SIZE - rsp->h.length;
 535
 536         /* endianness prevents direct cast */
 537         if (codec_cap->media_codec_type == A2DP_CODEC_SBC) {
 538                 struct sbc_codec_cap *sbc_cap = (void *) codec_cap;
 539                 sbc_capabilities_t *sbc = (void *) codec;
 540
 541                 if (space_left < sizeof(sbc_capabilities_t))
 542                         return -ENOMEM;
 543
 544                 if (type == AVDTP_SEP_TYPE_SINK)
 545                         codec->type = BT_A2DP_SBC_SINK;
 546                 else if (type == AVDTP_SEP_TYPE_SOURCE)
 547                         codec->type = BT_A2DP_SBC_SOURCE;
 548                 else
 549                         return -EINVAL;
 550
 551                 codec->length = sizeof(sbc_capabilities_t);
 552
 553                 sbc->channel_mode = sbc_cap->channel_mode;
 554                 sbc->frequency = sbc_cap->frequency;
 555                 sbc->allocation_method = sbc_cap->allocation_method;
 556                 sbc->subbands = sbc_cap->subbands;
 557                 sbc->block_length = sbc_cap->block_length;
 558                 sbc->min_bitpool = sbc_cap->min_bitpool;
 559                 sbc->max_bitpool = sbc_cap->max_bitpool;
 560
 561                 print_sbc(sbc_cap);
 562         } else if (codec_cap->media_codec_type == A2DP_CODEC_MPEG12) {
 563                 struct mpeg_codec_cap *mpeg_cap = (void *) codec_cap;
 564                 mpeg_capabilities_t *mpeg = (void *) codec;
 565
 566                 if (space_left < sizeof(mpeg_capabilities_t))
 567                         return -ENOMEM;
 568
 569                 if (type == AVDTP_SEP_TYPE_SINK)
 570                         codec->type = BT_A2DP_MPEG12_SINK;
 571                 else if (type == AVDTP_SEP_TYPE_SOURCE)
 572                         codec->type = BT_A2DP_MPEG12_SOURCE;
 573                 else
 574                         return -EINVAL;
 575
 576                 codec->length = sizeof(mpeg_capabilities_t);
 577
 578                 mpeg->channel_mode = mpeg_cap->channel_mode;
 579                 mpeg->crc = mpeg_cap->crc;
 580                 mpeg->layer = mpeg_cap->layer;
 581                 mpeg->frequency = mpeg_cap->frequency;
 582                 mpeg->mpf = mpeg_cap->mpf;
 583                 mpeg->bitrate = mpeg_cap->bitrate;
 584
 585                 print_mpeg12(mpeg_cap);
 586         } else {
 587                 size_t codec_length, type_length, total_length;
 588
 589                 codec_length = cap->length - (sizeof(struct avdtp_service_capability)
 590                                 + sizeof(struct avdtp_media_codec_capability));
 591                 type_length = sizeof(codec_cap->media_codec_type);
 592                 total_length = type_length + codec_length +
 593                                 sizeof(codec_capabilities_t);
 594
 595                 if (space_left < total_length)
 596                         return -ENOMEM;
 597
 598                 if (type == AVDTP_SEP_TYPE_SINK)
 599                         codec->type = BT_A2DP_UNKNOWN_SINK;
 600                 else if (type == AVDTP_SEP_TYPE_SOURCE)
 601                         codec->type = BT_A2DP_UNKNOWN_SOURCE;
 602                 else
 603                         return -EINVAL;
 604
 605                 codec->length = total_length;
 606                 memcpy(codec->data, &codec_cap->media_codec_type, type_length);
 607                 memcpy(codec->data + type_length, codec_cap->data,
 608                         codec_length);
 609         }
 610
 611         codec->seid = seid;
 612         codec->configured = configured;
 613         codec->lock = lock;
 614         rsp->h.length += codec->length;
 615
 616         DBG("Append %s seid %d - length %d - total %d",
 617                 configured ? "configured" : "", seid, codec->length,
 618                 rsp->h.length);
 619
 620         return 0;
 621 }
 622
 623 static void a2dp_discovery_complete(struct avdtp *session, GSList *seps,
 624                                         struct avdtp_error *err,
 625                                         void *user_data)
 626 {
 627         struct unix_client *client = user_data;
 628         char buf[BT_SUGGESTED_BUFFER_SIZE];
 629         struct bt_get_capabilities_rsp *rsp = (void *) buf;
 630         struct a2dp_data *a2dp = &client->d.a2dp;
 631
 632         if (!g_slist_find(clients, client)) {
 633                 DBG("Client disconnected during discovery");
 634                 return;
 635         }
 636
 637         if (err)
 638                 goto failed;
 639
 640         memset(buf, 0, sizeof(buf));
 641         client->req_id = 0;
 642
 643         rsp->h.type = BT_RESPONSE;
 644         rsp->h.name = BT_GET_CAPABILITIES;
 645         rsp->h.length = sizeof(*rsp);
 646         ba2str(&client->dev->src, rsp->source);
 647         ba2str(&client->dev->dst, rsp->destination);
 648         strncpy(rsp->object, client->dev->path, sizeof(rsp->object));
 649
 650         for (; seps; seps = g_slist_next(seps)) {
 651                 struct avdtp_remote_sep *rsep = seps->data;
 652                 struct a2dp_sep *sep;
 653                 struct avdtp_service_capability *cap;
 654                 struct avdtp_stream *stream;
 655                 uint8_t type, seid, configured = 0, lock = 0;
 656                 GSList *cl;
 657
 658                 type = avdtp_get_type(rsep);
 659
 660                 if (type != AVDTP_SEP_TYPE_SINK &&
 661                                                 type != AVDTP_SEP_TYPE_SOURCE)
 662                         continue;
 663
 664                 cap = avdtp_get_codec(rsep);
 665
 666                 if (cap->category != AVDTP_MEDIA_CODEC)
 667                         continue;
 668
 669                 seid = avdtp_get_seid(rsep);
 670
 671                 if (client->seid != 0 && client->seid != seid)
 672                         continue;
 673
 674                 stream = avdtp_get_stream(rsep);
 675                 if (stream) {
 676                         configured = 1;
 677                         if (client->seid == seid)
 678                                 cap = avdtp_stream_get_codec(stream);
 679                 }
 680
 681                 for (cl = clients; cl; cl = cl->next) {
 682                         struct unix_client *c = cl->data;
 683                         struct a2dp_data *ca2dp = &c->d.a2dp;
 684
 685                         if (ca2dp->session == session && c->seid == seid) {
 686                                 lock = c->lock;
 687                                 break;
 688                         }
 689                 }
 690
 691                 sep = a2dp_get_sep(session, stream);
 692                 if (sep && a2dp_sep_get_lock(sep))
 693                         lock = BT_WRITE_LOCK;
 694
 695                 a2dp_append_codec(rsp, cap, seid, type, configured, lock);
 696         }
 697
 698         unix_ipc_sendmsg(client, &rsp->h);
 699
 700         return;
 701
 702 failed:
 703         error("discovery failed");
 704         unix_ipc_error(client, BT_GET_CAPABILITIES, EIO);
 705
 706         if (a2dp->sep) {
 707                 a2dp_sep_unlock(a2dp->sep, a2dp->session);
 708                 a2dp->sep = NULL;
 709         }
 710
 711         avdtp_unref(a2dp->session);
 712         a2dp->session = NULL;
 713         a2dp->stream = NULL;
 714 }
 715
 716 static void a2dp_config_complete(struct avdtp *session, struct a2dp_sep *sep,
 717                                         struct avdtp_stream *stream,
 718                                         struct avdtp_error *err,
 719                                         void *user_data)
 720 {
 721         struct unix_client *client = user_data;
 722         char buf[BT_SUGGESTED_BUFFER_SIZE];
 723         struct bt_set_configuration_rsp *rsp = (void *) buf;
 724         struct a2dp_data *a2dp = &client->d.a2dp;
 725         uint16_t imtu, omtu;
 726         GSList *caps;
 727
 728         client->req_id = 0;
 729
 730         if (err)
 731                 goto failed;
 732
 733         memset(buf, 0, sizeof(buf));
 734
 735         if (!stream)
 736                 goto failed;
 737
 738         if (client->cb_id > 0)
 739                 avdtp_stream_remove_cb(a2dp->session, a2dp->stream,
 740                                                                 client->cb_id);
 741
 742         a2dp->sep = sep;
 743         a2dp->stream = stream;
 744
 745         if (!avdtp_stream_get_transport(stream, &client->data_fd, &imtu, &omtu,
 746                                         &caps)) {
 747                 error("Unable to get stream transport");
 748                 goto failed;
 749         }
 750
 751         rsp->h.type = BT_RESPONSE;
 752         rsp->h.name = BT_SET_CONFIGURATION;
 753         rsp->h.length = sizeof(*rsp);
 754
 755         /* FIXME: Use imtu when fd_opt is CFG_FD_OPT_READ */
 756         rsp->link_mtu = omtu;
 757
 758         unix_ipc_sendmsg(client, &rsp->h);
 759
 760         client->cb_id = avdtp_stream_add_cb(session, stream,
 761                                                 stream_state_changed, client);
 762
 763         return;
 764
 765 failed:
 766         error("config failed");
 767
 768         unix_ipc_error(client, BT_SET_CONFIGURATION, EIO);
 769
 770         avdtp_unref(a2dp->session);
 771
 772         a2dp->session = NULL;
 773         a2dp->stream = NULL;
 774         a2dp->sep = NULL;
 775 }
 776
 777 static void a2dp_resume_complete(struct avdtp *session,
 778                                 struct avdtp_error *err, void *user_data)
 779 {
 780         struct unix_client *client = user_data;
 781         char buf[BT_SUGGESTED_BUFFER_SIZE];
 782         struct bt_start_stream_rsp *rsp = (void *) buf;
 783         struct bt_new_stream_ind *ind = (void *) buf;
 784         struct a2dp_data *a2dp = &client->d.a2dp;
 785
 786         if (err)
 787                 goto failed;
 788
 789         memset(buf, 0, sizeof(buf));
 790         rsp->h.type = BT_RESPONSE;
 791         rsp->h.name = BT_START_STREAM;
 792         rsp->h.length = sizeof(*rsp);
 793
 794         unix_ipc_sendmsg(client, &rsp->h);
 795
 796         memset(buf, 0, sizeof(buf));
 797         ind->h.type = BT_RESPONSE;
 798         ind->h.name = BT_NEW_STREAM;
 799         rsp->h.length = sizeof(*ind);
 800
 801         unix_ipc_sendmsg(client, &ind->h);
 802
 803         if (unix_sendmsg_fd(client->sock, client->data_fd) < 0) {
 804                 error("unix_sendmsg_fd: %s(%d)", strerror(errno), errno);
 805                 goto failed;
 806         }
 807
 808         return;
 809
 810 failed:
 811         error("resume failed");
 812
 813         unix_ipc_error(client, BT_START_STREAM, EIO);
 814
 815         if (client->cb_id > 0) {
 816                 avdtp_stream_remove_cb(a2dp->session, a2dp->stream,
 817                                         client->cb_id);
 818                 client->cb_id = 0;
 819         }
 820
 821         if (a2dp->sep) {
 822                 a2dp_sep_unlock(a2dp->sep, a2dp->session);
 823                 a2dp->sep = NULL;
 824         }
 825
 826         avdtp_unref(a2dp->session);
 827         a2dp->session = NULL;
 828         a2dp->stream = NULL;
 829 }
 830
 831 static void a2dp_suspend_complete(struct avdtp *session,
 832                                 struct avdtp_error *err, void *user_data)
 833 {
 834         struct unix_client *client = user_data;
 835         char buf[BT_SUGGESTED_BUFFER_SIZE];
 836         struct bt_stop_stream_rsp *rsp = (void *) buf;
 837
 838         if (err)
 839                 goto failed;
 840
 841         memset(buf, 0, sizeof(buf));
 842         rsp->h.type = BT_RESPONSE;
 843         rsp->h.name = BT_STOP_STREAM;
 844         rsp->h.length = sizeof(*rsp);
 845
 846         unix_ipc_sendmsg(client, &rsp->h);
 847
 848         return;
 849
 850 failed:
 851         error("suspend failed");
 852
 853         unix_ipc_error(client, BT_STOP_STREAM, EIO);
 854 }
 855
 856 static void start_discovery(struct audio_device *dev, struct unix_client *client)
 857 {
 858         struct a2dp_data *a2dp;
 859         int err = 0;
 860
 861         switch (client->type) {
 862         case TYPE_SINK:
 863         case TYPE_SOURCE:
 864                 a2dp = &client->d.a2dp;
 865
 866                 if (!a2dp->session)
 867                         a2dp->session = avdtp_get(&dev->src, &dev->dst);
 868
 869                 if (!a2dp->session) {
 870                         error("Unable to get a session");
 871                         goto failed;
 872                 }
 873
 874                 err = avdtp_discover(a2dp->session, a2dp_discovery_complete,
 875                                         client);
 876                 if (err) {
 877                         if (a2dp->session) {
 878                                 avdtp_unref(a2dp->session);
 879                                 a2dp->session = NULL;
 880                         }
 881                         goto failed;
 882                 }
 883                 break;
 884
 885         case TYPE_HEADSET:
 886         case TYPE_GATEWAY:
 887                 headset_discovery_complete(dev, client);
 888                 break;
 889
 890         default:
 891                 error("No known services for device");
 892                 goto failed;
 893         }
 894
 895         client->dev = dev;
 896
 897         return;
 898
 899 failed:
 900         unix_ipc_error(client, BT_GET_CAPABILITIES, err ? : EIO);
 901 }
 902
 903 static void open_complete(struct audio_device *dev, void *user_data)
 904 {
 905         struct unix_client *client = user_data;
 906         char buf[BT_SUGGESTED_BUFFER_SIZE];
 907         struct bt_open_rsp *rsp = (void *) buf;
 908
 909         memset(buf, 0, sizeof(buf));
 910
 911         rsp->h.type = BT_RESPONSE;
 912         rsp->h.name = BT_OPEN;
 913         rsp->h.length = sizeof(*rsp);
 914
 915         ba2str(&dev->src, rsp->source);
 916         ba2str(&dev->dst, rsp->destination);
 917         strncpy(rsp->object, dev->path, sizeof(rsp->object));
 918
 919         unix_ipc_sendmsg(client, &rsp->h);
 920 }
 921
 922 static void start_open(struct audio_device *dev, struct unix_client *client)
 923 {
 924         struct a2dp_data *a2dp;
 925         struct headset_data *hs;
 926         struct avdtp_remote_sep *rsep;
 927         gboolean unref_avdtp_on_fail = FALSE;
 928
 929         switch (client->type) {
 930         case TYPE_SINK:
 931         case TYPE_SOURCE:
 932                 a2dp = &client->d.a2dp;
 933
 934                 if (!a2dp->session) {
 935                         a2dp->session = avdtp_get(&dev->src, &dev->dst);
 936                         unref_avdtp_on_fail = TRUE;
 937                 }
 938
 939                 if (!a2dp->session) {
 940                         error("Unable to get a session");
 941                         goto failed;
 942                 }
 943
 944                 if (a2dp->sep) {
 945                         error("Client already has an opened session");
 946                         goto failed;
 947                 }
 948
 949                 rsep = avdtp_get_remote_sep(a2dp->session, client->seid);
 950                 if (!rsep) {
 951                         error("Invalid seid %d", client->seid);
 952                         goto failed;
 953                 }
 954
 955                 a2dp->sep = a2dp_get(a2dp->session, rsep);
 956                 if (!a2dp->sep) {
 957                         error("seid %d not available or locked", client->seid);
 958                         goto failed;
 959                 }
 960
 961                 if (!a2dp_sep_lock(a2dp->sep, a2dp->session)) {
 962                         error("Unable to open seid %d", client->seid);
 963                         a2dp->sep = NULL;
 964                         goto failed;
 965                 }
 966
 967                 break;
 968
 969         case TYPE_HEADSET:
 970                 hs = &client->d.hs;
 971
 972                 if (hs->locked) {
 973                         error("Client already has an opened session");
 974                         goto failed;
 975                 }
 976
 977                 hs->locked = headset_lock(dev, client->lock);
 978                 if (!hs->locked) {
 979                         error("Unable to open seid %d", client->seid);
 980                         goto failed;
 981                 }
 982                 break;
 983
 984         case TYPE_GATEWAY:
 985                 break;
 986         default:
 987                 error("No known services for device");
 988                 goto failed;
 989         }
 990
 991         client->dev = dev;
 992
 993         open_complete(dev, client);
 994
 995         return;
 996
 997 failed:
 998         if (unref_avdtp_on_fail && a2dp->session) {
 999                 avdtp_unref(a2dp->session);
1000                 a2dp->session = NULL;
1001         }
1002         unix_ipc_error(client, BT_OPEN, EINVAL);
1003 }
1004
1005 static void start_config(struct audio_device *dev, struct unix_client *client)
1006 {
1007         struct a2dp_data *a2dp;
1008         struct headset_data *hs;
1009         unsigned int id;
1010
1011         switch (client->type) {
1012         case TYPE_SINK:
1013         case TYPE_SOURCE:
1014                 a2dp = &client->d.a2dp;
1015
1016                 if (!a2dp->session)
1017                         a2dp->session = avdtp_get(&dev->src, &dev->dst);
1018
1019                 if (!a2dp->session) {
1020                         error("Unable to get a session");
1021                         goto failed;
1022                 }
1023
1024                 if (!a2dp->sep) {
1025                         error("seid %d not opened", client->seid);
1026                         goto failed;
1027                 }
1028
1029                 id = a2dp_config(a2dp->session, a2dp->sep, a2dp_config_complete,
1030                                         client->caps, client);
1031                 client->cancel = a2dp_cancel;
1032                 break;
1033
1034         case TYPE_HEADSET:
1035                 hs = &client->d.hs;
1036
1037                 if (!hs->locked) {
1038                         error("seid %d not opened", client->seid);
1039                         goto failed;
1040                 }
1041
1042                 id = headset_config_stream(dev, TRUE, headset_setup_complete,
1043                                                 client);
1044                 client->cancel = headset_cancel_stream;
1045                 break;
1046         case TYPE_GATEWAY:
1047                 id = gateway_config_stream(dev, gateway_setup_complete, client);
1048                 client->cancel = gateway_cancel_stream;
1049                 break;
1050
1051         default:
1052                 error("No known services for device");
1053                 goto failed;
1054         }
1055
1056         if (id == 0) {
1057                 error("config failed");
1058                 goto failed;
1059         }
1060
1061         client->req_id = id;
1062         g_slist_free(client->caps);
1063         client->caps = NULL;
1064
1065         return;
1066
1067 failed:
1068         unix_ipc_error(client, BT_SET_CONFIGURATION, EIO);
1069 }
1070
1071 static void start_resume(struct audio_device *dev, struct unix_client *client)
1072 {
1073         struct a2dp_data *a2dp = NULL;
1074         struct headset_data *hs;
1075         unsigned int id;
1076         struct avdtp *session = NULL;
1077
1078         switch (client->type) {
1079         case TYPE_SINK:
1080         case TYPE_SOURCE:
1081                 a2dp = &client->d.a2dp;
1082
1083                 if (!a2dp->sep) {
1084                         error("seid not opened");
1085                         goto failed;
1086                 }
1087
1088                 if (!a2dp->session) {
1089                         session = avdtp_get(&dev->src, &dev->dst);
1090                         if (!session) {
1091                                 error("Unable to get a session");
1092                                 goto failed;
1093                         }
1094                         a2dp->session = session;
1095                 }
1096
1097                 id = a2dp_resume(a2dp->session, a2dp->sep, a2dp_resume_complete,
1098                                         client);
1099                 client->cancel = a2dp_cancel;
1100
1101                 break;
1102
1103         case TYPE_HEADSET:
1104                 hs = &client->d.hs;
1105
1106                 if (!hs->locked) {
1107                         error("seid not opened");
1108                         goto failed;
1109                 }
1110
1111                 id = headset_request_stream(dev, headset_resume_complete,
1112                                                 client);
1113                 client->cancel = headset_cancel_stream;
1114                 break;
1115
1116         case TYPE_GATEWAY:
1117                 id = gateway_request_stream(dev, gateway_resume_complete,
1118                                                 client);
1119                 client->cancel = gateway_cancel_stream;
1120                 break;
1121
1122         default:
1123                 error("No known services for device");
1124                 goto failed;
1125         }
1126
1127         if (id == 0) {
1128                 error("start_resume: resume failed");
1129                 goto failed;
1130         }
1131
1132         client->req_id = id;
1133
1134         return;
1135
1136 failed:
1137         if (session) {
1138                 avdtp_unref(session);
1139                 a2dp->session = NULL;
1140         }
1141
1142         unix_ipc_error(client, BT_START_STREAM, EIO);
1143 }
1144
1145 static void start_suspend(struct audio_device *dev, struct unix_client *client)
1146 {
1147         struct a2dp_data *a2dp = NULL;
1148         struct headset_data *hs;
1149         unsigned int id;
1150         struct avdtp *session = NULL;
1151
1152         switch (client->type) {
1153         case TYPE_SINK:
1154         case TYPE_SOURCE:
1155                 a2dp = &client->d.a2dp;
1156
1157                 if (!a2dp->sep) {
1158                         error("seid not opened");
1159                         goto failed;
1160                 }
1161
1162                 if (!a2dp->session) {
1163                         session = avdtp_get(&dev->src, &dev->dst);
1164                         if (!session) {
1165                                 error("Unable to get a session");
1166                                 goto failed;
1167                         }
1168                         a2dp->session = session;
1169                 }
1170
1171                 if (!a2dp->sep) {
1172                         error("Unable to get a sep");
1173                         goto failed;
1174                 }
1175
1176                 id = a2dp_suspend(a2dp->session, a2dp->sep,
1177                                         a2dp_suspend_complete, client);
1178                 client->cancel = a2dp_cancel;
1179                 break;
1180
1181         case TYPE_HEADSET:
1182                 hs = &client->d.hs;
1183
1184                 if (!hs->locked) {
1185                         error("seid not opened");
1186                         goto failed;
1187                 }
1188
1189                 id = headset_suspend_stream(dev, headset_suspend_complete,
1190                                                 client);
1191                 client->cancel = headset_cancel_stream;
1192                 break;
1193
1194         case TYPE_GATEWAY:
1195                 gateway_suspend_stream(dev);
1196                 client->cancel = gateway_cancel_stream;
1197                 headset_suspend_complete(dev, client);
1198                 id = 1;
1199                 break;
1200
1201         default:
1202                 error("No known services for device");
1203                 goto failed;
1204         }
1205
1206         if (id == 0) {
1207                 error("suspend failed");
1208                 goto failed;
1209         }
1210
1211         return;
1212
1213 failed:
1214         if (session) {
1215                 avdtp_unref(session);
1216                 a2dp->session = NULL;
1217         }
1218
1219         unix_ipc_error(client, BT_STOP_STREAM, EIO);
1220 }
1221
1222 static void close_complete(struct audio_device *dev, void *user_data)
1223 {
1224         struct unix_client *client = user_data;
1225         char buf[BT_SUGGESTED_BUFFER_SIZE];
1226         struct bt_close_rsp *rsp = (void *) buf;
1227
1228         memset(buf, 0, sizeof(buf));
1229
1230         rsp->h.type = BT_RESPONSE;
1231         rsp->h.name = BT_CLOSE;
1232         rsp->h.length = sizeof(*rsp);
1233
1234         unix_ipc_sendmsg(client, &rsp->h);
1235
1236         return;
1237 }
1238
1239 static void start_close(struct audio_device *dev, struct unix_client *client,
1240                         gboolean reply)
1241 {
1242         struct a2dp_data *a2dp;
1243         struct headset_data *hs;
1244
1245         if (!client->dev)
1246                 goto failed;
1247
1248         switch (client->type) {
1249         case TYPE_HEADSET:
1250                 hs = &client->d.hs;
1251
1252                 if (client->dev && hs->locked) {
1253                         headset_unlock(client->dev, client->lock);
1254                         hs->locked = FALSE;
1255                 }
1256                 break;
1257         case TYPE_GATEWAY:
1258                 break;
1259         case TYPE_SOURCE:
1260         case TYPE_SINK:
1261                 a2dp = &client->d.a2dp;
1262
1263                 if (client->cb_id > 0) {
1264                         avdtp_stream_remove_cb(a2dp->session, a2dp->stream,
1265                                                                 client->cb_id);
1266                         client->cb_id = 0;
1267                 }
1268                 if (a2dp->sep) {
1269                         a2dp_sep_unlock(a2dp->sep, a2dp->session);
1270                         a2dp->sep = NULL;
1271                 }
1272                 if (a2dp->session) {
1273                         avdtp_unref(a2dp->session);
1274                         a2dp->session = NULL;
1275                 }
1276                 a2dp->stream = NULL;
1277                 break;
1278         default:
1279                 error("No known services for device");
1280                 goto failed;
1281         }
1282
1283         if (!reply)
1284                 return;
1285
1286         close_complete(dev, client);
1287         client->dev = NULL;
1288
1289         return;
1290
1291 failed:
1292         if (reply)
1293                 unix_ipc_error(client, BT_STOP_STREAM, EINVAL);
1294 }
1295
1296 static void handle_getcapabilities_req(struct unix_client *client,
1297                                         struct bt_get_capabilities_req *req)
1298 {
1299         struct audio_device *dev;
1300         bdaddr_t src, dst;
1301         int err = EIO;
1302         const char *interface;
1303
1304         if (!check_nul(req->source) || !check_nul(req->destination) ||
1305                         !check_nul(req->object)) {
1306                 err = EINVAL;
1307                 goto failed;
1308         }
1309
1310         str2ba(req->source, &src);
1311         str2ba(req->destination, &dst);
1312
1313         if (!manager_find_device(req->object, &src, &dst, NULL, FALSE))
1314                 goto failed;
1315
1316         if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO)
1317                 interface = AUDIO_HEADSET_INTERFACE;
1318         else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP)
1319                 interface = AUDIO_SINK_INTERFACE;
1320         else
1321                 interface = client->interface;
1322
1323         dev = manager_find_device(req->object, &src, &dst, interface, TRUE);
1324         if (!dev && (req->flags & BT_FLAG_AUTOCONNECT))
1325                 dev = manager_find_device(req->object, &src, &dst,
1326                                                         interface, FALSE);
1327
1328         if (!dev) {
1329                 if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO)
1330                         interface = AUDIO_GATEWAY_INTERFACE;
1331                 else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP)
1332                         interface = AUDIO_SOURCE_INTERFACE;
1333                 else
1334                         interface = NULL;
1335                 dev = manager_find_device(req->object, &src, &dst,
1336                                                         interface, TRUE);
1337                 if (!dev && (req->flags & BT_FLAG_AUTOCONNECT))
1338                         dev = manager_find_device(req->object, &src, &dst,
1339                                                         interface, FALSE);
1340         }
1341
1342         if (!dev) {
1343                 error("Unable to find a matching device");
1344                 goto failed;
1345         }
1346
1347         client->type = select_service(dev, interface);
1348         if (client->type == TYPE_NONE) {
1349                 error("No matching service found");
1350                 goto failed;
1351         }
1352
1353         if (g_strcmp0(interface, client->interface) != 0) {
1354                 g_free(client->interface);
1355                 client->interface = g_strdup(interface);
1356         }
1357
1358         client->seid = req->seid;
1359
1360         start_discovery(dev, client);
1361
1362         return;
1363
1364 failed:
1365         unix_ipc_error(client, BT_GET_CAPABILITIES, err);
1366 }
1367
1368 static int handle_sco_open(struct unix_client *client, struct bt_open_req *req)
1369 {
1370         if (!client->interface)
1371                 client->interface = g_strdup(AUDIO_HEADSET_INTERFACE);
1372         else if (!g_str_equal(client->interface, AUDIO_HEADSET_INTERFACE) &&
1373                 !g_str_equal(client->interface, AUDIO_GATEWAY_INTERFACE))
1374                 return -EIO;
1375
1376         DBG("open sco - object=%s source=%s destination=%s lock=%s%s",
1377                         strcmp(req->object, "") ? req->object : "ANY",
1378                         strcmp(req->source, "") ? req->source : "ANY",
1379                         strcmp(req->destination, "") ? req->destination : "ANY",
1380                         req->lock & BT_READ_LOCK ? "read" : "",
1381                         req->lock & BT_WRITE_LOCK ? "write" : "");
1382
1383         return 0;
1384 }
1385
1386 static int handle_a2dp_open(struct unix_client *client, struct bt_open_req *req)
1387 {
1388         if (!client->interface)
1389                 /* FIXME: are we treating a sink or a source? */
1390                 client->interface = g_strdup(AUDIO_SINK_INTERFACE);
1391         else if (!g_str_equal(client->interface, AUDIO_SINK_INTERFACE) &&
1392                         !g_str_equal(client->interface, AUDIO_SOURCE_INTERFACE))
1393                 return -EIO;
1394
1395         DBG("open a2dp - object=%s source=%s destination=%s lock=%s%s",
1396                         strcmp(req->object, "") ? req->object : "ANY",
1397                         strcmp(req->source, "") ? req->source : "ANY",
1398                         strcmp(req->destination, "") ? req->destination : "ANY",
1399                         req->lock & BT_READ_LOCK ? "read" : "",
1400                         req->lock & BT_WRITE_LOCK ? "write" : "");
1401
1402         return 0;
1403 }
1404
1405 static void handle_open_req(struct unix_client *client, struct bt_open_req *req)
1406 {
1407         struct audio_device *dev;
1408         bdaddr_t src, dst;
1409         int err = 0;
1410
1411         if (!check_nul(req->source) || !check_nul(req->destination) ||
1412                         !check_nul(req->object)) {
1413                 err = EINVAL;
1414                 goto failed;
1415         }
1416
1417         str2ba(req->source, &src);
1418         str2ba(req->destination, &dst);
1419
1420         if (req->seid > BT_A2DP_SEID_RANGE) {
1421                 err = handle_sco_open(client, req);
1422                 if (err < 0) {
1423                         err = -err;
1424                         goto failed;
1425                 }
1426         } else {
1427                 err = handle_a2dp_open(client, req);
1428                 if (err < 0) {
1429                         err = -err;
1430                         goto failed;
1431                 }
1432         }
1433
1434         if (!manager_find_device(req->object, &src, &dst, NULL, FALSE))
1435                 goto failed;
1436
1437         dev = manager_find_device(req->object, &src, &dst, client->interface,
1438                                 TRUE);
1439         if (!dev)
1440                 dev = manager_find_device(req->object, &src, &dst,
1441                                         client->interface, FALSE);
1442
1443         if (!dev)
1444                 goto failed;
1445
1446         client->seid = req->seid;
1447         client->lock = req->lock;
1448
1449         start_open(dev, client);
1450
1451         return;
1452
1453 failed:
1454         unix_ipc_error(client, BT_OPEN, err ? : EIO);
1455 }
1456
1457 static int handle_sco_transport(struct unix_client *client,
1458                                 struct bt_set_configuration_req *req)
1459 {
1460         struct audio_device *dev = client->dev;
1461
1462         if (!client->interface) {
1463                 if (dev->headset)
1464                         client->interface = g_strdup(AUDIO_HEADSET_INTERFACE);
1465                 else if (dev->gateway)
1466                         client->interface = g_strdup(AUDIO_GATEWAY_INTERFACE);
1467                 else
1468                         return -EIO;
1469         } else if (!g_str_equal(client->interface, AUDIO_HEADSET_INTERFACE) &&
1470                         !g_str_equal(client->interface, AUDIO_GATEWAY_INTERFACE))
1471                 return -EIO;
1472
1473         return 0;
1474 }
1475
1476 static int handle_a2dp_transport(struct unix_client *client,
1477                                 struct bt_set_configuration_req *req)
1478 {
1479         struct avdtp_service_capability *media_transport, *media_codec;
1480         struct sbc_codec_cap sbc_cap;
1481         struct mpeg_codec_cap mpeg_cap;
1482
1483         if (!client->interface)
1484                 /* FIXME: are we treating a sink or a source? */
1485                 client->interface = g_strdup(AUDIO_SINK_INTERFACE);
1486         else if (!g_str_equal(client->interface, AUDIO_SINK_INTERFACE) &&
1487                         !g_str_equal(client->interface, AUDIO_SOURCE_INTERFACE))
1488                 return -EIO;
1489
1490         g_slist_free_full(client->caps, g_free);
1491         client->caps = NULL;
1492
1493         media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT,
1494                                                 NULL, 0);
1495
1496         client->caps = g_slist_append(client->caps, media_transport);
1497
1498         if (req->codec.type == BT_A2DP_MPEG12_SINK ||
1499                 req->codec.type == BT_A2DP_MPEG12_SOURCE) {
1500                 mpeg_capabilities_t *mpeg = (void *) &req->codec;
1501
1502                 memset(&mpeg_cap, 0, sizeof(mpeg_cap));
1503
1504                 mpeg_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO;
1505                 mpeg_cap.cap.media_codec_type = A2DP_CODEC_MPEG12;
1506                 mpeg_cap.channel_mode = mpeg->channel_mode;
1507                 mpeg_cap.crc = mpeg->crc;
1508                 mpeg_cap.layer = mpeg->layer;
1509                 mpeg_cap.frequency = mpeg->frequency;
1510                 mpeg_cap.mpf = mpeg->mpf;
1511                 mpeg_cap.bitrate = mpeg->bitrate;
1512
1513                 media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &mpeg_cap,
1514                                                         sizeof(mpeg_cap));
1515
1516                 print_mpeg12(&mpeg_cap);
1517         } else if (req->codec.type == BT_A2DP_SBC_SINK ||
1518                         req->codec.type == BT_A2DP_SBC_SOURCE) {
1519                 sbc_capabilities_t *sbc = (void *) &req->codec;
1520
1521                 memset(&sbc_cap, 0, sizeof(sbc_cap));
1522
1523                 sbc_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO;
1524                 sbc_cap.cap.media_codec_type = A2DP_CODEC_SBC;
1525                 sbc_cap.channel_mode = sbc->channel_mode;
1526                 sbc_cap.frequency = sbc->frequency;
1527                 sbc_cap.allocation_method = sbc->allocation_method;
1528                 sbc_cap.subbands = sbc->subbands;
1529                 sbc_cap.block_length = sbc->block_length;
1530                 sbc_cap.min_bitpool = sbc->min_bitpool;
1531                 sbc_cap.max_bitpool = sbc->max_bitpool;
1532
1533                 media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &sbc_cap,
1534                                                         sizeof(sbc_cap));
1535
1536                 print_sbc(&sbc_cap);
1537         } else
1538                 return -EINVAL;
1539
1540         client->caps = g_slist_append(client->caps, media_codec);
1541
1542         return 0;
1543 }
1544
1545 static void handle_setconfiguration_req(struct unix_client *client,
1546                                         struct bt_set_configuration_req *req)
1547 {
1548         int err = 0;
1549
1550         if (req->codec.seid != client->seid) {
1551                 error("Unable to set configuration: seid %d not opened",
1552                                 req->codec.seid);
1553                 goto failed;
1554         }
1555
1556         if (!client->dev)
1557                 goto failed;
1558
1559         if (req->codec.transport == BT_CAPABILITIES_TRANSPORT_SCO) {
1560                 err = handle_sco_transport(client, req);
1561                 if (err < 0) {
1562                         err = -err;
1563                         goto failed;
1564                 }
1565         } else if (req->codec.transport == BT_CAPABILITIES_TRANSPORT_A2DP) {
1566                 err = handle_a2dp_transport(client, req);
1567                 if (err < 0) {
1568                         err = -err;
1569                         goto failed;
1570                 }
1571         }
1572
1573         start_config(client->dev, client);
1574
1575         return;
1576
1577 failed:
1578         unix_ipc_error(client, BT_SET_CONFIGURATION, err ? : EIO);
1579 }
1580
1581 static void handle_streamstart_req(struct unix_client *client,
1582                                         struct bt_start_stream_req *req)
1583 {
1584         if (!client->dev)
1585                 goto failed;
1586
1587         start_resume(client->dev, client);
1588
1589         return;
1590
1591 failed:
1592         unix_ipc_error(client, BT_START_STREAM, EIO);
1593 }
1594
1595 static void handle_streamstop_req(struct unix_client *client,
1596                                         struct bt_stop_stream_req *req)
1597 {
1598         if (!client->dev)
1599                 goto failed;
1600
1601         start_suspend(client->dev, client);
1602
1603         return;
1604
1605 failed:
1606         unix_ipc_error(client, BT_STOP_STREAM, EIO);
1607 }
1608
1609 static void handle_close_req(struct unix_client *client,
1610                                 struct bt_close_req *req)
1611 {
1612         if (!client->dev)
1613                 goto failed;
1614
1615         start_close(client->dev, client, TRUE);
1616
1617         return;
1618
1619 failed:
1620         unix_ipc_error(client, BT_CLOSE, EIO);
1621 }
1622
1623 static void handle_control_req(struct unix_client *client,
1624                                         struct bt_control_req *req)
1625 {
1626         /* FIXME: really implement that */
1627         char buf[BT_SUGGESTED_BUFFER_SIZE];
1628         struct bt_set_configuration_rsp *rsp = (void *) buf;
1629
1630         memset(buf, 0, sizeof(buf));
1631         rsp->h.type = BT_RESPONSE;
1632         rsp->h.name = BT_CONTROL;
1633         rsp->h.length = sizeof(*rsp);
1634
1635         unix_ipc_sendmsg(client, &rsp->h);
1636 }
1637
1638 static void handle_delay_report_req(struct unix_client *client,
1639                                         struct bt_delay_report_req *req)
1640 {
1641         char buf[BT_SUGGESTED_BUFFER_SIZE];
1642         struct bt_set_configuration_rsp *rsp = (void *) buf;
1643         struct a2dp_data *a2dp;
1644         int err;
1645
1646         if (!client->dev) {
1647                 err = -ENODEV;
1648                 goto failed;
1649         }
1650
1651         switch (client->type) {
1652         case TYPE_HEADSET:
1653         case TYPE_GATEWAY:
1654                 err = -EINVAL;
1655                 goto failed;
1656         case TYPE_SOURCE:
1657         case TYPE_SINK:
1658                 a2dp = &client->d.a2dp;
1659                 if (a2dp->session && a2dp->stream) {
1660                         err = avdtp_delay_report(a2dp->session, a2dp->stream,
1661                                                                 req->delay);
1662                         if (err < 0)
1663                                 goto failed;
1664                 } else {
1665                         err = -EINVAL;
1666                         goto failed;
1667                 }
1668                 break;
1669         default:
1670                 error("No known services for device");
1671                 err = -EINVAL;
1672                 goto failed;
1673         }
1674
1675         memset(buf, 0, sizeof(buf));
1676         rsp->h.type = BT_RESPONSE;
1677         rsp->h.name = BT_DELAY_REPORT;
1678         rsp->h.length = sizeof(*rsp);
1679
1680         unix_ipc_sendmsg(client, &rsp->h);
1681
1682         return;
1683
1684 failed:
1685         unix_ipc_error(client, BT_DELAY_REPORT, -err);
1686 }
1687
1688 static gboolean client_cb(GIOChannel *chan, GIOCondition cond, gpointer data)
1689 {
1690         char buf[BT_SUGGESTED_BUFFER_SIZE];
1691         bt_audio_msg_header_t *msghdr = (void *) buf;
1692         struct unix_client *client = data;
1693         int len;
1694         const char *type, *name;
1695
1696         if (cond & G_IO_NVAL)
1697                 return FALSE;
1698
1699         if (cond & (G_IO_HUP | G_IO_ERR)) {
1700                 DBG("Unix client disconnected (fd=%d)", client->sock);
1701
1702                 goto failed;
1703         }
1704
1705         memset(buf, 0, sizeof(buf));
1706
1707         len = recv(client->sock, buf, sizeof(buf), 0);
1708         if (len < 0) {
1709                 error("recv: %s (%d)", strerror(errno), errno);
1710                 goto failed;
1711         }
1712
1713         type = bt_audio_strtype(msghdr->type);
1714         name = bt_audio_strname(msghdr->name);
1715
1716         DBG("Audio API: %s <- %s", type, name);
1717
1718         if (msghdr->length != len) {
1719                 error("Invalid message: length mismatch");
1720                 goto failed;
1721         }
1722
1723         switch (msghdr->name) {
1724         case BT_GET_CAPABILITIES:
1725                 handle_getcapabilities_req(client,
1726                                 (struct bt_get_capabilities_req *) msghdr);
1727                 break;
1728         case BT_OPEN:
1729                 handle_open_req(client,
1730                                 (struct bt_open_req *) msghdr);
1731                 break;
1732         case BT_SET_CONFIGURATION:
1733                 handle_setconfiguration_req(client,
1734                                 (struct bt_set_configuration_req *) msghdr);
1735                 break;
1736         case BT_START_STREAM:
1737                 handle_streamstart_req(client,
1738                                 (struct bt_start_stream_req *) msghdr);
1739                 break;
1740         case BT_STOP_STREAM:
1741                 handle_streamstop_req(client,
1742                                 (struct bt_stop_stream_req *) msghdr);
1743                 break;
1744         case BT_CLOSE:
1745                 handle_close_req(client,
1746                                 (struct bt_close_req *) msghdr);
1747                 break;
1748         case BT_CONTROL:
1749                 handle_control_req(client,
1750                                 (struct bt_control_req *) msghdr);
1751                 break;
1752         case BT_DELAY_REPORT:
1753                 handle_delay_report_req(client,
1754                                 (struct bt_delay_report_req *) msghdr);
1755                 break;
1756         default:
1757                 error("Audio API: received unexpected message name %d",
1758                                 msghdr->name);
1759         }
1760
1761         return TRUE;
1762
1763 failed:
1764         clients = g_slist_remove(clients, client);
1765         start_close(client->dev, client, FALSE);
1766         client_free(client);
1767         return FALSE;
1768 }
1769
1770 static gboolean server_cb(GIOChannel *chan, GIOCondition cond, gpointer data)
1771 {
1772         struct sockaddr_un addr;
1773         socklen_t addrlen;
1774         int sk, cli_sk;
1775         struct unix_client *client;
1776         GIOChannel *io;
1777
1778         if (cond & G_IO_NVAL)
1779                 return FALSE;
1780
1781         if (cond & (G_IO_HUP | G_IO_ERR)) {
1782                 g_io_channel_shutdown(chan, TRUE, NULL);
1783                 return FALSE;
1784         }
1785
1786         sk = g_io_channel_unix_get_fd(chan);
1787
1788         memset(&addr, 0, sizeof(addr));
1789         addrlen = sizeof(addr);
1790
1791         cli_sk = accept(sk, (struct sockaddr *) &addr, &addrlen);
1792         if (cli_sk < 0) {
1793                 error("accept: %s (%d)", strerror(errno), errno);
1794                 return TRUE;
1795         }
1796
1797         DBG("Accepted new client connection on unix socket (fd=%d)", cli_sk);
1798         set_nonblocking(cli_sk);
1799
1800         client = g_new0(struct unix_client, 1);
1801         client->sock = cli_sk;
1802         clients = g_slist_append(clients, client);
1803
1804         io = g_io_channel_unix_new(cli_sk);
1805         g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1806                                                         client_cb, client);
1807         g_io_channel_unref(io);
1808
1809         return TRUE;
1810 }
1811
1812 void unix_device_removed(struct audio_device *dev)
1813 {
1814         GSList *l;
1815
1816         DBG("unix_device_removed(%p)", dev);
1817
1818         l = clients;
1819         while (l) {
1820                 struct unix_client *client = l->data;
1821
1822                 l = l->next;
1823
1824                 if (client->dev == dev) {
1825                         clients = g_slist_remove(clients, client);
1826                         start_close(client->dev, client, FALSE);
1827                         client_free(client);
1828                 }
1829         }
1830 }
1831
1832 void unix_delay_report(struct audio_device *dev, uint8_t seid, uint16_t delay)
1833 {
1834         GSList *l;
1835         struct bt_delay_report_ind ind;
1836
1837         DBG("unix_delay_report(%p): %u.%ums", dev, delay / 10, delay % 10);
1838
1839         memset(&ind, 0, sizeof(ind));
1840         ind.h.type = BT_INDICATION;
1841         ind.h.name = BT_DELAY_REPORT;
1842         ind.h.length = sizeof(ind);
1843         ind.delay = delay;
1844
1845         for (l = clients; l != NULL; l = g_slist_next(l)) {
1846                 struct unix_client *client = l->data;
1847
1848                 if (client->dev != dev || client->seid != seid)
1849                         continue;
1850
1851                 unix_ipc_sendmsg(client, (void *) &ind);
1852         }
1853 }
1854
1855 int unix_init(void)
1856 {
1857         GIOChannel *io;
1858         struct sockaddr_un addr = {
1859                 AF_UNIX, BT_IPC_SOCKET_NAME
1860         };
1861
1862         int sk, err;
1863
1864         sk = socket(PF_LOCAL, SOCK_STREAM, 0);
1865         if (sk < 0) {
1866                 err = -errno;
1867                 error("Can't create unix socket: %s (%d)", strerror(-err),
1868                                                                         -err);
1869                 return err;
1870         }
1871
1872         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1873                 err = -errno;
1874                 error("Can't bind unix socket: %s (%d)", strerror(-err),
1875                                                                         -err);
1876                 close(sk);
1877                 return err;
1878         }
1879
1880         set_nonblocking(sk);
1881
1882         if (listen(sk, 1) < 0) {
1883                 err = -errno;
1884                 error("Can't listen on unix socket: %s (%d)", strerror(-err),
1885                                                                         -err);
1886                 close(sk);
1887                 return err;
1888         }
1889
1890         unix_sock = sk;
1891
1892         io = g_io_channel_unix_new(sk);
1893         g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1894                                                         server_cb, NULL);
1895         g_io_channel_unref(io);
1896
1897         DBG("Unix socket created: %d", sk);
1898
1899         return 0;
1900 }
1901
1902 void unix_exit(void)
1903 {
1904         g_slist_free_full(clients, client_free);
1905         if (unix_sock >= 0) {
1906                 close(unix_sock);
1907                 unix_sock = -1;
1908         }
1909 }