audio/avdtp.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <stdint.h>
  32 #include <errno.h>
  33 #include <unistd.h>
  34 #include <assert.h>
  35 #include <signal.h>
  36 #include <netinet/in.h>
  37
  38 #include <bluetooth/bluetooth.h>
  39 #include <bluetooth/sdp.h>
  40 #include <bluetooth/sdp_lib.h>
  41
  42 #include <glib.h>
  43 #include <dbus/dbus.h>
  44
  45 #include "log.h"
  46
  47 #include "../src/adapter.h"
  48 #include "../src/manager.h"
  49 #include "../src/device.h"
  50
  51 #include "device.h"
  52 #include "manager.h"
  53 #include "control.h"
  54 #include "avdtp.h"
  55 #include "glib-compat.h"
  56 #include "btio.h"
  57 #include "sink.h"
  58 #include "source.h"
  59
  60 #define AVDTP_PSM 25
  61
  62 #define MAX_SEID 0x3E
  63
  64 #ifndef MAX
  65 # define MAX(x, y) ((x) > (y) ? (x) : (y))
  66 #endif
  67
  68 #define AVDTP_DISCOVER                          0x01
  69 #define AVDTP_GET_CAPABILITIES                  0x02
  70 #define AVDTP_SET_CONFIGURATION                 0x03
  71 #define AVDTP_GET_CONFIGURATION                 0x04
  72 #define AVDTP_RECONFIGURE                       0x05
  73 #define AVDTP_OPEN                              0x06
  74 #define AVDTP_START                             0x07
  75 #define AVDTP_CLOSE                             0x08
  76 #define AVDTP_SUSPEND                           0x09
  77 #define AVDTP_ABORT                             0x0A
  78 #define AVDTP_SECURITY_CONTROL                  0x0B
  79 #define AVDTP_GET_ALL_CAPABILITIES              0x0C
  80 #define AVDTP_DELAY_REPORT                      0x0D
  81
  82 #define AVDTP_PKT_TYPE_SINGLE                   0x00
  83 #define AVDTP_PKT_TYPE_START                    0x01
  84 #define AVDTP_PKT_TYPE_CONTINUE                 0x02
  85 #define AVDTP_PKT_TYPE_END                      0x03
  86
  87 #define AVDTP_MSG_TYPE_COMMAND                  0x00
  88 #define AVDTP_MSG_TYPE_GEN_REJECT               0x01
  89 #define AVDTP_MSG_TYPE_ACCEPT                   0x02
  90 #define AVDTP_MSG_TYPE_REJECT                   0x03
  91
  92 #ifdef __TIZEN_PATCH__
  93 #define REQ_TIMEOUT 10
  94 #else
  95 #define REQ_TIMEOUT 6
  96 #endif
  97
  98 #define ABORT_TIMEOUT 2
  99 #define DISCONNECT_TIMEOUT 1
 100 #define STREAM_TIMEOUT 20
 101
 102 #if __BYTE_ORDER == __LITTLE_ENDIAN
 103
 104 struct avdtp_common_header {
 105         uint8_t message_type:2;
 106         uint8_t packet_type:2;
 107         uint8_t transaction:4;
 108 } __attribute__ ((packed));
 109
 110 struct avdtp_single_header {
 111         uint8_t message_type:2;
 112         uint8_t packet_type:2;
 113         uint8_t transaction:4;
 114         uint8_t signal_id:6;
 115         uint8_t rfa0:2;
 116 } __attribute__ ((packed));
 117
 118 struct avdtp_start_header {
 119         uint8_t message_type:2;
 120         uint8_t packet_type:2;
 121         uint8_t transaction:4;
 122         uint8_t no_of_packets;
 123         uint8_t signal_id:6;
 124         uint8_t rfa0:2;
 125 } __attribute__ ((packed));
 126
 127 struct avdtp_continue_header {
 128         uint8_t message_type:2;
 129         uint8_t packet_type:2;
 130         uint8_t transaction:4;
 131 } __attribute__ ((packed));
 132
 133 struct seid_info {
 134         uint8_t rfa0:1;
 135         uint8_t inuse:1;
 136         uint8_t seid:6;
 137         uint8_t rfa2:3;
 138         uint8_t type:1;
 139         uint8_t media_type:4;
 140 } __attribute__ ((packed));
 141
 142 struct seid {
 143         uint8_t rfa0:2;
 144         uint8_t seid:6;
 145 } __attribute__ ((packed));
 146
 147 #elif __BYTE_ORDER == __BIG_ENDIAN
 148
 149 struct avdtp_common_header {
 150         uint8_t transaction:4;
 151         uint8_t packet_type:2;
 152         uint8_t message_type:2;
 153 } __attribute__ ((packed));
 154
 155 struct avdtp_single_header {
 156         uint8_t transaction:4;
 157         uint8_t packet_type:2;
 158         uint8_t message_type:2;
 159         uint8_t rfa0:2;
 160         uint8_t signal_id:6;
 161 } __attribute__ ((packed));
 162
 163 struct avdtp_start_header {
 164         uint8_t transaction:4;
 165         uint8_t packet_type:2;
 166         uint8_t message_type:2;
 167         uint8_t no_of_packets;
 168         uint8_t rfa0:2;
 169         uint8_t signal_id:6;
 170 } __attribute__ ((packed));
 171
 172 struct avdtp_continue_header {
 173         uint8_t transaction:4;
 174         uint8_t packet_type:2;
 175         uint8_t message_type:2;
 176 } __attribute__ ((packed));
 177
 178 struct seid_info {
 179         uint8_t seid:6;
 180         uint8_t inuse:1;
 181         uint8_t rfa0:1;
 182         uint8_t media_type:4;
 183         uint8_t type:1;
 184         uint8_t rfa2:3;
 185 } __attribute__ ((packed));
 186
 187 struct seid {
 188         uint8_t seid:6;
 189         uint8_t rfa0:2;
 190 } __attribute__ ((packed));
 191
 192 #else
 193 #error "Unknown byte order"
 194 #endif
 195
 196 /* packets */
 197
 198 struct discover_resp {
 199         struct seid_info seps[0];
 200 } __attribute__ ((packed));
 201
 202 struct getcap_resp {
 203         uint8_t caps[0];
 204 } __attribute__ ((packed));
 205
 206 struct start_req {
 207         struct seid first_seid;
 208         struct seid other_seids[0];
 209 } __attribute__ ((packed));
 210
 211 struct suspend_req {
 212         struct seid first_seid;
 213         struct seid other_seids[0];
 214 } __attribute__ ((packed));
 215
 216 struct seid_rej {
 217         uint8_t error;
 218 } __attribute__ ((packed));
 219
 220 struct conf_rej {
 221         uint8_t category;
 222         uint8_t error;
 223 } __attribute__ ((packed));
 224
 225 #if __BYTE_ORDER == __LITTLE_ENDIAN
 226
 227 struct seid_req {
 228         uint8_t rfa0:2;
 229         uint8_t acp_seid:6;
 230 } __attribute__ ((packed));
 231
 232 struct setconf_req {
 233         uint8_t rfa0:2;
 234         uint8_t acp_seid:6;
 235         uint8_t rfa1:2;
 236         uint8_t int_seid:6;
 237
 238         uint8_t caps[0];
 239 } __attribute__ ((packed));
 240
 241 struct stream_rej {
 242         uint8_t rfa0:2;
 243         uint8_t acp_seid:6;
 244         uint8_t error;
 245 } __attribute__ ((packed));
 246
 247 struct reconf_req {
 248         uint8_t rfa0:2;
 249         uint8_t acp_seid:6;
 250
 251         uint8_t serv_cap;
 252         uint8_t serv_cap_len;
 253
 254         uint8_t caps[0];
 255 } __attribute__ ((packed));
 256
 257 struct delay_req {
 258         uint8_t rfa0:2;
 259         uint8_t acp_seid:6;
 260         uint16_t delay;
 261 } __attribute__ ((packed));
 262
 263 #elif __BYTE_ORDER == __BIG_ENDIAN
 264
 265 struct seid_req {
 266         uint8_t acp_seid:6;
 267         uint8_t rfa0:2;
 268 } __attribute__ ((packed));
 269
 270 struct setconf_req {
 271         uint8_t acp_seid:6;
 272         uint8_t rfa0:2;
 273         uint8_t int_seid:6;
 274         uint8_t rfa1:2;
 275
 276         uint8_t caps[0];
 277 } __attribute__ ((packed));
 278
 279 struct stream_rej {
 280         uint8_t acp_seid:6;
 281         uint8_t rfa0:2;
 282         uint8_t error;
 283 } __attribute__ ((packed));
 284
 285 struct reconf_req {
 286         uint8_t acp_seid:6;
 287         uint8_t rfa0:2;
 288
 289         uint8_t serv_cap;
 290         uint8_t serv_cap_len;
 291
 292         uint8_t caps[0];
 293 } __attribute__ ((packed));
 294
 295 struct delay_req {
 296         uint8_t acp_seid:6;
 297         uint8_t rfa0:2;
 298         uint16_t delay;
 299 } __attribute__ ((packed));
 300
 301 #else
 302 #error "Unknown byte order"
 303 #endif
 304
 305 struct in_buf {
 306         gboolean active;
 307         int no_of_packets;
 308         uint8_t transaction;
 309         uint8_t message_type;
 310         uint8_t signal_id;
 311         uint8_t buf[1024];
 312         uint8_t data_size;
 313 };
 314
 315 struct pending_req {
 316         uint8_t transaction;
 317         uint8_t signal_id;
 318         void *data;
 319         size_t data_size;
 320         struct avdtp_stream *stream; /* Set if the request targeted a stream */
 321         guint timeout;
 322 };
 323
 324 struct avdtp_remote_sep {
 325         uint8_t seid;
 326         uint8_t type;
 327         uint8_t media_type;
 328         struct avdtp_service_capability *codec;
 329         gboolean delay_reporting;
 330         GSList *caps; /* of type struct avdtp_service_capability */
 331         struct avdtp_stream *stream;
 332 };
 333
 334 struct avdtp_server {
 335         bdaddr_t src;
 336         uint16_t version;
 337         GIOChannel *io;
 338         GSList *seps;
 339         GSList *sessions;
 340 };
 341
 342 struct avdtp_local_sep {
 343         avdtp_state_t state;
 344         struct avdtp_stream *stream;
 345         struct seid_info info;
 346         uint8_t codec;
 347         gboolean delay_reporting;
 348         GSList *caps;
 349         struct avdtp_sep_ind *ind;
 350         struct avdtp_sep_cfm *cfm;
 351         void *user_data;
 352         struct avdtp_server *server;
 353 };
 354
 355 struct stream_callback {
 356         avdtp_stream_state_cb cb;
 357         void *user_data;
 358         unsigned int id;
 359 };
 360
 361 struct avdtp_state_callback {
 362         avdtp_session_state_cb cb;
 363         void *user_data;
 364         unsigned int id;
 365 };
 366
 367 struct avdtp_stream {
 368         GIOChannel *io;
 369         uint16_t imtu;
 370         uint16_t omtu;
 371         struct avdtp *session;
 372         struct avdtp_local_sep *lsep;
 373         uint8_t rseid;
 374         GSList *caps;
 375         GSList *callbacks;
 376         struct avdtp_service_capability *codec;
 377         guint io_id;            /* Transport GSource ID */
 378         guint timer;            /* Waiting for other side to close or open
 379                                  * the transport channel */
 380         gboolean open_acp;      /* If we are in ACT role for Open */
 381         gboolean close_int;     /* If we are in INT role for Close */
 382         gboolean abort_int;     /* If we are in INT role for Abort */
 383         guint idle_timer;
 384         gboolean delay_reporting;
 385         uint16_t delay;         /* AVDTP 1.3 Delay Reporting feature */
 386         gboolean starting;      /* only valid while sep state == OPEN */
 387 };
 388
 389 /* Structure describing an AVDTP connection between two devices */
 390
 391 struct avdtp {
 392         int ref;
 393         int free_lock;
 394
 395         uint16_t version;
 396
 397         struct avdtp_server *server;
 398         bdaddr_t dst;
 399
 400         avdtp_session_state_t state;
 401
 402         /* True if the session should be automatically disconnected */
 403         gboolean auto_dc;
 404
 405         /* True if the entire device is being disconnected */
 406         gboolean device_disconnect;
 407
 408         GIOChannel *io;
 409         guint io_id;
 410
 411         GSList *seps; /* Elements of type struct avdtp_remote_sep * */
 412
 413         GSList *streams; /* Elements of type struct avdtp_stream * */
 414
 415         GSList *req_queue; /* Elements of type struct pending_req * */
 416         GSList *prio_queue; /* Same as req_queue but is processed before it */
 417
 418         struct avdtp_stream *pending_open;
 419
 420         uint16_t imtu;
 421         uint16_t omtu;
 422
 423         struct in_buf in;
 424
 425         char *buf;
 426
 427         avdtp_discover_cb_t discov_cb;
 428         void *user_data;
 429
 430         struct pending_req *req;
 431
 432         guint dc_timer;
 433
 434         /* Attempt stream setup instead of disconnecting */
 435         gboolean stream_setup;
 436
 437         DBusPendingCall *pending_auth;
 438 };
 439
 440 static GSList *servers = NULL;
 441
 442 static GSList *avdtp_callbacks = NULL;
 443
 444 static gboolean auto_connect = TRUE;
 445
 446 static int send_request(struct avdtp *session, gboolean priority,
 447                         struct avdtp_stream *stream, uint8_t signal_id,
 448                         void *buffer, size_t size);
 449 static gboolean avdtp_parse_resp(struct avdtp *session,
 450                                         struct avdtp_stream *stream,
 451                                         uint8_t transaction, uint8_t signal_id,
 452                                         void *buf, int size);
 453 static gboolean avdtp_parse_rej(struct avdtp *session,
 454                                         struct avdtp_stream *stream,
 455                                         uint8_t transaction, uint8_t signal_id,
 456                                         void *buf, int size);
 457 static int process_queue(struct avdtp *session);
 458 static void connection_lost(struct avdtp *session, int err);
 459 static void avdtp_sep_set_state(struct avdtp *session,
 460                                 struct avdtp_local_sep *sep,
 461                                 avdtp_state_t state);
 462 static void auth_cb(DBusError *derr, void *user_data);
 463
 464 static struct avdtp_server *find_server(GSList *list, const bdaddr_t *src)
 465 {
 466         for (; list; list = list->next) {
 467                 struct avdtp_server *server = list->data;
 468
 469                 if (bacmp(&server->src, src) == 0)
 470                         return server;
 471         }
 472
 473         return NULL;
 474 }
 475
 476 static const char *avdtp_statestr(avdtp_state_t state)
 477 {
 478         switch (state) {
 479         case AVDTP_STATE_IDLE:
 480                 return "IDLE";
 481         case AVDTP_STATE_CONFIGURED:
 482                 return "CONFIGURED";
 483         case AVDTP_STATE_OPEN:
 484                 return "OPEN";
 485         case AVDTP_STATE_STREAMING:
 486                 return "STREAMING";
 487         case AVDTP_STATE_CLOSING:
 488                 return "CLOSING";
 489         case AVDTP_STATE_ABORTING:
 490                 return "ABORTING";
 491         default:
 492                 return "<unknown state>";
 493         }
 494 }
 495
 496 static gboolean try_send(int sk, void *data, size_t len)
 497 {
 498         int err;
 499
 500         do {
 501                 err = send(sk, data, len, 0);
 502         } while (err < 0 && errno == EINTR);
 503
 504         if (err < 0) {
 505                 error("send: %s (%d)", strerror(errno), errno);
 506                 return FALSE;
 507         } else if ((size_t) err != len) {
 508                 error("try_send: complete buffer not sent (%d/%zu bytes)",
 509                                                                 err, len);
 510                 return FALSE;
 511         }
 512
 513         return TRUE;
 514 }
 515
 516 static gboolean avdtp_send(struct avdtp *session, uint8_t transaction,
 517                                 uint8_t message_type, uint8_t signal_id,
 518                                 void *data, size_t len)
 519 {
 520         unsigned int cont_fragments, sent;
 521         struct avdtp_start_header start;
 522         struct avdtp_continue_header cont;
 523         int sock;
 524
 525         if (session->io == NULL) {
 526                 error("avdtp_send: session is closed");
 527                 return FALSE;
 528         }
 529
 530         sock = g_io_channel_unix_get_fd(session->io);
 531
 532         /* Single packet - no fragmentation */
 533         if (sizeof(struct avdtp_single_header) + len <= session->omtu) {
 534                 struct avdtp_single_header single;
 535
 536                 memset(&single, 0, sizeof(single));
 537
 538                 single.transaction = transaction;
 539                 single.packet_type = AVDTP_PKT_TYPE_SINGLE;
 540                 single.message_type = message_type;
 541                 single.signal_id = signal_id;
 542
 543                 memcpy(session->buf, &single, sizeof(single));
 544                 memcpy(session->buf + sizeof(single), data, len);
 545
 546                 return try_send(sock, session->buf, sizeof(single) + len);
 547         }
 548
 549         /* Check if there is enough space to start packet */
 550         if (session->omtu < sizeof(start)) {
 551                 error("No enough space to fragment packet");
 552                 return FALSE;
 553         }
 554
 555         /* Count the number of needed fragments */
 556         cont_fragments = (len - (session->omtu - sizeof(start))) /
 557                                         (session->omtu - sizeof(cont)) + 1;
 558
 559         DBG("%zu bytes split into %d fragments", len, cont_fragments + 1);
 560
 561         /* Send the start packet */
 562         memset(&start, 0, sizeof(start));
 563         start.transaction = transaction;
 564         start.packet_type = AVDTP_PKT_TYPE_START;
 565         start.message_type = message_type;
 566         start.no_of_packets = cont_fragments + 1;
 567         start.signal_id = signal_id;
 568
 569         memcpy(session->buf, &start, sizeof(start));
 570         memcpy(session->buf + sizeof(start), data,
 571                                         session->omtu - sizeof(start));
 572
 573         if (!try_send(sock, session->buf, session->omtu))
 574                 return FALSE;
 575
 576         DBG("first packet with %zu bytes sent", session->omtu - sizeof(start));
 577
 578         sent = session->omtu - sizeof(start);
 579
 580         /* Send the continue fragments and the end packet */
 581         while (sent < len) {
 582                 int left, to_copy;
 583
 584                 left = len - sent;
 585                 if (left + sizeof(cont) > session->omtu) {
 586                         cont.packet_type = AVDTP_PKT_TYPE_CONTINUE;
 587                         to_copy = session->omtu - sizeof(cont);
 588                         DBG("sending continue with %d bytes", to_copy);
 589                 } else {
 590                         cont.packet_type = AVDTP_PKT_TYPE_END;
 591                         to_copy = left;
 592                         DBG("sending end with %d bytes", to_copy);
 593                 }
 594
 595                 cont.transaction = transaction;
 596                 cont.message_type = message_type;
 597
 598                 memcpy(session->buf, &cont, sizeof(cont));
 599                 memcpy(session->buf + sizeof(cont), data + sent, to_copy);
 600
 601                 if (!try_send(sock, session->buf, to_copy + sizeof(cont)))
 602                         return FALSE;
 603
 604                 sent += to_copy;
 605         }
 606
 607         return TRUE;
 608 }
 609
 610 static void pending_req_free(struct pending_req *req)
 611 {
 612         if (req->timeout)
 613                 g_source_remove(req->timeout);
 614         g_free(req->data);
 615         g_free(req);
 616 }
 617
 618 static void close_stream(struct avdtp_stream *stream)
 619 {
 620         int sock;
 621
 622         if (stream->io == NULL)
 623                 return;
 624
 625         sock = g_io_channel_unix_get_fd(stream->io);
 626
 627         shutdown(sock, SHUT_RDWR);
 628
 629         g_io_channel_shutdown(stream->io, FALSE, NULL);
 630
 631         g_io_channel_unref(stream->io);
 632         stream->io = NULL;
 633 }
 634
 635 static gboolean stream_close_timeout(gpointer user_data)
 636 {
 637         struct avdtp_stream *stream = user_data;
 638
 639         DBG("Timed out waiting for peer to close the transport channel");
 640
 641         stream->timer = 0;
 642
 643         close_stream(stream);
 644
 645         return FALSE;
 646 }
 647
 648 static gboolean stream_open_timeout(gpointer user_data)
 649 {
 650         struct avdtp_stream *stream = user_data;
 651
 652         DBG("Timed out waiting for peer to open the transport channel");
 653
 654         stream->timer = 0;
 655
 656         stream->session->pending_open = NULL;
 657
 658         avdtp_abort(stream->session, stream);
 659
 660         return FALSE;
 661 }
 662
 663 static gboolean disconnect_timeout(gpointer user_data)
 664 {
 665         struct avdtp *session = user_data;
 666         struct audio_device *dev;
 667         gboolean stream_setup;
 668
 669         session->dc_timer = 0;
 670         stream_setup = session->stream_setup;
 671         session->stream_setup = FALSE;
 672
 673         dev = manager_get_device(&session->server->src, &session->dst, FALSE);
 674
 675         if (dev && dev->sink && stream_setup)
 676                 sink_setup_stream(dev->sink, session);
 677         else if (dev && dev->source && stream_setup)
 678                 source_setup_stream(dev->source, session);
 679         else
 680                 connection_lost(session, ETIMEDOUT);
 681
 682         return FALSE;
 683 }
 684
 685 static void remove_disconnect_timer(struct avdtp *session)
 686 {
 687         g_source_remove(session->dc_timer);
 688         session->dc_timer = 0;
 689         session->stream_setup = FALSE;
 690 }
 691
 692 static void set_disconnect_timer(struct avdtp *session)
 693 {
 694         if (session->dc_timer)
 695                 remove_disconnect_timer(session);
 696
 697         if (session->device_disconnect) {
 698                 session->dc_timer = g_idle_add(disconnect_timeout, session);
 699                 return;
 700         }
 701
 702         session->dc_timer = g_timeout_add_seconds(DISCONNECT_TIMEOUT,
 703                                                 disconnect_timeout,
 704                                                 session);
 705 }
 706
 707 void avdtp_error_init(struct avdtp_error *err, uint8_t category, int id)
 708 {
 709         err->category = category;
 710
 711         if (category == AVDTP_ERRNO)
 712                 err->err.posix_errno = id;
 713         else
 714                 err->err.error_code = id;
 715 }
 716
 717 uint8_t avdtp_error_category(struct avdtp_error *err)
 718 {
 719         return err->category;
 720 }
 721
 722 int avdtp_error_error_code(struct avdtp_error *err)
 723 {
 724         assert(err->category != AVDTP_ERRNO);
 725         return err->err.error_code;
 726 }
 727
 728 int avdtp_error_posix_errno(struct avdtp_error *err)
 729 {
 730         assert(err->category == AVDTP_ERRNO);
 731         return err->err.posix_errno;
 732 }
 733
 734 static struct avdtp_stream *find_stream_by_rseid(struct avdtp *session,
 735                                                         uint8_t rseid)
 736 {
 737         GSList *l;
 738
 739         for (l = session->streams; l != NULL; l = g_slist_next(l)) {
 740                 struct avdtp_stream *stream = l->data;
 741
 742                 if (stream->rseid == rseid)
 743                         return stream;
 744         }
 745
 746         return NULL;
 747 }
 748
 749 static struct avdtp_remote_sep *find_remote_sep(GSList *seps, uint8_t seid)
 750 {
 751         GSList *l;
 752
 753         for (l = seps; l != NULL; l = g_slist_next(l)) {
 754                 struct avdtp_remote_sep *sep = l->data;
 755
 756                 if (sep->seid == seid)
 757                         return sep;
 758         }
 759
 760         return NULL;
 761 }
 762
 763 static void avdtp_set_state(struct avdtp *session,
 764                                         avdtp_session_state_t new_state)
 765 {
 766         GSList *l;
 767         struct audio_device *dev;
 768         bdaddr_t src, dst;
 769         avdtp_session_state_t old_state = session->state;
 770
 771         session->state = new_state;
 772
 773         avdtp_get_peers(session, &src, &dst);
 774         dev = manager_get_device(&src, &dst, FALSE);
 775         if (dev == NULL) {
 776                 error("avdtp_set_state(): no matching audio device");
 777                 return;
 778         }
 779
 780         for (l = avdtp_callbacks; l != NULL; l = l->next) {
 781                 struct avdtp_state_callback *cb = l->data;
 782                 cb->cb(dev, session, old_state, new_state, cb->user_data);
 783         }
 784 }
 785
 786 static void stream_free(struct avdtp_stream *stream)
 787 {
 788         struct avdtp_remote_sep *rsep;
 789
 790         stream->lsep->info.inuse = 0;
 791         stream->lsep->stream = NULL;
 792
 793         rsep = find_remote_sep(stream->session->seps, stream->rseid);
 794         if (rsep)
 795                 rsep->stream = NULL;
 796
 797         if (stream->timer)
 798                 g_source_remove(stream->timer);
 799
 800         if (stream->io)
 801                 close_stream(stream);
 802
 803         if (stream->io_id)
 804                 g_source_remove(stream->io_id);
 805
 806         g_slist_free_full(stream->callbacks, g_free);
 807         g_slist_free_full(stream->caps, g_free);
 808
 809         g_free(stream);
 810 }
 811
 812 static gboolean stream_timeout(gpointer user_data)
 813 {
 814         struct avdtp_stream *stream = user_data;
 815         struct avdtp *session = stream->session;
 816
 817         if (avdtp_close(session, stream, FALSE) < 0)
 818                 error("stream_timeout: closing AVDTP stream failed");
 819
 820         stream->idle_timer = 0;
 821
 822         return FALSE;
 823 }
 824
 825 static gboolean transport_cb(GIOChannel *chan, GIOCondition cond,
 826                                 gpointer data)
 827 {
 828         struct avdtp_stream *stream = data;
 829         struct avdtp_local_sep *sep = stream->lsep;
 830
 831         if (stream->close_int && sep->cfm && sep->cfm->close)
 832                 sep->cfm->close(stream->session, sep, stream, NULL,
 833                                 sep->user_data);
 834
 835         if (!(cond & G_IO_NVAL))
 836                 close_stream(stream);
 837
 838         stream->io_id = 0;
 839
 840         if (!stream->abort_int)
 841                 avdtp_sep_set_state(stream->session, sep, AVDTP_STATE_IDLE);
 842
 843         return FALSE;
 844 }
 845
 846 static int get_send_buffer_size(int sk)
 847 {
 848         int size;
 849         socklen_t optlen = sizeof(size);
 850
 851         if (getsockopt(sk, SOL_SOCKET, SO_SNDBUF, &size, &optlen) < 0) {
 852                 int err = -errno;
 853                 error("getsockopt(SO_SNDBUF) failed: %s (%d)", strerror(-err),
 854                                                                         -err);
 855                 return err;
 856         }
 857
 858         /*
 859          * Doubled value is returned by getsockopt since kernel uses that
 860          * space for its own purposes (see man 7 socket, bookkeeping overhead
 861          * for SO_SNDBUF).
 862          */
 863         return size / 2;
 864 }
 865
 866 static int set_send_buffer_size(int sk, int size)
 867 {
 868         socklen_t optlen = sizeof(size);
 869
 870         if (setsockopt(sk, SOL_SOCKET, SO_SNDBUF, &size, optlen) < 0) {
 871                 int err = -errno;
 872                 error("setsockopt(SO_SNDBUF) failed: %s (%d)", strerror(-err),
 873                                                                         -err);
 874                 return err;
 875         }
 876
 877         return 0;
 878 }
 879
 880 static void handle_transport_connect(struct avdtp *session, GIOChannel *io,
 881                                         uint16_t imtu, uint16_t omtu)
 882 {
 883         struct avdtp_stream *stream = session->pending_open;
 884         struct avdtp_local_sep *sep = stream->lsep;
 885         int sk, buf_size, min_buf_size;
 886         GError *err = NULL;
 887
 888         session->pending_open = NULL;
 889
 890         if (stream->timer) {
 891                 g_source_remove(stream->timer);
 892                 stream->timer = 0;
 893         }
 894
 895         if (io == NULL) {
 896                 if (!stream->open_acp && sep->cfm && sep->cfm->open) {
 897                         struct avdtp_error err;
 898                         avdtp_error_init(&err, AVDTP_ERRNO, EIO);
 899                         sep->cfm->open(session, sep, NULL, &err,
 900                                         sep->user_data);
 901                 }
 902                 return;
 903         }
 904
 905         if (stream->io == NULL)
 906                 stream->io = g_io_channel_ref(io);
 907
 908         stream->omtu = omtu;
 909         stream->imtu = imtu;
 910
 911         /* Apply special settings only if local SEP is of type SRC */
 912         if (sep->info.type != AVDTP_SEP_TYPE_SOURCE)
 913                 goto proceed;
 914
 915         bt_io_set(stream->io, BT_IO_L2CAP, &err,
 916                                         BT_IO_OPT_FLUSHABLE, TRUE,
 917                                         BT_IO_OPT_INVALID);
 918         if (err != NULL) {
 919                 error("Enabling flushable packets failed: %s", err->message);
 920                 g_error_free(err);
 921         } else
 922                 DBG("Flushable packets enabled");
 923
 924         sk = g_io_channel_unix_get_fd(stream->io);
 925         buf_size = get_send_buffer_size(sk);
 926         if (buf_size < 0)
 927                 goto proceed;
 928
 929         DBG("sk %d, omtu %d, send buffer size %d", sk, omtu, buf_size);
 930         min_buf_size = omtu * 2;
 931         if (buf_size < min_buf_size) {
 932                 DBG("send buffer size to be increassed to %d",
 933                                 min_buf_size);
 934                 set_send_buffer_size(sk, min_buf_size);
 935         }
 936
 937 proceed:
 938         if (!stream->open_acp && sep->cfm && sep->cfm->open)
 939                 sep->cfm->open(session, sep, stream, NULL, sep->user_data);
 940
 941         avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
 942
 943         stream->io_id = g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
 944                                         (GIOFunc) transport_cb, stream);
 945 }
 946
 947 static int pending_req_cmp(gconstpointer a, gconstpointer b)
 948 {
 949         const struct pending_req *req = a;
 950         const struct avdtp_stream *stream = b;
 951
 952         if (req->stream == stream)
 953                 return 0;
 954
 955         return -1;
 956 }
 957
 958 static void cleanup_queue(struct avdtp *session, struct avdtp_stream *stream)
 959 {
 960         GSList *l;
 961         struct pending_req *req;
 962
 963         while ((l = g_slist_find_custom(session->prio_queue, stream,
 964                                                         pending_req_cmp))) {
 965                 req = l->data;
 966                 pending_req_free(req);
 967                 session->prio_queue = g_slist_remove(session->prio_queue, req);
 968         }
 969
 970         while ((l = g_slist_find_custom(session->req_queue, stream,
 971                                                         pending_req_cmp))) {
 972                 req = l->data;
 973                 pending_req_free(req);
 974                 session->req_queue = g_slist_remove(session->req_queue, req);
 975         }
 976 }
 977
 978 static void handle_unanswered_req(struct avdtp *session,
 979                                                 struct avdtp_stream *stream)
 980 {
 981         struct pending_req *req;
 982         struct avdtp_local_sep *lsep;
 983         struct avdtp_error err;
 984
 985         if (session->req->signal_id == AVDTP_ABORT) {
 986                 /* Avoid freeing the Abort request here */
 987                 DBG("handle_unanswered_req: Abort req, returning");
 988                 session->req->stream = NULL;
 989                 return;
 990         }
 991
 992         req = session->req;
 993         session->req = NULL;
 994
 995         avdtp_error_init(&err, AVDTP_ERRNO, EIO);
 996
 997         lsep = stream->lsep;
 998
 999         switch (req->signal_id) {
1000         case AVDTP_RECONFIGURE:
1001                 error("No reply to Reconfigure request");
1002                 if (lsep && lsep->cfm && lsep->cfm->reconfigure)
1003                         lsep->cfm->reconfigure(session, lsep, stream, &err,
1004                                                 lsep->user_data);
1005                 break;
1006         case AVDTP_OPEN:
1007                 error("No reply to Open request");
1008                 if (lsep && lsep->cfm && lsep->cfm->open)
1009                         lsep->cfm->open(session, lsep, stream, &err,
1010                                         lsep->user_data);
1011                 break;
1012         case AVDTP_START:
1013                 error("No reply to Start request");
1014                 if (lsep && lsep->cfm && lsep->cfm->start)
1015                         lsep->cfm->start(session, lsep, stream, &err,
1016                                                 lsep->user_data);
1017                 break;
1018         case AVDTP_SUSPEND:
1019                 error("No reply to Suspend request");
1020                 if (lsep && lsep->cfm && lsep->cfm->suspend)
1021                         lsep->cfm->suspend(session, lsep, stream, &err,
1022                                                 lsep->user_data);
1023                 break;
1024         case AVDTP_CLOSE:
1025                 error("No reply to Close request");
1026                 if (lsep && lsep->cfm && lsep->cfm->close)
1027                         lsep->cfm->close(session, lsep, stream, &err,
1028                                                 lsep->user_data);
1029                 break;
1030         case AVDTP_SET_CONFIGURATION:
1031                 error("No reply to SetConfiguration request");
1032                 if (lsep && lsep->cfm && lsep->cfm->set_configuration)
1033                         lsep->cfm->set_configuration(session, lsep, stream,
1034                                                         &err, lsep->user_data);
1035         }
1036
1037         pending_req_free(req);
1038 }
1039
1040 static void avdtp_sep_set_state(struct avdtp *session,
1041                                 struct avdtp_local_sep *sep,
1042                                 avdtp_state_t state)
1043 {
1044         struct avdtp_stream *stream = sep->stream;
1045         avdtp_state_t old_state;
1046         struct avdtp_error err, *err_ptr = NULL;
1047         GSList *l;
1048
1049         if (!stream) {
1050                 error("Error changing sep state: stream not available");
1051                 return;
1052         }
1053
1054         if (sep->state == state) {
1055                 avdtp_error_init(&err, AVDTP_ERRNO, EIO);
1056                 DBG("stream state change failed: %s", avdtp_strerror(&err));
1057                 err_ptr = &err;
1058         } else {
1059                 err_ptr = NULL;
1060                 DBG("stream state changed: %s -> %s",
1061                                 avdtp_statestr(sep->state),
1062                                 avdtp_statestr(state));
1063         }
1064
1065         old_state = sep->state;
1066         sep->state = state;
1067
1068         switch (state) {
1069         case AVDTP_STATE_CONFIGURED:
1070                 if (sep->info.type == AVDTP_SEP_TYPE_SINK)
1071                         avdtp_delay_report(session, stream, stream->delay);
1072                 break;
1073         case AVDTP_STATE_OPEN:
1074                 stream->starting = FALSE;
1075                 if (old_state > AVDTP_STATE_OPEN && session->auto_dc)
1076                         stream->idle_timer = g_timeout_add_seconds(STREAM_TIMEOUT,
1077                                                                 stream_timeout,
1078                                                                 stream);
1079                 break;
1080         case AVDTP_STATE_STREAMING:
1081         case AVDTP_STATE_CLOSING:
1082         case AVDTP_STATE_ABORTING:
1083                 if (stream->idle_timer) {
1084                         g_source_remove(stream->idle_timer);
1085                         stream->idle_timer = 0;
1086                 }
1087                 break;
1088         case AVDTP_STATE_IDLE:
1089                 if (stream->idle_timer) {
1090                         g_source_remove(stream->idle_timer);
1091                         stream->idle_timer = 0;
1092                 }
1093                 if (session->pending_open == stream)
1094                         handle_transport_connect(session, NULL, 0, 0);
1095                 if (session->req && session->req->stream == stream)
1096                         handle_unanswered_req(session, stream);
1097                 /* Remove pending commands for this stream from the queue */
1098                 cleanup_queue(session, stream);
1099                 break;
1100         default:
1101                 break;
1102         }
1103
1104         l = stream->callbacks;
1105         while (l != NULL) {
1106                 struct stream_callback *cb = l->data;
1107                 l = g_slist_next(l);
1108                 cb->cb(stream, old_state, state, err_ptr, cb->user_data);
1109         }
1110
1111         if (state == AVDTP_STATE_IDLE &&
1112                                 g_slist_find(session->streams, stream)) {
1113                 session->streams = g_slist_remove(session->streams, stream);
1114                 stream_free(stream);
1115         }
1116 }
1117
1118 static void finalize_discovery(struct avdtp *session, int err)
1119 {
1120         struct avdtp_error avdtp_err;
1121
1122         avdtp_error_init(&avdtp_err, AVDTP_ERRNO, err);
1123
1124         if (!session->discov_cb)
1125                 return;
1126
1127         session->discov_cb(session, session->seps,
1128                                 err ? &avdtp_err : NULL,
1129                                 session->user_data);
1130
1131         session->discov_cb = NULL;
1132         session->user_data = NULL;
1133 }
1134
1135 static void release_stream(struct avdtp_stream *stream, struct avdtp *session)
1136 {
1137         struct avdtp_local_sep *sep = stream->lsep;
1138
1139         if (sep->cfm && sep->cfm->abort &&
1140                                 (sep->state != AVDTP_STATE_ABORTING ||
1141                                                         stream->abort_int))
1142                 sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
1143
1144         avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
1145 }
1146
1147 static int avdtp_cancel_authorization(struct avdtp *session)
1148 {
1149         struct audio_device *dev;
1150
1151         if (session->state != AVDTP_SESSION_STATE_CONNECTING)
1152                 return 0;
1153
1154         dev = manager_get_device(&session->server->src, &session->dst, FALSE);
1155         if (dev == NULL)
1156                 return -ENODEV;
1157
1158         return audio_device_cancel_authorization(dev, auth_cb, session);
1159 }
1160
1161 static void connection_lost(struct avdtp *session, int err)
1162 {
1163         char address[18];
1164
1165         ba2str(&session->dst, address);
1166         DBG("Disconnected from %s", address);
1167
1168         if (err != EACCES)
1169                 avdtp_cancel_authorization(session);
1170
1171         session->free_lock = 1;
1172
1173         finalize_discovery(session, err);
1174
1175         g_slist_foreach(session->streams, (GFunc) release_stream, session);
1176         session->streams = NULL;
1177
1178         session->free_lock = 0;
1179
1180         if (session->io) {
1181                 g_io_channel_shutdown(session->io, FALSE, NULL);
1182                 g_io_channel_unref(session->io);
1183                 session->io = NULL;
1184         }
1185
1186         avdtp_set_state(session, AVDTP_SESSION_STATE_DISCONNECTED);
1187
1188         if (session->io_id) {
1189                 g_source_remove(session->io_id);
1190                 session->io_id = 0;
1191         }
1192
1193         if (session->dc_timer)
1194                 remove_disconnect_timer(session);
1195
1196         session->auto_dc = TRUE;
1197
1198         if (session->ref != 1)
1199                 error("connection_lost: ref count not 1 after all callbacks");
1200         else
1201                 avdtp_unref(session);
1202 }
1203
1204 void avdtp_unref(struct avdtp *session)
1205 {
1206         struct avdtp_server *server;
1207
1208         if (!session)
1209                 return;
1210
1211         session->ref--;
1212
1213         DBG("%p: ref=%d", session, session->ref);
1214
1215         if (session->ref == 1) {
1216                 if (session->state == AVDTP_SESSION_STATE_CONNECTING &&
1217                                                                 session->io) {
1218                         avdtp_cancel_authorization(session);
1219                         g_io_channel_shutdown(session->io, TRUE, NULL);
1220                         g_io_channel_unref(session->io);
1221                         session->io = NULL;
1222                         avdtp_set_state(session,
1223                                         AVDTP_SESSION_STATE_DISCONNECTED);
1224                 }
1225
1226                 if (session->io)
1227                         set_disconnect_timer(session);
1228                 else if (!session->free_lock) /* Drop the local ref if we
1229                                                  aren't connected */
1230                         session->ref--;
1231         }
1232
1233         if (session->ref > 0)
1234                 return;
1235
1236         server = session->server;
1237
1238         DBG("%p: freeing session and removing from list", session);
1239
1240         if (session->dc_timer)
1241                 remove_disconnect_timer(session);
1242
1243         server->sessions = g_slist_remove(server->sessions, session);
1244
1245         if (session->req)
1246                 pending_req_free(session->req);
1247
1248         g_slist_free_full(session->seps, g_free);
1249
1250         g_free(session->buf);
1251
1252         g_free(session);
1253 }
1254
1255 struct avdtp *avdtp_ref(struct avdtp *session)
1256 {
1257         session->ref++;
1258         DBG("%p: ref=%d", session, session->ref);
1259         if (session->dc_timer)
1260                 remove_disconnect_timer(session);
1261         return session;
1262 }
1263
1264 static struct avdtp_local_sep *find_local_sep_by_seid(struct avdtp_server *server,
1265                                                         uint8_t seid)
1266 {
1267         GSList *l;
1268
1269         for (l = server->seps; l != NULL; l = g_slist_next(l)) {
1270                 struct avdtp_local_sep *sep = l->data;
1271
1272                 if (sep->info.seid == seid)
1273                         return sep;
1274         }
1275
1276         return NULL;
1277 }
1278
1279 struct avdtp_remote_sep *avdtp_find_remote_sep(struct avdtp *session,
1280                                                 struct avdtp_local_sep *lsep)
1281 {
1282         GSList *l;
1283
1284         if (lsep->info.inuse)
1285                 return NULL;
1286
1287         for (l = session->seps; l != NULL; l = g_slist_next(l)) {
1288                 struct avdtp_remote_sep *sep = l->data;
1289                 struct avdtp_service_capability *cap;
1290                 struct avdtp_media_codec_capability *codec_data;
1291
1292                 /* Type must be different: source <-> sink */
1293                 if (sep->type == lsep->info.type)
1294                         continue;
1295
1296                 if (sep->media_type != lsep->info.media_type)
1297                         continue;
1298
1299                 if (!sep->codec)
1300                         continue;
1301
1302                 cap = sep->codec;
1303                 codec_data = (void *) cap->data;
1304
1305                 if (codec_data->media_codec_type != lsep->codec)
1306                         continue;
1307
1308                 if (sep->stream == NULL)
1309                         return sep;
1310         }
1311
1312         return NULL;
1313 }
1314
1315 static GSList *caps_to_list(uint8_t *data, int size,
1316                                 struct avdtp_service_capability **codec,
1317                                 gboolean *delay_reporting)
1318 {
1319         GSList *caps;
1320         int processed;
1321
1322         if (delay_reporting)
1323                 *delay_reporting = FALSE;
1324
1325         for (processed = 0, caps = NULL; processed + 2 <= size;) {
1326                 struct avdtp_service_capability *cap;
1327                 uint8_t length, category;
1328
1329                 category = data[0];
1330                 length = data[1];
1331
1332                 if (processed + 2 + length > size) {
1333                         error("Invalid capability data in getcap resp");
1334                         break;
1335                 }
1336
1337                 cap = g_malloc(sizeof(struct avdtp_service_capability) +
1338                                         length);
1339                 memcpy(cap, data, 2 + length);
1340
1341                 processed += 2 + length;
1342                 data += 2 + length;
1343
1344                 caps = g_slist_append(caps, cap);
1345
1346                 if (category == AVDTP_MEDIA_CODEC &&
1347                                 length >=
1348                                 sizeof(struct avdtp_media_codec_capability))
1349                         *codec = cap;
1350                 else if (category == AVDTP_DELAY_REPORTING && delay_reporting)
1351                         *delay_reporting = TRUE;
1352         }
1353
1354         return caps;
1355 }
1356
1357 static gboolean avdtp_unknown_cmd(struct avdtp *session, uint8_t transaction,
1358                                                         uint8_t signal_id)
1359 {
1360         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_GEN_REJECT,
1361                                                         signal_id, NULL, 0);
1362 }
1363
1364 static gboolean avdtp_discover_cmd(struct avdtp *session, uint8_t transaction,
1365                                                         void *buf, int size)
1366 {
1367         GSList *l;
1368         unsigned int rsp_size, sep_count, i;
1369         struct seid_info *seps;
1370         gboolean ret;
1371
1372         sep_count = g_slist_length(session->server->seps);
1373
1374         if (sep_count == 0) {
1375                 uint8_t err = AVDTP_NOT_SUPPORTED_COMMAND;
1376                 return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1377                                         AVDTP_DISCOVER, &err, sizeof(err));
1378         }
1379
1380         rsp_size = sep_count * sizeof(struct seid_info);
1381
1382         seps = g_new0(struct seid_info, sep_count);
1383
1384         for (l = session->server->seps, i = 0; l != NULL; l = l->next, i++) {
1385                 struct avdtp_local_sep *sep = l->data;
1386
1387                 memcpy(&seps[i], &sep->info, sizeof(struct seid_info));
1388         }
1389
1390         ret = avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1391                                 AVDTP_DISCOVER, seps, rsp_size);
1392         g_free(seps);
1393
1394         return ret;
1395 }
1396
1397 static gboolean avdtp_getcap_cmd(struct avdtp *session, uint8_t transaction,
1398                                         struct seid_req *req, unsigned int size,
1399                                         gboolean get_all)
1400 {
1401         GSList *l, *caps;
1402         struct avdtp_local_sep *sep = NULL;
1403         unsigned int rsp_size;
1404         uint8_t err, buf[1024], *ptr = buf;
1405         uint8_t cmd;
1406
1407         cmd = get_all ? AVDTP_GET_ALL_CAPABILITIES : AVDTP_GET_CAPABILITIES;
1408
1409         if (size < sizeof(struct seid_req)) {
1410                 err = AVDTP_BAD_LENGTH;
1411                 goto failed;
1412         }
1413
1414         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1415         if (!sep) {
1416                 err = AVDTP_BAD_ACP_SEID;
1417                 goto failed;
1418         }
1419
1420         if (get_all && session->server->version < 0x0103)
1421                 return avdtp_unknown_cmd(session, transaction, cmd);
1422
1423         if (!sep->ind->get_capability(session, sep, get_all, &caps,
1424                                                         &err, sep->user_data))
1425                 goto failed;
1426
1427         for (l = caps, rsp_size = 0; l != NULL; l = g_slist_next(l)) {
1428                 struct avdtp_service_capability *cap = l->data;
1429
1430                 if (rsp_size + cap->length + 2 > sizeof(buf))
1431                         break;
1432
1433                 memcpy(ptr, cap, cap->length + 2);
1434                 rsp_size += cap->length + 2;
1435                 ptr += cap->length + 2;
1436
1437                 g_free(cap);
1438         }
1439
1440         g_slist_free(caps);
1441
1442         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT, cmd,
1443                                                                 buf, rsp_size);
1444
1445 failed:
1446         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT, cmd,
1447                                                         &err, sizeof(err));
1448 }
1449
1450 static void setconf_cb(struct avdtp *session, struct avdtp_stream *stream,
1451                                                 struct avdtp_error *err)
1452 {
1453         struct conf_rej rej;
1454         struct avdtp_local_sep *sep;
1455
1456         if (err != NULL) {
1457                 rej.error = AVDTP_UNSUPPORTED_CONFIGURATION;
1458                 rej.category = err->err.error_code;
1459                 avdtp_send(session, session->in.transaction,
1460                                 AVDTP_MSG_TYPE_REJECT, AVDTP_SET_CONFIGURATION,
1461                                 &rej, sizeof(rej));
1462                 return;
1463         }
1464
1465         if (!avdtp_send(session, session->in.transaction, AVDTP_MSG_TYPE_ACCEPT,
1466                                         AVDTP_SET_CONFIGURATION, NULL, 0)) {
1467                 stream_free(stream);
1468                 return;
1469         }
1470
1471         sep = stream->lsep;
1472         sep->stream = stream;
1473         sep->info.inuse = 1;
1474         session->streams = g_slist_append(session->streams, stream);
1475
1476         avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1477 }
1478
1479 static gboolean avdtp_setconf_cmd(struct avdtp *session, uint8_t transaction,
1480                                 struct setconf_req *req, unsigned int size)
1481 {
1482         struct conf_rej rej;
1483         struct avdtp_local_sep *sep;
1484         struct avdtp_stream *stream;
1485         uint8_t err, category = 0x00;
1486         struct audio_device *dev;
1487         bdaddr_t src, dst;
1488         GSList *l;
1489
1490         if (size < sizeof(struct setconf_req)) {
1491                 error("Too short getcap request");
1492                 return FALSE;
1493         }
1494
1495         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1496         if (!sep) {
1497                 err = AVDTP_BAD_ACP_SEID;
1498                 goto failed;
1499         }
1500
1501         if (sep->stream) {
1502                 err = AVDTP_SEP_IN_USE;
1503                 goto failed;
1504         }
1505
1506         avdtp_get_peers(session, &src, &dst);
1507         dev = manager_get_device(&src, &dst, FALSE);
1508         if (!dev) {
1509                 error("Unable to get a audio device object");
1510                 err = AVDTP_BAD_STATE;
1511                 goto failed;
1512         }
1513
1514         switch (sep->info.type) {
1515         case AVDTP_SEP_TYPE_SOURCE:
1516                 if (!dev->sink) {
1517                         btd_device_add_uuid(dev->btd_dev, A2DP_SINK_UUID);
1518                         if (!dev->sink) {
1519                                 error("Unable to get a audio sink object");
1520                                 err = AVDTP_BAD_STATE;
1521                                 goto failed;
1522                         }
1523                 }
1524                 break;
1525         case AVDTP_SEP_TYPE_SINK:
1526                 if (!dev->source) {
1527                         btd_device_add_uuid(dev->btd_dev, A2DP_SOURCE_UUID);
1528                         if (!dev->sink) {
1529                                 error("Unable to get a audio source object");
1530                                 err = AVDTP_BAD_STATE;
1531                                 goto failed;
1532                         }
1533                 }
1534                 break;
1535         }
1536
1537         stream = g_new0(struct avdtp_stream, 1);
1538         stream->session = session;
1539         stream->lsep = sep;
1540         stream->rseid = req->int_seid;
1541         stream->caps = caps_to_list(req->caps,
1542                                         size - sizeof(struct setconf_req),
1543                                         &stream->codec,
1544                                         &stream->delay_reporting);
1545
1546         /* Verify that the Media Transport capability's length = 0. Reject otherwise */
1547         for (l = stream->caps; l != NULL; l = g_slist_next(l)) {
1548                 struct avdtp_service_capability *cap = l->data;
1549
1550                 if (cap->category == AVDTP_MEDIA_TRANSPORT && cap->length != 0) {
1551                         err = AVDTP_BAD_MEDIA_TRANSPORT_FORMAT;
1552                         goto failed_stream;
1553                 }
1554         }
1555
1556         if (stream->delay_reporting && session->version < 0x0103)
1557                 session->version = 0x0103;
1558
1559         if (sep->ind && sep->ind->set_configuration) {
1560                 if (!sep->ind->set_configuration(session, sep, stream,
1561                                                         stream->caps,
1562                                                         setconf_cb,
1563                                                         sep->user_data)) {
1564                         err = AVDTP_UNSUPPORTED_CONFIGURATION;
1565                         category = 0x00;
1566                         goto failed_stream;
1567                 }
1568         } else {
1569                 if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1570                                         AVDTP_SET_CONFIGURATION, NULL, 0)) {
1571                         stream_free(stream);
1572                         return FALSE;
1573                 }
1574
1575                 sep->stream = stream;
1576                 sep->info.inuse = 1;
1577                 session->streams = g_slist_append(session->streams, stream);
1578
1579                 avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
1580         }
1581
1582         return TRUE;
1583
1584 failed_stream:
1585         stream_free(stream);
1586 failed:
1587         rej.error = err;
1588         rej.category = category;
1589         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1590                                 AVDTP_SET_CONFIGURATION, &rej, sizeof(rej));
1591 }
1592
1593 static gboolean avdtp_getconf_cmd(struct avdtp *session, uint8_t transaction,
1594                                         struct seid_req *req, int size)
1595 {
1596         GSList *l;
1597         struct avdtp_local_sep *sep = NULL;
1598         int rsp_size;
1599         uint8_t err;
1600         uint8_t buf[1024];
1601         uint8_t *ptr = buf;
1602
1603         if (size < (int) sizeof(struct seid_req)) {
1604                 error("Too short getconf request");
1605                 return FALSE;
1606         }
1607
1608         memset(buf, 0, sizeof(buf));
1609
1610         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1611         if (!sep) {
1612                 err = AVDTP_BAD_ACP_SEID;
1613                 goto failed;
1614         }
1615         if (!sep->stream || !sep->stream->caps) {
1616                 err = AVDTP_UNSUPPORTED_CONFIGURATION;
1617                 goto failed;
1618         }
1619
1620         for (l = sep->stream->caps, rsp_size = 0; l != NULL; l = g_slist_next(l)) {
1621                 struct avdtp_service_capability *cap = l->data;
1622
1623                 if (rsp_size + cap->length + 2 > (int) sizeof(buf))
1624                         break;
1625
1626                 memcpy(ptr, cap, cap->length + 2);
1627                 rsp_size += cap->length + 2;
1628                 ptr += cap->length + 2;
1629         }
1630
1631         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1632                                 AVDTP_GET_CONFIGURATION, buf, rsp_size);
1633
1634 failed:
1635         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1636                                 AVDTP_GET_CONFIGURATION, &err, sizeof(err));
1637 }
1638
1639 static gboolean avdtp_reconf_cmd(struct avdtp *session, uint8_t transaction,
1640                                         struct seid_req *req, int size)
1641 {
1642         return avdtp_unknown_cmd(session, transaction, AVDTP_RECONFIGURE);
1643 }
1644
1645 static gboolean avdtp_open_cmd(struct avdtp *session, uint8_t transaction,
1646                                 struct seid_req *req, unsigned int size)
1647 {
1648         struct avdtp_local_sep *sep;
1649         struct avdtp_stream *stream;
1650         uint8_t err;
1651
1652         if (size < sizeof(struct seid_req)) {
1653                 error("Too short abort request");
1654                 return FALSE;
1655         }
1656
1657         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1658         if (!sep) {
1659                 err = AVDTP_BAD_ACP_SEID;
1660                 goto failed;
1661         }
1662
1663         if (sep->state != AVDTP_STATE_CONFIGURED) {
1664                 err = AVDTP_BAD_STATE;
1665                 goto failed;
1666         }
1667
1668         stream = sep->stream;
1669
1670         if (sep->ind && sep->ind->open) {
1671                 if (!sep->ind->open(session, sep, stream, &err,
1672                                         sep->user_data))
1673                         goto failed;
1674         }
1675
1676         if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1677                                                 AVDTP_OPEN, NULL, 0))
1678                 return FALSE;
1679
1680         stream->open_acp = TRUE;
1681         session->pending_open = stream;
1682         stream->timer = g_timeout_add_seconds(REQ_TIMEOUT,
1683                                                 stream_open_timeout,
1684                                                 stream);
1685
1686         return TRUE;
1687
1688 failed:
1689         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1690                                 AVDTP_OPEN, &err, sizeof(err));
1691 }
1692
1693 static gboolean avdtp_start_cmd(struct avdtp *session, uint8_t transaction,
1694                                 struct start_req *req, unsigned int size)
1695 {
1696         struct avdtp_local_sep *sep;
1697         struct avdtp_stream *stream;
1698         struct stream_rej rej;
1699         struct seid *seid;
1700         uint8_t err, failed_seid;
1701         int seid_count, i;
1702
1703         if (size < sizeof(struct start_req)) {
1704                 error("Too short start request");
1705                 return FALSE;
1706         }
1707
1708         seid_count = 1 + size - sizeof(struct start_req);
1709
1710         seid = &req->first_seid;
1711
1712         for (i = 0; i < seid_count; i++, seid++) {
1713                 failed_seid = seid->seid;
1714
1715                 sep = find_local_sep_by_seid(session->server,
1716                                         req->first_seid.seid);
1717                 if (!sep || !sep->stream) {
1718                         err = AVDTP_BAD_ACP_SEID;
1719                         goto failed;
1720                 }
1721
1722                 stream = sep->stream;
1723
1724                 /* Also reject start cmd if we already initiated start */
1725                 if (sep->state != AVDTP_STATE_OPEN ||
1726                                                 stream->starting == TRUE) {
1727                         err = AVDTP_BAD_STATE;
1728                         goto failed;
1729                 }
1730                 stream->starting = TRUE;
1731
1732                 if (sep->ind && sep->ind->start) {
1733                         if (!sep->ind->start(session, sep, stream, &err,
1734                                                 sep->user_data))
1735                                 goto failed;
1736                 }
1737
1738                 avdtp_sep_set_state(session, sep, AVDTP_STATE_STREAMING);
1739         }
1740
1741         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1742                                                 AVDTP_START, NULL, 0);
1743
1744 failed:
1745         DBG("Rejecting (%d)", err);
1746         memset(&rej, 0, sizeof(rej));
1747         rej.acp_seid = failed_seid;
1748         rej.error = err;
1749         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1750                                 AVDTP_START, &rej, sizeof(rej));
1751 }
1752
1753 static gboolean avdtp_close_cmd(struct avdtp *session, uint8_t transaction,
1754                                 struct seid_req *req, unsigned int size)
1755 {
1756         struct avdtp_local_sep *sep;
1757         struct avdtp_stream *stream;
1758         uint8_t err;
1759
1760         if (size < sizeof(struct seid_req)) {
1761                 error("Too short close request");
1762                 return FALSE;
1763         }
1764
1765         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1766         if (!sep || !sep->stream) {
1767                 err = AVDTP_BAD_ACP_SEID;
1768                 goto failed;
1769         }
1770
1771         if (sep->state != AVDTP_STATE_OPEN &&
1772                         sep->state != AVDTP_STATE_STREAMING) {
1773                 err = AVDTP_BAD_STATE;
1774                 goto failed;
1775         }
1776
1777         stream = sep->stream;
1778
1779         if (sep->ind && sep->ind->close) {
1780                 if (!sep->ind->close(session, sep, stream, &err,
1781                                         sep->user_data))
1782                         goto failed;
1783         }
1784
1785         avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
1786
1787         if (!avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1788                                                 AVDTP_CLOSE, NULL, 0))
1789                 return FALSE;
1790
1791         stream->timer = g_timeout_add_seconds(REQ_TIMEOUT,
1792                                         stream_close_timeout,
1793                                         stream);
1794
1795         return TRUE;
1796
1797 failed:
1798         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1799                                         AVDTP_CLOSE, &err, sizeof(err));
1800 }
1801
1802 static gboolean avdtp_suspend_cmd(struct avdtp *session, uint8_t transaction,
1803                                 struct suspend_req *req, unsigned int size)
1804 {
1805         struct avdtp_local_sep *sep;
1806         struct avdtp_stream *stream;
1807         struct stream_rej rej;
1808         struct seid *seid;
1809         uint8_t err, failed_seid;
1810         int seid_count, i;
1811
1812         if (size < sizeof(struct suspend_req)) {
1813                 error("Too short suspend request");
1814                 return FALSE;
1815         }
1816
1817         seid_count = 1 + size - sizeof(struct suspend_req);
1818
1819         seid = &req->first_seid;
1820
1821         for (i = 0; i < seid_count; i++, seid++) {
1822                 failed_seid = seid->seid;
1823
1824                 sep = find_local_sep_by_seid(session->server,
1825                                         req->first_seid.seid);
1826                 if (!sep || !sep->stream) {
1827                         err = AVDTP_BAD_ACP_SEID;
1828                         goto failed;
1829                 }
1830
1831                 stream = sep->stream;
1832
1833                 if (sep->state != AVDTP_STATE_STREAMING) {
1834                         err = AVDTP_BAD_STATE;
1835                         goto failed;
1836                 }
1837
1838                 if (sep->ind && sep->ind->suspend) {
1839                         if (!sep->ind->suspend(session, sep, stream, &err,
1840                                                 sep->user_data))
1841                                 goto failed;
1842                 }
1843
1844                 avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
1845         }
1846
1847         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1848                                                 AVDTP_SUSPEND, NULL, 0);
1849
1850 failed:
1851         memset(&rej, 0, sizeof(rej));
1852         rej.acp_seid = failed_seid;
1853         rej.error = err;
1854         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1855                                 AVDTP_SUSPEND, &rej, sizeof(rej));
1856 }
1857
1858 static gboolean avdtp_abort_cmd(struct avdtp *session, uint8_t transaction,
1859                                 struct seid_req *req, unsigned int size)
1860 {
1861         struct avdtp_local_sep *sep;
1862         uint8_t err;
1863         gboolean ret;
1864
1865         if (size < sizeof(struct seid_req)) {
1866                 error("Too short abort request");
1867                 return FALSE;
1868         }
1869
1870         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1871         if (!sep || !sep->stream) {
1872                 err = AVDTP_BAD_ACP_SEID;
1873                 goto failed;
1874         }
1875
1876         if (sep->ind && sep->ind->abort) {
1877                 if (!sep->ind->abort(session, sep, sep->stream, &err,
1878                                         sep->user_data))
1879                         goto failed;
1880         }
1881
1882         ret = avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1883                                                 AVDTP_ABORT, NULL, 0);
1884         if (ret)
1885                 avdtp_sep_set_state(session, sep, AVDTP_STATE_ABORTING);
1886
1887         return ret;
1888
1889 failed:
1890         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1891                                         AVDTP_ABORT, &err, sizeof(err));
1892 }
1893
1894 static gboolean avdtp_secctl_cmd(struct avdtp *session, uint8_t transaction,
1895                                         struct seid_req *req, int size)
1896 {
1897         return avdtp_unknown_cmd(session, transaction, AVDTP_SECURITY_CONTROL);
1898 }
1899
1900 static gboolean avdtp_delayreport_cmd(struct avdtp *session,
1901                                         uint8_t transaction,
1902                                         struct delay_req *req,
1903                                         unsigned int size)
1904 {
1905         struct avdtp_local_sep *sep;
1906         struct avdtp_stream *stream;
1907         uint8_t err;
1908
1909         if (size < sizeof(struct delay_req)) {
1910                 error("Too short delay report request");
1911                 return FALSE;
1912         }
1913
1914         sep = find_local_sep_by_seid(session->server, req->acp_seid);
1915         if (!sep || !sep->stream) {
1916                 err = AVDTP_BAD_ACP_SEID;
1917                 goto failed;
1918         }
1919
1920         stream = sep->stream;
1921
1922         if (sep->state != AVDTP_STATE_CONFIGURED &&
1923                                         sep->state != AVDTP_STATE_STREAMING) {
1924                 err = AVDTP_BAD_STATE;
1925                 goto failed;
1926         }
1927
1928         stream->delay = ntohs(req->delay);
1929
1930         if (sep->ind && sep->ind->delayreport) {
1931                 if (!sep->ind->delayreport(session, sep, stream->rseid,
1932                                                 stream->delay, &err,
1933                                                 sep->user_data))
1934                         goto failed;
1935         }
1936
1937         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_ACCEPT,
1938                                                 AVDTP_DELAY_REPORT, NULL, 0);
1939
1940 failed:
1941         return avdtp_send(session, transaction, AVDTP_MSG_TYPE_REJECT,
1942                                         AVDTP_DELAY_REPORT, &err, sizeof(err));
1943 }
1944
1945 static gboolean avdtp_parse_cmd(struct avdtp *session, uint8_t transaction,
1946                                 uint8_t signal_id, void *buf, int size)
1947 {
1948         switch (signal_id) {
1949         case AVDTP_DISCOVER:
1950                 DBG("Received DISCOVER_CMD");
1951                 return avdtp_discover_cmd(session, transaction, buf, size);
1952         case AVDTP_GET_CAPABILITIES:
1953                 DBG("Received  GET_CAPABILITIES_CMD");
1954                 return avdtp_getcap_cmd(session, transaction, buf, size,
1955                                                                         FALSE);
1956         case AVDTP_GET_ALL_CAPABILITIES:
1957                 DBG("Received  GET_ALL_CAPABILITIES_CMD");
1958                 return avdtp_getcap_cmd(session, transaction, buf, size, TRUE);
1959         case AVDTP_SET_CONFIGURATION:
1960                 DBG("Received SET_CONFIGURATION_CMD");
1961                 return avdtp_setconf_cmd(session, transaction, buf, size);
1962         case AVDTP_GET_CONFIGURATION:
1963                 DBG("Received GET_CONFIGURATION_CMD");
1964                 return avdtp_getconf_cmd(session, transaction, buf, size);
1965         case AVDTP_RECONFIGURE:
1966                 DBG("Received RECONFIGURE_CMD");
1967                 return avdtp_reconf_cmd(session, transaction, buf, size);
1968         case AVDTP_OPEN:
1969                 DBG("Received OPEN_CMD");
1970                 return avdtp_open_cmd(session, transaction, buf, size);
1971         case AVDTP_START:
1972                 DBG("Received START_CMD");
1973                 return avdtp_start_cmd(session, transaction, buf, size);
1974         case AVDTP_CLOSE:
1975                 DBG("Received CLOSE_CMD");
1976                 return avdtp_close_cmd(session, transaction, buf, size);
1977         case AVDTP_SUSPEND:
1978                 DBG("Received SUSPEND_CMD");
1979                 return avdtp_suspend_cmd(session, transaction, buf, size);
1980         case AVDTP_ABORT:
1981                 DBG("Received ABORT_CMD");
1982                 return avdtp_abort_cmd(session, transaction, buf, size);
1983         case AVDTP_SECURITY_CONTROL:
1984                 DBG("Received SECURITY_CONTROL_CMD");
1985                 return avdtp_secctl_cmd(session, transaction, buf, size);
1986         case AVDTP_DELAY_REPORT:
1987                 DBG("Received DELAY_REPORT_CMD");
1988                 return avdtp_delayreport_cmd(session, transaction, buf, size);
1989         default:
1990                 DBG("Received unknown request id %u", signal_id);
1991                 return avdtp_unknown_cmd(session, transaction, signal_id);
1992         }
1993 }
1994
1995 enum avdtp_parse_result { PARSE_ERROR, PARSE_FRAGMENT, PARSE_SUCCESS };
1996
1997 static enum avdtp_parse_result avdtp_parse_data(struct avdtp *session,
1998                                                         void *buf, size_t size)
1999 {
2000         struct avdtp_common_header *header = buf;
2001         struct avdtp_single_header *single = (void *) session->buf;
2002         struct avdtp_start_header *start = (void *) session->buf;
2003         void *payload;
2004         gsize payload_size;
2005
2006         switch (header->packet_type) {
2007         case AVDTP_PKT_TYPE_SINGLE:
2008                 if (size < sizeof(*single)) {
2009                         error("Received too small single packet (%zu bytes)", size);
2010                         return PARSE_ERROR;
2011                 }
2012                 if (session->in.active) {
2013                         error("SINGLE: Invalid AVDTP packet fragmentation");
2014                         return PARSE_ERROR;
2015                 }
2016
2017                 payload = session->buf + sizeof(*single);
2018                 payload_size = size - sizeof(*single);
2019
2020                 session->in.active = TRUE;
2021                 session->in.data_size = 0;
2022                 session->in.no_of_packets = 1;
2023                 session->in.transaction = header->transaction;
2024                 session->in.message_type = header->message_type;
2025                 session->in.signal_id = single->signal_id;
2026
2027                 break;
2028         case AVDTP_PKT_TYPE_START:
2029                 if (size < sizeof(*start)) {
2030                         error("Received too small start packet (%zu bytes)", size);
2031                         return PARSE_ERROR;
2032                 }
2033                 if (session->in.active) {
2034                         error("START: Invalid AVDTP packet fragmentation");
2035                         return PARSE_ERROR;
2036                 }
2037
2038                 session->in.active = TRUE;
2039                 session->in.data_size = 0;
2040                 session->in.transaction = header->transaction;
2041                 session->in.message_type = header->message_type;
2042                 session->in.no_of_packets = start->no_of_packets;
2043                 session->in.signal_id = start->signal_id;
2044
2045                 payload = session->buf + sizeof(*start);
2046                 payload_size = size - sizeof(*start);
2047
2048                 break;
2049         case AVDTP_PKT_TYPE_CONTINUE:
2050                 if (size < sizeof(struct avdtp_continue_header)) {
2051                         error("Received too small continue packet (%zu bytes)",
2052                                                                         size);
2053                         return PARSE_ERROR;
2054                 }
2055                 if (!session->in.active) {
2056                         error("CONTINUE: Invalid AVDTP packet fragmentation");
2057                         return PARSE_ERROR;
2058                 }
2059                 if (session->in.transaction != header->transaction) {
2060                         error("Continue transaction id doesn't match");
2061                         return PARSE_ERROR;
2062                 }
2063                 if (session->in.no_of_packets <= 1) {
2064                         error("Too few continue packets");
2065                         return PARSE_ERROR;
2066                 }
2067
2068                 payload = session->buf + sizeof(struct avdtp_continue_header);
2069                 payload_size = size - sizeof(struct avdtp_continue_header);
2070
2071                 break;
2072         case AVDTP_PKT_TYPE_END:
2073                 if (size < sizeof(struct avdtp_continue_header)) {
2074                         error("Received too small end packet (%zu bytes)", size);
2075                         return PARSE_ERROR;
2076                 }
2077                 if (!session->in.active) {
2078                         error("END: Invalid AVDTP packet fragmentation");
2079                         return PARSE_ERROR;
2080                 }
2081                 if (session->in.transaction != header->transaction) {
2082                         error("End transaction id doesn't match");
2083                         return PARSE_ERROR;
2084                 }
2085                 if (session->in.no_of_packets > 1) {
2086                         error("Got an end packet too early");
2087                         return PARSE_ERROR;
2088                 }
2089
2090                 payload = session->buf + sizeof(struct avdtp_continue_header);
2091                 payload_size = size - sizeof(struct avdtp_continue_header);
2092
2093                 break;
2094         default:
2095                 error("Invalid AVDTP packet type 0x%02X", header->packet_type);
2096                 return PARSE_ERROR;
2097         }
2098
2099         if (session->in.data_size + payload_size >
2100                                         sizeof(session->in.buf)) {
2101                 error("Not enough incoming buffer space!");
2102                 return PARSE_ERROR;
2103         }
2104
2105         memcpy(session->in.buf + session->in.data_size, payload, payload_size);
2106         session->in.data_size += payload_size;
2107
2108         if (session->in.no_of_packets > 1) {
2109                 session->in.no_of_packets--;
2110                 DBG("Received AVDTP fragment. %d to go",
2111                                                 session->in.no_of_packets);
2112                 return PARSE_FRAGMENT;
2113         }
2114
2115         session->in.active = FALSE;
2116
2117         return PARSE_SUCCESS;
2118 }
2119
2120 static gboolean session_cb(GIOChannel *chan, GIOCondition cond,
2121                                 gpointer data)
2122 {
2123         struct avdtp *session = data;
2124         struct avdtp_common_header *header;
2125         ssize_t size;
2126         int fd;
2127
2128         DBG("");
2129
2130         if (cond & G_IO_NVAL)
2131                 return FALSE;
2132
2133         header = (void *) session->buf;
2134
2135         if (cond & (G_IO_HUP | G_IO_ERR))
2136                 goto failed;
2137
2138         fd = g_io_channel_unix_get_fd(chan);
2139         size = read(fd, session->buf, session->imtu);
2140         if (size < 0) {
2141                 error("IO Channel read error");
2142                 goto failed;
2143         }
2144
2145         if ((size_t) size < sizeof(struct avdtp_common_header)) {
2146                 error("Received too small packet (%zu bytes)", size);
2147                 goto failed;
2148         }
2149
2150         switch (avdtp_parse_data(session, session->buf, size)) {
2151         case PARSE_ERROR:
2152                 goto failed;
2153         case PARSE_FRAGMENT:
2154                 return TRUE;
2155         case PARSE_SUCCESS:
2156                 break;
2157         }
2158
2159         if (session->in.message_type == AVDTP_MSG_TYPE_COMMAND) {
2160                 if (!avdtp_parse_cmd(session, session->in.transaction,
2161                                         session->in.signal_id,
2162                                         session->in.buf,
2163                                         session->in.data_size)) {
2164                         error("Unable to handle command. Disconnecting");
2165                         goto failed;
2166                 }
2167
2168                 if (session->ref == 1 && !session->streams && !session->req)
2169                         set_disconnect_timer(session);
2170
2171                 if (session->streams && session->dc_timer)
2172                         remove_disconnect_timer(session);
2173
2174                 return TRUE;
2175         }
2176
2177         if (session->req == NULL) {
2178                 error("No pending request, ignoring message");
2179                 return TRUE;
2180         }
2181
2182         if (header->transaction != session->req->transaction) {
2183                 error("Transaction label doesn't match");
2184                 return TRUE;
2185         }
2186
2187         if (session->in.signal_id != session->req->signal_id) {
2188                 error("Response signal doesn't match");
2189                 return TRUE;
2190         }
2191
2192         g_source_remove(session->req->timeout);
2193         session->req->timeout = 0;
2194
2195         switch (header->message_type) {
2196         case AVDTP_MSG_TYPE_ACCEPT:
2197                 if (!avdtp_parse_resp(session, session->req->stream,
2198                                                 session->in.transaction,
2199                                                 session->in.signal_id,
2200                                                 session->in.buf,
2201                                                 session->in.data_size)) {
2202                         error("Unable to parse accept response");
2203                         goto failed;
2204                 }
2205                 break;
2206         case AVDTP_MSG_TYPE_REJECT:
2207                 if (!avdtp_parse_rej(session, session->req->stream,
2208                                                 session->in.transaction,
2209                                                 session->in.signal_id,
2210                                                 session->in.buf,
2211                                                 session->in.data_size)) {
2212                         error("Unable to parse reject response");
2213                         goto failed;
2214                 }
2215                 break;
2216         case AVDTP_MSG_TYPE_GEN_REJECT:
2217                 error("Received a General Reject message");
2218                 break;
2219         default:
2220                 error("Unknown message type 0x%02X", header->message_type);
2221                 break;
2222         }
2223
2224         pending_req_free(session->req);
2225         session->req = NULL;
2226
2227         process_queue(session);
2228
2229         return TRUE;
2230
2231 failed:
2232         connection_lost(session, EIO);
2233
2234         return FALSE;
2235 }
2236
2237 static struct avdtp *find_session(GSList *list, const bdaddr_t *dst)
2238 {
2239         for (; list != NULL; list = g_slist_next(list)) {
2240                 struct avdtp *s = list->data;
2241
2242                 if (bacmp(dst, &s->dst))
2243                         continue;
2244
2245                 return s;
2246         }
2247
2248         return NULL;
2249 }
2250
2251 static uint16_t get_version(struct avdtp *session)
2252 {
2253         struct btd_adapter *adapter;
2254         struct btd_device *device;
2255         const sdp_record_t *rec;
2256         sdp_list_t *protos;
2257         sdp_data_t *proto_desc;
2258         char addr[18];
2259         uint16_t ver = 0x0100;
2260
2261         adapter = manager_find_adapter(&session->server->src);
2262         if (!adapter)
2263                 return ver;
2264
2265         ba2str(&session->dst, addr);
2266         device = adapter_find_device(adapter, addr);
2267         if (!device)
2268                 return ver;
2269
2270         rec = btd_device_get_record(device, A2DP_SINK_UUID);
2271         if (!rec)
2272                 rec = btd_device_get_record(device, A2DP_SOURCE_UUID);
2273
2274         if (!rec)
2275                 return ver;
2276
2277         if (sdp_get_access_protos(rec, &protos) < 0)
2278                 return ver;
2279
2280         proto_desc = sdp_get_proto_desc(protos, AVDTP_UUID);
2281         if (proto_desc && proto_desc->dtd == SDP_UINT16)
2282                 ver = proto_desc->val.uint16;
2283
2284         sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL);
2285         sdp_list_free(protos, NULL);
2286
2287         return ver;
2288 }
2289
2290 static struct avdtp *avdtp_get_internal(const bdaddr_t *src, const bdaddr_t *dst)
2291 {
2292         struct avdtp_server *server;
2293         struct avdtp *session;
2294
2295         assert(src != NULL);
2296         assert(dst != NULL);
2297
2298         server = find_server(servers, src);
2299         if (server == NULL)
2300                 return NULL;
2301
2302         session = find_session(server->sessions, dst);
2303         if (session) {
2304                 if (session->pending_auth)
2305                         return NULL;
2306                 else
2307                         return session;
2308         }
2309
2310         session = g_new0(struct avdtp, 1);
2311
2312         session->server = server;
2313         bacpy(&session->dst, dst);
2314         session->ref = 1;
2315         /* We don't use avdtp_set_state() here since this isn't a state change
2316          * but just setting of the initial state */
2317         session->state = AVDTP_SESSION_STATE_DISCONNECTED;
2318         session->auto_dc = TRUE;
2319
2320         session->version = get_version(session);
2321
2322         server->sessions = g_slist_append(server->sessions, session);
2323
2324         return session;
2325 }
2326
2327 struct avdtp *avdtp_get(bdaddr_t *src, bdaddr_t *dst)
2328 {
2329         struct avdtp *session;
2330
2331         session = avdtp_get_internal(src, dst);
2332
2333         if (!session)
2334                 return NULL;
2335
2336         return avdtp_ref(session);
2337 }
2338
2339 static void avdtp_connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
2340 {
2341         struct avdtp *session = user_data;
2342         char address[18];
2343         GError *gerr = NULL;
2344
2345         if (err) {
2346                 error("%s", err->message);
2347                 goto failed;
2348         }
2349
2350         if (!session->io)
2351                 session->io = g_io_channel_ref(chan);
2352
2353         bt_io_get(chan, BT_IO_L2CAP, &gerr,
2354                         BT_IO_OPT_OMTU, &session->omtu,
2355                         BT_IO_OPT_IMTU, &session->imtu,
2356                         BT_IO_OPT_INVALID);
2357         if (gerr) {
2358                 error("%s", gerr->message);
2359                 g_error_free(gerr);
2360                 goto failed;
2361         }
2362
2363         ba2str(&session->dst, address);
2364         DBG("AVDTP: connected %s channel to %s",
2365                         session->pending_open ? "transport" : "signaling",
2366                         address);
2367
2368         if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
2369                 DBG("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
2370
2371                 session->buf = g_malloc0(MAX(session->imtu, session->omtu));
2372                 avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTED);
2373
2374                 if (session->io_id)
2375                         g_source_remove(session->io_id);
2376
2377                 /* This watch should be low priority since otherwise the
2378                  * connect callback might be dispatched before the session
2379                  * callback if the kernel wakes us up at the same time for
2380                  * them. This could happen if a headset is very quick in
2381                  * sending the Start command after connecting the stream
2382                  * transport channel.
2383                  */
2384                 session->io_id = g_io_add_watch_full(chan,
2385                                                 G_PRIORITY_LOW,
2386                                                 G_IO_IN | G_IO_ERR | G_IO_HUP
2387                                                 | G_IO_NVAL,
2388                                                 (GIOFunc) session_cb, session,
2389                                                 NULL);
2390
2391                 if (session->stream_setup) {
2392                         set_disconnect_timer(session);
2393                         avdtp_set_auto_disconnect(session, FALSE);
2394                 }
2395         } else if (session->pending_open)
2396                 handle_transport_connect(session, chan, session->imtu,
2397                                                                 session->omtu);
2398         else
2399                 goto failed;
2400
2401         process_queue(session);
2402
2403         return;
2404
2405 failed:
2406         if (session->pending_open) {
2407                 struct avdtp_stream *stream = session->pending_open;
2408
2409                 handle_transport_connect(session, NULL, 0, 0);
2410
2411                 if (avdtp_abort(session, stream) < 0)
2412                         avdtp_sep_set_state(session, stream->lsep,
2413                                                 AVDTP_STATE_IDLE);
2414         } else
2415                 connection_lost(session, EIO);
2416 }
2417
2418 static void auth_cb(DBusError *derr, void *user_data)
2419 {
2420         struct avdtp *session = user_data;
2421         GError *err = NULL;
2422
2423         if (derr && dbus_error_is_set(derr)) {
2424                 error("Access denied: %s", derr->message);
2425                 connection_lost(session, EACCES);
2426                 return;
2427         }
2428
2429         if (!bt_io_accept(session->io, avdtp_connect_cb, session, NULL,
2430                                                                 &err)) {
2431                 error("bt_io_accept: %s", err->message);
2432                 connection_lost(session, EACCES);
2433                 g_error_free(err);
2434                 return;
2435         }
2436
2437         /* This is so that avdtp_connect_cb will know to do the right thing
2438          * with respect to the disconnect timer */
2439         session->stream_setup = TRUE;
2440 }
2441
2442 static void avdtp_confirm_cb(GIOChannel *chan, gpointer data)
2443 {
2444         struct avdtp *session;
2445         struct audio_device *dev;
2446         char address[18];
2447         bdaddr_t src, dst;
2448         int perr;
2449         GError *err = NULL;
2450
2451         bt_io_get(chan, BT_IO_L2CAP, &err,
2452                         BT_IO_OPT_SOURCE_BDADDR, &src,
2453                         BT_IO_OPT_DEST_BDADDR, &dst,
2454                         BT_IO_OPT_DEST, address,
2455                         BT_IO_OPT_INVALID);
2456         if (err) {
2457                 error("%s", err->message);
2458                 g_error_free(err);
2459                 goto drop;
2460         }
2461
2462         DBG("AVDTP: incoming connect from %s", address);
2463
2464         session = avdtp_get_internal(&src, &dst);
2465         if (!session)
2466                 goto drop;
2467
2468         /* This state (ie, session is already *connecting*) happens when the
2469          * device initiates a connect (really a config'd L2CAP channel) even
2470          * though there is a connect we initiated in progress. In sink.c &
2471          * source.c, this state is referred to as XCASE connect:connect.
2472          * Abort the device's channel in favor of our own.
2473          */
2474         if (session->state == AVDTP_SESSION_STATE_CONNECTING) {
2475                 DBG("connect already in progress (XCASE connect:connect)");
2476                 goto drop;
2477         }
2478
2479         if (session->pending_open && session->pending_open->open_acp) {
2480                 if (!bt_io_accept(chan, avdtp_connect_cb, session, NULL, NULL))
2481                         goto drop;
2482                 return;
2483         }
2484
2485         if (session->io) {
2486                 error("Refusing unexpected connect from %s", address);
2487                 goto drop;
2488         }
2489
2490         dev = manager_get_device(&src, &dst, FALSE);
2491         if (!dev) {
2492                 dev = manager_get_device(&src, &dst, TRUE);
2493                 if (!dev) {
2494                         error("Unable to get audio device object for %s",
2495                                         address);
2496                         goto drop;
2497                 }
2498                 btd_device_add_uuid(dev->btd_dev, ADVANCED_AUDIO_UUID);
2499         }
2500
2501         session->io = g_io_channel_ref(chan);
2502         avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTING);
2503
2504         session->io_id = g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
2505                                         (GIOFunc) session_cb, session);
2506
2507         perr = audio_device_request_authorization(dev, ADVANCED_AUDIO_UUID,
2508                                                         auth_cb, session);
2509         if (perr < 0) {
2510                 avdtp_set_state(session, AVDTP_SESSION_STATE_DISCONNECTED);
2511                 avdtp_unref(session);
2512                 goto drop;
2513         }
2514
2515         dev->auto_connect = auto_connect;
2516
2517         return;
2518
2519 drop:
2520         g_io_channel_shutdown(chan, TRUE, NULL);
2521 }
2522
2523 static GIOChannel *l2cap_connect(struct avdtp *session)
2524 {
2525         GError *err = NULL;
2526         GIOChannel *io;
2527
2528         io = bt_io_connect(BT_IO_L2CAP, avdtp_connect_cb, session,
2529                                 NULL, &err,
2530                                 BT_IO_OPT_SOURCE_BDADDR, &session->server->src,
2531                                 BT_IO_OPT_DEST_BDADDR, &session->dst,
2532                                 BT_IO_OPT_PSM, AVDTP_PSM,
2533                                 BT_IO_OPT_INVALID);
2534         if (!io) {
2535                 error("%s", err->message);
2536                 g_error_free(err);
2537                 return NULL;
2538         }
2539
2540         return io;
2541 }
2542
2543 static void queue_request(struct avdtp *session, struct pending_req *req,
2544                         gboolean priority)
2545 {
2546         if (priority)
2547                 session->prio_queue = g_slist_append(session->prio_queue, req);
2548         else
2549                 session->req_queue = g_slist_append(session->req_queue, req);
2550 }
2551
2552 static uint8_t req_get_seid(struct pending_req *req)
2553 {
2554         if (req->signal_id == AVDTP_DISCOVER)
2555                 return 0;
2556
2557         return ((struct seid_req *) (req->data))->acp_seid;
2558 }
2559
2560 static int cancel_request(struct avdtp *session, int err)
2561 {
2562         struct pending_req *req;
2563         struct seid_req sreq;
2564         struct avdtp_local_sep *lsep;
2565         struct avdtp_stream *stream;
2566         uint8_t seid;
2567         struct avdtp_error averr;
2568
2569         req = session->req;
2570         session->req = NULL;
2571
2572         avdtp_error_init(&averr, AVDTP_ERRNO, err);
2573
2574         seid = req_get_seid(req);
2575         if (seid)
2576                 stream = find_stream_by_rseid(session, seid);
2577         else
2578                 stream = NULL;
2579
2580         if (stream) {
2581                 stream->abort_int = TRUE;
2582                 lsep = stream->lsep;
2583         } else
2584                 lsep = NULL;
2585
2586         switch (req->signal_id) {
2587         case AVDTP_RECONFIGURE:
2588                 error("Reconfigure: %s (%d)", strerror(err), err);
2589                 if (lsep && lsep->cfm && lsep->cfm->reconfigure)
2590                         lsep->cfm->reconfigure(session, lsep, stream, &averr,
2591                                                 lsep->user_data);
2592                 break;
2593         case AVDTP_OPEN:
2594                 error("Open: %s (%d)", strerror(err), err);
2595                 if (lsep && lsep->cfm && lsep->cfm->open)
2596                         lsep->cfm->open(session, lsep, stream, &averr,
2597                                         lsep->user_data);
2598                 break;
2599         case AVDTP_START:
2600                 error("Start: %s (%d)", strerror(err), err);
2601                 if (lsep && lsep->cfm && lsep->cfm->start) {
2602                         lsep->cfm->start(session, lsep, stream, &averr,
2603                                                 lsep->user_data);
2604                         if (stream)
2605                                 stream->starting = FALSE;
2606                 }
2607                 break;
2608         case AVDTP_SUSPEND:
2609                 error("Suspend: %s (%d)", strerror(err), err);
2610                 if (lsep && lsep->cfm && lsep->cfm->suspend)
2611                         lsep->cfm->suspend(session, lsep, stream, &averr,
2612                                                 lsep->user_data);
2613                 break;
2614         case AVDTP_CLOSE:
2615                 error("Close: %s (%d)", strerror(err), err);
2616                 if (lsep && lsep->cfm && lsep->cfm->close) {
2617                         lsep->cfm->close(session, lsep, stream, &averr,
2618                                                 lsep->user_data);
2619                         if (stream)
2620                                 stream->close_int = FALSE;
2621                 }
2622                 break;
2623         case AVDTP_SET_CONFIGURATION:
2624                 error("SetConfiguration: %s (%d)", strerror(err), err);
2625                 if (lsep && lsep->cfm && lsep->cfm->set_configuration)
2626                         lsep->cfm->set_configuration(session, lsep, stream,
2627                                                         &averr, lsep->user_data);
2628                 goto failed;
2629         case AVDTP_DISCOVER:
2630                 error("Discover: %s (%d)", strerror(err), err);
2631                 goto failed;
2632         case AVDTP_GET_CAPABILITIES:
2633                 error("GetCapabilities: %s (%d)", strerror(err), err);
2634                 goto failed;
2635         case AVDTP_ABORT:
2636                 error("Abort: %s (%d)", strerror(err), err);
2637                 goto failed;
2638         }
2639
2640         if (!stream)
2641                 goto failed;
2642
2643         memset(&sreq, 0, sizeof(sreq));
2644         sreq.acp_seid = seid;
2645
2646         err = send_request(session, TRUE, stream, AVDTP_ABORT, &sreq,
2647                                 sizeof(sreq));
2648         if (err < 0) {
2649                 error("Unable to send abort request");
2650                 goto failed;
2651         }
2652
2653         goto done;
2654
2655 failed:
2656         connection_lost(session, err);
2657 done:
2658         pending_req_free(req);
2659         return err;
2660 }
2661
2662 static gboolean request_timeout(gpointer user_data)
2663 {
2664         struct avdtp *session = user_data;
2665
2666         cancel_request(session, ETIMEDOUT);
2667
2668         return FALSE;
2669 }
2670
2671 static int send_req(struct avdtp *session, gboolean priority,
2672                         struct pending_req *req)
2673 {
2674         static int transaction = 0;
2675         int err;
2676
2677         if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {
2678                 session->io = l2cap_connect(session);
2679                 if (!session->io) {
2680                         err = -EIO;
2681                         goto failed;
2682                 }
2683                 avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTING);
2684         }
2685
2686         if (session->state < AVDTP_SESSION_STATE_CONNECTED ||
2687                         session->req != NULL) {
2688                 queue_request(session, req, priority);
2689                 return 0;
2690         }
2691
2692         req->transaction = transaction++;
2693         transaction %= 16;
2694
2695         /* FIXME: Should we retry to send if the buffer
2696         was not totally sent or in case of EINTR? */
2697         if (!avdtp_send(session, req->transaction, AVDTP_MSG_TYPE_COMMAND,
2698                                 req->signal_id, req->data, req->data_size)) {
2699                 err = -EIO;
2700                 goto failed;
2701         }
2702
2703         session->req = req;
2704
2705         req->timeout = g_timeout_add_seconds(req->signal_id == AVDTP_ABORT ?
2706                                         ABORT_TIMEOUT : REQ_TIMEOUT,
2707                                         request_timeout,
2708                                         session);
2709         return 0;
2710
2711 failed:
2712         g_free(req->data);
2713         g_free(req);
2714         return err;
2715 }
2716
2717 static int send_request(struct avdtp *session, gboolean priority,
2718                         struct avdtp_stream *stream, uint8_t signal_id,
2719                         void *buffer, size_t size)
2720 {
2721         struct pending_req *req;
2722
2723         if (stream && stream->abort_int && signal_id != AVDTP_ABORT) {
2724                 DBG("Unable to send requests while aborting");
2725                 return -EINVAL;
2726         }
2727
2728         req = g_new0(struct pending_req, 1);
2729         req->signal_id = signal_id;
2730         req->data = g_malloc(size);
2731         memcpy(req->data, buffer, size);
2732         req->data_size = size;
2733         req->stream = stream;
2734
2735         return send_req(session, priority, req);
2736 }
2737
2738 static gboolean avdtp_discover_resp(struct avdtp *session,
2739                                         struct discover_resp *resp, int size)
2740 {
2741         int sep_count, i;
2742         uint8_t getcap_cmd;
2743         int ret = 0;
2744         gboolean getcap_pending = FALSE;
2745
2746         if (session->version >= 0x0103 && session->server->version >= 0x0103)
2747                 getcap_cmd = AVDTP_GET_ALL_CAPABILITIES;
2748         else
2749                 getcap_cmd = AVDTP_GET_CAPABILITIES;
2750
2751         sep_count = size / sizeof(struct seid_info);
2752
2753         for (i = 0; i < sep_count; i++) {
2754                 struct avdtp_remote_sep *sep;
2755                 struct avdtp_stream *stream;
2756                 struct seid_req req;
2757
2758                 DBG("seid %d type %d media %d in use %d",
2759                                 resp->seps[i].seid, resp->seps[i].type,
2760                                 resp->seps[i].media_type, resp->seps[i].inuse);
2761
2762                 stream = find_stream_by_rseid(session, resp->seps[i].seid);
2763
2764                 sep = find_remote_sep(session->seps, resp->seps[i].seid);
2765                 if (!sep) {
2766                         if (resp->seps[i].inuse && !stream)
2767                                 continue;
2768                         sep = g_new0(struct avdtp_remote_sep, 1);
2769                         session->seps = g_slist_append(session->seps, sep);
2770                 }
2771
2772                 sep->stream = stream;
2773                 sep->seid = resp->seps[i].seid;
2774                 sep->type = resp->seps[i].type;
2775                 sep->media_type = resp->seps[i].media_type;
2776
2777                 memset(&req, 0, sizeof(req));
2778                 req.acp_seid = sep->seid;
2779
2780                 ret = send_request(session, TRUE, NULL, getcap_cmd,
2781                                                         &req, sizeof(req));
2782                 if (ret < 0)
2783                         break;
2784                 getcap_pending = TRUE;
2785         }
2786
2787         if (!getcap_pending)
2788                 finalize_discovery(session, -ret);
2789
2790         return TRUE;
2791 }
2792
2793 static gboolean avdtp_get_capabilities_resp(struct avdtp *session,
2794                                                 struct getcap_resp *resp,
2795                                                 unsigned int size)
2796 {
2797         struct avdtp_remote_sep *sep;
2798         uint8_t seid;
2799
2800         /* Check for minimum required packet size includes:
2801          *   1. getcap resp header
2802          *   2. media transport capability (2 bytes)
2803          *   3. media codec capability type + length (2 bytes)
2804          *   4. the actual media codec elements
2805          * */
2806         if (size < (sizeof(struct getcap_resp) + 4 +
2807                                 sizeof(struct avdtp_media_codec_capability))) {
2808                 error("Too short getcap resp packet");
2809                 return FALSE;
2810         }
2811
2812         seid = ((struct seid_req *) session->req->data)->acp_seid;
2813
2814         sep = find_remote_sep(session->seps, seid);
2815
2816         DBG("seid %d type %d media %d", sep->seid,
2817                                         sep->type, sep->media_type);
2818
2819         if (sep->caps) {
2820                 g_slist_free_full(sep->caps, g_free);
2821                 sep->caps = NULL;
2822                 sep->codec = NULL;
2823                 sep->delay_reporting = FALSE;
2824         }
2825
2826         sep->caps = caps_to_list(resp->caps, size - sizeof(struct getcap_resp),
2827                                         &sep->codec, &sep->delay_reporting);
2828
2829         return TRUE;
2830 }
2831
2832 static gboolean avdtp_set_configuration_resp(struct avdtp *session,
2833                                                 struct avdtp_stream *stream,
2834                                                 struct avdtp_single_header *resp,
2835                                                 int size)
2836 {
2837         struct avdtp_local_sep *sep = stream->lsep;
2838
2839         if (sep->cfm && sep->cfm->set_configuration)
2840                 sep->cfm->set_configuration(session, sep, stream, NULL,
2841                                                 sep->user_data);
2842
2843         avdtp_sep_set_state(session, sep, AVDTP_STATE_CONFIGURED);
2844
2845         return TRUE;
2846 }
2847
2848 static gboolean avdtp_reconfigure_resp(struct avdtp *session,
2849                                         struct avdtp_stream *stream,
2850                                         struct avdtp_single_header *resp, int size)
2851 {
2852         return TRUE;
2853 }
2854
2855 static gboolean avdtp_open_resp(struct avdtp *session, struct avdtp_stream *stream,
2856                                 struct seid_rej *resp, int size)
2857 {
2858         struct avdtp_local_sep *sep = stream->lsep;
2859
2860         stream->io = l2cap_connect(session);
2861         if (!stream->io) {
2862                 avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
2863                 return FALSE;
2864         }
2865
2866         session->pending_open = stream;
2867
2868         return TRUE;
2869 }
2870
2871 static gboolean avdtp_start_resp(struct avdtp *session,
2872                                         struct avdtp_stream *stream,
2873                                         struct seid_rej *resp, int size)
2874 {
2875         struct avdtp_local_sep *sep = stream->lsep;
2876
2877         if (sep->cfm && sep->cfm->start)
2878                 sep->cfm->start(session, sep, stream, NULL, sep->user_data);
2879
2880         /* We might be in STREAMING already if both sides send START_CMD at the
2881          * same time and the one in SNK role doesn't reject it as it should */
2882         if (sep->state != AVDTP_STATE_STREAMING)
2883                 avdtp_sep_set_state(session, sep, AVDTP_STATE_STREAMING);
2884
2885         return TRUE;
2886 }
2887
2888 static gboolean avdtp_close_resp(struct avdtp *session,
2889                                         struct avdtp_stream *stream,
2890                                         struct seid_rej *resp, int size)
2891 {
2892         struct avdtp_local_sep *sep = stream->lsep;
2893
2894         avdtp_sep_set_state(session, sep, AVDTP_STATE_CLOSING);
2895
2896         close_stream(stream);
2897
2898         return TRUE;
2899 }
2900
2901 static gboolean avdtp_suspend_resp(struct avdtp *session,
2902                                         struct avdtp_stream *stream,
2903                                         void *data, int size)
2904 {
2905         struct avdtp_local_sep *sep = stream->lsep;
2906
2907         avdtp_sep_set_state(session, sep, AVDTP_STATE_OPEN);
2908
2909         if (sep->cfm && sep->cfm->suspend)
2910                 sep->cfm->suspend(session, sep, stream, NULL, sep->user_data);
2911
2912         return TRUE;
2913 }
2914
2915 static gboolean avdtp_abort_resp(struct avdtp *session,
2916                                         struct avdtp_stream *stream,
2917                                         struct seid_rej *resp, int size)
2918 {
2919         struct avdtp_local_sep *sep = stream->lsep;
2920
2921         avdtp_sep_set_state(session, sep, AVDTP_STATE_ABORTING);
2922
2923         if (sep->cfm && sep->cfm->abort)
2924                 sep->cfm->abort(session, sep, stream, NULL, sep->user_data);
2925
2926         avdtp_sep_set_state(session, sep, AVDTP_STATE_IDLE);
2927
2928         return TRUE;
2929 }
2930
2931 static gboolean avdtp_delay_report_resp(struct avdtp *session,
2932                                         struct avdtp_stream *stream,
2933                                         void *data, int size)
2934 {
2935         struct avdtp_local_sep *sep = stream->lsep;
2936
2937         if (sep->cfm && sep->cfm->delay_report)
2938                 sep->cfm->delay_report(session, sep, stream, NULL, sep->user_data);
2939
2940         return TRUE;
2941 }
2942
2943 static gboolean avdtp_parse_resp(struct avdtp *session,
2944                                         struct avdtp_stream *stream,
2945                                         uint8_t transaction, uint8_t signal_id,
2946                                         void *buf, int size)
2947 {
2948         struct pending_req *next;
2949         const char *get_all = "";
2950
2951         if (session->prio_queue)
2952                 next = session->prio_queue->data;
2953         else if (session->req_queue)
2954                 next = session->req_queue->data;
2955         else
2956                 next = NULL;
2957
2958         switch (signal_id) {
2959         case AVDTP_DISCOVER:
2960                 DBG("DISCOVER request succeeded");
2961                 return avdtp_discover_resp(session, buf, size);
2962         case AVDTP_GET_ALL_CAPABILITIES:
2963                 get_all = "ALL_";
2964         case AVDTP_GET_CAPABILITIES:
2965                 DBG("GET_%sCAPABILITIES request succeeded", get_all);
2966                 if (!avdtp_get_capabilities_resp(session, buf, size))
2967                         return FALSE;
2968                 if (!(next && (next->signal_id == AVDTP_GET_CAPABILITIES ||
2969                                 next->signal_id == AVDTP_GET_ALL_CAPABILITIES)))
2970                         finalize_discovery(session, 0);
2971                 return TRUE;
2972         }
2973
2974         /* The remaining commands require an existing stream so bail out
2975          * here if the stream got unexpectedly disconnected */
2976         if (!stream) {
2977                 DBG("AVDTP: stream was closed while waiting for reply");
2978                 return TRUE;
2979         }
2980
2981         switch (signal_id) {
2982         case AVDTP_SET_CONFIGURATION:
2983                 DBG("SET_CONFIGURATION request succeeded");
2984                 return avdtp_set_configuration_resp(session, stream,
2985                                                                 buf, size);
2986         case AVDTP_RECONFIGURE:
2987                 DBG("RECONFIGURE request succeeded");
2988                 return avdtp_reconfigure_resp(session, stream, buf, size);
2989         case AVDTP_OPEN:
2990                 DBG("OPEN request succeeded");
2991                 return avdtp_open_resp(session, stream, buf, size);
2992         case AVDTP_SUSPEND:
2993                 DBG("SUSPEND request succeeded");
2994                 return avdtp_suspend_resp(session, stream, buf, size);
2995         case AVDTP_START:
2996                 DBG("START request succeeded");
2997                 return avdtp_start_resp(session, stream, buf, size);
2998         case AVDTP_CLOSE:
2999                 DBG("CLOSE request succeeded");
3000                 return avdtp_close_resp(session, stream, buf, size);
3001         case AVDTP_ABORT:
3002                 DBG("ABORT request succeeded");
3003                 return avdtp_abort_resp(session, stream, buf, size);
3004         case AVDTP_DELAY_REPORT:
3005                 DBG("DELAY_REPORT request succeeded");
3006                 return avdtp_delay_report_resp(session, stream, buf, size);
3007         }
3008
3009         error("Unknown signal id in accept response: %u", signal_id);
3010         return TRUE;
3011 }
3012
3013 static gboolean seid_rej_to_err(struct seid_rej *rej, unsigned int size,
3014                                         struct avdtp_error *err)
3015 {
3016         if (size < sizeof(struct seid_rej)) {
3017                 error("Too small packet for seid_rej");
3018                 return FALSE;
3019         }
3020
3021         avdtp_error_init(err, 0x00, rej->error);
3022
3023         return TRUE;
3024 }
3025
3026 static gboolean conf_rej_to_err(struct conf_rej *rej, unsigned int size,
3027                                 struct avdtp_error *err)
3028 {
3029         if (size < sizeof(struct conf_rej)) {
3030                 error("Too small packet for conf_rej");
3031                 return FALSE;
3032         }
3033
3034         avdtp_error_init(err, rej->category, rej->error);
3035
3036         return TRUE;
3037 }
3038
3039 static gboolean stream_rej_to_err(struct stream_rej *rej, unsigned int size,
3040                                         struct avdtp_error *err,
3041                                         uint8_t *acp_seid)
3042 {
3043         if (size < sizeof(struct stream_rej)) {
3044                 error("Too small packet for stream_rej");
3045                 return FALSE;
3046         }
3047
3048         avdtp_error_init(err, 0x00, rej->error);
3049
3050         if (acp_seid)
3051                 *acp_seid = rej->acp_seid;
3052
3053         return TRUE;
3054 }
3055
3056 static gboolean avdtp_parse_rej(struct avdtp *session,
3057                                         struct avdtp_stream *stream,
3058                                         uint8_t transaction, uint8_t signal_id,
3059                                         void *buf, int size)
3060 {
3061         struct avdtp_error err;
3062         uint8_t acp_seid;
3063         struct avdtp_local_sep *sep = stream ? stream->lsep : NULL;
3064
3065         switch (signal_id) {
3066         case AVDTP_DISCOVER:
3067                 if (!seid_rej_to_err(buf, size, &err))
3068                         return FALSE;
3069                 error("DISCOVER request rejected: %s (%d)",
3070                                 avdtp_strerror(&err), err.err.error_code);
3071                 return TRUE;
3072         case AVDTP_GET_CAPABILITIES:
3073         case AVDTP_GET_ALL_CAPABILITIES:
3074                 if (!seid_rej_to_err(buf, size, &err))
3075                         return FALSE;
3076                 error("GET_CAPABILITIES request rejected: %s (%d)",
3077                                 avdtp_strerror(&err), err.err.error_code);
3078                 return TRUE;
3079         case AVDTP_OPEN:
3080                 if (!seid_rej_to_err(buf, size, &err))
3081                         return FALSE;
3082                 error("OPEN request rejected: %s (%d)",
3083                                 avdtp_strerror(&err), err.err.error_code);
3084                 if (sep && sep->cfm && sep->cfm->open)
3085                         sep->cfm->open(session, sep, stream, &err,
3086                                         sep->user_data);
3087                 return TRUE;
3088         case AVDTP_SET_CONFIGURATION:
3089                 if (!conf_rej_to_err(buf, size, &err))
3090                         return FALSE;
3091                 error("SET_CONFIGURATION request rejected: %s (%d)",
3092                                 avdtp_strerror(&err), err.err.error_code);
3093                 if (sep && sep->cfm && sep->cfm->set_configuration)
3094                         sep->cfm->set_configuration(session, sep, stream,
3095                                                         &err, sep->user_data);
3096                 return TRUE;
3097         case AVDTP_RECONFIGURE:
3098                 if (!conf_rej_to_err(buf, size, &err))
3099                         return FALSE;
3100                 error("RECONFIGURE request rejected: %s (%d)",
3101                                 avdtp_strerror(&err), err.err.error_code);
3102                 if (sep && sep->cfm && sep->cfm->reconfigure)
3103                         sep->cfm->reconfigure(session, sep, stream, &err,
3104                                                 sep->user_data);
3105                 return TRUE;
3106         case AVDTP_START:
3107                 if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3108                         return FALSE;
3109                 error("START request rejected: %s (%d)",
3110                                 avdtp_strerror(&err), err.err.error_code);
3111                 if (sep && sep->cfm && sep->cfm->start) {
3112                         sep->cfm->start(session, sep, stream, &err,
3113                                         sep->user_data);
3114                         stream->starting = FALSE;
3115                 }
3116                 return TRUE;
3117         case AVDTP_SUSPEND:
3118                 if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3119                         return FALSE;
3120                 error("SUSPEND request rejected: %s (%d)",
3121                                 avdtp_strerror(&err), err.err.error_code);
3122                 if (sep && sep->cfm && sep->cfm->suspend)
3123                         sep->cfm->suspend(session, sep, stream, &err,
3124                                                 sep->user_data);
3125                 return TRUE;
3126         case AVDTP_CLOSE:
3127                 if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3128                         return FALSE;
3129                 error("CLOSE request rejected: %s (%d)",
3130                                 avdtp_strerror(&err), err.err.error_code);
3131                 if (sep && sep->cfm && sep->cfm->close) {
3132                         sep->cfm->close(session, sep, stream, &err,
3133                                         sep->user_data);
3134                         stream->close_int = FALSE;
3135                 }
3136                 return TRUE;
3137         case AVDTP_ABORT:
3138                 if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3139                         return FALSE;
3140                 error("ABORT request rejected: %s (%d)",
3141                                 avdtp_strerror(&err), err.err.error_code);
3142                 if (sep && sep->cfm && sep->cfm->abort)
3143                         sep->cfm->abort(session, sep, stream, &err,
3144                                         sep->user_data);
3145                 return FALSE;
3146         case AVDTP_DELAY_REPORT:
3147                 if (!stream_rej_to_err(buf, size, &err, &acp_seid))
3148                         return FALSE;
3149                 error("DELAY_REPORT request rejected: %s (%d)",
3150                                 avdtp_strerror(&err), err.err.error_code);
3151                 if (sep && sep->cfm && sep->cfm->delay_report)
3152                         sep->cfm->delay_report(session, sep, stream, &err,
3153                                                         sep->user_data);
3154                 return TRUE;
3155         default:
3156                 error("Unknown reject response signal id: %u", signal_id);
3157                 return TRUE;
3158         }
3159 }
3160
3161 gboolean avdtp_is_connected(const bdaddr_t *src, const bdaddr_t *dst)
3162 {
3163         struct avdtp_server *server;
3164         struct avdtp *session;
3165
3166         server = find_server(servers, src);
3167         if (!server)
3168                 return FALSE;
3169
3170         session = find_session(server->sessions, dst);
3171         if (!session)
3172                 return FALSE;
3173
3174         if (session->state != AVDTP_SESSION_STATE_DISCONNECTED)
3175                 return TRUE;
3176
3177         return FALSE;
3178 }
3179
3180 struct avdtp_service_capability *avdtp_stream_get_codec(
3181                                                 struct avdtp_stream *stream)
3182 {
3183         GSList *l;
3184
3185         for (l = stream->caps; l; l = l->next) {
3186                 struct avdtp_service_capability *cap = l->data;
3187
3188                 if (cap->category == AVDTP_MEDIA_CODEC)
3189                         return cap;
3190         }
3191
3192         return NULL;
3193 }
3194
3195 gboolean avdtp_stream_has_capability(struct avdtp_stream *stream,
3196                                 struct avdtp_service_capability *cap)
3197 {
3198         GSList *l;
3199         struct avdtp_service_capability *stream_cap;
3200
3201         for (l = stream->caps; l; l = g_slist_next(l)) {
3202                 stream_cap = l->data;
3203
3204                 if (stream_cap->category != cap->category ||
3205                         stream_cap->length != cap->length)
3206                         continue;
3207
3208                 if (memcmp(stream_cap->data, cap->data, cap->length) == 0)
3209                         return TRUE;
3210         }
3211
3212         return FALSE;
3213 }
3214
3215 gboolean avdtp_stream_has_capabilities(struct avdtp_stream *stream,
3216                                         GSList *caps)
3217 {
3218         for (; caps; caps = g_slist_next(caps)) {
3219                 struct avdtp_service_capability *cap = caps->data;
3220
3221                 if (!avdtp_stream_has_capability(stream, cap))
3222                         return FALSE;
3223         }
3224
3225         return TRUE;
3226 }
3227
3228 struct avdtp_remote_sep *avdtp_stream_get_remote_sep(
3229                                                 struct avdtp_stream *stream)
3230 {
3231         return avdtp_get_remote_sep(stream->session, stream->rseid);
3232 }
3233
3234 gboolean avdtp_stream_get_transport(struct avdtp_stream *stream, int *sock,
3235                                         uint16_t *imtu, uint16_t *omtu,
3236                                         GSList **caps)
3237 {
3238         if (stream->io == NULL)
3239                 return FALSE;
3240
3241         if (sock)
3242                 *sock = g_io_channel_unix_get_fd(stream->io);
3243
3244         if (omtu)
3245                 *omtu = stream->omtu;
3246
3247         if (imtu)
3248                 *imtu = stream->imtu;
3249
3250         if (caps)
3251                 *caps = stream->caps;
3252
3253         return TRUE;
3254 }
3255
3256 static int process_queue(struct avdtp *session)
3257 {
3258         GSList **queue, *l;
3259         struct pending_req *req;
3260
3261         if (session->req)
3262                 return 0;
3263
3264         if (session->prio_queue)
3265                 queue = &session->prio_queue;
3266         else
3267                 queue = &session->req_queue;
3268
3269         if (!*queue)
3270                 return 0;
3271
3272         l = *queue;
3273         req = l->data;
3274
3275         *queue = g_slist_remove(*queue, req);
3276
3277         return send_req(session, FALSE, req);
3278 }
3279
3280 struct avdtp_remote_sep *avdtp_get_remote_sep(struct avdtp *session,
3281                                                 uint8_t seid)
3282 {
3283         GSList *l;
3284
3285         for (l = session->seps; l; l = l->next) {
3286                 struct avdtp_remote_sep *sep = l->data;
3287
3288                 if (sep->seid == seid)
3289                         return sep;
3290         }
3291
3292         return NULL;
3293 }
3294
3295 uint8_t avdtp_get_seid(struct avdtp_remote_sep *sep)
3296 {
3297         return sep->seid;
3298 }
3299
3300 uint8_t avdtp_get_type(struct avdtp_remote_sep *sep)
3301 {
3302         return sep->type;
3303 }
3304
3305 struct avdtp_service_capability *avdtp_get_codec(struct avdtp_remote_sep *sep)
3306 {
3307         return sep->codec;
3308 }
3309
3310 gboolean avdtp_get_delay_reporting(struct avdtp_remote_sep *sep)
3311 {
3312         return sep->delay_reporting;
3313 }
3314
3315 struct avdtp_stream *avdtp_get_stream(struct avdtp_remote_sep *sep)
3316 {
3317         return sep->stream;
3318 }
3319
3320 struct avdtp_service_capability *avdtp_service_cap_new(uint8_t category,
3321                                                         void *data, int length)
3322 {
3323         struct avdtp_service_capability *cap;
3324
3325         if (category < AVDTP_MEDIA_TRANSPORT || category > AVDTP_DELAY_REPORTING)
3326                 return NULL;
3327
3328         cap = g_malloc(sizeof(struct avdtp_service_capability) + length);
3329         cap->category = category;
3330         cap->length = length;
3331         memcpy(cap->data, data, length);
3332
3333         return cap;
3334 }
3335
3336 static gboolean process_discover(gpointer data)
3337 {
3338         struct avdtp *session = data;
3339
3340         finalize_discovery(session, 0);
3341
3342         return FALSE;
3343 }
3344
3345 int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb,
3346                         void *user_data)
3347 {
3348         int err;
3349
3350         if (session->discov_cb)
3351                 return -EBUSY;
3352
3353         if (session->seps) {
3354                 session->discov_cb = cb;
3355                 session->user_data = user_data;
3356                 g_idle_add(process_discover, session);
3357                 return 0;
3358         }
3359
3360         err = send_request(session, FALSE, NULL, AVDTP_DISCOVER, NULL, 0);
3361         if (err == 0) {
3362                 session->discov_cb = cb;
3363                 session->user_data = user_data;
3364         }
3365
3366         return err;
3367 }
3368
3369 gboolean avdtp_stream_remove_cb(struct avdtp *session,
3370                                 struct avdtp_stream *stream,
3371                                 unsigned int id)
3372 {
3373         GSList *l;
3374         struct stream_callback *cb;
3375
3376         if (!stream)
3377                 return FALSE;
3378
3379         for (cb = NULL, l = stream->callbacks; l != NULL; l = l->next) {
3380                 struct stream_callback *tmp = l->data;
3381                 if (tmp && tmp->id == id) {
3382                         cb = tmp;
3383                         break;
3384                 }
3385         }
3386
3387         if (!cb)
3388                 return FALSE;
3389
3390         stream->callbacks = g_slist_remove(stream->callbacks, cb);
3391         g_free(cb);
3392
3393         return TRUE;
3394 }
3395
3396 unsigned int avdtp_stream_add_cb(struct avdtp *session,
3397                                         struct avdtp_stream *stream,
3398                                         avdtp_stream_state_cb cb, void *data)
3399 {
3400         struct stream_callback *stream_cb;
3401         static unsigned int id = 0;
3402
3403         stream_cb = g_new(struct stream_callback, 1);
3404         stream_cb->cb = cb;
3405         stream_cb->user_data = data;
3406         stream_cb->id = ++id;
3407
3408         stream->callbacks = g_slist_append(stream->callbacks, stream_cb);
3409
3410         return stream_cb->id;
3411 }
3412
3413 int avdtp_get_configuration(struct avdtp *session, struct avdtp_stream *stream)
3414 {
3415         struct seid_req req;
3416
3417         if (session->state < AVDTP_SESSION_STATE_CONNECTED)
3418                 return -EINVAL;
3419
3420         memset(&req, 0, sizeof(req));
3421         req.acp_seid = stream->rseid;
3422
3423         return send_request(session, FALSE, stream, AVDTP_GET_CONFIGURATION,
3424                                                         &req, sizeof(req));
3425 }
3426
3427 static void copy_capabilities(gpointer data, gpointer user_data)
3428 {
3429         struct avdtp_service_capability *src_cap = data;
3430         struct avdtp_service_capability *dst_cap;
3431         GSList **l = user_data;
3432
3433         dst_cap = avdtp_service_cap_new(src_cap->category, src_cap->data,
3434                                         src_cap->length);
3435
3436         *l = g_slist_append(*l, dst_cap);
3437 }
3438
3439 int avdtp_set_configuration(struct avdtp *session,
3440                                 struct avdtp_remote_sep *rsep,
3441                                 struct avdtp_local_sep *lsep,
3442                                 GSList *caps,
3443                                 struct avdtp_stream **stream)
3444 {
3445         struct setconf_req *req;
3446         struct avdtp_stream *new_stream;
3447         unsigned char *ptr;
3448         int err, caps_len;
3449         struct avdtp_service_capability *cap;
3450         GSList *l;
3451
3452         if (session->state != AVDTP_SESSION_STATE_CONNECTED)
3453                 return -ENOTCONN;
3454
3455         if (!(lsep && rsep))
3456                 return -EINVAL;
3457
3458         DBG("%p: int_seid=%u, acp_seid=%u", session,
3459                         lsep->info.seid, rsep->seid);
3460
3461         new_stream = g_new0(struct avdtp_stream, 1);
3462         new_stream->session = session;
3463         new_stream->lsep = lsep;
3464         new_stream->rseid = rsep->seid;
3465
3466         if (rsep->delay_reporting && lsep->delay_reporting) {
3467                 struct avdtp_service_capability *delay_reporting;
3468
3469                 delay_reporting = avdtp_service_cap_new(AVDTP_DELAY_REPORTING,
3470                                                                 NULL, 0);
3471                 caps = g_slist_append(caps, delay_reporting);
3472                 new_stream->delay_reporting = TRUE;
3473         }
3474
3475         g_slist_foreach(caps, copy_capabilities, &new_stream->caps);
3476
3477         /* Calculate total size of request */
3478         for (l = caps, caps_len = 0; l != NULL; l = g_slist_next(l)) {
3479                 cap = l->data;
3480                 caps_len += cap->length + 2;
3481         }
3482
3483         req = g_malloc0(sizeof(struct setconf_req) + caps_len);
3484
3485         req->int_seid = lsep->info.seid;
3486         req->acp_seid = rsep->seid;
3487
3488         /* Copy the capabilities into the request */
3489         for (l = caps, ptr = req->caps; l != NULL; l = g_slist_next(l)) {
3490                 cap = l->data;
3491                 memcpy(ptr, cap, cap->length + 2);
3492                 ptr += cap->length + 2;
3493         }
3494
3495         err = send_request(session, FALSE, new_stream,
3496                                 AVDTP_SET_CONFIGURATION, req,
3497                                 sizeof(struct setconf_req) + caps_len);
3498         if (err < 0)
3499                 stream_free(new_stream);
3500         else {
3501                 lsep->info.inuse = 1;
3502                 lsep->stream = new_stream;
3503                 rsep->stream = new_stream;
3504                 session->streams = g_slist_append(session->streams, new_stream);
3505                 if (stream)
3506                         *stream = new_stream;
3507         }
3508
3509         g_free(req);
3510
3511         return err;
3512 }
3513
3514 int avdtp_reconfigure(struct avdtp *session, GSList *caps,
3515                         struct avdtp_stream *stream)
3516 {
3517         struct reconf_req *req;
3518         unsigned char *ptr;
3519         int caps_len, err;
3520         GSList *l;
3521         struct avdtp_service_capability *cap;
3522
3523         if (!g_slist_find(session->streams, stream))
3524                 return -EINVAL;
3525
3526         if (stream->lsep->state != AVDTP_STATE_OPEN)
3527                 return -EINVAL;
3528
3529         /* Calculate total size of request */
3530         for (l = caps, caps_len = 0; l != NULL; l = g_slist_next(l)) {
3531                 cap = l->data;
3532                 caps_len += cap->length + 2;
3533         }
3534
3535         req = g_malloc0(sizeof(struct reconf_req) + caps_len);
3536
3537         req->acp_seid = stream->rseid;
3538
3539         /* Copy the capabilities into the request */
3540         for (l = caps, ptr = req->caps; l != NULL; l = g_slist_next(l)) {
3541                 cap = l->data;
3542                 memcpy(ptr, cap, cap->length + 2);
3543                 ptr += cap->length + 2;
3544         }
3545
3546         err = send_request(session, FALSE, stream, AVDTP_RECONFIGURE, req,
3547                                                 sizeof(*req) + caps_len);
3548         g_free(req);
3549
3550         return err;
3551 }
3552
3553 int avdtp_open(struct avdtp *session, struct avdtp_stream *stream)
3554 {
3555         struct seid_req req;
3556
3557         if (!g_slist_find(session->streams, stream))
3558                 return -EINVAL;
3559
3560         if (stream->lsep->state > AVDTP_STATE_CONFIGURED)
3561                 return -EINVAL;
3562
3563         memset(&req, 0, sizeof(req));
3564         req.acp_seid = stream->rseid;
3565
3566         return send_request(session, FALSE, stream, AVDTP_OPEN,
3567                                                         &req, sizeof(req));
3568 }
3569
3570 int avdtp_start(struct avdtp *session, struct avdtp_stream *stream)
3571 {
3572         struct start_req req;
3573         int ret;
3574
3575         if (!g_slist_find(session->streams, stream))
3576                 return -EINVAL;
3577
3578         if (stream->lsep->state != AVDTP_STATE_OPEN)
3579                 return -EINVAL;
3580
3581         if (stream->close_int == TRUE) {
3582                 error("avdtp_start: rejecting start since close is initiated");
3583                 return -EINVAL;
3584         }
3585
3586         if (stream->starting == TRUE) {
3587                 DBG("stream already started");
3588                 return -EINVAL;
3589         }
3590
3591         memset(&req, 0, sizeof(req));
3592         req.first_seid.seid = stream->rseid;
3593
3594         ret = send_request(session, FALSE, stream, AVDTP_START,
3595                                                         &req, sizeof(req));
3596         if (ret == 0)
3597                 stream->starting = TRUE;
3598
3599         return ret;
3600 }
3601
3602 int avdtp_close(struct avdtp *session, struct avdtp_stream *stream,
3603                 gboolean immediate)
3604 {
3605         struct seid_req req;
3606         int ret;
3607
3608         if (!g_slist_find(session->streams, stream))
3609                 return -EINVAL;
3610
3611         if (stream->lsep->state < AVDTP_STATE_OPEN)
3612                 return -EINVAL;
3613
3614         if (stream->close_int == TRUE) {
3615                 error("avdtp_close: rejecting since close is already initiated");
3616                 return -EINVAL;
3617         }
3618
3619         if (immediate && session->req && stream == session->req->stream)
3620                 return avdtp_abort(session, stream);
3621
3622         memset(&req, 0, sizeof(req));
3623         req.acp_seid = stream->rseid;
3624
3625         ret = send_request(session, FALSE, stream, AVDTP_CLOSE,
3626                                                         &req, sizeof(req));
3627         if (ret == 0)
3628                 stream->close_int = TRUE;
3629
3630         return ret;
3631 }
3632
3633 int avdtp_suspend(struct avdtp *session, struct avdtp_stream *stream)
3634 {
3635         struct seid_req req;
3636
3637         if (!g_slist_find(session->streams, stream))
3638                 return -EINVAL;
3639
3640         if (stream->lsep->state <= AVDTP_STATE_OPEN || stream->close_int)
3641                 return -EINVAL;
3642
3643         memset(&req, 0, sizeof(req));
3644         req.acp_seid = stream->rseid;
3645
3646         return send_request(session, FALSE, stream, AVDTP_SUSPEND,
3647                                                         &req, sizeof(req));
3648 }
3649
3650 int avdtp_abort(struct avdtp *session, struct avdtp_stream *stream)
3651 {
3652         struct seid_req req;
3653         int ret;
3654
3655         if (!g_slist_find(session->streams, stream))
3656                 return -EINVAL;
3657
3658         if (stream->lsep->state == AVDTP_STATE_ABORTING)
3659                 return -EINVAL;
3660
3661         if (session->req && stream == session->req->stream)
3662                 return cancel_request(session, ECANCELED);
3663
3664         memset(&req, 0, sizeof(req));
3665         req.acp_seid = stream->rseid;
3666
3667         ret = send_request(session, TRUE, stream, AVDTP_ABORT,
3668                                                         &req, sizeof(req));
3669         if (ret == 0)
3670                 stream->abort_int = TRUE;
3671
3672         return ret;
3673 }
3674
3675 int avdtp_delay_report(struct avdtp *session, struct avdtp_stream *stream,
3676                                                         uint16_t delay)
3677 {
3678         struct delay_req req;
3679
3680         if (!g_slist_find(session->streams, stream))
3681                 return -EINVAL;
3682
3683         if (stream->lsep->state != AVDTP_STATE_CONFIGURED &&
3684                                 stream->lsep->state != AVDTP_STATE_STREAMING)
3685                 return -EINVAL;
3686
3687         if (!stream->delay_reporting || session->version < 0x0103 ||
3688                                         session->server->version < 0x0103)
3689                 return -EINVAL;
3690
3691         stream->delay = delay;
3692
3693         memset(&req, 0, sizeof(req));
3694         req.acp_seid = stream->rseid;
3695         req.delay = htons(delay);
3696
3697         return send_request(session, TRUE, stream, AVDTP_DELAY_REPORT,
3698                                                         &req, sizeof(req));
3699 }
3700
3701 struct avdtp_local_sep *avdtp_register_sep(const bdaddr_t *src, uint8_t type,
3702                                                 uint8_t media_type,
3703                                                 uint8_t codec_type,
3704                                                 gboolean delay_reporting,
3705                                                 struct avdtp_sep_ind *ind,
3706                                                 struct avdtp_sep_cfm *cfm,
3707                                                 void *user_data)
3708 {
3709         struct avdtp_server *server;
3710         struct avdtp_local_sep *sep;
3711
3712         server = find_server(servers, src);
3713         if (!server)
3714                 return NULL;
3715
3716         if (g_slist_length(server->seps) > MAX_SEID)
3717                 return NULL;
3718
3719         sep = g_new0(struct avdtp_local_sep, 1);
3720
3721         sep->state = AVDTP_STATE_IDLE;
3722         sep->info.seid = g_slist_length(server->seps) + 1;
3723         sep->info.type = type;
3724         sep->info.media_type = media_type;
3725         sep->codec = codec_type;
3726         sep->ind = ind;
3727         sep->cfm = cfm;
3728         sep->user_data = user_data;
3729         sep->server = server;
3730         sep->delay_reporting = TRUE;
3731
3732         DBG("SEP %p registered: type:%d codec:%d seid:%d", sep,
3733                         sep->info.type, sep->codec, sep->info.seid);
3734         server->seps = g_slist_append(server->seps, sep);
3735
3736         return sep;
3737 }
3738
3739 int avdtp_unregister_sep(struct avdtp_local_sep *sep)
3740 {
3741         struct avdtp_server *server;
3742
3743         if (!sep)
3744                 return -EINVAL;
3745
3746         server = sep->server;
3747         server->seps = g_slist_remove(server->seps, sep);
3748
3749         if (sep->stream)
3750                 release_stream(sep->stream, sep->stream->session);
3751
3752         DBG("SEP %p unregistered: type:%d codec:%d seid:%d", sep,
3753                         sep->info.type, sep->codec, sep->info.seid);
3754
3755         g_free(sep);
3756
3757         return 0;
3758 }
3759
3760 static GIOChannel *avdtp_server_socket(const bdaddr_t *src, gboolean master)
3761 {
3762         GError *err = NULL;
3763         GIOChannel *io;
3764
3765         io = bt_io_listen(BT_IO_L2CAP, NULL, avdtp_confirm_cb,
3766                                 NULL, NULL, &err,
3767                                 BT_IO_OPT_SOURCE_BDADDR, src,
3768                                 BT_IO_OPT_PSM, AVDTP_PSM,
3769                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
3770                                 BT_IO_OPT_MASTER, master,
3771                                 BT_IO_OPT_INVALID);
3772         if (!io) {
3773                 error("%s", err->message);
3774                 g_error_free(err);
3775         }
3776
3777         return io;
3778 }
3779
3780 const char *avdtp_strerror(struct avdtp_error *err)
3781 {
3782         if (err->category == AVDTP_ERRNO)
3783                 return strerror(err->err.posix_errno);
3784
3785         switch(err->err.error_code) {
3786         case AVDTP_BAD_HEADER_FORMAT:
3787                 return "Bad Header Format";
3788         case AVDTP_BAD_LENGTH:
3789                 return "Bad Packet Length";
3790         case AVDTP_BAD_ACP_SEID:
3791                 return "Bad Acceptor SEID";
3792         case AVDTP_SEP_IN_USE:
3793                 return "Stream End Point in Use";
3794         case AVDTP_SEP_NOT_IN_USE:
3795                 return "Stream End Point Not in Use";
3796         case AVDTP_BAD_SERV_CATEGORY:
3797                 return "Bad Service Category";
3798         case AVDTP_BAD_PAYLOAD_FORMAT:
3799                 return "Bad Payload format";
3800         case AVDTP_NOT_SUPPORTED_COMMAND:
3801                 return "Command Not Supported";
3802         case AVDTP_INVALID_CAPABILITIES:
3803                 return "Invalid Capabilities";
3804         case AVDTP_BAD_RECOVERY_TYPE:
3805                 return "Bad Recovery Type";
3806         case AVDTP_BAD_MEDIA_TRANSPORT_FORMAT:
3807                 return "Bad Media Transport Format";
3808         case AVDTP_BAD_RECOVERY_FORMAT:
3809                 return "Bad Recovery Format";
3810         case AVDTP_BAD_ROHC_FORMAT:
3811                 return "Bad Header Compression Format";
3812         case AVDTP_BAD_CP_FORMAT:
3813                 return "Bad Content Protetion Format";
3814         case AVDTP_BAD_MULTIPLEXING_FORMAT:
3815                 return "Bad Multiplexing Format";
3816         case AVDTP_UNSUPPORTED_CONFIGURATION:
3817                 return "Configuration not supported";
3818         case AVDTP_BAD_STATE:
3819                 return "Bad State";
3820         default:
3821                 return "Unknow error";
3822         }
3823 }
3824
3825 avdtp_state_t avdtp_sep_get_state(struct avdtp_local_sep *sep)
3826 {
3827         return sep->state;
3828 }
3829
3830 void avdtp_get_peers(struct avdtp *session, bdaddr_t *src, bdaddr_t *dst)
3831 {
3832         if (src)
3833                 bacpy(src, &session->server->src);
3834         if (dst)
3835                 bacpy(dst, &session->dst);
3836 }
3837
3838 int avdtp_init(const bdaddr_t *src, GKeyFile *config, uint16_t *version)
3839 {
3840         GError *err = NULL;
3841         gboolean tmp, master = TRUE;
3842         struct avdtp_server *server;
3843         uint16_t ver = 0x0102;
3844
3845         if (!config)
3846                 goto proceed;
3847
3848         tmp = g_key_file_get_boolean(config, "General",
3849                         "Master", &err);
3850         if (err) {
3851                 DBG("audio.conf: %s", err->message);
3852                 g_clear_error(&err);
3853         } else
3854                 master = tmp;
3855
3856         tmp = g_key_file_get_boolean(config, "General", "AutoConnect",
3857                         &err);
3858         if (err)
3859                 g_clear_error(&err);
3860         else
3861                 auto_connect = tmp;
3862
3863         if (g_key_file_get_boolean(config, "A2DP", "DelayReporting", NULL))
3864                 ver = 0x0103;
3865
3866 proceed:
3867         server = g_new0(struct avdtp_server, 1);
3868         if (!server)
3869                 return -ENOMEM;
3870
3871         server->version = ver;
3872
3873         if (version)
3874                 *version = server->version;
3875
3876         server->io = avdtp_server_socket(src, master);
3877         if (!server->io) {
3878                 g_free(server);
3879                 return -1;
3880         }
3881
3882         bacpy(&server->src, src);
3883
3884         servers = g_slist_append(servers, server);
3885
3886         return 0;
3887 }
3888
3889 void avdtp_exit(const bdaddr_t *src)
3890 {
3891         struct avdtp_server *server;
3892         GSList *l;
3893
3894         server = find_server(servers, src);
3895         if (!server)
3896                 return;
3897
3898         l = server->sessions;
3899         while (l) {
3900                 struct avdtp *session = l->data;
3901
3902                 l = l->next;
3903                 /* value of l pointer should be updated before invoking
3904                  * connection_lost since it internally uses avdtp_unref
3905                  * which operates on server->session list as well
3906                  */
3907                 connection_lost(session, -ECONNABORTED);
3908         }
3909
3910         servers = g_slist_remove(servers, server);
3911
3912         g_io_channel_shutdown(server->io, TRUE, NULL);
3913         g_io_channel_unref(server->io);
3914         g_free(server);
3915 }
3916
3917 gboolean avdtp_has_stream(struct avdtp *session, struct avdtp_stream *stream)
3918 {
3919         return g_slist_find(session->streams, stream) ? TRUE : FALSE;
3920 }
3921
3922 void avdtp_set_auto_disconnect(struct avdtp *session, gboolean auto_dc)
3923 {
3924         session->auto_dc = auto_dc;
3925 }
3926
3927 gboolean avdtp_stream_setup_active(struct avdtp *session)
3928 {
3929         return session->stream_setup;
3930 }
3931
3932 void avdtp_set_device_disconnect(struct avdtp *session, gboolean dev_dc)
3933 {
3934         session->device_disconnect = dev_dc;
3935 }
3936
3937 unsigned int avdtp_add_state_cb(avdtp_session_state_cb cb, void *user_data)
3938 {
3939         struct avdtp_state_callback *state_cb;
3940         static unsigned int id = 0;
3941
3942         state_cb = g_new(struct avdtp_state_callback, 1);
3943         state_cb->cb = cb;
3944         state_cb->user_data = user_data;
3945         state_cb->id = ++id;
3946
3947         avdtp_callbacks = g_slist_append(avdtp_callbacks, state_cb);
3948
3949         return state_cb->id;
3950 }
3951
3952 gboolean avdtp_remove_state_cb(unsigned int id)
3953 {
3954         GSList *l;
3955
3956         for (l = avdtp_callbacks; l != NULL; l = l->next) {
3957                 struct avdtp_state_callback *cb = l->data;
3958                 if (cb && cb->id == id) {
3959                         avdtp_callbacks = g_slist_remove(avdtp_callbacks, cb);
3960                         g_free(cb);
3961                         return TRUE;
3962                 }
3963         }
3964
3965         return FALSE;
3966 }