utils/audio/avdtp.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2007  Nokia Corporation
   6  *  Copyright (C) 2004-2008  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 <stdint.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <assert.h>
  34 #include <signal.h>
  35 #include <netinet/in.h>
  36
  37 #include <bluetooth/bluetooth.h>
  38 #include <bluetooth/sdp.h>
  39
  40 #include <glib.h>
  41 #include <dbus/dbus.h>
  42
  43 #include "dbus-service.h"
  44 #include "logging.h"
  45
  46 #include "device.h"
  47 #include "manager.h"
  48 #include "control.h"
  49 #include "avdtp.h"
  50 #include "glib-helper.h"
  51
  52 #include <bluetooth/l2cap.h>
  53
  54 #define AVDTP_PSM 25
  55
  56 #define MAX_SEID 0x3E
  57
  58 #define AVDTP_DISCOVER                          0x01
  59 #define AVDTP_GET_CAPABILITIES                  0x02
  60 #define AVDTP_SET_CONFIGURATION                 0x03
  61 #define AVDTP_GET_CONFIGURATION                 0x04
  62 #define AVDTP_RECONFIGURE                       0x05
  63 #define AVDTP_OPEN                              0x06
  64 #define AVDTP_START                             0x07
  65 #define AVDTP_CLOSE                             0x08
  66 #define AVDTP_SUSPEND                           0x09
  67 #define AVDTP_ABORT                             0x0A
  68 #define AVDTP_SECURITY_CONTROL                  0x0B
  69
  70 #define AVDTP_PKT_TYPE_SINGLE                   0x00
  71 #define AVDTP_PKT_TYPE_START                    0x01
  72 #define AVDTP_PKT_TYPE_CONTINUE                 0x02
  73 #define AVDTP_PKT_TYPE_END                      0x03
  74
  75 #define AVDTP_MSG_TYPE_COMMAND                  0x00
  76 #define AVDTP_MSG_TYPE_ACCEPT                   0x02
  77 #define AVDTP_MSG_TYPE_REJECT                   0x03
  78
  79 #define REQ_TIMEOUT 4000
  80 #define DISCONNECT_TIMEOUT 5000
  81 #define STREAM_TIMEOUT 20000
  82
  83 typedef enum {
  84         AVDTP_SESSION_STATE_DISCONNECTED,
  85         AVDTP_SESSION_STATE_CONNECTING,
  86         AVDTP_SESSION_STATE_CONNECTED
  87 } avdtp_session_state_t;
  88
  89 #if __BYTE_ORDER == __LITTLE_ENDIAN
  90
  91 struct avdtp_header {
  92         uint8_t message_type:2;
  93         uint8_t packet_type:2;
  94         uint8_t transaction:4;
  95         uint8_t signal_id:6;
  96         uint8_t rfa0:2;
  97 } __attribute__ ((packed));
  98
  99 struct seid_info {
 100         uint8_t rfa0:1;
 101         uint8_t inuse:1;
 102         uint8_t seid:6;
 103         uint8_t rfa2:3;
 104         uint8_t type:1;
 105         uint8_t media_type:4;
 106 } __attribute__ ((packed));
 107
 108 struct seid {
 109         uint8_t rfa0:2;
 110         uint8_t seid:6;
 111 } __attribute__ ((packed));
 112
 113 #elif __BYTE_ORDER == __BIG_ENDIAN
 114
 115 struct avdtp_header {
 116         uint8_t transaction:4;
 117         uint8_t packet_type:2;
 118         uint8_t message_type:2;
 119         uint8_t rfa0:2;
 120         uint8_t signal_id:6;
 121 } __attribute__ ((packed));
 122
 123 struct seid_info {
 124         uint8_t seid:6;
 125         uint8_t inuse:1;
 126         uint8_t rfa0:1;
 127         uint8_t media_type:4;
 128         uint8_t type:1;
 129         uint8_t rfa2:3;
 130 } __attribute__ ((packed));
 131
 132 struct seid {
 133         uint8_t seid:6;
 134         uint8_t rfa0:2;
 135 } __attribute__ ((packed));
 136
 137 #else
 138 #error "Unknown byte order"
 139 #endif
 140
 141 /* packets */
 142
 143 struct gen_req {
 144         struct avdtp_header header;
 145 } __attribute__ ((packed));
 146
 147 struct gen_resp {
 148         struct avdtp_header header;
 149 } __attribute__ ((packed));
 150
 151 struct discover_resp {
 152         struct avdtp_header header;
 153         struct seid_info seps[0];
 154 } __attribute__ ((packed));
 155
 156 struct getcap_resp {
 157         struct avdtp_header header;
 158         uint8_t caps[0];
 159 } __attribute__ ((packed));
 160
 161 struct start_req {
 162         struct avdtp_header header;
 163         struct seid first_seid;
 164         struct seid other_seids[0];
 165 } __attribute__ ((packed));
 166
 167 struct suspend_req {
 168         struct avdtp_header header;
 169         struct seid first_seid;
 170         struct seid other_seids[0];
 171 } __attribute__ ((packed));
 172
 173 struct seid_rej {
 174         struct avdtp_header header;
 175         uint8_t error;
 176 } __attribute__ ((packed));
 177
 178 struct conf_rej {
 179         struct avdtp_header header;
 180         uint8_t category;
 181         uint8_t error;
 182 } __attribute__ ((packed));
 183
 184 #if __BYTE_ORDER == __LITTLE_ENDIAN
 185
 186 struct seid_req {
 187         struct avdtp_header header;
 188         uint8_t rfa0:2;
 189         uint8_t acp_seid:6;
 190 } __attribute__ ((packed));
 191
 192 struct setconf_req {
 193         struct avdtp_header header;
 194
 195         uint8_t rfa0:2;
 196         uint8_t acp_seid:6;
 197         uint8_t rfa1:2;
 198         uint8_t int_seid:6;
 199
 200         uint8_t caps[0];
 201 } __attribute__ ((packed));
 202
 203 struct stream_rej {
 204         struct avdtp_header header;
 205         uint8_t rfa0:2;
 206         uint8_t acp_seid:6;
 207         uint8_t error;
 208 } __attribute__ ((packed));
 209
 210 struct reconf_req {
 211         struct avdtp_header header;
 212
 213         uint8_t rfa0:2;
 214         uint8_t acp_seid:6;
 215
 216         uint8_t serv_cap;
 217         uint8_t serv_cap_len;
 218
 219         uint8_t caps[0];
 220 } __attribute__ ((packed));
 221
 222 struct avdtp_general_rej {
 223         uint8_t message_type:2;
 224         uint8_t packet_type:2;
 225         uint8_t transaction:4;
 226         uint8_t rfa0;
 227 } __attribute__ ((packed));
 228
 229 #elif __BYTE_ORDER == __BIG_ENDIAN
 230
 231 struct seid_req {
 232         struct avdtp_header header;
 233         uint8_t acp_seid:6;
 234         uint8_t rfa0:2;
 235 } __attribute__ ((packed));
 236
 237 struct setconf_req {
 238         struct avdtp_header header;
 239
 240         uint8_t acp_seid:6;
 241         uint8_t rfa0:2;
 242         uint8_t int_seid:6;
 243         uint8_t rfa1:2;
 244
 245         uint8_t caps[0];
 246 } __attribute__ ((packed));
 247
 248 struct stream_rej {
 249         struct avdtp_header header;
 250         uint8_t acp_seid:6;
 251         uint8_t rfa0:2;
 252         uint8_t error;
 253 } __attribute__ ((packed));
 254
 255 struct reconf_req {
 256         struct avdtp_header header;
 257
 258         uint8_t acp_seid:6;
 259         uint8_t rfa0:2;
 260
 261         uint8_t serv_cap;
 262         uint8_t serv_cap_len;
 263
 264         uint8_t caps[0];
 265 } __attribute__ ((packed));
 266
 267 struct avdtp_general_rej {
 268         uint8_t transaction:4;
 269         uint8_t packet_type:2;
 270         uint8_t message_type:2;
 271         uint8_t rfa0;
 272 } __attribute__ ((packed));
 273
 274 #else
 275 #error "Unknown byte order"
 276 #endif
 277
 278 struct pending_req {
 279         struct avdtp_header *msg;
 280         int msg_size;
 281         struct avdtp_stream *stream; /* Set if the request targeted a stream */
 282         guint timeout;
 283 };
 284
 285 struct avdtp_remote_sep {
 286         uint8_t seid;
 287         uint8_t type;
 288         uint8_t media_type;
 289         struct avdtp_service_capability *codec;
 290         GSList *caps; /* of type struct avdtp_service_capability */
 291         struct avdtp_stream *stream;
 292 };
 293
 294 struct avdtp_local_sep {
 295         avdtp_state_t state;
 296         struct avdtp_stream *stream;
 297         struct seid_info info;
 298         uint8_t codec;
 299         GSList *caps;
 300         struct avdtp_sep_ind *ind;
 301         struct avdtp_sep_cfm *cfm;
 302         void *user_data;
 303 };
 304
 305 struct stream_callback {
 306         avdtp_stream_state_cb cb;
 307         void *user_data;
 308         unsigned int id;
 309 };
 310
 311 struct avdtp_stream {
 312         int sock;
 313         uint16_t imtu;
 314         uint16_t omtu;
 315         struct avdtp *session;
 316         struct avdtp_local_sep *lsep;
 317         uint8_t rseid;
 318         GSList *caps;
 319         GSList *callbacks;
 320         struct avdtp_service_capability *codec;
 321         guint io;               /* Transport GSource ID */
 322         guint timer;            /* Waiting for other side to close or open
 323                                    the transport channel */
 324         gboolean open_acp;      /* If we are in ACT role for Open */
 325         gboolean close_int;     /* If we are in INT role for Close */
 326         guint idle_timer;
 327 };
 328
 329 /* Structure describing an AVDTP connection between two devices */
 330 struct avdtp {
 331         int ref;
 332         int free_lock;
 333
 334         bdaddr_t src;
 335         bdaddr_t dst;
 336
 337         avdtp_session_state_t last_state;
 338         avdtp_session_state_t state;
 339
 340         guint io;
 341         int sock;
 342
 343         GSList *seps; /* Elements of type struct avdtp_remote_sep * */
 344
 345         GSList *streams; /* Elements of type struct avdtp_stream * */
 346
 347         GSList *req_queue; /* Elements of type struct pending_req * */
 348         GSList *prio_queue; /* Same as req_queue but is processed before it */
 349
 350         struct avdtp_stream *pending_open;
 351
 352         uint16_t mtu;
 353         char *buf;
 354
 355         avdtp_discover_cb_t discov_cb;
 356         void *user_data;
 357
 358         struct pending_req *req;
 359
 360         guint dc_timer;
 361
 362         /* Attempt stream setup instead of disconnecting */
 363         gboolean stream_setup;
 364
 365         DBusPendingCall *pending_auth;
 366 };
 367
 368 static uint8_t free_seid = 1;
 369 static GSList *local_seps = NULL;
 370
 371 static GIOChannel *avdtp_server = NULL;
 372
 373 static GSList *sessions = NULL;
 374
 375 static int send_request(struct avdtp *session, gboolean priority,
 376                         struct avdtp_stream *stream, void *buffer, int size);
 377 static gboolean avdtp_parse_resp(struct avdtp *session,
 378                                         struct avdtp_stream *stream,
 379                                         struct avdtp_header *header, int size);
 380 static gboolean avdtp_parse_rej(struct avdtp *session,
 381                                 struct avdtp_stream *stream,
 382                                 struct avdtp_header *header, int size);
 383 static int process_queue(struct avdtp *session);
 384 static void connection_lost(struct avdtp *session, int err);
 385 static void avdtp_sep_set_state(struct avdtp *session,
 386                                 struct avdtp_local_sep *sep,
 387                                 avdtp_state_t state);
 388
 389 static const char *avdtp_statestr(avdtp_state_t state)
 390 {
 391         switch (state) {
 392         case AVDTP_STATE_IDLE:
 393                 return "IDLE";
 394         case AVDTP_STATE_CONFIGURED:
 395                 return "CONFIGURED";
 396         case AVDTP_STATE_OPEN:
 397                 return "OPEN";
 398         case AVDTP_STATE_STREAMING:
 399                 return "STREAMING";
 400         case AVDTP_STATE_CLOSING:
 401                 return "CLOSING";
 402         case AVDTP_STATE_ABORTING:
 403                 return "ABORTING";
 404         default:
 405                 return "<unknown state>";
 406         }
 407 }
 408
 409 static gboolean avdtp_send(struct avdtp *session, void *data, int len)
 410 {
 411         int ret;
 412
 413         if (session->sock < 0) {
 414                 error("avdtp_send: session is closed");
 415                 return FALSE;
 416         }
 417
 418         ret = send(session->sock, data, len, 0);
 419
 420         if (ret < 0)
 421                 ret = -errno;
 422         else if (ret != len)
 423                 ret = -EIO;
 424
 425         if (ret < 0) {
 426                 error("avdtp_send: %s (%d)", strerror(-ret), -ret);
 427                 return FALSE;
 428         }
 429
 430         return TRUE;
 431 }
 432
 433 static void pending_req_free(struct pending_req *req)
 434 {
 435         if (req->timeout)
 436                 g_source_remove(req->timeout);
 437         g_free(req->msg);
 438         g_free(req);
 439 }
 440
 441 static gboolean stream_close_timeout(gpointer user_data)
 442 {
 443         struct avdtp_stream *stream = user_data;
 444
 445         debug("Timed out waiting for peer to close the transport channel");
 446
 447         stream->timer = 0;
 448
 449         close(stream->sock);
 450
 451         return FALSE;
 452 }
 453
 454 static gboolean stream_open_timeout(gpointer user_data)
 455 {
 456         struct avdtp_stream *stream = user_data;
 457
 458         debug("Timed out waiting for peer to open the transport channel");
 459
 460         stream->timer = 0;
 461
 462         stream->session->pending_open = NULL;
 463
 464         avdtp_abort(stream->session, stream);
 465
 466         return FALSE;
 467 }
 468
 469 static gboolean disconnect_timeout(gpointer user_data)
 470 {
 471         struct avdtp *session = user_data;
 472         struct audio_device *dev;
 473         gboolean stream_setup;
 474         int i = 0;
 475
 476         assert(session->ref == 1);
 477
 478         session->dc_timer = 0;
 479         stream_setup = session->stream_setup;
 480         session->stream_setup = FALSE;
 481         dev = manager_find_device(&session->dst, AUDIO_CONTROL_INTERFACE, FALSE);
 482
 483         if (dev && dev->sink && stream_setup)
 484                 sink_setup_stream(dev->sink, session);
 485         else
 486                 connection_lost(session, -ETIMEDOUT);
 487         return FALSE;
 488 }
 489
 490 static void remove_disconnect_timer(struct avdtp *session)
 491 {
 492         g_source_remove(session->dc_timer);
 493         session->dc_timer = 0;
 494         session->stream_setup = FALSE;
 495 }
 496
 497 static void set_disconnect_timer(struct avdtp *session)
 498 {
 499         if (session->dc_timer)
 500                 remove_disconnect_timer(session);
 501
 502         session->dc_timer = g_timeout_add(DISCONNECT_TIMEOUT,
 503                                                 disconnect_timeout, session);
 504 }
 505
 506 void avdtp_error_init(struct avdtp_error *err, uint8_t type, int id)
 507 {
 508         err->type = type;
 509         switch (type) {
 510         case AVDTP_ERROR_ERRNO:
 511                 err->err.posix_errno = id;
 512                 break;
 513         case AVDTP_ERROR_ERROR_CODE:
 514                 err->err.error_code = id;
 515                 break;
 516         }
 517 }
 518
 519 avdtp_error_type_t avdtp_error_type(struct avdtp_error *err)
 520 {
 521         return err->type;
 522 }
 523
 524 int avdtp_error_error_code(struct avdtp_error *err)
 525 {
 526         assert(err->type == AVDTP_ERROR_ERROR_CODE);
 527         return err->err.error_code;
 528 }
 529
 530 int avdtp_error_posix_errno(struct avdtp_error *err)
 531 {
 532         assert(err->type == AVDTP_ERROR_ERRNO);
 533         return err->err.posix_errno;
 534 }
 535
 536 static struct avdtp_stream *find_stream_by_rseid(struct avdtp *session,
 537                                                         uint8_t rseid)
 538 {
 539         GSList *l;
 540
 541         for (l = session->streams; l != NULL; l = g_slist_next(l)) {
 542                 struct avdtp_stream *stream = l->data;
 543
 544                 if (stream->rseid == rseid)
 545                         return stream;
 546         }
 547
 548         return NULL;
 549 }
 550
 551 static struct avdtp_remote_sep *find_remote_sep(GSList *seps, uint8_t seid)
 552 {
 553         GSList *l;
 554
 555         for (l = seps; l != NULL; l = g_slist_next(l)) {
 556                 struct avdtp_remote_sep *sep = l->data;
 557
 558                 if (sep->seid == seid)
 559                         return sep;
 560         }
 561
 562         return NULL;
 563 }
 564
 565 static void stream_free(struct avdtp_stream *stream)
 566 {
 567         struct avdtp_remote_sep *rsep;
 568
 569         stream->lsep->info.inuse = 0;
 570         stream->lsep->stream = NULL;
 571
 572         rsep = find_remote_sep(stream->session->seps, stream->rseid);
 573         if (rsep)
 574                 rsep->stream = NULL;
 575
 576         if (stream->timer)
 577                 g_source_remove(stream->timer);
 578
 579         if (stream->sock >= 0)
 580                 close(stream->sock);
 581
 582         if (stream->io)
 583                 g_source_remove(stream->io);
 584
 585         g_slist_foreach(stream->callbacks, (GFunc) g_free, NULL);
 586         g_slist_free(stream->callbacks);
 587
 588         g_slist_foreach(stream->caps, (GFunc) g_free, NULL);
 589         g_slist_free(stream->caps);
 590
 591         g_free(stream);
 592 }
 593
 594 static gboolean stream_timeout(struct avdtp_stream *stream)
 595 {
 596         struct avdtp *session = stream->session;
 597
 598 /* Disabled so we do not disconnect immediately after sending BT_STREAMSTOP_REQ
 599         avdtp_close(session, stream);
 600 */
 601         stream->idle_timer = 0;
 602
 603         return FALSE;
 604 }
 605
 606 static gboolean transport_cb(GIOChannel *chan, GIOCondition cond,
 607                                 gpointer data)
 608 {
 609         struct avdtp_stream *stream = data;
 610         struct avdtp_local_sep *sep = stream->lsep;
 611
 612         if (stream->close_int && sep->cfm && sep->cfm->close)
 613                 sep->cfm->close(stream->session, sep, stream, NULL,
 614                                 sep->user_data);
 615
 616         stream->io = 0;
 617
 618         avdtp_sep_set_state(stream->session, sep, AVDTP_STATE_IDLE);
 619
 620         return FALSE;
 621 }
 622
 623 static void handle_transport_connect(struct avdtp *session, int sock,
 624                                         uint16_t imtu, uint16_t omtu)
 625 {
 626         struct avdtp_stream *stream = session->pending_open;
 627         struct avdtp_local_sep *sep = stream->lsep;
 628         GIOChannel *channel;
 629
 630         session->pending_open = NULL;
 631
 632         if (stream->timer) {
 633                 g_source_remove(stream->timer);
 634                 stream->timer = 0;
 635         }
 636
 637         if (sock < 0) {
 638                 if (!stream->open_acp && sep->cfm && sep->cfm->open) {
 639                         struct avdtp_error err;
 640                         avdtp_error_init(&err, AVDTP_ERROR_ERRNO, EIO);
 641                         sep->cfm->open(session, sep, NULL, &err,
 642                                         sep->user_data);
 643                 }
 644                 return;
 645         }
 646
 647         stream->sock = sock;
 648         stream->omtu = omtu;
 649         stream->imtu = imtu;
 650
 651         if (!stream->open_acp && sep->cfm && sep->cfm->open)
 652                 sep->cfm->open(session, sep, stream, NULL, sep->user_data);
 653
 654         avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
 655
 656         channel = g_io_channel_unix_new(stream->sock);
 657
 658         stream->io = g_io_add_watch(channel, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
 659                                         (GIOFunc) transport_cb, stream);
 660         g_io_channel_unref(channel);
 661 }
 662
 663 static void avdtp_sep_set_state(struct avdtp *session,
 664                                 struct avdtp_local_sep *sep,
 665                                 avdtp_state_t state)
 666 {
 667         struct avdtp_stream *stream = sep->stream;
 668         avdtp_state_t old_state;
 669         struct avdtp_error err, *err_ptr = NULL;
 670
 671         if (sep->state == state) {
 672                 avdtp_error_init(&err, AVDTP_ERROR_ERRNO, EIO);
 673                 debug("stream state change failed: %s", avdtp_strerror(&err));
 674                 err_ptr = &err;
 675         } else {
 676                 err_ptr = NULL;
 677                 debug("stream state changed: %s -> %s",
 678                                 avdtp_statestr(sep->state),
 679                                 avdtp_statestr(state));
 680         }
 681
 682         old_state = sep->state;
 683         sep->state = state;
 684
 685         if (stream) {
 686                 GSList *l;
 687                 for (l = stream->callbacks; l != NULL; l = g_slist_next(l)) {
 688                         struct stream_callback *cb = l->data;
 689                         cb->cb(stream, old_state, state, err_ptr,
 690                                         cb->user_data);
 691                 }
 692         }
 693
 694         switch (state) {
 695         case AVDTP_STATE_OPEN:
 696                 break;
 697         case AVDTP_STATE_STREAMING:
 698         case AVDTP_STATE_CLOSING:
 699         case AVDTP_STATE_ABORTING:
 700                 if (stream->idle_timer) {
 701                         g_source_remove(stream->idle_timer);
 702                         stream->idle_timer = 0;
 703                 }
 704                 break;
 705         case AVDTP_STATE_IDLE:
 706                 if (stream->idle_timer) {
 707                         g_source_remove(stream->idle_timer);
 708                         stream->idle_timer = 0;
 709                 }
 710                 session->streams = g_slist_remove(session->streams, stream);
 711                 if (session->pending_open == stream)
 712                         handle_transport_connect(session, -1, 0, 0);
 713                 if (session->req && session->req->stream == stream)
 714                         session->req->stream = NULL;
 715                 stream_free(stream);
 716                 if (session->ref == 1 && !session->streams)
 717                         set_disconnect_timer(session);
 718                 break;
 719         default:
 720                 break;
 721         }
 722 }
 723
 724 static void finalize_discovery(struct avdtp *session, int err)
 725 {
 726         struct avdtp_error avdtp_err;
 727
 728         avdtp_error_init(&avdtp_err, AVDTP_ERROR_ERRNO, -err);
 729
 730         if (!session->discov_cb)
 731                 return;
 732
 733         session->discov_cb(session, session->seps,
 734                                 err ? &avdtp_err : NULL,
 735                                 session->user_data);
 736
 737         session->discov_cb = NULL;
 738         session->user_data = NULL;
 739 }
 740
 741 static void release_stream(struct avdtp_stream *stream, struct avdtp *session)
 742 {
 743         struct avdtp_local_sep *sep = stream->lsep;
 744
 745         if (sep->cfm && sep->cfm->abort)
 746                 sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
 747
 748         avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
 749 }
 750
 751 static void connection_lost(struct avdtp *session, int err)
 752 {
 753         struct audio_device *dev;
 754
 755         dev = manager_find_device(&session->dst, AUDIO_CONTROL_INTERFACE,
 756                                         FALSE);
 757         if (dev && dev->control) {
 758                 device_remove_control_timer(dev);
 759                 avrcp_disconnect(dev);
 760         }
 761
 762         if (session->state == AVDTP_SESSION_STATE_CONNECTED) {
 763                 char address[18];
 764
 765                 ba2str(&session->dst, address);
 766                 debug("Disconnected from %s", address);
 767         }
 768
 769         session->free_lock = 1;
 770
 771         finalize_discovery(session, err);
 772
 773         g_slist_foreach(session->streams, (GFunc) release_stream, session);
 774         session->streams = NULL;
 775
 776         session->free_lock = 0;
 777
 778         if (session->sock >= 0) {
 779                 close(session->sock);
 780                 session->sock = -1;
 781         }
 782
 783         session->state = AVDTP_SESSION_STATE_DISCONNECTED;
 784
 785         if (session->io) {
 786                 g_source_remove(session->io);
 787                 session->io = 0;
 788         }
 789
 790         if (session->ref != 1)
 791                 error("connection_lost: ref count not 1 after all callbacks");
 792         else
 793                 avdtp_unref(session);
 794 }
 795
 796 void avdtp_unref(struct avdtp *session)
 797 {
 798         if (!session)
 799                 return;
 800
 801         if (!g_slist_find(sessions, session)) {
 802                 error("avdtp_unref: trying to unref a unknown session");
 803                 return;
 804         }
 805
 806         session->ref--;
 807
 808         debug("avdtp_unref(%p): ref=%d", session, session->ref);
 809
 810         if (session->ref == 1) {
 811                 if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
 812                         close(session->sock);
 813                         session->sock = -1;
 814                 }
 815
 816                 if (session->sock >= 0)
 817                         set_disconnect_timer(session);
 818                 else if (!session->free_lock) /* Drop the local ref if we
 819                                                  aren't connected */
 820                         session->ref--;
 821         }
 822
 823         if (session->ref > 0)
 824                 return;
 825
 826         debug("avdtp_unref(%p): freeing session and removing from list",
 827                         session);
 828
 829         if (session->dc_timer)
 830                 remove_disconnect_timer(session);
 831
 832         sessions = g_slist_remove(sessions, session);
 833
 834         if (session->req)
 835                 pending_req_free(session->req);
 836
 837         g_slist_foreach(session->seps, (GFunc) g_free, NULL);
 838         g_slist_free(session->seps);
 839
 840         g_free(session->buf);
 841
 842         g_free(session);
 843 }
 844
 845 struct avdtp *avdtp_ref(struct avdtp *session)
 846 {
 847         session->ref++;
 848         debug("avdtp_ref(%p): ref=%d", session, session->ref);
 849         if (session->dc_timer)
 850                 remove_disconnect_timer(session);
 851         return session;
 852 }
 853
 854 static struct avdtp_local_sep *find_local_sep_by_seid(uint8_t seid)
 855 {
 856         GSList *l;
 857
 858         for (l = local_seps; l != NULL; l = g_slist_next(l)) {
 859                 struct avdtp_local_sep *sep = l->data;
 860
 861                 if (sep->info.seid == seid)
 862                         return sep;
 863         }
 864
 865         return NULL;
 866 }
 867
 868 static struct avdtp_local_sep *find_local_sep(uint8_t type, uint8_t media_type,
 869                                                 uint8_t codec)
 870 {
 871         GSList *l;
 872
 873         for (l = local_seps; l != NULL; l = g_slist_next(l)) {
 874                 struct avdtp_local_sep *sep = l->data;
 875
 876                 if (sep->info.inuse)
 877                         continue;
 878
 879                 if (sep->info.type == type &&
 880                                 sep->info.media_type == media_type &&
 881                                 sep->codec == codec)
 882                         return sep;
 883         }
 884
 885         return NULL;
 886 }
 887
 888 static GSList *caps_to_list(uint8_t *data, int size,
 889                                 struct avdtp_service_capability **codec)
 890 {
 891         GSList *caps;
 892         int processed;
 893
 894         for (processed = 0, caps = NULL; processed + 2 < size;) {
 895                 struct avdtp_service_capability *cap;
 896                 uint8_t length, category;
 897
 898                 category = data[0];
 899                 length = data[1];
 900
 901                 if (processed + 2 + length > size) {
 902                         error("Invalid capability data in getcap resp");
 903                         break;
 904                 }
 905
 906                 cap = g_malloc(sizeof(struct avdtp_service_capability) +
 907                                         length);
 908                 memcpy(cap, data, 2 + length);
 909
 910                 processed += 2 + length;
 911                 data += 2 + length;
 912
 913                 caps = g_slist_append(caps, cap);
 914
 915                 if (category == AVDTP_MEDIA_CODEC &&
 916                                 length >=
 917                                 sizeof(struct avdtp_media_codec_capability))
 918                         *codec = cap;
 919         }
 920
 921         return caps;
 922 }
 923
 924 static void init_response(struct avdtp_header *rsp, struct avdtp_header *req,
 925                                 gboolean accept)
 926 {
 927         rsp->packet_type = AVDTP_PKT_TYPE_SINGLE;
 928         rsp->message_type = accept ? AVDTP_MSG_TYPE_ACCEPT :
 929                                         AVDTP_MSG_TYPE_REJECT;
 930         rsp->transaction = req->transaction;
 931         rsp->signal_id = req->signal_id;
 932         rsp->rfa0 = 0;
 933 }
 934
 935 static gboolean avdtp_unknown_cmd(struct avdtp *session,
 936                                         struct avdtp_header *req, int size)
 937 {
 938         struct avdtp_general_rej rej;
 939
 940         memset(&rej, 0, sizeof(rej));
 941
 942         rej.packet_type = AVDTP_PKT_TYPE_SINGLE;
 943         rej.message_type = AVDTP_MSG_TYPE_REJECT;
 944         rej.transaction = req->transaction;
 945
 946         return avdtp_send(session, &rej, sizeof(rej));
 947 }
 948
 949 static gboolean avdtp_discover_cmd(struct avdtp *session,
 950                                         struct gen_req *req, int size)
 951 {
 952         GSList *l;
 953         struct discover_resp *rsp = (struct discover_resp *) session->buf;
 954         struct seid_info *info;
 955         int rsp_size;
 956
 957         init_response(&rsp->header, &req->header, TRUE);
 958         rsp_size = sizeof(struct discover_resp);
 959         info = rsp->seps;
 960
 961         for (l = local_seps; l != NULL; l = l->next) {
 962                 struct avdtp_local_sep *sep = l->data;
 963
 964                 if (rsp_size + sizeof(struct seid_info) > session->mtu)
 965                         break;
 966
 967                 memcpy(info, &sep->info, sizeof(struct seid_info));
 968                 rsp_size += sizeof(struct seid_info);
 969                 info++;
 970         }
 971
 972         return avdtp_send(session, session->buf, rsp_size);
 973 }
 974
 975 static gboolean avdtp_getcap_cmd(struct avdtp *session,
 976                                         struct seid_req *req, int size)
 977 {
 978         GSList *l, *caps;
 979         struct avdtp_local_sep *sep = NULL;
 980         struct seid_rej rej;
 981         struct getcap_resp *rsp = (struct getcap_resp *) session->buf;
 982         int rsp_size;
 983         unsigned char *ptr;
 984         uint8_t err;
 985
 986         if (size < sizeof(struct seid_req)) {
 987                 error("Too short getcap request");
 988                 return FALSE;
 989         }
 990
 991         sep = find_local_sep_by_seid(req->acp_seid);
 992         if (!sep) {
 993                 err = AVDTP_BAD_ACP_SEID;
 994                 goto failed;
 995         }
 996
 997         if (!sep->ind->get_capability(session, sep, &caps, &err,
 998                                         sep->user_data))
 999                 goto failed;
1000
1001         init_response(&rsp->header, &req->header, TRUE);
1002         rsp_size = sizeof(struct getcap_resp);
1003         ptr = rsp->caps;
1004
1005         for (l = caps; l != NULL; l = g_slist_next(l)) {
1006                 struct avdtp_service_capability *cap = l->data;
1007
1008                 if (rsp_size + cap->length + 2 > session->mtu)
1009                         break;
1010
1011                 memcpy(ptr, cap, cap->length + 2);
1012                 rsp_size += cap->length + 2;
1013                 ptr += cap->length + 2;
1014
1015                 g_free(cap);
1016         }
1017
1018         g_slist_free(caps);
1019
1020         return avdtp_send(session, session->buf, rsp_size);
1021
1022 failed:
1023         init_response(&rej.header, &req->header, FALSE);
1024         rej.error = AVDTP_BAD_ACP_SEID;
1025         return avdtp_send(session, &rej, sizeof(rej));
1026 }
1027
1028 static gboolean avdtp_setconf_cmd(struct avdtp *session,
1029                                         struct setconf_req *req, int size)
1030 {
1031         struct conf_rej rej;
1032         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1033         struct avdtp_local_sep *sep;
1034         struct avdtp_stream *stream;
1035         uint8_t err, category = 0x00;
1036
1037         if (size < sizeof(struct setconf_req)) {
1038                 error("Too short getcap request");
1039                 return FALSE;
1040         }
1041
1042         sep = find_local_sep_by_seid(req->acp_seid);
1043         if (!sep) {
1044                 err = AVDTP_BAD_ACP_SEID;
1045                 goto failed;
1046         }
1047
1048         if (sep->stream) {
1049                 err = AVDTP_SEP_IN_USE;
1050                 goto failed;
1051         }
1052
1053         stream = g_new0(struct avdtp_stream, 1);
1054         stream->session = session;
1055         stream->lsep = sep;
1056         stream->rseid = req->int_seid;
1057         stream->caps = caps_to_list(req->caps,
1058                                         size - sizeof(struct setconf_req),
1059                                         &stream->codec);
1060         stream->sock = -1;
1061
1062         if (sep->ind && sep->ind->set_configuration) {
1063                 if (!sep->ind->set_configuration(session, sep, stream,
1064                                                         stream->caps, &err,
1065                                                         &category,
1066                                                         sep->user_data)) {
1067                         stream_free(stream);
1068                         goto failed;
1069                 }
1070         }
1071
1072         init_response(&rsp->header, &req->header, TRUE);
1073
1074         if (!avdtp_send(session, rsp, sizeof(struct setconf_req))) {
1075                 stream_free(stream);
1076                 return FALSE;
1077         }
1078
1079         sep->stream = stream;
1080         session->streams = g_slist_append(session->streams, stream);
1081
1082         avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1083
1084         return TRUE;
1085
1086 failed:
1087         init_response(&rej.header, &req->header, FALSE);
1088         rej.error = err;
1089         rej.category = category;
1090         return avdtp_send(session, &rej, sizeof(rej));
1091 }
1092
1093 static gboolean avdtp_getconf_cmd(struct avdtp *session, struct seid_req *req,
1094                                         int size)
1095 {
1096         return avdtp_unknown_cmd(session, (void *) req, size);
1097 }
1098
1099 static gboolean avdtp_reconf_cmd(struct avdtp *session, struct seid_req *req,
1100                                         int size)
1101 {
1102         return avdtp_unknown_cmd(session, (void *) req, size);
1103 }
1104
1105 static gboolean avdtp_open_cmd(struct avdtp *session, struct seid_req *req,
1106                                 int size)
1107 {
1108         struct avdtp_local_sep *sep;
1109         struct avdtp_stream *stream;
1110         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1111         struct seid_rej rej;
1112         uint8_t err;
1113
1114         if (size < sizeof(struct seid_req)) {
1115                 error("Too short abort request");
1116                 return FALSE;
1117         }
1118
1119         sep = find_local_sep_by_seid(req->acp_seid);
1120         if (!sep) {
1121                 err = AVDTP_BAD_ACP_SEID;
1122                 goto failed;
1123         }
1124
1125         if (sep->state != AVDTP_STATE_CONFIGURED) {
1126                 err = AVDTP_BAD_STATE;
1127                 goto failed;
1128         }
1129
1130         stream = sep->stream;
1131
1132         if (sep->ind && sep->ind->open) {
1133                 if (!sep->ind->open(session, sep, stream, &err,
1134                                         sep->user_data))
1135                         goto failed;
1136         }
1137
1138         init_response(&rsp->header, &req->header, TRUE);
1139
1140         if (!avdtp_send(session, rsp, sizeof(struct gen_resp)))
1141                 return FALSE;
1142
1143         stream->open_acp = TRUE;
1144         session->pending_open = stream;
1145         stream->timer = g_timeout_add(REQ_TIMEOUT, stream_open_timeout,
1146                                                 stream);
1147
1148         return TRUE;
1149
1150 failed:
1151         init_response(&rej.header, &req->header, FALSE);
1152         rej.error = err;
1153         return avdtp_send(session, &rej, sizeof(rej));
1154 }
1155
1156 static gboolean avdtp_start_cmd(struct avdtp *session, struct start_req *req,
1157                                 int size)
1158 {
1159         struct avdtp_local_sep *sep;
1160         struct avdtp_stream *stream;
1161         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1162         struct stream_rej rej;
1163         struct seid *seid;
1164         uint8_t err, failed_seid;
1165         int seid_count, i;
1166
1167         if (size < sizeof(struct start_req)) {
1168                 error("Too short start request");
1169                 return FALSE;
1170         }
1171
1172         seid_count = 1 + size - sizeof(struct start_req);
1173
1174         seid = &req->first_seid;
1175
1176         for (i = 0; i < seid_count; i++, seid++) {
1177                 failed_seid = seid->seid;
1178
1179                 sep = find_local_sep_by_seid(req->first_seid.seid);
1180                 if (!sep || !sep->stream) {
1181                         err = AVDTP_BAD_ACP_SEID;
1182                         goto failed;
1183                 }
1184
1185                 stream = sep->stream;
1186
1187                 if (sep->state != AVDTP_STATE_OPEN) {
1188                         err = AVDTP_BAD_STATE;
1189                         goto failed;
1190                 }
1191
1192                 if (sep->ind && sep->ind->start) {
1193                         if (!sep->ind->start(session, sep, stream, &err,
1194                                                 sep->user_data))
1195                                 goto failed;
1196                 }
1197
1198                 avdtp_sep_set_state(session, sep, AVDTP_STATE_STREAMING);
1199         }
1200
1201         init_response(&rsp->header, &req->header, TRUE);
1202
1203         return avdtp_send(session, rsp, sizeof(struct gen_resp));
1204
1205 failed:
1206         memset(&rej, 0, sizeof(rej));
1207         init_response(&rej.header, &req->header, FALSE);
1208         rej.acp_seid = failed_seid;
1209         rej.error = err;
1210         return avdtp_send(session, &rej, sizeof(rej));
1211 }
1212
1213 static gboolean avdtp_close_cmd(struct avdtp *session, struct seid_req *req,
1214                                 int size)
1215 {
1216         struct avdtp_local_sep *sep;
1217         struct avdtp_stream *stream;
1218         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1219         struct seid_rej rej;
1220         uint8_t err;
1221
1222         if (size < sizeof(struct seid_req)) {
1223                 error("Too short close request");
1224                 return FALSE;
1225         }
1226
1227         sep = find_local_sep_by_seid(req->acp_seid);
1228         if (!sep || !sep->stream) {
1229                 err = AVDTP_BAD_ACP_SEID;
1230                 goto failed;
1231         }
1232
1233         if (sep->state != AVDTP_STATE_OPEN &&
1234                         sep->state != AVDTP_STATE_STREAMING) {
1235                 err = AVDTP_BAD_STATE;
1236                 goto failed;
1237         }
1238
1239         stream = sep->stream;
1240
1241         if (sep->ind && sep->ind->close) {
1242                 if (!sep->ind->close(session, sep, stream, &err,
1243                                         sep->user_data))
1244                         goto failed;
1245         }
1246
1247         avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
1248
1249         init_response(&rsp->header, &req->header, TRUE);
1250
1251         if (!avdtp_send(session, rsp, sizeof(struct gen_resp)))
1252                 return FALSE;
1253
1254         stream->timer = g_timeout_add(REQ_TIMEOUT, stream_close_timeout,
1255                                         stream);
1256
1257         return TRUE;
1258
1259 failed:
1260         init_response(&rej.header, &req->header, FALSE);
1261         rej.error = err;
1262         return avdtp_send(session, &rej, sizeof(rej));
1263 }
1264
1265 static gboolean avdtp_suspend_cmd(struct avdtp *session,
1266                                         struct suspend_req *req, int size)
1267 {
1268         struct avdtp_local_sep *sep;
1269         struct avdtp_stream *stream;
1270         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1271         struct stream_rej rej;
1272         struct seid *seid;
1273         uint8_t err, failed_seid;
1274         int seid_count, i;
1275
1276         if (size < sizeof(struct suspend_req)) {
1277                 error("Too short suspend request");
1278                 return FALSE;
1279         }
1280
1281         seid_count = 1 + size - sizeof(struct suspend_req);
1282
1283         seid = &req->first_seid;
1284
1285         for (i = 0; i < seid_count; i++, seid++) {
1286                 failed_seid = seid->seid;
1287
1288                 sep = find_local_sep_by_seid(req->first_seid.seid);
1289                 if (!sep || !sep->stream) {
1290                         err = AVDTP_BAD_ACP_SEID;
1291                         goto failed;
1292                 }
1293
1294                 stream = sep->stream;
1295
1296                 if (sep->state != AVDTP_STATE_STREAMING) {
1297                         err = AVDTP_BAD_STATE;
1298                         goto failed;
1299                 }
1300
1301                 if (sep->ind && sep->ind->suspend) {
1302                         if (!sep->ind->suspend(session, sep, stream, &err,
1303                                                 sep->user_data))
1304                                 goto failed;
1305                 }
1306
1307                 avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
1308         }
1309
1310         init_response(&rsp->header, &req->header, TRUE);
1311
1312         return avdtp_send(session, rsp, sizeof(struct gen_resp));
1313
1314 failed:
1315         memset(&rej, 0, sizeof(rej));
1316         init_response(&rej.header, &req->header, FALSE);
1317         rej.acp_seid = failed_seid;
1318         rej.error = err;
1319         return avdtp_send(session, &rej, sizeof(rej));
1320 }
1321
1322 static gboolean avdtp_abort_cmd(struct avdtp *session, struct seid_req *req,
1323                                 int size)
1324 {
1325         struct avdtp_local_sep *sep;
1326         struct gen_resp *rsp = (struct gen_resp *) session->buf;
1327         struct seid_rej rej;
1328         uint8_t err;
1329         gboolean ret;
1330
1331         if (size < sizeof(struct seid_req)) {
1332                 error("Too short abort request");
1333                 return FALSE;
1334         }
1335
1336         sep = find_local_sep_by_seid(req->acp_seid);
1337         if (!sep || !sep->stream) {
1338                 err = AVDTP_BAD_ACP_SEID;
1339                 goto failed;
1340         }
1341
1342         if (sep->ind && sep->ind->abort) {
1343                 if (!sep->ind->abort(session, sep, sep->stream, &err,
1344                                         sep->user_data))
1345                         goto failed;
1346         }
1347
1348         init_response(&rsp->header, &req->header, TRUE);
1349         ret = avdtp_send(session, rsp, sizeof(struct gen_resp));
1350
1351         if (ret)
1352                 avdtp_sep_set_state(session, sep, AVDTP_STATE_ABORTING);
1353
1354         return ret;
1355
1356 failed:
1357         init_response(&rej.header, &req->header, FALSE);
1358         rej.error = err;
1359         return avdtp_send(session, &rej, sizeof(rej));
1360 }
1361
1362 static gboolean avdtp_secctl_cmd(struct avdtp *session, struct seid_req *req,
1363                                         int size)
1364 {
1365         return avdtp_unknown_cmd(session, (void *) req, size);
1366 }
1367
1368 static gboolean avdtp_parse_cmd(struct avdtp *session,
1369                                 struct avdtp_header *header, int size)
1370 {
1371         switch (header->signal_id) {
1372         case AVDTP_DISCOVER:
1373                 debug("Received DISCOVER_CMD");
1374                 return avdtp_discover_cmd(session, (void *) header, size);
1375         case AVDTP_GET_CAPABILITIES:
1376                 debug("Received  GET_CAPABILITIES_CMD");
1377                 return avdtp_getcap_cmd(session, (void *) header, size);
1378         case AVDTP_SET_CONFIGURATION:
1379                 debug("Received SET_CONFIGURATION_CMD");
1380                 return avdtp_setconf_cmd(session, (void *) header, size);
1381         case AVDTP_GET_CONFIGURATION:
1382                 debug("Received GET_CONFIGURATION_CMD");
1383                 return avdtp_getconf_cmd(session, (void *) header, size);
1384         case AVDTP_RECONFIGURE:
1385                 debug("Received RECONFIGURE_CMD");
1386                 return avdtp_reconf_cmd(session, (void *) header, size);
1387         case AVDTP_OPEN:
1388                 debug("Received OPEN_CMD");
1389                 return avdtp_open_cmd(session, (void *) header, size);
1390         case AVDTP_START:
1391                 debug("Received START_CMD");
1392                 return avdtp_start_cmd(session, (void *) header, size);
1393         case AVDTP_CLOSE:
1394                 debug("Received CLOSE_CMD");
1395                 return avdtp_close_cmd(session, (void *) header, size);
1396         case AVDTP_SUSPEND:
1397                 debug("Received SUSPEND_CMD");
1398                 return avdtp_suspend_cmd(session, (void *) header, size);
1399         case AVDTP_ABORT:
1400                 debug("Received ABORT_CMD");
1401                 return avdtp_abort_cmd(session, (void *) header, size);
1402         case AVDTP_SECURITY_CONTROL:
1403                 debug("Received SECURITY_CONTROL_CMD");
1404                 return avdtp_secctl_cmd(session, (void *) header, size);
1405         default:
1406                 debug("Received unknown request id %u", header->signal_id);
1407                 return avdtp_unknown_cmd(session, (void *) header, size);
1408         }
1409 }
1410
1411 static void init_request(struct avdtp_header *header, int request_id)
1412 {
1413         static int transaction = 0;
1414
1415         header->packet_type = AVDTP_PKT_TYPE_SINGLE;
1416         header->message_type = AVDTP_MSG_TYPE_COMMAND;
1417         header->transaction = transaction;
1418         header->signal_id = request_id;
1419
1420         /* clear rfa bits */
1421         header->rfa0 = 0;
1422
1423         transaction = (transaction + 1) % 16;
1424 }
1425
1426 static gboolean session_cb(GIOChannel *chan, GIOCondition cond,
1427                                 gpointer data)
1428 {
1429         struct avdtp *session = data;
1430         struct avdtp_header *header;
1431         gsize size;
1432
1433         debug("session_cb");
1434
1435         if (cond & G_IO_NVAL)
1436                 return FALSE;
1437
1438         if (cond & (G_IO_HUP | G_IO_ERR))
1439                 goto failed;
1440
1441         if (g_io_channel_read(chan, session->buf, session->mtu,
1442                                 &size) != G_IO_ERROR_NONE) {
1443                 error("IO Channel read error");
1444                 goto failed;
1445         }
1446
1447         if (size < sizeof(struct avdtp_header)) {
1448                 error("Received too small packet (%d bytes)", size);
1449                 goto failed;
1450         }
1451
1452         header = (struct avdtp_header *) session->buf;
1453
1454         if (header->message_type == AVDTP_MSG_TYPE_COMMAND) {
1455                 if (!avdtp_parse_cmd(session, header, size)) {
1456                         error("Unable to handle command. Disconnecting");
1457                         goto failed;
1458                 }
1459
1460                 if (session->ref == 1 && !session->streams)
1461                         set_disconnect_timer(session);
1462
1463                 if (session->streams && session->dc_timer)
1464                         remove_disconnect_timer(session);
1465
1466                 return TRUE;
1467         }
1468
1469         if (session->req == NULL) {
1470                 error("No pending request, rejecting message");
1471                 return TRUE;
1472         }
1473
1474         if (header->transaction != session->req->msg->transaction) {
1475                 error("Transaction label doesn't match");
1476                 return TRUE;
1477         }
1478
1479         if (header->signal_id != session->req->msg->signal_id) {
1480                 error("Reponse signal doesn't match");
1481                 return TRUE;
1482         }
1483
1484         g_source_remove(session->req->timeout);
1485         session->req->timeout = 0;
1486
1487         switch(header->message_type) {
1488         case AVDTP_MSG_TYPE_ACCEPT:
1489                 if (!avdtp_parse_resp(session, session->req->stream,
1490                                                         header, size)) {
1491                         error("Unable to parse accept response");
1492                         goto failed;
1493                 }
1494                 break;
1495         case AVDTP_MSG_TYPE_REJECT:
1496                 if (!avdtp_parse_rej(session, session->req->stream,
1497                                                         header, size)) {
1498                         error("Unable to parse reject response");
1499                         goto failed;
1500                 }
1501                 break;
1502         default:
1503                 error("Unknown message type");
1504                 break;
1505         }
1506
1507         pending_req_free(session->req);
1508         session->req = NULL;
1509
1510         process_queue(session);
1511
1512         return TRUE;
1513
1514 failed:
1515         connection_lost(session, -EIO);
1516
1517         return FALSE;
1518 }
1519
1520 static void l2cap_connect_cb(GIOChannel *chan, int err, const bdaddr_t *src,
1521                         const bdaddr_t *dst, gpointer user_data)
1522 {
1523         struct avdtp *session = user_data;
1524         struct l2cap_options l2o;
1525         socklen_t len;
1526         int sk;
1527         char address[18];
1528
1529         if (!g_slist_find(sessions, session)) {
1530                 debug("l2cap_connect_cb: session got removed");
1531                 return;
1532         }
1533
1534         if (err < 0) {
1535                 error("connect(): %s (%d)", strerror(-err), -err);
1536                 goto failed;
1537         }
1538
1539         sk = g_io_channel_unix_get_fd(chan);
1540
1541         if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {
1542                 session->sock = sk;
1543                 session->state = AVDTP_SESSION_STATE_CONNECTING;
1544         }
1545
1546         ba2str(&session->dst, address);
1547         debug("AVDTP: connected %s channel to %s",
1548                         session->pending_open ? "transport" : "signaling",
1549                         address);
1550
1551         memset(&l2o, 0, sizeof(l2o));
1552         len = sizeof(l2o);
1553         if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &l2o,
1554                                 &len) < 0) {
1555                 err = errno;
1556                 error("getsockopt(L2CAP_OPTIONS): %s (%d)", strerror(err),
1557                                 err);
1558                 goto failed;
1559         }
1560
1561         if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
1562                 struct audio_device *dev;
1563
1564                 session->mtu = l2o.imtu;
1565                 session->buf = g_malloc0(session->mtu);
1566                 session->state = AVDTP_SESSION_STATE_CONNECTED;
1567                 session->io = g_io_add_watch(chan,
1568                                                 G_IO_IN | G_IO_ERR | G_IO_HUP
1569                                                 | G_IO_NVAL,
1570                                                 (GIOFunc) session_cb, session);
1571
1572                 dev = manager_find_device(&session->dst,
1573                                                 AUDIO_CONTROL_INTERFACE, FALSE);
1574                 if (dev)
1575                         avrcp_connect(dev);
1576         }
1577         else if (session->pending_open)
1578                 handle_transport_connect(session, sk, l2o.imtu, l2o.omtu);
1579         else {
1580                 err = -EIO;
1581                 goto failed;
1582         }
1583
1584         process_queue(session);
1585
1586         return;
1587
1588 failed:
1589         if (session->pending_open) {
1590                 avdtp_sep_set_state(session, session->pending_open->lsep,
1591                                         AVDTP_STATE_IDLE);
1592                 session->pending_open = NULL;
1593         } else
1594                 connection_lost(session, -err);
1595
1596         return;
1597 }
1598
1599 static int l2cap_connect(struct avdtp *session)
1600 {
1601         int err;
1602
1603         err = bt_l2cap_connect(&session->src, &session->dst, AVDTP_PSM, 0,
1604                                 l2cap_connect_cb, session);
1605         if (err < 0) {
1606                 error("Connect failed. %s(%d)", strerror(-err), -err);
1607                 return err;
1608         }
1609
1610         return 0;
1611 }
1612
1613 static void queue_request(struct avdtp *session, struct pending_req *req,
1614                         gboolean priority)
1615 {
1616         if (priority)
1617                 session->prio_queue = g_slist_append(session->prio_queue, req);
1618         else
1619                 session->req_queue = g_slist_append(session->req_queue, req);
1620 }
1621
1622 static gboolean request_timeout(gpointer user_data)
1623 {
1624         struct avdtp *session = user_data;
1625         struct pending_req *req;
1626         struct seid_req sreq;
1627         struct avdtp_local_sep *lsep;
1628         struct avdtp_stream *stream;
1629         uint8_t seid;
1630         struct avdtp_error err;
1631
1632         req = session->req;
1633         session->req = NULL;
1634
1635         avdtp_error_init(&err, AVDTP_ERROR_ERRNO, ETIMEDOUT);
1636
1637         seid = ((struct seid_req *) (req->msg))->acp_seid;
1638
1639         stream = find_stream_by_rseid(session, seid);
1640
1641         if (stream)
1642                 lsep = stream->lsep;
1643         else
1644                 lsep = NULL;
1645
1646         switch (req->msg->signal_id) {
1647         case AVDTP_RECONFIGURE:
1648                 error("Reconfigure request timed out");
1649                 if (lsep && lsep->cfm && lsep->cfm->reconfigure)
1650                         lsep->cfm->reconfigure(session, lsep, stream, &err,
1651                                                 lsep->user_data);
1652                 break;
1653         case AVDTP_OPEN:
1654                 error("Open request timed out");
1655                 if (lsep && lsep->cfm && lsep->cfm->open)
1656                         lsep->cfm->open(session, lsep, stream, &err,
1657                                         lsep->user_data);
1658                 break;
1659         case AVDTP_START:
1660                 error("Start request timed out");
1661                 if (lsep && lsep->cfm && lsep->cfm->start)
1662                         lsep->cfm->start(session, lsep, stream, &err,
1663                                                 lsep->user_data);
1664                 break;
1665         case AVDTP_SUSPEND:
1666                 error("Suspend request timed out");
1667                 if (lsep && lsep->cfm && lsep->cfm->suspend)
1668                         lsep->cfm->suspend(session, lsep, stream, &err,
1669                                                 lsep->user_data);
1670                 break;
1671         case AVDTP_CLOSE:
1672                 error("Close request timed out");
1673                 if (lsep && lsep->cfm && lsep->cfm->close)
1674                         lsep->cfm->close(session, lsep, stream, &err,
1675                                                 lsep->user_data);
1676                 break;
1677         case AVDTP_SET_CONFIGURATION:
1678                 error("SetConfiguration request timed out");
1679                 if (lsep && lsep->cfm && lsep->cfm->set_configuration)
1680                         lsep->cfm->set_configuration(session, lsep, stream,
1681                                                         &err, lsep->user_data);
1682                 goto failed;
1683         case AVDTP_DISCOVER:
1684                 error("Discover request timed out");
1685                 goto failed;
1686         case AVDTP_GET_CAPABILITIES:
1687                 error("GetCapabilities request timed out");
1688                 goto failed;
1689         case AVDTP_ABORT:
1690                 error("Abort request timed out");
1691                 goto failed;
1692         }
1693
1694         memset(&sreq, 0, sizeof(sreq));
1695         init_request(&sreq.header, AVDTP_ABORT);
1696         sreq.acp_seid = seid;
1697
1698         if (send_request(session, TRUE, stream, &sreq, sizeof(sreq)) < 0) {
1699                 error("Unable to send abort request");
1700                 goto failed;
1701         }
1702
1703         goto done;
1704
1705 failed:
1706         connection_lost(session, -ETIMEDOUT);
1707 done:
1708         pending_req_free(req);
1709         return FALSE;
1710 }
1711
1712 static int send_req(struct avdtp *session, gboolean priority,
1713                         struct pending_req *req)
1714 {
1715         int err;
1716
1717         if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {
1718                 err = l2cap_connect(session);
1719                 if (err < 0)
1720                         goto failed;
1721         }
1722
1723         if (session->state < AVDTP_SESSION_STATE_CONNECTED ||
1724                         session->req != NULL) {
1725                 queue_request(session, req, priority);
1726                 return 0;
1727         }
1728
1729         /* FIXME: Should we retry to send if the buffer
1730         was not totally sent or in case of EINTR? */
1731         if (!avdtp_send(session, req->msg, req->msg_size)) {
1732                 err = -EIO;
1733                 goto failed;
1734         }
1735
1736         session->req = req;
1737
1738         req->timeout = g_timeout_add(REQ_TIMEOUT, request_timeout,
1739                                         session);
1740         return 0;
1741
1742 failed:
1743         g_free(req->msg);
1744         g_free(req);
1745         return err;
1746 }
1747
1748 static int send_request(struct avdtp *session, gboolean priority,
1749                         struct avdtp_stream *stream, void *buffer, int size)
1750 {
1751         struct pending_req *req;
1752
1753         req = g_new0(struct pending_req, 1);
1754         req->msg = g_malloc(size);
1755         memcpy(req->msg, buffer, size);
1756         req->msg_size = size;
1757         req->stream = stream;
1758
1759         return send_req(session, priority, req);
1760 }
1761
1762 static gboolean avdtp_discover_resp(struct avdtp *session,
1763                                         struct discover_resp *resp, int size)
1764 {
1765         int sep_count, i, isize = sizeof(struct seid_info);
1766
1767         sep_count = (size - sizeof(struct avdtp_header)) / isize;
1768
1769         for (i = 0; i < sep_count; i++) {
1770                 struct avdtp_remote_sep *sep;
1771                 struct avdtp_stream *stream;
1772                 struct seid_req req;
1773                 int ret;
1774
1775                 debug("seid %d type %d media %d in use %d",
1776                                 resp->seps[i].seid, resp->seps[i].type,
1777                                 resp->seps[i].media_type, resp->seps[i].inuse);
1778
1779                 stream = find_stream_by_rseid(session, resp->seps[i].seid);
1780
1781                 sep = find_remote_sep(session->seps, resp->seps[i].seid);
1782                 if (!sep) {
1783                         if (resp->seps[i].inuse && !stream)
1784                                 continue;
1785                         sep = g_new0(struct avdtp_remote_sep, 1);
1786                         session->seps = g_slist_append(session->seps, sep);
1787                 }
1788
1789                 sep->stream = stream;
1790                 sep->seid = resp->seps[i].seid;
1791                 sep->type = resp->seps[i].type;
1792                 sep->media_type = resp->seps[i].media_type;
1793
1794                 memset(&req, 0, sizeof(req));
1795                 init_request(&req.header, AVDTP_GET_CAPABILITIES);
1796                 req.acp_seid = sep->seid;
1797
1798                 ret = send_request(session, TRUE, NULL, &req, sizeof(req));
1799                 if (ret < 0) {
1800                         finalize_discovery(session, ret);
1801                         break;
1802                 }
1803         }
1804
1805         return TRUE;
1806 }
1807
1808 static gboolean avdtp_get_capabilities_resp(struct avdtp *session,
1809                                                 struct getcap_resp *resp,
1810                                                 int size)
1811 {
1812         struct avdtp_remote_sep *sep;
1813         uint8_t seid;
1814
1815         /* Check for minimum required packet size includes:
1816          *   1. getcap resp header
1817          *   2. media transport capability (2 bytes)
1818          *   3. media codec capability type + length (2 bytes)
1819          *   4. the actual media codec elements
1820          * */
1821         if (size < (sizeof(struct getcap_resp) + 4 +
1822                                 sizeof(struct avdtp_media_codec_capability))) {
1823                 error("Too short getcap resp packet");
1824                 return FALSE;
1825         }
1826
1827         seid = ((struct seid_req *) session->req->msg)->acp_seid;
1828
1829         sep = find_remote_sep(session->seps, seid);
1830
1831         debug("seid %d type %d media %d", sep->seid,
1832                                         sep->type, sep->media_type);
1833
1834         if (sep->caps) {
1835                 g_slist_foreach(sep->caps, (GFunc) g_free, NULL);
1836                 g_slist_free(sep->caps);
1837                 sep->caps = NULL;
1838                 sep->codec = NULL;
1839         }
1840
1841         sep->caps = caps_to_list(resp->caps, size - sizeof(struct getcap_resp),
1842                                         &sep->codec);
1843
1844         return TRUE;
1845 }
1846
1847 static gboolean avdtp_set_configuration_resp(struct avdtp *session,
1848                                                 struct avdtp_stream *stream,
1849                                                 struct avdtp_header *resp,
1850                                                 int size)
1851 {
1852         struct avdtp_local_sep *sep = stream->lsep;
1853
1854         if (sep->cfm && sep->cfm->set_configuration)
1855                 sep->cfm->set_configuration(session, sep, stream, NULL,
1856                                                 sep->user_data);
1857
1858         avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1859
1860         return TRUE;
1861 }
1862
1863 static gboolean avdtp_reconfigure_resp(struct avdtp *session,
1864                                         struct avdtp_stream *stream,
1865                                         struct avdtp_header *resp, int size)
1866 {
1867         return TRUE;
1868 }
1869
1870 static gboolean avdtp_open_resp(struct avdtp *session, struct avdtp_stream *stream,
1871                                 struct seid_rej *resp, int size)
1872 {
1873         struct avdtp_local_sep *sep = stream->lsep;
1874
1875         if (l2cap_connect(session) < 0) {
1876                 avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
1877                 return FALSE;
1878         }
1879
1880         session->pending_open = stream;
1881
1882         avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
1883
1884         return TRUE;
1885 }
1886
1887 static gboolean avdtp_start_resp(struct avdtp *session,
1888                                         struct avdtp_stream *stream,
1889                                         struct seid_rej *resp, int size)
1890 {
1891         struct avdtp_local_sep *sep = stream->lsep;
1892
1893         if (sep->cfm && sep->cfm->start)
1894                 sep->cfm->start(session, sep, stream, NULL, sep->user_data);
1895
1896         avdtp_sep_set_state(session, sep, AVDTP_STATE_STREAMING);
1897
1898         return TRUE;
1899 }
1900
1901 static gboolean avdtp_close_resp(struct avdtp *session,
1902                                         struct avdtp_stream *stream,
1903                                         struct seid_rej *resp, int size)
1904 {
1905         struct avdtp_local_sep *sep = stream->lsep;
1906
1907         avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
1908
1909         close(stream->sock);
1910         stream->sock = -1;
1911
1912         return TRUE;
1913 }
1914
1915 static gboolean avdtp_suspend_resp(struct avdtp *session,
1916                                         struct avdtp_stream *stream,
1917                                         struct gen_resp *resp,
1918                                         int size)
1919 {
1920         struct avdtp_local_sep *sep = stream->lsep;
1921
1922         avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
1923
1924         stream->idle_timer = g_timeout_add(STREAM_TIMEOUT,
1925                                         (GSourceFunc) stream_timeout, stream);
1926
1927         if (sep->cfm && sep->cfm->suspend)
1928                 sep->cfm->suspend(session, sep, stream, NULL, sep->user_data);
1929
1930         return TRUE;
1931 }
1932
1933 static gboolean avdtp_abort_resp(struct avdtp *session,
1934                                         struct avdtp_stream *stream,
1935                                         struct seid_rej *resp, int size)
1936 {
1937         struct avdtp_local_sep *sep = stream->lsep;
1938
1939         if (sep->cfm && sep->cfm->abort)
1940                 sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
1941
1942         avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
1943
1944         return TRUE;
1945 }
1946
1947 static gboolean avdtp_parse_resp(struct avdtp *session,
1948                                         struct avdtp_stream *stream,
1949                                         struct avdtp_header *header, int size)
1950 {
1951         struct avdtp_header *next;
1952
1953         if (session->prio_queue)
1954                 next = ((struct pending_req *)
1955                                 (session->prio_queue->data))->msg;
1956         else if (session->req_queue)
1957                 next = ((struct pending_req *)
1958                                 (session->req_queue->data))->msg;
1959         else
1960                 next = NULL;
1961
1962         switch (header->signal_id) {
1963         case AVDTP_DISCOVER:
1964                 debug("DISCOVER request succeeded");
1965                 return avdtp_discover_resp(session, (void *) header, size);
1966         case AVDTP_GET_CAPABILITIES:
1967                 debug("GET_CAPABILITIES request succeeded");
1968                 if (!avdtp_get_capabilities_resp(session,
1969                                                 (void *) header, size))
1970                         return FALSE;
1971                 if (!(next && next->signal_id == AVDTP_GET_CAPABILITIES))
1972                         finalize_discovery(session, 0);
1973                 return TRUE;
1974         case AVDTP_SET_CONFIGURATION:
1975                 debug("SET_CONFIGURATION request succeeded");
1976                 return avdtp_set_configuration_resp(session, stream,
1977                                                         (void *) header, size);
1978         case AVDTP_RECONFIGURE:
1979                 debug("RECONFIGURE request succeeded");
1980                 return avdtp_reconfigure_resp(session, stream,
1981                                                         (void *) header, size);
1982         case AVDTP_OPEN:
1983                 debug("OPEN request succeeded");
1984                 return avdtp_open_resp(session, stream, (void *) header, size);
1985         case AVDTP_SUSPEND:
1986                 debug("SUSPEND request succeeded");
1987                 return avdtp_suspend_resp(session, stream,
1988                                                         (void *) header, size);
1989         case AVDTP_START:
1990                 debug("START request succeeded");
1991                 return avdtp_start_resp(session, stream, (void *) header, size);
1992         case AVDTP_CLOSE:
1993                 debug("CLOSE request succeeded");
1994                 return avdtp_close_resp(session, stream, (void *) header, size);
1995         case AVDTP_ABORT:
1996                 debug("ABORT request succeeded");
1997                 return avdtp_abort_resp(session, stream, (void *) header, size);
1998         }
1999
2000         error("Unknown signal id in accept response: %u", header->signal_id);
2001
2002         return TRUE;
2003 }
2004
2005 static gboolean seid_rej_to_err(struct seid_rej *rej, int size,
2006                                         struct avdtp_error *err)
2007 {
2008         if (size < sizeof(struct seid_rej)) {
2009                 error("Too small packet for seid_rej");
2010                 return FALSE;
2011         }
2012
2013         avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2014
2015         return TRUE;
2016 }
2017
2018 static gboolean conf_rej_to_err(struct conf_rej *rej, int size,
2019                                 struct avdtp_error *err, uint8_t *category)
2020 {
2021         if (size < sizeof(struct conf_rej)) {
2022                 error("Too small packet for conf_rej");
2023                 return FALSE;
2024         }
2025
2026         avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2027
2028         if (category)
2029                 *category = rej->category;
2030
2031         return TRUE;
2032 }
2033
2034 static gboolean stream_rej_to_err(struct stream_rej *rej, int size,
2035                                         struct avdtp_error *err,
2036                                         uint8_t *acp_seid)
2037 {
2038         if (size < sizeof(struct conf_rej)) {
2039                 error("Too small packet for stream_rej");
2040                 return FALSE;
2041         }
2042
2043         avdtp_error_init(err, AVDTP_ERROR_ERROR_CODE, rej->error);
2044
2045         if (acp_seid)
2046                 *acp_seid = rej->acp_seid;
2047
2048         return TRUE;
2049 }
2050
2051 static gboolean avdtp_parse_rej(struct avdtp *session,
2052                                 struct avdtp_stream *stream,
2053                                 struct avdtp_header *header, int size)
2054 {
2055         struct avdtp_error err;
2056         uint8_t acp_seid, category;
2057         struct avdtp_local_sep *sep = stream ? stream->lsep : NULL;
2058
2059         switch (header->signal_id) {
2060         case AVDTP_DISCOVER:
2061                 if (!seid_rej_to_err((void *) header, size, &err))
2062                         return FALSE;
2063                 error("DISCOVER request rejected: %s (%d)",
2064                                 avdtp_strerror(&err), err.err.error_code);
2065                 return TRUE;
2066         case AVDTP_GET_CAPABILITIES:
2067                 if (!seid_rej_to_err((void *) header, size, &err))
2068                         return FALSE;
2069                 error("GET_CAPABILITIES request rejected: %s (%d)",
2070                                 avdtp_strerror(&err), err.err.error_code);
2071                 return TRUE;
2072         case AVDTP_OPEN:
2073                 if (!seid_rej_to_err((void *) header, size, &err))
2074                         return FALSE;
2075                 error("OPEN request rejected: %s (%d)",
2076                                 avdtp_strerror(&err), err.err.error_code);
2077                 if (sep && sep->cfm && sep->cfm->open)
2078                         sep->cfm->open(session, sep, stream, &err,
2079                                         sep->user_data);
2080                 return TRUE;
2081         case AVDTP_SET_CONFIGURATION:
2082                 if (!conf_rej_to_err((void *) header, size, &err, &category))
2083                         return FALSE;
2084                 error("SET_CONFIGURATION request rejected: %s (%d)",
2085                                 avdtp_strerror(&err), err.err.error_code);
2086                 if (sep && sep->cfm && sep->cfm->set_configuration)
2087                         sep->cfm->set_configuration(session, sep, stream,
2088                                                         &err, sep->user_data);
2089                 return TRUE;
2090         case AVDTP_RECONFIGURE:
2091                 if (!conf_rej_to_err((void *) header, size, &err, &category))
2092                         return FALSE;
2093                 error("RECONFIGURE request rejected: %s (%d)",
2094                                 avdtp_strerror(&err), err.err.error_code);
2095                 if (sep && sep->cfm && sep->cfm->reconfigure)
2096                         sep->cfm->reconfigure(session, sep, stream, &err,
2097                                                 sep->user_data);
2098                 return TRUE;
2099         case AVDTP_START:
2100                 if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
2101                         return FALSE;
2102                 error("START request rejected: %s (%d)",
2103                                 avdtp_strerror(&err), err.err.error_code);
2104                 if (sep && sep->cfm && sep->cfm->start)
2105                         sep->cfm->start(session, sep, stream, &err,
2106                                         sep->user_data);
2107                 return TRUE;
2108         case AVDTP_SUSPEND:
2109                 if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
2110                         return FALSE;
2111                 error("SUSPEND request rejected: %s (%d)",
2112                                 avdtp_strerror(&err), err.err.error_code);
2113                 if (sep && sep->cfm && sep->cfm->suspend)
2114                         sep->cfm->suspend(session, sep, stream, &err,
2115                                                 sep->user_data);
2116                 return TRUE;
2117         case AVDTP_CLOSE:
2118                 if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
2119                         return FALSE;
2120                 error("CLOSE request rejected: %s (%d)",
2121                                 avdtp_strerror(&err), err.err.error_code);
2122                 if (sep && sep->cfm && sep->cfm->close)
2123                         sep->cfm->close(session, sep, stream, &err,
2124                                         sep->user_data);
2125                 return TRUE;
2126         case AVDTP_ABORT:
2127                 if (!stream_rej_to_err((void *) header, size, &err, &acp_seid))
2128                         return FALSE;
2129                 error("ABORT request rejected: %s (%d)",
2130                                 avdtp_strerror(&err), err.err.error_code);
2131                 if (sep && sep->cfm && sep->cfm->abort)
2132                         sep->cfm->abort(session, sep, stream, &err,
2133                                         sep->user_data);
2134                 return TRUE;
2135         default:
2136                 error("Unknown reject response signal id: %u",
2137                                 header->signal_id);
2138                 return TRUE;
2139         }
2140 }
2141
2142 static struct avdtp *find_session(const bdaddr_t *src, const bdaddr_t *dst)
2143 {
2144         GSList *l;
2145
2146         for (l = sessions; l != NULL; l = g_slist_next(l)) {
2147                 struct avdtp *s = l->data;
2148
2149                 if (bacmp(src, &s->src) || bacmp(dst, &s->dst))
2150                         continue;
2151
2152                 return s;
2153         }
2154
2155         return NULL;
2156 }
2157
2158 static struct avdtp *avdtp_get_internal(const bdaddr_t *src, const bdaddr_t *dst)
2159 {
2160         struct avdtp *session;
2161
2162         assert(src != NULL);
2163         assert(dst != NULL);
2164
2165         session = find_session(src, dst);
2166         if (session) {
2167                 if (session->pending_auth)
2168                         return NULL;
2169                 else
2170                         return session;
2171         }
2172
2173         session = g_new0(struct avdtp, 1);
2174
2175         session->sock = -1;
2176         bacpy(&session->src, src);
2177         bacpy(&session->dst, dst);
2178         session->ref = 1;
2179         session->state = AVDTP_SESSION_STATE_DISCONNECTED;
2180
2181         sessions = g_slist_append(sessions, session);
2182
2183         return session;
2184 }
2185
2186 struct avdtp *avdtp_get(bdaddr_t *src, bdaddr_t *dst)
2187 {
2188         struct avdtp *session;
2189
2190         session = avdtp_get_internal(src, dst);
2191
2192         if (!session)
2193                 return NULL;
2194
2195         return avdtp_ref(session);
2196 }
2197
2198 gboolean avdtp_is_connected(const bdaddr_t *src, const bdaddr_t *dst)
2199 {
2200         struct avdtp *session;
2201
2202         session = find_session(src, dst);
2203
2204         if (!session)
2205                 return FALSE;
2206
2207         if (session->state != AVDTP_SESSION_STATE_DISCONNECTED)
2208                 return TRUE;
2209
2210         return FALSE;
2211 }
2212
2213 gboolean avdtp_stream_has_capability(struct avdtp_stream *stream,
2214                                 struct avdtp_service_capability *cap)
2215 {
2216         GSList *l;
2217         struct avdtp_service_capability *stream_cap;
2218
2219         for (l = stream->caps; l; l = g_slist_next(l)) {
2220                 stream_cap = l->data;
2221                 if (stream_cap->category == cap->category &&
2222                         stream_cap->length == cap->length) {
2223                         if (!memcmp(stream_cap->data, cap->data, cap->length))
2224                                 return TRUE;
2225                 }
2226         }
2227
2228         return FALSE;
2229 }
2230
2231 gboolean avdtp_stream_has_capabilities(struct avdtp_stream *stream,
2232                                         GSList *caps)
2233 {
2234         GSList *l;
2235
2236         for (l = caps; l; l = g_slist_next(l)) {
2237                 struct avdtp_service_capability *cap = l->data;
2238
2239                 if (!avdtp_stream_has_capability(stream, cap))
2240                         return FALSE;
2241         }
2242
2243         return TRUE;
2244 }
2245
2246 gboolean avdtp_stream_get_transport(struct avdtp_stream *stream, int *sock,
2247                                         uint16_t *imtu, uint16_t *omtu,
2248                                         GSList **caps)
2249 {
2250         if (stream->sock < 0)
2251                 return FALSE;
2252
2253         if (sock)
2254                 *sock = stream->sock;
2255
2256         if (omtu)
2257                 *omtu = stream->omtu;
2258
2259         if (imtu)
2260                 *imtu = stream->imtu;
2261
2262         if (caps)
2263                 *caps = stream->caps;
2264
2265         return TRUE;
2266 }
2267
2268 static int process_queue(struct avdtp *session)
2269 {
2270         GSList **queue, *l;
2271         struct pending_req *req;
2272
2273         if (session->req)
2274                 return 0;
2275
2276         if (session->prio_queue)
2277                 queue = &session->prio_queue;
2278         else
2279                 queue = &session->req_queue;
2280
2281         if (!*queue)
2282                 return 0;
2283
2284         l = *queue;
2285         req = l->data;
2286
2287         *queue = g_slist_remove(*queue, req);
2288
2289         return send_req(session, FALSE, req);
2290 }
2291
2292 struct avdtp_service_capability *avdtp_get_codec(struct avdtp_remote_sep *sep)
2293 {
2294         return sep->codec;
2295 }
2296
2297 struct avdtp_service_capability *avdtp_service_cap_new(uint8_t category,
2298                                                         void *data, int length)
2299 {
2300         struct avdtp_service_capability *cap;
2301
2302         if (category < AVDTP_MEDIA_TRANSPORT || category > AVDTP_MEDIA_CODEC)
2303                 return NULL;
2304
2305         cap = g_malloc(sizeof(struct avdtp_service_capability) + length);
2306         cap->category = category;
2307         cap->length = length;
2308         memcpy(cap->data, data, length);
2309
2310         return cap;
2311 }
2312
2313 int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb,
2314                         void *user_data)
2315 {
2316         struct gen_req req;
2317         int ret;
2318
2319         if (session->discov_cb)
2320                 return -EBUSY;
2321
2322         if (session->seps) {
2323                 cb(session, session->seps, NULL, user_data);
2324                 return 0;
2325         }
2326
2327         memset(&req, 0, sizeof(req));
2328         init_request(&req.header, AVDTP_DISCOVER);
2329
2330         ret = send_request(session, FALSE, NULL, &req, sizeof(req));
2331         if (ret == 0) {
2332                 session->discov_cb = cb;
2333                 session->user_data = user_data;
2334         }
2335
2336         return ret;
2337 }
2338
2339 int avdtp_get_seps(struct avdtp *session, uint8_t acp_type, uint8_t media_type,
2340                         uint8_t codec, struct avdtp_local_sep **lsep,
2341                         struct avdtp_remote_sep **rsep)
2342 {
2343         GSList *l;
2344         uint8_t int_type;
2345
2346         int_type = acp_type == AVDTP_SEP_TYPE_SINK ?
2347                                 AVDTP_SEP_TYPE_SOURCE : AVDTP_SEP_TYPE_SINK;
2348
2349         *lsep = find_local_sep(int_type, media_type, codec);
2350         if (!*lsep)
2351                 return -EINVAL;
2352
2353         for (l = session->seps; l != NULL; l = g_slist_next(l)) {
2354                 struct avdtp_remote_sep *sep = l->data;
2355                 struct avdtp_service_capability *cap;
2356                 struct avdtp_media_codec_capability *codec_data;
2357
2358                 if (sep->type != acp_type)
2359                         continue;
2360
2361                 if (sep->media_type != media_type)
2362                         continue;
2363
2364                 if (!sep->codec)
2365                         continue;
2366
2367                 cap = sep->codec;
2368                 codec_data = (void *) cap->data;
2369
2370                 if (codec_data->media_codec_type != codec)
2371                         continue;
2372
2373                 if (!sep->stream) {
2374                         *rsep = sep;
2375                         return 0;
2376                 }
2377         }
2378
2379         return -EINVAL;
2380 }
2381
2382 gboolean avdtp_stream_remove_cb(struct avdtp *session,
2383                                 struct avdtp_stream *stream,
2384                                 unsigned int id)
2385 {
2386         GSList *l;
2387         struct stream_callback *cb;
2388
2389         if (!stream)
2390                 return FALSE;
2391
2392         for (cb = NULL, l = stream->callbacks; l != NULL; l = l->next) {
2393                 struct stream_callback *tmp = l->data;
2394                 if (tmp->id == id) {
2395                         cb = tmp;
2396                         break;
2397                 }
2398         }
2399
2400         if (!cb)
2401                 return FALSE;
2402
2403         stream->callbacks = g_slist_remove(stream->callbacks, cb);
2404         g_free(cb);
2405
2406         return TRUE;
2407 }
2408
2409 unsigned int avdtp_stream_add_cb(struct avdtp *session,
2410                                         struct avdtp_stream *stream,
2411                                         avdtp_stream_state_cb cb, void *data)
2412 {
2413         struct stream_callback *stream_cb;
2414         static unsigned int id = 0;
2415
2416         stream_cb = g_new(struct stream_callback, 1);
2417         stream_cb->cb = cb;
2418         stream_cb->user_data = data;
2419         stream_cb->id = ++id;
2420
2421         stream->callbacks = g_slist_append(stream->callbacks, stream_cb);;
2422
2423         return stream_cb->id;
2424 }
2425
2426 int avdtp_get_configuration(struct avdtp *session, struct avdtp_stream *stream)
2427 {
2428         struct seid_req req;
2429
2430         if (session->state < AVDTP_SESSION_STATE_CONNECTED)
2431                 return -EINVAL;
2432
2433         memset(&req, 0, sizeof(req));
2434         init_request(&req.header, AVDTP_GET_CONFIGURATION);
2435         req.acp_seid = stream->rseid;
2436
2437         return send_request(session, FALSE, stream, &req, sizeof(req));
2438 }
2439
2440 static void copy_capabilities(gpointer data, gpointer user_data)
2441 {
2442         struct avdtp_service_capability *src_cap = data;
2443         struct avdtp_service_capability *dst_cap;
2444         GSList **l = user_data;
2445
2446         dst_cap = avdtp_service_cap_new(src_cap->category, src_cap->data,
2447                                         src_cap->length);
2448
2449         *l = g_slist_append(*l, dst_cap);
2450 }
2451
2452 int avdtp_set_configuration(struct avdtp *session,
2453                                 struct avdtp_remote_sep *rsep,
2454                                 struct avdtp_local_sep *lsep,
2455                                 GSList *caps,
2456                                 struct avdtp_stream **stream)
2457 {
2458         struct setconf_req *req;
2459         struct avdtp_stream *new_stream;
2460         unsigned char *ptr;
2461         int ret, caps_len;
2462         struct avdtp_service_capability *cap;
2463         GSList *l;
2464
2465         if (session->state != AVDTP_SESSION_STATE_CONNECTED)
2466                 return -ENOTCONN;
2467
2468         if (!(lsep && rsep))
2469                 return -EINVAL;
2470
2471         debug("avdtp_set_configuration(%p): int_seid=%u, acp_seid=%u",
2472                         session, lsep->info.seid, rsep->seid);
2473
2474         new_stream = g_new0(struct avdtp_stream, 1);
2475
2476         new_stream->session = session;
2477         new_stream->lsep = lsep;
2478         new_stream->rseid = rsep->seid;
2479
2480         g_slist_foreach(caps, copy_capabilities, &new_stream->caps);
2481
2482         /* Calculate total size of request */
2483         for (l = caps, caps_len = 0; l != NULL; l = g_slist_next(l)) {
2484                 cap = l->data;
2485                 caps_len += cap->length + 2;
2486         }
2487
2488         req = g_malloc0(sizeof(struct setconf_req) + caps_len);
2489
2490         init_request(&req->header, AVDTP_SET_CONFIGURATION);
2491         req->int_seid = lsep->info.seid;
2492         req->acp_seid = rsep->seid;
2493
2494         /* Copy the capabilities into the request */
2495         for (l = caps, ptr = req->caps; l != NULL; l = g_slist_next(l)) {
2496                 cap = l->data;
2497                 memcpy(ptr, cap, cap->length + 2);
2498                 ptr += cap->length + 2;
2499         }
2500
2501         ret = send_request(session, FALSE, new_stream, req,
2502                                 sizeof(struct setconf_req) + caps_len);
2503         if (ret < 0)
2504                 stream_free(new_stream);
2505         else {
2506                 lsep->info.inuse = 1;
2507                 lsep->stream = new_stream;
2508                 rsep->stream = new_stream;
2509                 session->streams = g_slist_append(session->streams, new_stream);
2510                 if (stream)
2511                         *stream = new_stream;
2512         }
2513
2514         g_free(req);
2515
2516         return ret;
2517 }
2518
2519 int avdtp_reconfigure(struct avdtp *session, GSList *caps,
2520                         struct avdtp_stream *stream)
2521 {
2522         struct reconf_req *req;
2523         unsigned char *ptr;
2524         int caps_len;
2525         GSList *l;
2526         struct avdtp_service_capability *cap;
2527
2528         if (!g_slist_find(session->streams, stream))
2529                 return -EINVAL;
2530
2531         if (stream->lsep->state != AVDTP_STATE_OPEN)
2532                 return -EINVAL;
2533
2534         /* Calculate total size of request */
2535         for (l = caps, caps_len = 0; l != NULL; l = g_slist_next(l)) {
2536                 cap = l->data;
2537                 caps_len += cap->length + 2;
2538         }
2539
2540         req = g_malloc0(sizeof(struct reconf_req) + caps_len);
2541
2542         init_request(&req->header, AVDTP_RECONFIGURE);
2543         req->acp_seid = stream->rseid;
2544
2545         /* Copy the capabilities into the request */
2546         for (l = caps, ptr = req->caps; l != NULL; l = g_slist_next(l)) {
2547                 cap = l->data;
2548                 memcpy(ptr, cap, cap->length + 2);
2549                 ptr += cap->length + 2;
2550         }
2551
2552         return send_request(session, FALSE, stream, req, sizeof(*req)
2553                                 + caps_len);
2554 }
2555
2556 int avdtp_open(struct avdtp *session, struct avdtp_stream *stream)
2557 {
2558         struct seid_req req;
2559
2560         if (!g_slist_find(session->streams, stream))
2561                 return -EINVAL;
2562
2563         if (stream->lsep->state > AVDTP_STATE_CONFIGURED)
2564                 return -EINVAL;
2565
2566         memset(&req, 0, sizeof(req));
2567         init_request(&req.header, AVDTP_OPEN);
2568         req.acp_seid = stream->rseid;
2569
2570         return send_request(session, FALSE, stream, &req, sizeof(req));
2571 }
2572
2573 int avdtp_start(struct avdtp *session, struct avdtp_stream *stream)
2574 {
2575         struct start_req req;
2576
2577         if (!g_slist_find(session->streams, stream))
2578                 return -EINVAL;
2579
2580         if (stream->lsep->state != AVDTP_STATE_OPEN)
2581                 return -EINVAL;
2582
2583         memset(&req, 0, sizeof(req));
2584         init_request(&req.header, AVDTP_START);
2585         req.first_seid.seid = stream->rseid;
2586
2587         return send_request(session, FALSE, stream, &req, sizeof(req));
2588 }
2589
2590 int avdtp_close(struct avdtp *session, struct avdtp_stream *stream)
2591 {
2592         struct seid_req req;
2593         int ret;
2594
2595         if (!g_slist_find(session->streams, stream))
2596                 return -EINVAL;
2597
2598         if (stream->lsep->state < AVDTP_STATE_OPEN)
2599                 return -EINVAL;
2600
2601         memset(&req, 0, sizeof(req));
2602         init_request(&req.header, AVDTP_CLOSE);
2603         req.acp_seid = stream->rseid;
2604
2605         ret = send_request(session, FALSE, stream, &req, sizeof(req));
2606         if (ret == 0)
2607                 stream->close_int = TRUE;
2608
2609         return ret;
2610 }
2611
2612 int avdtp_suspend(struct avdtp *session, struct avdtp_stream *stream)
2613 {
2614         struct seid_req req;
2615
2616         if (!g_slist_find(session->streams, stream))
2617                 return -EINVAL;
2618
2619         if (stream->lsep->state <= AVDTP_STATE_OPEN)
2620                 return -EINVAL;
2621
2622         memset(&req, 0, sizeof(req));
2623         init_request(&req.header, AVDTP_SUSPEND);
2624         req.acp_seid = stream->rseid;
2625
2626         return send_request(session, FALSE, stream, &req, sizeof(req));
2627 }
2628
2629 int avdtp_abort(struct avdtp *session, struct avdtp_stream *stream)
2630 {
2631         struct seid_req req;
2632         int ret;
2633
2634         if (!g_slist_find(session->streams, stream))
2635                 return -EINVAL;
2636
2637         if (stream->lsep->state <= AVDTP_STATE_OPEN)
2638                 return -EINVAL;
2639
2640         memset(&req, 0, sizeof(req));
2641         init_request(&req.header, AVDTP_ABORT);
2642         req.acp_seid = stream->rseid;
2643
2644         ret = send_request(session, FALSE, stream, &req, sizeof(req));
2645         if (ret == 0)
2646                 avdtp_sep_set_state(session, stream->lsep,
2647                                         AVDTP_STATE_ABORTING);
2648
2649         return 0;
2650 }
2651
2652 struct avdtp_local_sep *avdtp_register_sep(uint8_t type, uint8_t media_type,
2653                                                 uint8_t codec_type,
2654                                                 struct avdtp_sep_ind *ind,
2655                                                 struct avdtp_sep_cfm *cfm,
2656                                                 void *user_data)
2657 {
2658         struct avdtp_local_sep *sep;
2659
2660         if (free_seid > MAX_SEID)
2661                 return NULL;
2662
2663         sep = g_new0(struct avdtp_local_sep, 1);
2664
2665         sep->state = AVDTP_STATE_IDLE;
2666         sep->info.seid = free_seid++;
2667         sep->info.type = type;
2668         sep->info.media_type = media_type;
2669         sep->codec = codec_type;
2670         sep->ind = ind;
2671         sep->cfm = cfm;
2672         sep->user_data = user_data;
2673
2674         debug("SEP %p registered: type:%d codec:%d seid:%d", sep,
2675                         sep->info.type, sep->codec, sep->info.seid);
2676         local_seps = g_slist_append(local_seps, sep);
2677
2678         return sep;
2679 }
2680
2681 int avdtp_unregister_sep(struct avdtp_local_sep *sep)
2682 {
2683         if (!sep)
2684                 return -EINVAL;
2685
2686         if (sep->info.inuse)
2687                 return -EBUSY;
2688
2689         local_seps = g_slist_remove(local_seps, sep);
2690
2691         g_free(sep);
2692
2693         return 0;
2694 }
2695
2696 static void auth_cb(DBusError *derr, void *user_data)
2697 {
2698         struct avdtp *session = user_data;
2699         struct audio_device *dev;
2700         GIOChannel *io;
2701
2702         if (derr && dbus_error_is_set(derr)) {
2703                 error("Access denied: %s", derr->message);
2704                 if (dbus_error_has_name(derr, DBUS_ERROR_NO_REPLY)) {
2705                         debug("Canceling authorization request");
2706                         service_cancel_auth(&session->src, &session->dst);
2707                 }
2708
2709                 connection_lost(session, -EACCES);
2710                 return;
2711         }
2712
2713         session->buf = g_malloc0(session->mtu);
2714
2715         session->stream_setup = TRUE;
2716         set_disconnect_timer(session);
2717
2718         session->state = AVDTP_SESSION_STATE_CONNECTED;
2719
2720         dev = manager_find_device(&session->dst, AUDIO_CONTROL_INTERFACE,
2721                                         FALSE);
2722         if (dev && dev->control)
2723                 device_set_control_timer(dev);
2724
2725         g_source_remove(session->io);
2726
2727         io = g_io_channel_unix_new(session->sock);
2728         session->io = g_io_add_watch(io,
2729                                 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
2730                                 (GIOFunc) session_cb, session);
2731         g_io_channel_unref(io);
2732 }
2733
2734 static void avdtp_server_cb(GIOChannel *chan, int err, const bdaddr_t *src,
2735                 const bdaddr_t *dst, gpointer data)
2736 {
2737         int sk;
2738         socklen_t size;
2739         struct l2cap_options l2o;
2740         struct avdtp *session;
2741         char address[18];
2742
2743         if (err < 0) {
2744                 error("accept: %s (%d)", strerror(-err), -err);
2745                 return;
2746         }
2747
2748         sk = g_io_channel_unix_get_fd(chan);
2749
2750         ba2str(dst, address);
2751         debug("AVDTP: incoming connect from %s", address);
2752
2753         memset(&l2o, 0, sizeof(l2o));
2754         size = sizeof(l2o);
2755         if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &size) < 0) {
2756                 error("getsockopt(L2CAP_OPTIONS): %s (%d)", strerror(errno),
2757                         errno);
2758                 goto drop;
2759         }
2760
2761         session = avdtp_get_internal(src, dst);
2762
2763         if (session->pending_open && session->pending_open->open_acp) {
2764                 handle_transport_connect(session, sk, l2o.imtu, l2o.omtu);
2765                 return;
2766         }
2767
2768         if (session->sock >= 0) {
2769                 error("Refusing unexpected connect from %s", address);
2770                 goto drop;
2771         }
2772
2773         session->mtu = l2o.imtu;
2774         session->sock = sk;
2775
2776         session->io = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
2777                                         (GIOFunc) session_cb, session);
2778
2779         if (service_req_auth(src, dst, ADVANCED_AUDIO_UUID, auth_cb,
2780                         session) < 0) {
2781                 avdtp_unref(session);
2782                 goto drop;
2783         }
2784
2785         g_io_channel_unref(chan);
2786         return;
2787
2788 drop:
2789         g_io_channel_close(chan);
2790         g_io_channel_unref(chan);
2791 }
2792
2793 static GIOChannel *avdtp_server_socket(gboolean master)
2794 {
2795         int lm;
2796
2797         lm = L2CAP_LM_SECURE;
2798
2799         if (master)
2800                 lm |= L2CAP_LM_MASTER;
2801
2802         return bt_l2cap_listen(BDADDR_ANY, AVDTP_PSM, 0, lm, avdtp_server_cb,
2803                         NULL);
2804 }
2805
2806 const char *avdtp_strerror(struct avdtp_error *err)
2807 {
2808         if (err->type == AVDTP_ERROR_ERRNO)
2809                 return strerror(err->err.posix_errno);
2810
2811         switch(err->err.error_code) {
2812         case AVDTP_BAD_HEADER_FORMAT:
2813                 return "Bad Header Format";
2814         case AVDTP_BAD_LENGTH:
2815                 return "Bad Packet Lenght";
2816         case AVDTP_BAD_ACP_SEID:
2817                 return "Bad Acceptor SEID";
2818         case AVDTP_SEP_IN_USE:
2819                 return "Stream End Point in Use";
2820         case AVDTP_SEP_NOT_IN_USE:
2821                 return "Stream End Point Not in Use";
2822         case AVDTP_BAD_SERV_CATEGORY:
2823                 return "Bad Service Category";
2824         case AVDTP_BAD_PAYLOAD_FORMAT:
2825                 return "Bad Payload format";
2826         case AVDTP_NOT_SUPPORTED_COMMAND:
2827                 return "Command Not Supported";
2828         case AVDTP_INVALID_CAPABILITIES:
2829                 return "Invalid Capabilities";
2830         case AVDTP_BAD_RECOVERY_TYPE:
2831                 return "Bad Recovery Type";
2832         case AVDTP_BAD_MEDIA_TRANSPORT_FORMAT:
2833                 return "Bad Media Transport Format";
2834         case AVDTP_BAD_RECOVERY_FORMAT:
2835                 return "Bad Recovery Format";
2836         case AVDTP_BAD_ROHC_FORMAT:
2837                 return "Bad Header Compression Format";
2838         case AVDTP_BAD_CP_FORMAT:
2839                 return "Bad Content Protetion Format";
2840         case AVDTP_BAD_MULTIPLEXING_FORMAT:
2841                 return "Bad Multiplexing Format";
2842         case AVDTP_UNSUPPORTED_CONFIGURATION:
2843                 return "Configuration not supported";
2844         case AVDTP_BAD_STATE:
2845                 return "Bad State";
2846         default:
2847                 return "Unknow error";
2848         }
2849 }
2850
2851 avdtp_state_t avdtp_sep_get_state(struct avdtp_local_sep *sep)
2852 {
2853         return sep->state;
2854 }
2855
2856 void avdtp_get_peers(struct avdtp *session, bdaddr_t *src, bdaddr_t *dst)
2857 {
2858         if (src)
2859                 bacpy(src, &session->src);
2860         if (dst)
2861                 bacpy(dst, &session->dst);
2862 }
2863
2864 int avdtp_init(GKeyFile *config)
2865 {
2866         GError *err = NULL;
2867         gboolean tmp, master = TRUE;
2868
2869         if (avdtp_server)
2870                 return 0;
2871
2872         if (config) {
2873                 tmp = g_key_file_get_boolean(config, "General",
2874                                                         "Master", &err);
2875                 if (err) {
2876                         debug("audio.conf: %s", err->message);
2877                         g_error_free(err);
2878                 } else
2879                         master = tmp;
2880         }
2881
2882         avdtp_server = avdtp_server_socket(master);
2883         if (!avdtp_server)
2884                 return -1;
2885
2886         return 0;
2887 }
2888
2889 void avdtp_exit(void)
2890 {
2891         if (!avdtp_server)
2892                 return;
2893
2894         g_io_channel_close(avdtp_server);
2895         g_io_channel_unref(avdtp_server);
2896         avdtp_server = NULL;
2897 }
2898
2899 gboolean avdtp_has_stream(struct avdtp *session, struct avdtp_stream *stream)
2900 {
2901         return g_slist_find(session->streams, stream) ? TRUE : FALSE;
2902 }