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