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