tools/l2test.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2000-2001  Qualcomm Incorporated
   6  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdbool.h>
  32 #include <errno.h>
  33 #include <ctype.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37 #include <getopt.h>
  38 #include <syslog.h>
  39 #include <signal.h>
  40 #include <sys/time.h>
  41 #include <poll.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/socket.h>
  44
  45 #include "lib/bluetooth.h"
  46 #include "lib/hci.h"
  47 #include "lib/hci_lib.h"
  48 #include "lib/l2cap.h"
  49
  50 #include "src/shared/util.h"
  51
  52 #define NIBBLE_TO_ASCII(c)  ((c) < 0x0a ? (c) + 0x30 : (c) + 0x57)
  53
  54 #define BREDR_DEFAULT_PSM       0x1011
  55 #define LE_DEFAULT_PSM          0x0080
  56
  57 /* Test modes */
  58 enum {
  59         SEND,
  60         RECV,
  61         RECONNECT,
  62         MULTY,
  63         DUMP,
  64         CONNECT,
  65         CRECV,
  66         LSEND,
  67         SENDDUMP,
  68         LSENDDUMP,
  69         LSENDRECV,
  70         CSENDRECV,
  71         INFOREQ,
  72 #ifdef __TIZEN_PATCH__
  73         CONFIGREQ,
  74 #endif
  75         PAIRING,
  76 };
  77
  78 #ifdef __TIZEN_PATCH__
  79 #define L2CAP_DEFAULT_RETRANS_TO        2000    /* 2 seconds */
  80 #define L2CAP_DEFAULT_MONITOR_TO        12000   /* 12 seconds */
  81 #endif
  82
  83 static unsigned char *buf;
  84
  85 /* Default mtu */
  86 static int imtu = 672;
  87 static int omtu = 0;
  88
  89 /* Default FCS option */
  90 static int fcs = 0x01;
  91
  92 /* Default Transmission Window */
  93 static int txwin_size = 63;
  94
  95 /* Default Max Transmission */
  96 static int max_transmit = 3;
  97
  98 /* Default data size */
  99 static long data_size = -1;
 100 static long buffer_size = 2048;
 101
 102 /* Default addr and psm and cid */
 103 static bdaddr_t bdaddr;
 104 static unsigned short psm = 0;
 105 static unsigned short cid = 0;
 106 #ifdef __TIZEN_PATCH__
 107 static uint16_t dcid = 0x0000;
 108 #endif
 109
 110 /* Default number of frames to send (-1 = infinite) */
 111 static int num_frames = -1;
 112
 113 /* Default number of consecutive frames before the delay */
 114 static int count = 1;
 115
 116 /* Default delay after sending count number of frames */
 117 static unsigned long send_delay = 0;
 118
 119 /* Default delay before receiving */
 120 static unsigned long recv_delay = 0;
 121
 122 /* Default delay before disconnecting */
 123 static unsigned long disc_delay = 0;
 124
 125 /* Initial sequence value when sending frames */
 126 static int seq_start = 0;
 127
 128 static const char *filename = NULL;
 129
 130 static int rfcmode = 0;
 131 static int master = 0;
 132 static int auth = 0;
 133 static int encr = 0;
 134 static int secure = 0;
 135 static int socktype = SOCK_SEQPACKET;
 136 static int linger = 0;
 137 static int reliable = 0;
 138 static int timestamp = 0;
 139 static int defer_setup = 0;
 140 static int priority = -1;
 141 static int rcvbuf = 0;
 142 static int chan_policy = -1;
 143 static int bdaddr_type = 0;
 144
 145 struct lookup_table {
 146         const char *name;
 147         int flag;
 148 };
 149
 150 static struct lookup_table l2cap_modes[] = {
 151         { "basic",      L2CAP_MODE_BASIC        },
 152         /* Not implemented
 153         { "flowctl",    L2CAP_MODE_FLOWCTL      },
 154         { "retrans",    L2CAP_MODE_RETRANS      },
 155         */
 156         { "ertm",       L2CAP_MODE_ERTM         },
 157         { "streaming",  L2CAP_MODE_STREAMING    },
 158         { 0 }
 159 };
 160
 161 static struct lookup_table chan_policies[] = {
 162         { "bredr",      BT_CHANNEL_POLICY_BREDR_ONLY            },
 163         { "bredr_pref", BT_CHANNEL_POLICY_BREDR_PREFERRED       },
 164         { "amp_pref",   BT_CHANNEL_POLICY_AMP_PREFERRED         },
 165         { NULL,         0                                       },
 166 };
 167
 168 static struct lookup_table bdaddr_types[] = {
 169         { "bredr",      BDADDR_BREDR            },
 170         { "le_public",  BDADDR_LE_PUBLIC        },
 171         { "le_random",  BDADDR_LE_RANDOM        },
 172         { NULL,         0                       },
 173 };
 174
 175 static int get_lookup_flag(struct lookup_table *table, char *name)
 176 {
 177         int i;
 178
 179         for (i = 0; table[i].name; i++)
 180                 if (!strcasecmp(table[i].name, name))
 181                         return table[i].flag;
 182
 183         return -1;
 184 }
 185
 186 static const char *get_lookup_str(struct lookup_table *table, int flag)
 187 {
 188         int i;
 189
 190         for (i = 0; table[i].name; i++)
 191                 if (table[i].flag == flag)
 192                         return table[i].name;
 193
 194         return NULL;
 195 }
 196
 197 static void print_lookup_values(struct lookup_table *table, char *header)
 198 {
 199         int i;
 200
 201         printf("%s\n", header);
 202
 203         for (i = 0; table[i].name; i++)
 204                 printf("\t%s\n", table[i].name);
 205 }
 206
 207 static float tv2fl(struct timeval tv)
 208 {
 209         return (float)tv.tv_sec + (float)(tv.tv_usec/1000000.0);
 210 }
 211
 212 static char *ltoh(unsigned long c, char *s)
 213 {
 214         int c1;
 215
 216         c1     = (c >> 28) & 0x0f;
 217         *(s++) = NIBBLE_TO_ASCII (c1);
 218         c1     = (c >> 24) & 0x0f;
 219         *(s++) = NIBBLE_TO_ASCII (c1);
 220         c1     = (c >> 20) & 0x0f;
 221         *(s++) = NIBBLE_TO_ASCII (c1);
 222         c1     = (c >> 16) & 0x0f;
 223         *(s++) = NIBBLE_TO_ASCII (c1);
 224         c1     = (c >> 12) & 0x0f;
 225         *(s++) = NIBBLE_TO_ASCII (c1);
 226         c1     = (c >>  8) & 0x0f;
 227         *(s++) = NIBBLE_TO_ASCII (c1);
 228         c1     = (c >>  4) & 0x0f;
 229         *(s++) = NIBBLE_TO_ASCII (c1);
 230         c1     = c & 0x0f;
 231         *(s++) = NIBBLE_TO_ASCII (c1);
 232         *s     = 0;
 233         return s;
 234 }
 235
 236 static char *ctoh(char c, char *s)
 237 {
 238         char c1;
 239
 240         c1     = (c >> 4) & 0x0f;
 241         *(s++) = NIBBLE_TO_ASCII (c1);
 242         c1     = c & 0x0f;
 243         *(s++) = NIBBLE_TO_ASCII (c1);
 244         *s     = 0;
 245         return s;
 246 }
 247
 248 static void hexdump(unsigned char *s, unsigned long l)
 249 {
 250         char bfr[80];
 251         char *pb;
 252         unsigned long i, n = 0;
 253
 254         if (l == 0)
 255                 return;
 256
 257         while (n < l) {
 258                 pb = bfr;
 259                 pb = ltoh (n, pb);
 260                 *(pb++) = ':';
 261                 *(pb++) = ' ';
 262                 for (i = 0; i < 16; i++) {
 263                         if (n + i >= l) {
 264                                 *(pb++) = ' ';
 265                                 *(pb++) = ' ';
 266                         } else
 267                                 pb = ctoh (*(s + i), pb);
 268                         *(pb++) = ' ';
 269                 }
 270                 *(pb++) = ' ';
 271                 for (i = 0; i < 16; i++) {
 272                         if (n + i >= l)
 273                                 break;
 274                         else
 275                                 *(pb++) = (isprint (*(s + i)) ? *(s + i) : '.');
 276                 }
 277                 *pb = 0;
 278                 n += 16;
 279                 s += 16;
 280                 puts(bfr);
 281         }
 282 }
 283
 284 static int getopts(int sk, struct l2cap_options *opts, bool connected)
 285 {
 286         socklen_t optlen;
 287         int err;
 288
 289         memset(opts, 0, sizeof(*opts));
 290
 291         if (bdaddr_type == BDADDR_BREDR) {
 292                 optlen = sizeof(*opts);
 293                 return getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, opts, &optlen);
 294         }
 295
 296         optlen = sizeof(opts->imtu);
 297         err = getsockopt(sk, SOL_BLUETOOTH, BT_RCVMTU, &opts->imtu, &optlen);
 298         if (err < 0 || !connected)
 299                 return err;
 300
 301         optlen = sizeof(opts->omtu);
 302         return getsockopt(sk, SOL_BLUETOOTH, BT_SNDMTU, &opts->omtu, &optlen);
 303 }
 304
 305 static int setopts(int sk, struct l2cap_options *opts)
 306 {
 307         if (bdaddr_type == BDADDR_BREDR)
 308                 return setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, opts,
 309                                                                 sizeof(*opts));
 310
 311         return setsockopt(sk, SOL_BLUETOOTH, BT_RCVMTU, &opts->imtu,
 312                                                         sizeof(opts->imtu));
 313 }
 314
 315 static int do_connect(char *svr)
 316 {
 317         struct sockaddr_l2 addr;
 318         struct l2cap_options opts;
 319         struct l2cap_conninfo conn;
 320         socklen_t optlen;
 321         int sk, opt;
 322         char ba[18];
 323
 324         /* Create socket */
 325         sk = socket(PF_BLUETOOTH, socktype, BTPROTO_L2CAP);
 326         if (sk < 0) {
 327                 syslog(LOG_ERR, "Can't create socket: %s (%d)",
 328                                                         strerror(errno), errno);
 329                 return -1;
 330         }
 331
 332         /* Bind to local address */
 333         memset(&addr, 0, sizeof(addr));
 334         addr.l2_family = AF_BLUETOOTH;
 335         bacpy(&addr.l2_bdaddr, &bdaddr);
 336         addr.l2_bdaddr_type = bdaddr_type;
 337         if (cid)
 338                 addr.l2_cid = htobs(cid);
 339
 340         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 341                 syslog(LOG_ERR, "Can't bind socket: %s (%d)",
 342                                                         strerror(errno), errno);
 343                 goto error;
 344         }
 345
 346         /* Get default options */
 347         if (getopts(sk, &opts, false) < 0) {
 348                 syslog(LOG_ERR, "Can't get default L2CAP options: %s (%d)",
 349                                                 strerror(errno), errno);
 350                 goto error;
 351         }
 352
 353         /* Set new options */
 354         opts.omtu = omtu;
 355         opts.imtu = imtu;
 356         opts.mode = rfcmode;
 357
 358         opts.fcs = fcs;
 359         opts.txwin_size = txwin_size;
 360         opts.max_tx = max_transmit;
 361
 362         if (setopts(sk, &opts) < 0) {
 363                 syslog(LOG_ERR, "Can't set L2CAP options: %s (%d)",
 364                                                         strerror(errno), errno);
 365                 goto error;
 366         }
 367
 368 #if 0
 369         /* Enable SO_TIMESTAMP */
 370         if (timestamp) {
 371                 int t = 1;
 372
 373                 if (setsockopt(sk, SOL_SOCKET, SO_TIMESTAMP, &t, sizeof(t)) < 0) {
 374                         syslog(LOG_ERR, "Can't enable SO_TIMESTAMP: %s (%d)",
 375                                                         strerror(errno), errno);
 376                         goto error;
 377                 }
 378         }
 379 #endif
 380
 381         if (chan_policy != -1) {
 382                 if (setsockopt(sk, SOL_BLUETOOTH, BT_CHANNEL_POLICY,
 383                                 &chan_policy, sizeof(chan_policy)) < 0) {
 384                         syslog(LOG_ERR, "Can't enable chan policy : %s (%d)",
 385                                                         strerror(errno), errno);
 386                         goto error;
 387                 }
 388         }
 389
 390         /* Enable SO_LINGER */
 391         if (linger) {
 392                 struct linger l = { .l_onoff = 1, .l_linger = linger };
 393
 394                 if (setsockopt(sk, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) {
 395                         syslog(LOG_ERR, "Can't enable SO_LINGER: %s (%d)",
 396                                                         strerror(errno), errno);
 397                         goto error;
 398                 }
 399         }
 400
 401         /* Set link mode */
 402         opt = 0;
 403         if (reliable)
 404                 opt |= L2CAP_LM_RELIABLE;
 405         if (master)
 406                 opt |= L2CAP_LM_MASTER;
 407         if (auth)
 408                 opt |= L2CAP_LM_AUTH;
 409         if (encr)
 410                 opt |= L2CAP_LM_ENCRYPT;
 411         if (secure)
 412                 opt |= L2CAP_LM_SECURE;
 413
 414         if (setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
 415                 syslog(LOG_ERR, "Can't set L2CAP link mode: %s (%d)",
 416                                                         strerror(errno), errno);
 417                 goto error;
 418         }
 419
 420         /* Set receive buffer size */
 421         if (rcvbuf && setsockopt(sk, SOL_SOCKET, SO_RCVBUF,
 422                                                 &rcvbuf, sizeof(rcvbuf)) < 0) {
 423                 syslog(LOG_ERR, "Can't set socket rcv buf size: %s (%d)",
 424                                                         strerror(errno), errno);
 425                 goto error;
 426         }
 427
 428         optlen = sizeof(rcvbuf);
 429         if (getsockopt(sk, SOL_SOCKET, SO_RCVBUF, &rcvbuf, &optlen) < 0) {
 430                 syslog(LOG_ERR, "Can't get socket rcv buf size: %s (%d)",
 431                                                         strerror(errno), errno);
 432                 goto error;
 433         }
 434
 435         /* Connect to remote device */
 436         memset(&addr, 0, sizeof(addr));
 437         addr.l2_family = AF_BLUETOOTH;
 438         str2ba(svr, &addr.l2_bdaddr);
 439         addr.l2_bdaddr_type = bdaddr_type;
 440         if (cid)
 441                 addr.l2_cid = htobs(cid);
 442         else if (psm)
 443                 addr.l2_psm = htobs(psm);
 444         else
 445                 goto error;
 446
 447         if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
 448                 syslog(LOG_ERR, "Can't connect: %s (%d)",
 449                                                         strerror(errno), errno);
 450                 goto error;
 451         }
 452
 453         /* Get current options */
 454         if (getopts(sk, &opts, true) < 0) {
 455                 syslog(LOG_ERR, "Can't get L2CAP options: %s (%d)",
 456                                                         strerror(errno), errno);
 457                 goto error;
 458         }
 459
 460         /* Get connection information */
 461         memset(&conn, 0, sizeof(conn));
 462         optlen = sizeof(conn);
 463
 464         if (getsockopt(sk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &optlen) < 0) {
 465                 syslog(LOG_ERR, "Can't get L2CAP connection information: %s (%d)",
 466                                                         strerror(errno), errno);
 467                 goto error;
 468         }
 469
 470         if (priority > 0 && setsockopt(sk, SOL_SOCKET, SO_PRIORITY, &priority,
 471                                                 sizeof(priority)) < 0) {
 472                 syslog(LOG_ERR, "Can't set socket priority: %s (%d)",
 473                                                         strerror(errno), errno);
 474                 goto error;
 475         }
 476
 477         if (getsockopt(sk, SOL_SOCKET, SO_PRIORITY, &opt, &optlen) < 0) {
 478                 syslog(LOG_ERR, "Can't get socket priority: %s (%d)",
 479                                                         strerror(errno), errno);
 480                 goto error;
 481         }
 482
 483         /* Check for remote address */
 484         memset(&addr, 0, sizeof(addr));
 485         optlen = sizeof(addr);
 486
 487         if (getpeername(sk, (struct sockaddr *) &addr, &optlen) < 0) {
 488                 syslog(LOG_ERR, "Can't get socket name: %s (%d)",
 489                                                         strerror(errno), errno);
 490                 goto error;
 491         }
 492
 493         ba2str(&addr.l2_bdaddr, ba);
 494         syslog(LOG_INFO, "Connected to %s (%s, psm %d, scid %d)", ba,
 495                 get_lookup_str(bdaddr_types, addr.l2_bdaddr_type),
 496                 addr.l2_psm, addr.l2_cid);
 497
 498         /* Check for socket address */
 499         memset(&addr, 0, sizeof(addr));
 500         optlen = sizeof(addr);
 501
 502         if (getsockname(sk, (struct sockaddr *) &addr, &optlen) < 0) {
 503                 syslog(LOG_ERR, "Can't get socket name: %s (%d)",
 504                                                         strerror(errno), errno);
 505                 goto error;
 506         }
 507
 508         ba2str(&addr.l2_bdaddr, ba);
 509         syslog(LOG_INFO, "Local device %s (%s, psm %d, scid %d)", ba,
 510                 get_lookup_str(bdaddr_types, addr.l2_bdaddr_type),
 511                 addr.l2_psm, addr.l2_cid);
 512
 513         syslog(LOG_INFO, "Options [imtu %d, omtu %d, flush_to %d, "
 514                 "mode %d, handle %d, class 0x%02x%02x%02x, priority %d, rcvbuf %d]",
 515                 opts.imtu, opts.omtu, opts.flush_to, opts.mode, conn.hci_handle,
 516                 conn.dev_class[2], conn.dev_class[1], conn.dev_class[0], opt,
 517                 rcvbuf);
 518
 519         omtu = (opts.omtu > buffer_size) ? buffer_size : opts.omtu;
 520         imtu = (opts.imtu > buffer_size) ? buffer_size : opts.imtu;
 521
 522         return sk;
 523
 524 error:
 525         close(sk);
 526         return -1;
 527 }
 528
 529 static void do_listen(void (*handler)(int sk))
 530 {
 531         struct sockaddr_l2 addr;
 532         struct l2cap_options opts;
 533         struct l2cap_conninfo conn;
 534         socklen_t optlen;
 535         int sk, nsk, opt;
 536         char ba[18];
 537
 538         /* Create socket */
 539         sk = socket(PF_BLUETOOTH, socktype, BTPROTO_L2CAP);
 540         if (sk < 0) {
 541                 syslog(LOG_ERR, "Can't create socket: %s (%d)",
 542                                                         strerror(errno), errno);
 543                 exit(1);
 544         }
 545
 546         /* Bind to local address */
 547         memset(&addr, 0, sizeof(addr));
 548         addr.l2_family = AF_BLUETOOTH;
 549         bacpy(&addr.l2_bdaddr, &bdaddr);
 550         addr.l2_bdaddr_type = bdaddr_type;
 551         if (cid)
 552                 addr.l2_cid = htobs(cid);
 553         else if (psm)
 554                 addr.l2_psm = htobs(psm);
 555
 556         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 557                 syslog(LOG_ERR, "Can't bind socket: %s (%d)",
 558                                                         strerror(errno), errno);
 559                 goto error;
 560         }
 561
 562         /* Set link mode */
 563         opt = 0;
 564         if (reliable)
 565                 opt |= L2CAP_LM_RELIABLE;
 566         if (master)
 567                 opt |= L2CAP_LM_MASTER;
 568         if (auth)
 569                 opt |= L2CAP_LM_AUTH;
 570         if (encr)
 571                 opt |= L2CAP_LM_ENCRYPT;
 572         if (secure)
 573                 opt |= L2CAP_LM_SECURE;
 574
 575         if (opt && setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
 576                 syslog(LOG_ERR, "Can't set L2CAP link mode: %s (%d)",
 577                                                         strerror(errno), errno);
 578                 goto error;
 579         }
 580
 581         /* Get default options */
 582         if (getopts(sk, &opts, false) < 0) {
 583                 syslog(LOG_ERR, "Can't get default L2CAP options: %s (%d)",
 584                                                         strerror(errno), errno);
 585                 goto error;
 586         }
 587
 588         /* Set new options */
 589         opts.omtu = omtu;
 590         opts.imtu = imtu;
 591         if (rfcmode > 0)
 592                 opts.mode = rfcmode;
 593
 594         opts.fcs = fcs;
 595         opts.txwin_size = txwin_size;
 596         opts.max_tx = max_transmit;
 597
 598         if (setopts(sk, &opts) < 0) {
 599                 syslog(LOG_ERR, "Can't set L2CAP options: %s (%d)",
 600                                                         strerror(errno), errno);
 601                 goto error;
 602         }
 603
 604         if (socktype == SOCK_DGRAM) {
 605                 handler(sk);
 606                 close(sk);
 607                 return;
 608         }
 609
 610         /* Enable deferred setup */
 611         opt = defer_setup;
 612
 613         if (opt && setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP,
 614                                                 &opt, sizeof(opt)) < 0) {
 615                 syslog(LOG_ERR, "Can't enable deferred setup : %s (%d)",
 616                                                         strerror(errno), errno);
 617                 goto error;
 618         }
 619
 620
 621         /* Listen for connections */
 622         if (listen(sk, 10)) {
 623                 syslog(LOG_ERR, "Can not listen on the socket: %s (%d)",
 624                                                         strerror(errno), errno);
 625                 goto error;
 626         }
 627
 628         /* Check for socket address */
 629         memset(&addr, 0, sizeof(addr));
 630         optlen = sizeof(addr);
 631
 632         if (getsockname(sk, (struct sockaddr *) &addr, &optlen) < 0) {
 633                 syslog(LOG_ERR, "Can't get socket name: %s (%d)",
 634                                                         strerror(errno), errno);
 635                 goto error;
 636         }
 637
 638         psm = btohs(addr.l2_psm);
 639         cid = btohs(addr.l2_cid);
 640
 641         syslog(LOG_INFO, "Waiting for connection on psm %d ...", psm);
 642
 643         while (1) {
 644                 memset(&addr, 0, sizeof(addr));
 645                 optlen = sizeof(addr);
 646
 647                 nsk = accept(sk, (struct sockaddr *) &addr, &optlen);
 648                 if (nsk < 0) {
 649                         syslog(LOG_ERR, "Accept failed: %s (%d)",
 650                                                         strerror(errno), errno);
 651                         goto error;
 652                 }
 653                 if (fork()) {
 654                         /* Parent */
 655                         close(nsk);
 656                         continue;
 657                 }
 658                 /* Child */
 659
 660                 /* Set receive buffer size */
 661                 if (rcvbuf && setsockopt(nsk, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
 662                                                         sizeof(rcvbuf)) < 0) {
 663                         syslog(LOG_ERR, "Can't set rcv buf size: %s (%d)",
 664                                                         strerror(errno), errno);
 665                         goto error;
 666                 }
 667
 668                 optlen = sizeof(rcvbuf);
 669                 if (getsockopt(nsk, SOL_SOCKET, SO_RCVBUF, &rcvbuf, &optlen)
 670                                                                         < 0) {
 671                         syslog(LOG_ERR, "Can't get rcv buf size: %s (%d)",
 672                                                         strerror(errno), errno);
 673                         goto error;
 674                 }
 675
 676                 /* Get current options */
 677                 if (getopts(nsk, &opts, true) < 0) {
 678                         syslog(LOG_ERR, "Can't get L2CAP options: %s (%d)",
 679                                                         strerror(errno), errno);
 680                         if (!defer_setup) {
 681                                 close(nsk);
 682                                 goto error;
 683                         }
 684                 }
 685
 686                 /* Get connection information */
 687                 memset(&conn, 0, sizeof(conn));
 688                 optlen = sizeof(conn);
 689
 690                 if (getsockopt(nsk, SOL_L2CAP, L2CAP_CONNINFO, &conn, &optlen) < 0) {
 691                         syslog(LOG_ERR, "Can't get L2CAP connection information: %s (%d)",
 692                                                         strerror(errno), errno);
 693                         if (!defer_setup) {
 694                                 close(nsk);
 695                                 goto error;
 696                         }
 697                 }
 698
 699                 if (priority > 0 && setsockopt(nsk, SOL_SOCKET, SO_PRIORITY,
 700                                         &priority, sizeof(priority)) < 0) {
 701                         syslog(LOG_ERR, "Can't set socket priority: %s (%d)",
 702                                                 strerror(errno), errno);
 703                         close(nsk);
 704                         goto error;
 705                 }
 706
 707                 optlen = sizeof(priority);
 708                 if (getsockopt(nsk, SOL_SOCKET, SO_PRIORITY, &opt, &optlen) < 0) {
 709                         syslog(LOG_ERR, "Can't get socket priority: %s (%d)",
 710                                                         strerror(errno), errno);
 711                         goto error;
 712                 }
 713
 714                 ba2str(&addr.l2_bdaddr, ba);
 715                 syslog(LOG_INFO, "Connect from %s (%s, psm %d, dcid %d)", ba,
 716                                 get_lookup_str(bdaddr_types, addr.l2_bdaddr_type),
 717                                 addr.l2_psm, addr.l2_cid);
 718
 719                 /* Check for socket address */
 720                 memset(&addr, 0, sizeof(addr));
 721                 optlen = sizeof(addr);
 722
 723                 if (getsockname(nsk, (struct sockaddr *) &addr, &optlen) < 0) {
 724                         syslog(LOG_ERR, "Can't get socket name: %s (%d)",
 725                                                         strerror(errno), errno);
 726                         goto error;
 727                 }
 728
 729                 ba2str(&addr.l2_bdaddr, ba);
 730                 syslog(LOG_INFO, "Local device %s (%s, psm %d, scid %d)", ba,
 731                                 get_lookup_str(bdaddr_types, addr.l2_bdaddr_type),
 732                                 addr.l2_psm, addr.l2_cid);
 733
 734                 syslog(LOG_INFO, "Options [imtu %d, omtu %d, "
 735                                 "flush_to %d, mode %d, handle %d, "
 736                                 "class 0x%02x%02x%02x, priority %d, rcvbuf %d]",
 737                                 opts.imtu, opts.omtu, opts.flush_to,
 738                                 opts.mode, conn.hci_handle, conn.dev_class[2],
 739                                 conn.dev_class[1], conn.dev_class[0], opt,
 740                                 rcvbuf);
 741
 742                 omtu = (opts.omtu > buffer_size) ? buffer_size : opts.omtu;
 743                 imtu = (opts.imtu > buffer_size) ? buffer_size : opts.imtu;
 744
 745 #if 0
 746                 /* Enable SO_TIMESTAMP */
 747                 if (timestamp) {
 748                         int t = 1;
 749
 750                         if (setsockopt(nsk, SOL_SOCKET, SO_TIMESTAMP, &t, sizeof(t)) < 0) {
 751                                 syslog(LOG_ERR, "Can't enable SO_TIMESTAMP: %s (%d)",
 752                                                         strerror(errno), errno);
 753                                 goto error;
 754                         }
 755                 }
 756 #endif
 757
 758                 /* Enable SO_LINGER */
 759                 if (linger) {
 760                         struct linger l = { .l_onoff = 1, .l_linger = linger };
 761
 762                         if (setsockopt(nsk, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) {
 763                                 syslog(LOG_ERR, "Can't enable SO_LINGER: %s (%d)",
 764                                                         strerror(errno), errno);
 765                                 close(nsk);
 766                                 goto error;
 767                         }
 768                 }
 769
 770                 /* Handle deferred setup */
 771                 if (defer_setup) {
 772                         syslog(LOG_INFO, "Waiting for %d seconds",
 773                                                         abs(defer_setup) - 1);
 774                         sleep(abs(defer_setup) - 1);
 775
 776                         if (defer_setup < 0) {
 777                                 close(nsk);
 778                                 goto error;
 779                         }
 780                 }
 781
 782                 handler(nsk);
 783                 close(sk);
 784
 785                 syslog(LOG_INFO, "Disconnect: %m");
 786                 exit(0);
 787         }
 788
 789 error:
 790         close(sk);
 791         exit(1);
 792 }
 793
 794 static void dump_mode(int sk)
 795 {
 796         socklen_t optlen;
 797         int opt, len;
 798
 799         if (data_size < 0)
 800                 data_size = imtu;
 801
 802         if (defer_setup) {
 803                 len = read(sk, buf, data_size);
 804                 if (len < 0)
 805                         syslog(LOG_ERR, "Initial read error: %s (%d)",
 806                                                 strerror(errno), errno);
 807                 else
 808                         syslog(LOG_INFO, "Initial bytes %d", len);
 809         }
 810
 811         syslog(LOG_INFO, "Receiving ...");
 812         while (1) {
 813                 fd_set rset;
 814
 815                 FD_ZERO(&rset);
 816                 FD_SET(sk, &rset);
 817
 818                 if (select(sk + 1, &rset, NULL, NULL, NULL) < 0)
 819                         return;
 820
 821                 if (!FD_ISSET(sk, &rset))
 822                         continue;
 823
 824                 len = read(sk, buf, data_size);
 825                 if (len <= 0) {
 826                         if (len < 0) {
 827                                 if (reliable && (errno == ECOMM)) {
 828                                         syslog(LOG_INFO, "L2CAP Error ECOMM - clearing error and continuing.");
 829                                         optlen = sizeof(opt);
 830                                         if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &opt, &optlen) < 0) {
 831                                                 syslog(LOG_ERR, "Couldn't getsockopt(SO_ERROR): %s (%d)",
 832                                                         strerror(errno), errno);
 833                                                 return;
 834                                         }
 835                                         continue;
 836                                 } else {
 837                                         syslog(LOG_ERR, "Read error: %s(%d)",
 838                                                         strerror(errno), errno);
 839                                 }
 840                         }
 841                         return;
 842                 }
 843
 844                 syslog(LOG_INFO, "Recevied %d bytes", len);
 845                 hexdump(buf, len);
 846         }
 847 }
 848
 849 static void recv_mode(int sk)
 850 {
 851         struct timeval tv_beg, tv_end, tv_diff;
 852         struct pollfd p;
 853         char ts[30];
 854         long total;
 855         uint32_t seq;
 856         socklen_t optlen;
 857         int opt, len;
 858
 859         if (data_size < 0)
 860                 data_size = imtu;
 861
 862         if (defer_setup) {
 863                 len = read(sk, buf, data_size);
 864                 if (len < 0)
 865                         syslog(LOG_ERR, "Initial read error: %s (%d)",
 866                                                 strerror(errno), errno);
 867                 else
 868                         syslog(LOG_INFO, "Initial bytes %d", len);
 869         }
 870
 871         if (recv_delay)
 872                 usleep(recv_delay);
 873
 874         syslog(LOG_INFO, "Receiving ...");
 875
 876         memset(ts, 0, sizeof(ts));
 877
 878         p.fd = sk;
 879         p.events = POLLIN | POLLERR | POLLHUP;
 880
 881         seq = 0;
 882         while (1) {
 883                 gettimeofday(&tv_beg, NULL);
 884                 total = 0;
 885                 while (total < data_size) {
 886                         uint32_t sq;
 887                         uint16_t l;
 888                         int i;
 889
 890                         p.revents = 0;
 891                         if (poll(&p, 1, -1) <= 0)
 892                                 return;
 893
 894                         if (p.revents & (POLLERR | POLLHUP))
 895                                 return;
 896
 897                         len = recv(sk, buf, data_size, 0);
 898                         if (len < 0) {
 899                                 if (reliable && (errno == ECOMM)) {
 900                                         syslog(LOG_INFO, "L2CAP Error ECOMM - clearing error and continuing.\n");
 901                                         optlen = sizeof(opt);
 902                                         if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &opt, &optlen) < 0) {
 903                                                 syslog(LOG_ERR, "Couldn't getsockopt(SO_ERROR): %s (%d)",
 904                                                         strerror(errno), errno);
 905                                                 return;
 906                                         }
 907                                         continue;
 908                                 } else {
 909                                         syslog(LOG_ERR, "Read failed: %s (%d)",
 910                                                 strerror(errno), errno);
 911                                 }
 912                         }
 913
 914                         if (len < 6)
 915                                 break;
 916
 917                         if (timestamp) {
 918                                 struct timeval tv;
 919
 920                                 if (ioctl(sk, SIOCGSTAMP, &tv) < 0) {
 921                                         timestamp = 0;
 922                                         memset(ts, 0, sizeof(ts));
 923                                 } else {
 924                                         sprintf(ts, "[%ld.%ld] ",
 925                                                         tv.tv_sec, tv.tv_usec);
 926                                 }
 927                         }
 928
 929                         /* Check sequence */
 930                         sq = get_le32(buf);
 931                         if (seq != sq) {
 932                                 syslog(LOG_INFO, "seq missmatch: %d -> %d", seq, sq);
 933                                 seq = sq;
 934                         }
 935                         seq++;
 936
 937                         /* Check length */
 938                         l = get_le16(buf + 4);
 939                         if (len != l) {
 940                                 syslog(LOG_INFO, "size missmatch: %d -> %d", len, l);
 941                                 continue;
 942                         }
 943
 944                         /* Verify data */
 945                         for (i = 6; i < len; i++) {
 946                                 if (buf[i] != 0x7f)
 947                                         syslog(LOG_INFO, "data missmatch: byte %d 0x%2.2x", i, buf[i]);
 948                         }
 949
 950                         total += len;
 951                 }
 952                 gettimeofday(&tv_end, NULL);
 953
 954                 timersub(&tv_end, &tv_beg, &tv_diff);
 955
 956                 syslog(LOG_INFO,"%s%ld bytes in %.2f sec, %.2f kB/s", ts, total,
 957                         tv2fl(tv_diff), (float)(total / tv2fl(tv_diff) ) / 1024.0);
 958         }
 959 }
 960
 961 static void do_send(int sk)
 962 {
 963         uint32_t seq;
 964         int i, fd, len, buflen, size, sent;
 965
 966         syslog(LOG_INFO, "Sending ...");
 967
 968         if (data_size < 0)
 969                 data_size = omtu;
 970
 971         if (filename) {
 972                 fd = open(filename, O_RDONLY);
 973                 if (fd < 0) {
 974                         syslog(LOG_ERR, "Open failed: %s (%d)",
 975                                                         strerror(errno), errno);
 976                         exit(1);
 977                 }
 978
 979                 sent = 0;
 980                 size = read(fd, buf, data_size);
 981                 while (size > 0) {
 982                         buflen = (size > omtu) ? omtu : size;
 983
 984                         len = send(sk, buf + sent, buflen, 0);
 985
 986                         sent += len;
 987                         size -= len;
 988                 }
 989
 990                 close(fd);
 991                 return;
 992         } else {
 993                 for (i = 6; i < data_size; i++)
 994                         buf[i] = 0x7f;
 995         }
 996
 997         if (!count && send_delay)
 998                 usleep(send_delay);
 999
1000         seq = seq_start;
1001         while ((num_frames == -1) || (num_frames-- > 0)) {
1002                 put_le32(seq, buf);
1003                 put_le16(data_size, buf + 4);
1004
1005                 seq++;
1006
1007                 sent = 0;
1008                 size = data_size;
1009                 while (size > 0) {
1010                         buflen = (size > omtu) ? omtu : size;
1011
1012                         len = send(sk, buf, buflen, 0);
1013                         if (len < 0 || len != buflen) {
1014                                 syslog(LOG_ERR, "Send failed: %s (%d)",
1015                                                         strerror(errno), errno);
1016                                 exit(1);
1017                         }
1018
1019                         sent += len;
1020                         size -= len;
1021                 }
1022
1023                 if (num_frames && send_delay && count &&
1024                                                 !(seq % (count + seq_start)))
1025                         usleep(send_delay);
1026         }
1027 }
1028
1029 static void send_mode(int sk)
1030 {
1031         do_send(sk);
1032
1033         if (disc_delay)
1034                 usleep(disc_delay);
1035
1036         syslog(LOG_INFO, "Closing channel ...");
1037         if (shutdown(sk, SHUT_RDWR) < 0)
1038                 syslog(LOG_INFO, "Close failed: %m");
1039         else
1040                 syslog(LOG_INFO, "Done");
1041 }
1042
1043 static void senddump_mode(int sk)
1044 {
1045         do_send(sk);
1046
1047         dump_mode(sk);
1048 }
1049
1050 static void send_and_recv_mode(int sk)
1051 {
1052         int flags;
1053
1054         if ((flags = fcntl(sk, F_GETFL, 0)) < 0)
1055                 flags = 0;
1056         fcntl(sk, F_SETFL, flags | O_NONBLOCK);
1057
1058         /* fork for duplex channel */
1059         if (fork())
1060                 send_mode(sk);
1061         else
1062                 recv_mode(sk);
1063         return;
1064 }
1065
1066 static void reconnect_mode(char *svr)
1067 {
1068         while (1) {
1069                 int sk = do_connect(svr);
1070                 close(sk);
1071         }
1072 }
1073
1074 static void connect_mode(char *svr)
1075 {
1076         struct pollfd p;
1077         int sk;
1078
1079         if ((sk = do_connect(svr)) < 0)
1080                 exit(1);
1081
1082         p.fd = sk;
1083         p.events = POLLERR | POLLHUP;
1084
1085         while (1) {
1086                 p.revents = 0;
1087                 if (poll(&p, 1, 500))
1088                         break;
1089         }
1090
1091         syslog(LOG_INFO, "Disconnected");
1092
1093         close(sk);
1094 }
1095
1096 static void multi_connect_mode(int argc, char *argv[])
1097 {
1098         int i, n, sk;
1099
1100         while (1) {
1101                 for (n = 0; n < argc; n++) {
1102                         for (i = 0; i < count; i++) {
1103                                 if (fork())
1104                                         continue;
1105
1106                                 /* Child */
1107                                 sk = do_connect(argv[n]);
1108                                 usleep(500);
1109                                 close(sk);
1110                                 exit(0);
1111                         }
1112                 }
1113                 sleep(4);
1114         }
1115 }
1116
1117 #ifdef __TIZEN_PATCH__
1118 static void l2cap_add_conf_opt(void **ptr, uint8_t type, uint8_t len, unsigned long val)
1119 {
1120         l2cap_conf_opt *opt = *ptr;
1121
1122         printf("type 0x%2.2x len %u val 0x%lx \n", type, len, val);
1123         opt->type = htobs(type);
1124         opt->len  = htobs(len);
1125
1126         switch (opt->len) {
1127         case 1:
1128                 *((uint8_t *) opt->val) = val;
1129                 break;
1130         case 2:
1131                 bt_put_le16(val, opt->val);
1132                 break;
1133         case 4:
1134                 bt_put_le32(val, opt->val);
1135                 break;
1136         default:
1137                 memcpy(opt->val, (void *) val, len);
1138                 break;
1139         }
1140
1141         *ptr += L2CAP_CONF_OPT_SIZE + len;
1142 }
1143
1144 static int l2cap_build_conf_req(void *data)
1145 {
1146         l2cap_conf_req *req = data;
1147         l2cap_conf_rfc rfc;
1148         void *ptr = req->data;
1149
1150         req->dcid = htobs(dcid);
1151         req->flags = htobs(0x0000);
1152
1153         switch (rfcmode) {
1154         case L2CAP_MODE_BASIC:
1155                 rfc.mode                        = htobs(L2CAP_MODE_BASIC);
1156                 rfc.txwin_size          = htobs(0);
1157                 rfc.max_transmit        = htobs(0);
1158                 rfc.retrans_timeout = htobs(0);
1159                 rfc.monitor_timeout = htobs(0);
1160                 rfc.max_pdu_size        = htobs(0);
1161
1162                 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1163                                    (unsigned long) &rfc);
1164
1165                 break;
1166
1167         case L2CAP_MODE_ERTM:
1168                 rfc.mode                        = htobs(L2CAP_MODE_ERTM);
1169                 rfc.txwin_size          = htobs(txwin_size);
1170                 rfc.max_transmit        = htobs(max_transmit);
1171                 rfc.retrans_timeout = htobs(L2CAP_DEFAULT_RETRANS_TO);
1172                 rfc.monitor_timeout = htobs(L2CAP_DEFAULT_MONITOR_TO);
1173                 rfc.max_pdu_size        = htobs(imtu);
1174
1175                 /* TODO: Enable FCS, FOC options if required */
1176                 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1177                                    (unsigned long) &rfc);
1178                 break;
1179
1180         case L2CAP_MODE_STREAMING:
1181                 rfc.mode                        = htobs(L2CAP_MODE_STREAMING);
1182                 rfc.txwin_size          = htobs(txwin_size);
1183                 rfc.max_transmit        = htobs(max_transmit);
1184                 rfc.retrans_timeout = htobs(L2CAP_DEFAULT_RETRANS_TO);
1185                 rfc.monitor_timeout = htobs(L2CAP_DEFAULT_MONITOR_TO);
1186                 rfc.max_pdu_size        = htobs(imtu);
1187
1188                 /* TODO: Enable FCS, FOC options if required */
1189                 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1190                                    (unsigned long) &rfc);
1191
1192                 break;
1193         default:
1194                 return L2CAP_CONF_REQ_SIZE;
1195         }
1196         return ptr - data;
1197 }
1198
1199 static void config_request(char *svr)
1200 {
1201         unsigned char buf[48];
1202         l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
1203         uint8_t *req_buf = (uint8_t *) (buf + L2CAP_CMD_HDR_SIZE);
1204 #ifndef __TIZEN_PATCH__
1205         uint16_t mtu;
1206         uint32_t channels, mask = 0x0000;
1207 #endif
1208         struct sockaddr_l2 addr;
1209 #ifndef __TIZEN_PATCH__
1210         int sk, err;
1211 #else
1212         int sk;
1213 #endif
1214         int data_len = 0;
1215
1216         sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1217         if (sk < 0) {
1218                 perror("Can't create socket");
1219                 return;
1220         }
1221
1222         memset(&addr, 0, sizeof(addr));
1223         addr.l2_family = AF_BLUETOOTH;
1224         bacpy(&addr.l2_bdaddr, &bdaddr);
1225         addr.l2_bdaddr_type = bdaddr_type;
1226
1227         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1228                 perror("Can't bind socket");
1229                 goto failed;
1230         }
1231
1232         memset(&addr, 0, sizeof(addr));
1233         addr.l2_family = AF_BLUETOOTH;
1234         str2ba(svr, &addr.l2_bdaddr);
1235         addr.l2_bdaddr_type = bdaddr_type;
1236
1237         if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
1238                 perror("Can't connect socket");
1239                 goto failed;
1240         }
1241
1242         memset(buf, 0, sizeof(buf));
1243         cmd->code  = L2CAP_CONF_REQ;
1244         cmd->ident = 141;
1245         data_len = l2cap_build_conf_req(req_buf);
1246         cmd->len = htobs(data_len);
1247
1248         if (send(sk, buf, L2CAP_CMD_HDR_SIZE + data_len, 0) < 0) {
1249                 perror("Can't send info request");
1250                 goto failed;
1251         }
1252 failed:
1253         close(sk);
1254 }
1255 #endif
1256
1257 static void info_request(char *svr)
1258 {
1259         unsigned char buf[48];
1260         l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
1261         l2cap_info_req *req = (l2cap_info_req *) (buf + L2CAP_CMD_HDR_SIZE);
1262         l2cap_info_rsp *rsp = (l2cap_info_rsp *) (buf + L2CAP_CMD_HDR_SIZE);
1263         uint16_t mtu;
1264         uint32_t channels, mask = 0x0000;
1265         struct sockaddr_l2 addr;
1266         int sk, err;
1267
1268         sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1269         if (sk < 0) {
1270                 perror("Can't create socket");
1271                 return;
1272         }
1273
1274         memset(&addr, 0, sizeof(addr));
1275         addr.l2_family = AF_BLUETOOTH;
1276         bacpy(&addr.l2_bdaddr, &bdaddr);
1277         addr.l2_bdaddr_type = bdaddr_type;
1278
1279         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1280                 perror("Can't bind socket");
1281                 goto failed;
1282         }
1283
1284         memset(&addr, 0, sizeof(addr));
1285         addr.l2_family = AF_BLUETOOTH;
1286         str2ba(svr, &addr.l2_bdaddr);
1287         addr.l2_bdaddr_type = bdaddr_type;
1288
1289         if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
1290                 perror("Can't connect socket");
1291                 goto failed;
1292         }
1293
1294         memset(buf, 0, sizeof(buf));
1295         cmd->code  = L2CAP_INFO_REQ;
1296         cmd->ident = 141;
1297         cmd->len   = htobs(2);
1298         req->type  = htobs(0x0001);
1299
1300         if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
1301                 perror("Can't send info request");
1302                 goto failed;
1303         }
1304
1305         err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 2, 0);
1306         if (err < 0) {
1307                 perror("Can't receive info response");
1308                 goto failed;
1309         }
1310
1311         switch (btohs(rsp->result)) {
1312         case 0x0000:
1313                 memcpy(&mtu, rsp->data, sizeof(mtu));
1314                 printf("Connectionless MTU size is %d\n", btohs(mtu));
1315                 break;
1316         case 0x0001:
1317                 printf("Connectionless MTU is not supported\n");
1318                 break;
1319         }
1320
1321         memset(buf, 0, sizeof(buf));
1322         cmd->code  = L2CAP_INFO_REQ;
1323         cmd->ident = 142;
1324         cmd->len   = htobs(2);
1325         req->type  = htobs(0x0002);
1326
1327         if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
1328                 perror("Can't send info request");
1329                 goto failed;
1330         }
1331
1332         err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 4, 0);
1333         if (err < 0) {
1334                 perror("Can't receive info response");
1335                 goto failed;
1336         }
1337
1338         switch (btohs(rsp->result)) {
1339         case 0x0000:
1340                 memcpy(&mask, rsp->data, sizeof(mask));
1341                 printf("Extended feature mask is 0x%04x\n", btohl(mask));
1342                 if (mask & L2CAP_FEAT_FLOWCTL)
1343                         printf("  Flow control mode\n");
1344                 if (mask & L2CAP_FEAT_RETRANS)
1345                         printf("  Retransmission mode\n");
1346                 if (mask & L2CAP_FEAT_BIDIR_QOS)
1347                         printf("  Bi-directional QoS\n");
1348                 if (mask & L2CAP_FEAT_ERTM)
1349                         printf("  Enhanced Retransmission mode\n");
1350                 if (mask & L2CAP_FEAT_STREAMING)
1351                         printf("  Streaming mode\n");
1352                 if (mask & L2CAP_FEAT_FCS)
1353                         printf("  FCS Option\n");
1354                 if (mask & L2CAP_FEAT_EXT_FLOW)
1355                         printf("  Extended Flow Specification\n");
1356                 if (mask & L2CAP_FEAT_FIXED_CHAN)
1357                         printf("  Fixed Channels\n");
1358                 if (mask & L2CAP_FEAT_EXT_WINDOW)
1359                         printf("  Extended Window Size\n");
1360                 if (mask & L2CAP_FEAT_UCD)
1361                         printf("  Unicast Connectionless Data Reception\n");
1362                 break;
1363         case 0x0001:
1364                 printf("Extended feature mask is not supported\n");
1365                 break;
1366         }
1367
1368         if (!(mask & 0x80))
1369                 goto failed;
1370
1371         memset(buf, 0, sizeof(buf));
1372         cmd->code  = L2CAP_INFO_REQ;
1373         cmd->ident = 143;
1374         cmd->len   = htobs(2);
1375         req->type  = htobs(0x0003);
1376
1377         if (send(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_REQ_SIZE, 0) < 0) {
1378                 perror("Can't send info request");
1379                 goto failed;
1380         }
1381
1382         err = recv(sk, buf, L2CAP_CMD_HDR_SIZE + L2CAP_INFO_RSP_SIZE + 8, 0);
1383         if (err < 0) {
1384                 perror("Can't receive info response");
1385                 goto failed;
1386         }
1387
1388         switch (btohs(rsp->result)) {
1389         case 0x0000:
1390                 memcpy(&channels, rsp->data, sizeof(channels));
1391                 printf("Fixed channels list is 0x%04x\n", btohl(channels));
1392                 break;
1393         case 0x0001:
1394                 printf("Fixed channels list is not supported\n");
1395                 break;
1396         }
1397
1398 failed:
1399         close(sk);
1400 }
1401
1402 static void do_pairing(char *svr)
1403 {
1404         struct sockaddr_l2 addr;
1405         int sk, opt;
1406
1407         sk = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP);
1408         if (sk < 0) {
1409                 perror("Can't create socket");
1410                 return;
1411         }
1412
1413         memset(&addr, 0, sizeof(addr));
1414         addr.l2_family = AF_BLUETOOTH;
1415         bacpy(&addr.l2_bdaddr, &bdaddr);
1416         addr.l2_bdaddr_type = bdaddr_type;
1417
1418         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1419                 perror("Can't bind socket");
1420                 goto failed;
1421         }
1422
1423         if (secure)
1424                 opt = L2CAP_LM_SECURE;
1425         else
1426                 opt = L2CAP_LM_ENCRYPT;
1427
1428         if (setsockopt(sk, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) {
1429                 perror("Can't set link mode");
1430                 goto failed;
1431         }
1432
1433         memset(&addr, 0, sizeof(addr));
1434         addr.l2_family = AF_BLUETOOTH;
1435         str2ba(svr, &addr.l2_bdaddr);
1436         addr.l2_bdaddr_type = bdaddr_type;
1437
1438         if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0 ) {
1439                 perror("Can't connect socket");
1440                 goto failed;
1441         }
1442
1443         printf("Pairing successful\n");
1444
1445 failed:
1446         close(sk);
1447 }
1448
1449 static void usage(void)
1450 {
1451         printf("l2test - L2CAP testing\n"
1452                 "Usage:\n");
1453         printf("\tl2test <mode> [options] [bdaddr]\n");
1454         printf("Modes:\n"
1455                 "\t-r listen and receive\n"
1456                 "\t-w listen and send\n"
1457                 "\t-d listen and dump incoming data\n"
1458                 "\t-x listen, then send, then dump incoming data\n"
1459                 "\t-t listen, then send and receive at the same time\n"
1460                 "\t-q connect, then send and receive at the same time\n"
1461                 "\t-s connect and send\n"
1462                 "\t-u connect and receive\n"
1463                 "\t-n connect and be silent\n"
1464                 "\t-y connect, then send, then dump incoming data\n"
1465                 "\t-c connect, disconnect, connect, ...\n"
1466                 "\t-m multiple connects\n"
1467                 "\t-p trigger dedicated bonding\n"
1468 #ifdef __TIZEN_PATCH__
1469                 "\t-o configuration request\n"
1470 #endif
1471                 "\t-z information request\n");
1472
1473         printf("Options:\n"
1474                 "\t[-b bytes] [-i device] [-P psm] [-J cid]\n"
1475                 "\t[-I imtu] [-O omtu]\n"
1476                 "\t[-L seconds] enable SO_LINGER\n"
1477                 "\t[-W seconds] enable deferred setup\n"
1478                 "\t[-B filename] use data packets from file\n"
1479                 "\t[-N num] send num frames (default = infinite)\n"
1480                 "\t[-C num] send num frames before delay (default = 1)\n"
1481                 "\t[-D milliseconds] delay after sending num frames (default = 0)\n"
1482                 "\t[-K milliseconds] delay before receiving (default = 0)\n"
1483                 "\t[-g milliseconds] delay before disconnecting (default = 0)\n"
1484                 "\t[-X mode] l2cap mode (help for list, default = basic)\n"
1485                 "\t[-a policy] chan policy (help for list, default = bredr)\n"
1486                 "\t[-F fcs] use CRC16 check (default = 1)\n"
1487                 "\t[-Q num] Max Transmit value (default = 3)\n"
1488                 "\t[-Z size] Transmission Window size (default = 63)\n"
1489                 "\t[-Y priority] socket priority\n"
1490                 "\t[-H size] Maximum receive buffer size\n"
1491                 "\t[-R] reliable mode\n"
1492                 "\t[-G] use connectionless channel (datagram)\n"
1493                 "\t[-U] use sock stream\n"
1494                 "\t[-A] request authentication\n"
1495                 "\t[-E] request encryption\n"
1496                 "\t[-S] secure connection\n"
1497                 "\t[-M] become master\n"
1498                 "\t[-T] enable timestamps\n"
1499                 "\t[-V type] address type (help for list, default = bredr)\n"
1500 #ifdef __TIZEN_PATCH__
1501                 "\t[-f DCID] destination CID\n"
1502 #endif
1503                 "\t[-e seq] initial sequence value (default = 0)\n");
1504 }
1505
1506 int main(int argc, char *argv[])
1507 {
1508         struct sigaction sa;
1509         int opt, sk, mode = RECV, need_addr = 0;
1510
1511         bacpy(&bdaddr, BDADDR_ANY);
1512
1513 #ifdef __TIZEN_PATCH__
1514         while ((opt = getopt(argc, argv, "a:b:cde:f:g:i:mnopqrstuwxyz"
1515                 "AB:C:D:EF:GH:I:J:K:L:MN:O:P:Q:RSTUV:W:X:Y:Z:")) != EOF) {
1516 #else
1517         while ((opt = getopt(argc, argv, "a:b:cde:g:i:mnpqrstuwxyz"
1518                 "AB:C:D:EF:GH:I:J:K:L:MN:O:P:Q:RSTUV:W:X:Y:Z:")) != EOF) {
1519 #endif
1520                 switch (opt) {
1521                 case 'r':
1522                         mode = RECV;
1523                         break;
1524
1525                 case 's':
1526                         mode = SEND;
1527                         need_addr = 1;
1528                         break;
1529
1530                 case 'w':
1531                         mode = LSEND;
1532                         break;
1533
1534                 case 'u':
1535                         mode = CRECV;
1536                         need_addr = 1;
1537                         break;
1538
1539                 case 'd':
1540                         mode = DUMP;
1541                         break;
1542
1543                 case 'c':
1544                         mode = RECONNECT;
1545                         need_addr = 1;
1546                         break;
1547
1548 #ifdef __TIZEN_PATCH__
1549                 case 'o':
1550                         mode = CONFIGREQ;
1551                         need_addr = 1;
1552                         break;
1553 #endif
1554
1555                 case 'n':
1556                         mode = CONNECT;
1557                         need_addr = 1;
1558                         break;
1559
1560                 case 'm':
1561                         mode = MULTY;
1562                         need_addr = 1;
1563                         break;
1564
1565                 case 't':
1566                         mode = LSENDRECV;
1567                         break;
1568
1569                 case 'q':
1570                         mode = CSENDRECV;
1571                         need_addr = 1;
1572                         break;
1573
1574                 case 'x':
1575                         mode = LSENDDUMP;
1576                         break;
1577
1578                 case 'y':
1579                         mode = SENDDUMP;
1580                         break;
1581
1582                 case 'z':
1583                         mode = INFOREQ;
1584                         need_addr = 1;
1585                         break;
1586
1587                 case 'p':
1588                         mode = PAIRING;
1589                         need_addr = 1;
1590                         break;
1591
1592                 case 'b':
1593                         data_size = atoi(optarg);
1594                         break;
1595
1596                 case 'i':
1597                         if (!strncasecmp(optarg, "hci", 3))
1598                                 hci_devba(atoi(optarg + 3), &bdaddr);
1599                         else
1600                                 str2ba(optarg, &bdaddr);
1601                         break;
1602
1603                 case 'P':
1604                         psm = atoi(optarg);
1605                         break;
1606
1607                 case 'I':
1608                         imtu = atoi(optarg);
1609                         break;
1610
1611                 case 'O':
1612                         omtu = atoi(optarg);
1613                         break;
1614
1615                 case 'L':
1616                         linger = atoi(optarg);
1617                         break;
1618
1619                 case 'W':
1620                         defer_setup = atoi(optarg);
1621                         break;
1622
1623                 case 'B':
1624                         filename = optarg;
1625                         break;
1626
1627                 case 'N':
1628                         num_frames = atoi(optarg);
1629                         break;
1630
1631                 case 'C':
1632                         count = atoi(optarg);
1633                         break;
1634
1635                 case 'D':
1636                         send_delay = atoi(optarg) * 1000;
1637                         break;
1638
1639                 case 'K':
1640                         recv_delay = atoi(optarg) * 1000;
1641                         break;
1642
1643                 case 'X':
1644                         rfcmode = get_lookup_flag(l2cap_modes, optarg);
1645
1646                         if (rfcmode == -1) {
1647                                 print_lookup_values(l2cap_modes,
1648                                                 "List L2CAP modes:");
1649                                 exit(1);
1650                         }
1651
1652                         break;
1653
1654                 case 'a':
1655                         chan_policy = get_lookup_flag(chan_policies, optarg);
1656
1657                         if (chan_policy == -1) {
1658                                 print_lookup_values(chan_policies,
1659                                                 "List L2CAP chan policies:");
1660                                 exit(1);
1661                         }
1662
1663                         break;
1664
1665                 case 'Y':
1666                         priority = atoi(optarg);
1667                         break;
1668
1669                 case 'F':
1670                         fcs = atoi(optarg);
1671                         break;
1672
1673                 case 'R':
1674                         reliable = 1;
1675                         break;
1676
1677                 case 'M':
1678                         master = 1;
1679                         break;
1680
1681                 case 'A':
1682                         auth = 1;
1683                         break;
1684
1685                 case 'E':
1686                         encr = 1;
1687                         break;
1688
1689                 case 'S':
1690                         secure = 1;
1691                         break;
1692
1693                 case 'G':
1694                         socktype = SOCK_DGRAM;
1695                         break;
1696
1697                 case 'U':
1698                         socktype = SOCK_STREAM;
1699                         break;
1700
1701                 case 'T':
1702                         timestamp = 1;
1703                         break;
1704
1705                 case 'Q':
1706                         max_transmit = atoi(optarg);
1707                         break;
1708
1709                 case 'Z':
1710                         txwin_size = atoi(optarg);
1711                         break;
1712
1713                 case 'J':
1714                         cid = atoi(optarg);
1715                         break;
1716
1717                 case 'H':
1718                         rcvbuf = atoi(optarg);
1719                         break;
1720
1721                 case 'V':
1722                         bdaddr_type = get_lookup_flag(bdaddr_types, optarg);
1723
1724                         if (bdaddr_type == -1) {
1725                                 print_lookup_values(bdaddr_types,
1726                                                 "List Address types:");
1727                                 exit(1);
1728                         }
1729
1730                         break;
1731
1732 #ifdef __TIZEN_PATCH__
1733                 case 'f':
1734                         dcid = atoi(optarg);
1735                         printf("dcid %d", dcid);
1736                         break;
1737 #endif
1738
1739                 case 'e':
1740                         seq_start = atoi(optarg);
1741                         break;
1742
1743                 case 'g':
1744                         disc_delay = atoi(optarg) * 1000;
1745                         break;
1746
1747                 default:
1748                         usage();
1749                         exit(1);
1750                 }
1751         }
1752
1753         if (!psm) {
1754                 if (bdaddr_type == BDADDR_BREDR)
1755                         psm = BREDR_DEFAULT_PSM;
1756                 else
1757                         psm = LE_DEFAULT_PSM;
1758         }
1759
1760         if (need_addr && !(argc - optind)) {
1761                 usage();
1762                 exit(1);
1763         }
1764
1765         if (data_size < 0)
1766                 buffer_size = (omtu > imtu) ? omtu : imtu;
1767         else
1768                 buffer_size = data_size;
1769
1770         if (!(buf = malloc(buffer_size))) {
1771                 perror("Can't allocate data buffer");
1772                 exit(1);
1773         }
1774
1775         memset(&sa, 0, sizeof(sa));
1776         sa.sa_handler = SIG_IGN;
1777         sa.sa_flags   = SA_NOCLDSTOP;
1778         sigaction(SIGCHLD, &sa, NULL);
1779
1780         openlog("l2test", LOG_PERROR | LOG_PID, LOG_LOCAL0);
1781
1782         switch (mode) {
1783                 case RECV:
1784                         do_listen(recv_mode);
1785                         break;
1786
1787                 case CRECV:
1788                         sk = do_connect(argv[optind]);
1789                         if (sk < 0)
1790                                 exit(1);
1791                         recv_mode(sk);
1792                         break;
1793
1794                 case DUMP:
1795                         do_listen(dump_mode);
1796                         break;
1797
1798                 case SEND:
1799                         sk = do_connect(argv[optind]);
1800                         if (sk < 0)
1801                                 exit(1);
1802                         send_mode(sk);
1803                         break;
1804
1805                 case LSEND:
1806                         do_listen(send_mode);
1807                         break;
1808
1809                 case RECONNECT:
1810                         reconnect_mode(argv[optind]);
1811                         break;
1812
1813                 case MULTY:
1814                         multi_connect_mode(argc - optind, argv + optind);
1815                         break;
1816
1817                 case CONNECT:
1818                         connect_mode(argv[optind]);
1819                         break;
1820
1821                 case SENDDUMP:
1822                         sk = do_connect(argv[optind]);
1823                         if (sk < 0)
1824                                 exit(1);
1825                         senddump_mode(sk);
1826                         break;
1827
1828                 case LSENDDUMP:
1829                         do_listen(senddump_mode);
1830                         break;
1831
1832                 case LSENDRECV:
1833                         do_listen(send_and_recv_mode);
1834                         break;
1835
1836                 case CSENDRECV:
1837                         sk = do_connect(argv[optind]);
1838                         if (sk < 0)
1839                                 exit(1);
1840
1841                         send_and_recv_mode(sk);
1842                         break;
1843
1844                 case INFOREQ:
1845                         info_request(argv[optind]);
1846                         exit(0);
1847
1848 #ifdef __TIZEN_PATCH__
1849                 case CONFIGREQ:
1850                         config_request(argv[optind]);
1851                         exit(0);
1852 #endif
1853
1854                 case PAIRING:
1855                         do_pairing(argv[optind]);
1856                         exit(0);
1857         }
1858
1859         syslog(LOG_INFO, "Exit");
1860
1861         closelog();
1862
1863         return 0;
1864 }