tools/avinfo.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2006-2010  Nokia Corporation
   6  *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <ctype.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <getopt.h>
  37 #include <stdint.h>
  38 #include <sys/param.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/socket.h>
  41
  42 #include <bluetooth/bluetooth.h>
  43 #include <bluetooth/hci.h>
  44 #include <bluetooth/hci_lib.h>
  45 #include <bluetooth/l2cap.h>
  46
  47 #define AVDTP_PSM                       25
  48
  49 /* Commands */
  50 #define AVDTP_DISCOVER                  0x01
  51 #define AVDTP_GET_CAPABILITIES          0x02
  52
  53 #define AVDTP_PKT_TYPE_SINGLE           0x00
  54
  55 #define AVDTP_MSG_TYPE_COMMAND          0x00
  56
  57 /* SEP capability categories */
  58 #define AVDTP_MEDIA_TRANSPORT           0x01
  59 #define AVDTP_REPORTING                 0x02
  60 #define AVDTP_RECOVERY                  0x03
  61 #define AVDTP_CONTENT_PROTECTION        0x04
  62 #define AVDTP_HEADER_COMPRESSION        0x05
  63 #define AVDTP_MULTIPLEXING              0x06
  64 #define AVDTP_MEDIA_CODEC               0x07
  65
  66 /* SEP types definitions */
  67 #define AVDTP_SEP_TYPE_SOURCE           0x00
  68 #define AVDTP_SEP_TYPE_SINK             0x01
  69
  70 /* Media types definitions */
  71 #define AVDTP_MEDIA_TYPE_AUDIO          0x00
  72 #define AVDTP_MEDIA_TYPE_VIDEO          0x01
  73 #define AVDTP_MEDIA_TYPE_MULTIMEDIA     0x02
  74
  75 #define A2DP_CODEC_SBC                  0x00
  76 #define A2DP_CODEC_MPEG12               0x01
  77 #define A2DP_CODEC_MPEG24               0x02
  78 #define A2DP_CODEC_ATRAC                0x03
  79
  80 #define SBC_SAMPLING_FREQ_16000         (1 << 3)
  81 #define SBC_SAMPLING_FREQ_32000         (1 << 2)
  82 #define SBC_SAMPLING_FREQ_44100         (1 << 1)
  83 #define SBC_SAMPLING_FREQ_48000         (1 << 0)
  84
  85 #define SBC_CHANNEL_MODE_MONO           (1 << 3)
  86 #define SBC_CHANNEL_MODE_DUAL_CHANNEL   (1 << 2)
  87 #define SBC_CHANNEL_MODE_STEREO         (1 << 1)
  88 #define SBC_CHANNEL_MODE_JOINT_STEREO   (1 << 0)
  89
  90 #define SBC_BLOCK_LENGTH_4              (1 << 3)
  91 #define SBC_BLOCK_LENGTH_8              (1 << 2)
  92 #define SBC_BLOCK_LENGTH_12             (1 << 1)
  93 #define SBC_BLOCK_LENGTH_16             (1 << 0)
  94
  95 #define SBC_SUBBANDS_4                  (1 << 1)
  96 #define SBC_SUBBANDS_8                  (1 << 0)
  97
  98 #define SBC_ALLOCATION_SNR              (1 << 1)
  99 #define SBC_ALLOCATION_LOUDNESS         (1 << 0)
 100
 101 #define MPEG_CHANNEL_MODE_MONO          (1 << 3)
 102 #define MPEG_CHANNEL_MODE_DUAL_CHANNEL  (1 << 2)
 103 #define MPEG_CHANNEL_MODE_STEREO        (1 << 1)
 104 #define MPEG_CHANNEL_MODE_JOINT_STEREO  (1 << 0)
 105
 106 #define MPEG_LAYER_MP1                  (1 << 2)
 107 #define MPEG_LAYER_MP2                  (1 << 1)
 108 #define MPEG_LAYER_MP3                  (1 << 0)
 109
 110 #define MPEG_SAMPLING_FREQ_16000        (1 << 5)
 111 #define MPEG_SAMPLING_FREQ_22050        (1 << 4)
 112 #define MPEG_SAMPLING_FREQ_24000        (1 << 3)
 113 #define MPEG_SAMPLING_FREQ_32000        (1 << 2)
 114 #define MPEG_SAMPLING_FREQ_44100        (1 << 1)
 115 #define MPEG_SAMPLING_FREQ_48000        (1 << 0)
 116
 117 #define MPEG_BIT_RATE_VBR               0x8000
 118 #define MPEG_BIT_RATE_320000            0x4000
 119 #define MPEG_BIT_RATE_256000            0x2000
 120 #define MPEG_BIT_RATE_224000            0x1000
 121 #define MPEG_BIT_RATE_192000            0x0800
 122 #define MPEG_BIT_RATE_160000            0x0400
 123 #define MPEG_BIT_RATE_128000            0x0200
 124 #define MPEG_BIT_RATE_112000            0x0100
 125 #define MPEG_BIT_RATE_96000             0x0080
 126 #define MPEG_BIT_RATE_80000             0x0040
 127 #define MPEG_BIT_RATE_64000             0x0020
 128 #define MPEG_BIT_RATE_56000             0x0010
 129 #define MPEG_BIT_RATE_48000             0x0008
 130 #define MPEG_BIT_RATE_40000             0x0004
 131 #define MPEG_BIT_RATE_32000             0x0002
 132 #define MPEG_BIT_RATE_FREE              0x0001
 133
 134 struct avdtp_service_capability {
 135         uint8_t category;
 136         uint8_t length;
 137         uint8_t data[0];
 138 } __attribute__ ((packed));
 139
 140 #if __BYTE_ORDER == __LITTLE_ENDIAN
 141
 142 struct avdtp_header {
 143         uint8_t message_type:2;
 144         uint8_t packet_type:2;
 145         uint8_t transaction:4;
 146         uint8_t signal_id:6;
 147         uint8_t rfa0:2;
 148 } __attribute__ ((packed));
 149
 150 struct seid_info {
 151         uint8_t rfa0:1;
 152         uint8_t inuse:1;
 153         uint8_t seid:6;
 154         uint8_t rfa2:3;
 155         uint8_t type:1;
 156         uint8_t media_type:4;
 157 } __attribute__ ((packed));
 158
 159 struct seid_req {
 160         struct avdtp_header header;
 161         uint8_t rfa0:2;
 162         uint8_t acp_seid:6;
 163 } __attribute__ ((packed));
 164
 165 struct avdtp_media_codec_capability {
 166         uint8_t rfa0:4;
 167         uint8_t media_type:4;
 168         uint8_t media_codec_type;
 169         uint8_t data[0];
 170 } __attribute__ ((packed));
 171
 172 struct sbc_codec_cap {
 173         struct avdtp_media_codec_capability cap;
 174         uint8_t channel_mode:4;
 175         uint8_t frequency:4;
 176         uint8_t allocation_method:2;
 177         uint8_t subbands:2;
 178         uint8_t block_length:4;
 179         uint8_t min_bitpool;
 180         uint8_t max_bitpool;
 181 } __attribute__ ((packed));
 182
 183 struct mpeg_codec_cap {
 184         struct avdtp_media_codec_capability cap;
 185         uint8_t channel_mode:4;
 186         uint8_t crc:1;
 187         uint8_t layer:3;
 188         uint8_t frequency:6;
 189         uint8_t mpf:1;
 190         uint8_t rfa:1;
 191         uint16_t bitrate;
 192 } __attribute__ ((packed));
 193
 194 #elif __BYTE_ORDER == __BIG_ENDIAN
 195
 196 struct avdtp_header {
 197         uint8_t transaction:4;
 198         uint8_t packet_type:2;
 199         uint8_t message_type:2;
 200         uint8_t rfa0:2;
 201         uint8_t signal_id:6;
 202 } __attribute__ ((packed));
 203
 204 struct seid_info {
 205         uint8_t seid:6;
 206         uint8_t inuse:1;
 207         uint8_t rfa0:1;
 208         uint8_t media_type:4;
 209         uint8_t type:1;
 210         uint8_t rfa2:3;
 211 } __attribute__ ((packed));
 212
 213 struct seid_req {
 214         struct avdtp_header header;
 215         uint8_t acp_seid:6;
 216         uint8_t rfa0:2;
 217 } __attribute__ ((packed));
 218
 219 struct avdtp_media_codec_capability {
 220         uint8_t media_type:4;
 221         uint8_t rfa0:4;
 222         uint8_t media_codec_type;
 223         uint8_t data[0];
 224 } __attribute__ ((packed));
 225
 226 struct sbc_codec_cap {
 227         struct avdtp_media_codec_capability cap;
 228         uint8_t frequency:4;
 229         uint8_t channel_mode:4;
 230         uint8_t block_length:4;
 231         uint8_t subbands:2;
 232         uint8_t allocation_method:2;
 233         uint8_t min_bitpool;
 234         uint8_t max_bitpool;
 235 } __attribute__ ((packed));
 236
 237 struct mpeg_codec_cap {
 238         struct avdtp_media_codec_capability cap;
 239         uint8_t layer:3;
 240         uint8_t crc:1;
 241         uint8_t channel_mode:4;
 242         uint8_t rfa:1;
 243         uint8_t mpf:1;
 244         uint8_t frequency:6;
 245         uint16_t bitrate;
 246 } __attribute__ ((packed));
 247
 248 #else
 249 #error "Unknown byte order"
 250 #endif
 251
 252 struct discover_resp {
 253         struct avdtp_header header;
 254         struct seid_info seps[0];
 255 } __attribute__ ((packed));
 256
 257 struct getcap_resp {
 258         struct avdtp_header header;
 259         uint8_t caps[0];
 260 } __attribute__ ((packed));
 261
 262
 263 static void print_mpeg12(struct mpeg_codec_cap *mpeg)
 264 {
 265         printf("\tMedia Codec: MPEG12\n\t\tChannel Modes: ");
 266
 267         if (mpeg->channel_mode & MPEG_CHANNEL_MODE_MONO)
 268                 printf("Mono ");
 269         if (mpeg->channel_mode & MPEG_CHANNEL_MODE_DUAL_CHANNEL)
 270                 printf("DualChannel ");
 271         if (mpeg->channel_mode & MPEG_CHANNEL_MODE_STEREO)
 272                 printf("Stereo ");
 273         if (mpeg->channel_mode & MPEG_CHANNEL_MODE_JOINT_STEREO)
 274                 printf("JointStereo");
 275
 276         printf("\n\t\tFrequencies: ");
 277         if (mpeg->frequency & MPEG_SAMPLING_FREQ_16000)
 278                 printf("16Khz ");
 279         if (mpeg->frequency & MPEG_SAMPLING_FREQ_22050)
 280                 printf("22.05Khz ");
 281         if (mpeg->frequency & MPEG_SAMPLING_FREQ_24000)
 282                 printf("24Khz ");
 283         if (mpeg->frequency & MPEG_SAMPLING_FREQ_32000)
 284                 printf("32Khz ");
 285         if (mpeg->frequency & MPEG_SAMPLING_FREQ_44100)
 286                 printf("44.1Khz ");
 287         if (mpeg->frequency & MPEG_SAMPLING_FREQ_48000)
 288                 printf("48Khz ");
 289
 290         printf("\n\t\tCRC: %s", mpeg->crc ? "Yes" : "No");
 291
 292         printf("\n\t\tLayer: ");
 293         if (mpeg->layer & MPEG_LAYER_MP1)
 294                 printf("1 ");
 295         if (mpeg->layer & MPEG_LAYER_MP2)
 296                 printf("2 ");
 297         if (mpeg->layer & MPEG_LAYER_MP3)
 298                 printf("3 ");
 299
 300         printf("\n\t\tBit Rate: ");
 301         if (mpeg->bitrate & MPEG_BIT_RATE_FREE)
 302                 printf("Free format");
 303         else {
 304                 if (mpeg->bitrate & MPEG_BIT_RATE_32000)
 305                         printf("32kbps ");
 306                 if (mpeg->bitrate & MPEG_BIT_RATE_40000)
 307                         printf("40kbps ");
 308                 if (mpeg->bitrate & MPEG_BIT_RATE_48000)
 309                         printf("48kbps ");
 310                 if (mpeg->bitrate & MPEG_BIT_RATE_56000)
 311                         printf("56kbps ");
 312                 if (mpeg->bitrate & MPEG_BIT_RATE_64000)
 313                         printf("64kbps ");
 314                 if (mpeg->bitrate & MPEG_BIT_RATE_80000)
 315                         printf("80kbps ");
 316                 if (mpeg->bitrate & MPEG_BIT_RATE_96000)
 317                         printf("96kbps ");
 318                 if (mpeg->bitrate & MPEG_BIT_RATE_112000)
 319                         printf("112kbps ");
 320                 if (mpeg->bitrate & MPEG_BIT_RATE_128000)
 321                         printf("128kbps ");
 322                 if (mpeg->bitrate & MPEG_BIT_RATE_160000)
 323                         printf("160kbps ");
 324                 if (mpeg->bitrate & MPEG_BIT_RATE_192000)
 325                         printf("192kbps ");
 326                 if (mpeg->bitrate & MPEG_BIT_RATE_224000)
 327                         printf("224kbps ");
 328                 if (mpeg->bitrate & MPEG_BIT_RATE_256000)
 329                         printf("256kbps ");
 330                 if (mpeg->bitrate & MPEG_BIT_RATE_320000)
 331                         printf("320kbps ");
 332         }
 333
 334         printf("\n\t\tVBR: %s", mpeg->bitrate & MPEG_BIT_RATE_VBR ? "Yes" :
 335                 "No");
 336
 337         printf("\n\t\tPayload Format: ");
 338         if (mpeg->mpf)
 339                 printf("RFC-2250 RFC-3119\n");
 340         else
 341                 printf("RFC-2250\n");
 342 }
 343
 344 static void print_sbc(struct sbc_codec_cap *sbc)
 345 {
 346         printf("\tMedia Codec: SBC\n\t\tChannel Modes: ");
 347
 348         if (sbc->channel_mode & SBC_CHANNEL_MODE_MONO)
 349                 printf("Mono ");
 350         if (sbc->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
 351                 printf("DualChannel ");
 352         if (sbc->channel_mode & SBC_CHANNEL_MODE_STEREO)
 353                 printf("Stereo ");
 354         if (sbc->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
 355                 printf("JointStereo");
 356
 357         printf("\n\t\tFrequencies: ");
 358         if (sbc->frequency & SBC_SAMPLING_FREQ_16000)
 359                 printf("16Khz ");
 360         if (sbc->frequency & SBC_SAMPLING_FREQ_32000)
 361                 printf("32Khz ");
 362         if (sbc->frequency & SBC_SAMPLING_FREQ_44100)
 363                 printf("44.1Khz ");
 364         if (sbc->frequency & SBC_SAMPLING_FREQ_48000)
 365                 printf("48Khz ");
 366
 367         printf("\n\t\tSubbands: ");
 368         if (sbc->allocation_method & SBC_SUBBANDS_4)
 369                 printf("4 ");
 370         if (sbc->allocation_method & SBC_SUBBANDS_8)
 371                 printf("8");
 372
 373         printf("\n\t\tBlocks: ");
 374         if (sbc->block_length & SBC_BLOCK_LENGTH_4)
 375                 printf("4 ");
 376         if (sbc->block_length & SBC_BLOCK_LENGTH_8)
 377                 printf("8 ");
 378         if (sbc->block_length & SBC_BLOCK_LENGTH_12)
 379                 printf("12 ");
 380         if (sbc->block_length & SBC_BLOCK_LENGTH_16)
 381                 printf("16 ");
 382
 383         printf("\n\t\tBitpool Range: %d-%d\n",
 384                                 sbc->min_bitpool, sbc->max_bitpool);
 385 }
 386
 387 static void print_media_codec(struct avdtp_media_codec_capability *cap)
 388 {
 389         switch (cap->media_codec_type) {
 390         case A2DP_CODEC_SBC:
 391                 print_sbc((void *) cap);
 392                 break;
 393         case A2DP_CODEC_MPEG12:
 394                 print_mpeg12((void *) cap);
 395                 break;
 396         default:
 397                 printf("\tMedia Codec: Unknown\n");
 398         }
 399 }
 400
 401 static void print_caps(void *data, int size)
 402 {
 403         int processed;
 404
 405         for (processed = 0; processed + 2 < size;) {
 406                 struct avdtp_service_capability *cap;
 407
 408                 cap = data;
 409
 410                 if (processed + 2 + cap->length > size) {
 411                         printf("Invalid capability data in getcap resp\n");
 412                         break;
 413                 }
 414
 415                 switch (cap->category) {
 416                 case AVDTP_MEDIA_TRANSPORT:
 417                 case AVDTP_REPORTING:
 418                 case AVDTP_RECOVERY:
 419                 case AVDTP_CONTENT_PROTECTION:
 420                 case AVDTP_MULTIPLEXING:
 421                         /* FIXME: Add proper functions */
 422                         break;
 423                 case AVDTP_MEDIA_CODEC:
 424                         print_media_codec((void *) cap->data);
 425                         break;
 426                 }
 427
 428                 processed += 2 + cap->length;
 429                 data += 2 + cap->length;
 430         }
 431 }
 432
 433 static void init_request(struct avdtp_header *header, int request_id)
 434 {
 435         static int transaction = 0;
 436
 437         header->packet_type = AVDTP_PKT_TYPE_SINGLE;
 438         header->message_type = AVDTP_MSG_TYPE_COMMAND;
 439         header->transaction = transaction;
 440         header->signal_id = request_id;
 441
 442         /* clear rfa bits */
 443         header->rfa0 = 0;
 444
 445         transaction = (transaction + 1) % 16;
 446 }
 447
 448 static ssize_t avdtp_send(int sk, void *data, int len)
 449 {
 450         ssize_t ret;
 451
 452         ret = send(sk, data, len, 0);
 453
 454         if (ret < 0)
 455                 ret = -errno;
 456         else if (ret != len)
 457                 ret = -EIO;
 458
 459         if (ret < 0) {
 460                 printf("Unable to send message: %s (%zd)\n",
 461                                                 strerror(-ret), -ret);
 462                 return ret;
 463         }
 464
 465         return ret;
 466 }
 467
 468 static ssize_t avdtp_receive(int sk, void *data, int len)
 469 {
 470         ssize_t ret;
 471
 472         ret = recv(sk, data, len, 0);
 473
 474         if (ret < 0) {
 475                 printf("Unable to receive message: %s (%d)\n",
 476                                                 strerror(errno), errno);
 477                 return -errno;
 478         }
 479
 480         return ret;
 481 }
 482
 483 static ssize_t avdtp_get_caps(int sk, int seid)
 484 {
 485         struct seid_req req;
 486         char buffer[1024];
 487         struct getcap_resp *caps = (void *) buffer;
 488         ssize_t ret;
 489
 490         memset(&req, 0, sizeof(req));
 491         init_request(&req.header, AVDTP_GET_CAPABILITIES);
 492         req.acp_seid = seid;
 493
 494         ret = avdtp_send(sk, &req, sizeof(req));
 495         if (ret < 0)
 496                 return ret;
 497
 498         memset(&buffer, 0, sizeof(buffer));
 499         ret = avdtp_receive(sk, caps, sizeof(buffer));
 500         if (ret < 0)
 501                 return ret;
 502
 503         if ((size_t) ret < (sizeof(struct getcap_resp) + 4 +
 504                         sizeof(struct avdtp_media_codec_capability))) {
 505                 printf("Invalid capabilities\n");
 506                 return -1;
 507         }
 508
 509         print_caps(caps, ret);
 510
 511         return 0;
 512 }
 513
 514 static ssize_t avdtp_discover(int sk)
 515 {
 516         struct avdtp_header req;
 517         char buffer[256];
 518         struct discover_resp *discover = (void *) buffer;
 519         int seps, i;
 520         ssize_t ret;
 521
 522         memset(&req, 0, sizeof(req));
 523         init_request(&req, AVDTP_DISCOVER);
 524
 525         ret = avdtp_send(sk, &req, sizeof(req));
 526         if (ret < 0)
 527                 return ret;
 528
 529         memset(&buffer, 0, sizeof(buffer));
 530         ret = avdtp_receive(sk, discover, sizeof(buffer));
 531         if (ret < 0)
 532                 return ret;
 533
 534         seps = (ret - sizeof(struct avdtp_header)) / sizeof(struct seid_info);
 535         for (i = 0; i < seps; i++) {
 536                 const char *type, *media;
 537
 538                 switch (discover->seps[i].type) {
 539                 case AVDTP_SEP_TYPE_SOURCE:
 540                         type = "Source";
 541                         break;
 542                 case AVDTP_SEP_TYPE_SINK:
 543                         type = "Sink";
 544                         break;
 545                 default:
 546                         type = "Invalid";
 547                 }
 548
 549                 switch (discover->seps[i].media_type) {
 550                 case AVDTP_MEDIA_TYPE_AUDIO:
 551                         media = "Audio";
 552                         break;
 553                 case AVDTP_MEDIA_TYPE_VIDEO:
 554                         media = "Video";
 555                         break;
 556                 case AVDTP_MEDIA_TYPE_MULTIMEDIA:
 557                         media = "Multimedia";
 558                         break;
 559                 default:
 560                         media = "Invalid";
 561                 }
 562
 563                 printf("Stream End-Point #%d: %s %s %s\n",
 564                                         discover->seps[i].seid, media, type,
 565                                         discover->seps[i].inuse ? "*" : "");
 566
 567                 avdtp_get_caps(sk, discover->seps[i].seid);
 568         }
 569
 570         return 0;
 571 }
 572
 573 static int l2cap_connect(bdaddr_t *src, bdaddr_t *dst)
 574 {
 575         struct sockaddr_l2 l2a;
 576         int sk;
 577
 578         memset(&l2a, 0, sizeof(l2a));
 579         l2a.l2_family = AF_BLUETOOTH;
 580         bacpy(&l2a.l2_bdaddr, src);
 581
 582         sk = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
 583         if (sk < 0) {
 584                 printf("Cannot create L2CAP socket. %s(%d)\n", strerror(errno),
 585                                 errno);
 586                 return -errno;
 587         }
 588
 589         if (bind(sk, (struct sockaddr *) &l2a, sizeof(l2a)) < 0) {
 590                 printf("Bind failed. %s (%d)\n", strerror(errno), errno);
 591                 return -errno;
 592         }
 593
 594         memset(&l2a, 0, sizeof(l2a));
 595         l2a.l2_family = AF_BLUETOOTH;
 596         bacpy(&l2a.l2_bdaddr, dst);
 597         l2a.l2_psm = htobs(AVDTP_PSM);
 598
 599         if (connect(sk, (struct sockaddr *) &l2a, sizeof(l2a)) < 0) {
 600                 printf("Connect failed. %s(%d)\n", strerror(errno), errno);
 601                 return -errno;
 602         }
 603
 604         return sk;
 605 }
 606
 607 static void usage(void)
 608 {
 609         printf("avinfo - Audio/Video Info Tool ver %s\n", VERSION);
 610         printf("Usage:\n"
 611                 "\tavinfo [options] <remote address>\n");
 612         printf("Options:\n"
 613                 "\t-h\t\tDisplay help\n"
 614                 "\t-i\t\tSpecify source interface\n");
 615 }
 616
 617 static struct option main_options[] = {
 618         { "help",       0, 0, 'h' },
 619         { "device",     1, 0, 'i' },
 620         { 0, 0, 0, 0 }
 621 };
 622
 623 int main(int argc, char *argv[])
 624 {
 625         bdaddr_t src, dst;
 626         int opt, sk, dev_id;
 627
 628         if (argc < 2) {
 629                 usage();
 630                 exit(0);
 631         }
 632
 633         bacpy(&src, BDADDR_ANY);
 634         dev_id = hci_get_route(&src);
 635         if ((dev_id < 0) || (hci_devba(dev_id, &src) < 0)) {
 636                 printf("Cannot find any local adapter\n");
 637                 exit(-1);
 638         }
 639
 640         while ((opt = getopt_long(argc, argv, "+i:h", main_options, NULL)) != -1) {
 641                 switch (opt) {
 642                 case 'i':
 643                         if (!strncmp(optarg, "hci", 3))
 644                                 hci_devba(atoi(optarg + 3), &src);
 645                         else
 646                                 str2ba(optarg, &src);
 647                         break;
 648
 649                 case 'h':
 650                 default:
 651                         usage();
 652                         exit(0);
 653                 }
 654         }
 655
 656         printf("Connecting ... \n");
 657
 658         if (bachk(argv[optind]) < 0) {
 659                 printf("Invalid argument\n");
 660                 exit(1);
 661         }
 662
 663         str2ba(argv[optind], &dst);
 664         sk = l2cap_connect(&src, &dst);
 665         if (sk < 0)
 666                 exit(1);
 667
 668         if (avdtp_discover(sk) < 0)
 669                 exit(1);
 670
 671         return 0;
 672 }