usr.sbin/btconfig/btconfig.c

   1 /* $NetBSD: btconfig.c,v 1.6 2007/09/07 18:40:01 plunky Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2006 Itronix Inc.
   5  * All rights reserved.
   6  *
   7  * Written by Iain Hibbert for Itronix Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. The name of Itronix Inc. may not be used to endorse
  18  *    or promote products derived from this software without specific
  19  *    prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
  25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  28  * ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/types.h>
  35 #include <sys/param.h>
  36 #include <sys/socket.h>
  37 #include <sys/ioctl.h>
  38
  39 #include <net/if.h>
  40
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <ctype.h>
  44 #include <stdlib.h>
  45 #include <stdarg.h>
  46 #include <unistd.h>
  47 #include <errno.h>
  48 #include <err.h>
  49 #include <bluetooth.h>
  50 #include <netbt/hci.h>
  51 #include <sys/endian.h>
  52
  53 /* inquiry results storage */
  54 struct result {
  55         bdaddr_t        bdaddr;
  56         uint8_t         page_scan_rep_mode;
  57         uint8_t         uclass[HCI_CLASS_SIZE];
  58         uint16_t        clock_offset;
  59         int8_t          rssi;
  60 };
  61
  62 void badarg(const char *);
  63 void badparam(const char *);
  64 void usage(void);
  65 int set_unit(unsigned long);
  66 void config_unit(void);
  67 void print_info(int);
  68 void print_stats(void);
  69 void print_class(const char *);
  70 void print_voice(int);
  71 void tag(const char *);
  72 void print_features(const char *, uint8_t *);
  73 void do_inquiry(void);
  74 void print_result(int, struct result *, int);
  75 void printb(uint16_t v, const char *bits);
  76
  77 void hci_req(uint16_t, uint8_t , void *, size_t, void *, size_t);
  78 #define save_value(opcode, cbuf, clen)  hci_req(opcode, 0, cbuf, clen, NULL, 0)
  79 #define load_value(opcode, rbuf, rlen)  hci_req(opcode, 0, NULL, 0, rbuf, rlen)
  80 #define hci_cmd(opcode, cbuf, clen)     hci_req(opcode, 0, cbuf, clen, NULL, 0)
  81
  82 #define MAX_STR_SIZE    0xff
  83
  84 /* print width */
  85 int width = 0;
  86 #define MAX_WIDTH       70
  87
  88 /* global variables */
  89 int hci;
  90 struct btreq btr;
  91
  92 /* command line flags */
  93 int verbose = 0;        /* more info */
  94 int lflag = 0;          /* list devices */
  95 int sflag = 0;          /* get/zero stats */
  96
  97 /* device up/down (flag) */
  98 int opt_enable = 0;
  99 int opt_reset = 0;
 100 #define FLAGBITS        "\001UP"                \
 101                         "\002RUNNING"           \
 102                         "\003XMIT_CMD"          \
 103                         "\004XMIT_ACL"          \
 104                         "\005XMIT_SCO"          \
 105                         "\006INIT_BDADDR"       \
 106                         "\007INIT_BUFFER_SIZE"  \
 107                         "\010INIT_FEATURES"
 108
 109 /* authorisation (flag) */
 110 int opt_auth = 0;
 111
 112 /* encryption (flag) */
 113 int opt_encrypt = 0;
 114
 115 /* scan enable options (flags) */
 116 int opt_pscan = 0;
 117 int opt_iscan = 0;
 118
 119 /* link policy options (flags) */
 120 int opt_switch = 0;
 121 int opt_hold = 0;
 122 int opt_sniff = 0;
 123 int opt_park = 0;
 124
 125 /* class of device (hex value) */
 126 int opt_class = 0;
 127 uint32_t class;
 128
 129 /* packet type mask (hex value) */
 130 int opt_ptype = 0;
 131 uint32_t ptype;
 132
 133 /* unit name (string) */
 134 int opt_name = 0;
 135 char name[MAX_STR_SIZE];
 136
 137 /* pin type */
 138 int opt_pin = 0;
 139
 140 /* Inquiry */
 141 int opt_rssi = 0;                       /* inquiry_with_rssi (flag) */
 142 int opt_inquiry = 0;
 143 #define INQUIRY_LENGTH          10      /* about 12 seconds */
 144 #define INQUIRY_MAX_RESPONSES   10
 145
 146 /* Voice Settings */
 147 int opt_voice = 0;
 148 uint32_t voice;
 149
 150 /* Page Timeout */
 151 int opt_pto = 0;
 152 uint32_t pto;
 153
 154 /* set SCO mtu */
 155 int opt_scomtu;
 156 uint32_t scomtu;
 157
 158 struct parameter {
 159         const char      *name;
 160         enum { P_SET, P_CLR, P_STR, P_HEX, P_NUM } type;
 161         int             *opt;
 162         void            *val;
 163 } parameters[] = {
 164         { "up",         P_SET,  &opt_enable,    NULL    },
 165         { "enable",     P_SET,  &opt_enable,    NULL    },
 166         { "down",       P_CLR,  &opt_enable,    NULL    },
 167         { "disable",    P_CLR,  &opt_enable,    NULL    },
 168         { "name",       P_STR,  &opt_name,      name    },
 169         { "pscan",      P_SET,  &opt_pscan,     NULL    },
 170         { "-pscan",     P_CLR,  &opt_pscan,     NULL    },
 171         { "iscan",      P_SET,  &opt_iscan,     NULL    },
 172         { "-iscan",     P_CLR,  &opt_iscan,     NULL    },
 173         { "switch",     P_SET,  &opt_switch,    NULL    },
 174         { "-switch",    P_CLR,  &opt_switch,    NULL    },
 175         { "hold",       P_SET,  &opt_hold,      NULL    },
 176         { "-hold",      P_CLR,  &opt_hold,      NULL    },
 177         { "sniff",      P_SET,  &opt_sniff,     NULL    },
 178         { "-sniff",     P_CLR,  &opt_sniff,     NULL    },
 179         { "park",       P_SET,  &opt_park,      NULL    },
 180         { "-park",      P_CLR,  &opt_park,      NULL    },
 181         { "auth",       P_SET,  &opt_auth,      NULL    },
 182         { "-auth",      P_CLR,  &opt_auth,      NULL    },
 183         { "encrypt",    P_SET,  &opt_encrypt,   NULL    },
 184         { "-encrypt",   P_CLR,  &opt_encrypt,   NULL    },
 185         { "ptype",      P_HEX,  &opt_ptype,     &ptype  },
 186         { "class",      P_HEX,  &opt_class,     &class  },
 187         { "fixed",      P_SET,  &opt_pin,       NULL    },
 188         { "variable",   P_CLR,  &opt_pin,       NULL    },
 189         { "inq",        P_SET,  &opt_inquiry,   NULL    },
 190         { "inquiry",    P_SET,  &opt_inquiry,   NULL    },
 191         { "rssi",       P_SET,  &opt_rssi,      NULL    },
 192         { "-rssi",      P_CLR,  &opt_rssi,      NULL    },
 193         { "reset",      P_SET,  &opt_reset,     NULL    },
 194         { "voice",      P_HEX,  &opt_voice,     &voice  },
 195         { "pto",        P_NUM,  &opt_pto,       &pto    },
 196         { "scomtu",     P_NUM,  &opt_scomtu,    &scomtu },
 197         { NULL,         0,      NULL,           NULL    }
 198 };
 199
 200 int
 201 main(int ac, char *av[])
 202 {
 203         int ch;
 204         struct parameter *p;
 205
 206         while ((ch = getopt(ac, av, "hlsvz")) != -1) {
 207                 switch(ch) {
 208                 case 'l':
 209                         lflag = 1;
 210                         break;
 211
 212                 case 's':
 213                         sflag = 1;
 214                         break;
 215
 216                 case 'v':
 217                         verbose++;
 218                         break;
 219
 220                 case 'z':
 221                         sflag = 2;
 222                         break;
 223
 224                 case 'h':
 225                 default:
 226                         usage();
 227                 }
 228         }
 229         av += optind;
 230         ac -= optind;
 231
 232         if (lflag && sflag)
 233                 usage();
 234
 235
 236         hci = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 237         if (hci == -1)
 238                 err(EXIT_FAILURE, "socket");
 239
 240         if (ac == 0) {
 241                 verbose++;
 242
 243                 memset(&btr, 0, sizeof(btr));
 244                 while (set_unit(SIOCNBTINFO) != -1) {
 245                         print_info(99);
 246                         print_stats();
 247                 }
 248
 249                 tag(NULL);
 250         } else {
 251                 strlcpy(btr.btr_name, *av, HCI_DEVNAME_SIZE);
 252                 av++, ac--;
 253
 254                 if (set_unit(SIOCGBTINFO) < 0)
 255                         err(EXIT_FAILURE, "%s", btr.btr_name);
 256
 257                 if (ac == 0)
 258                         verbose += 2;
 259
 260                 while (ac > 0) {
 261                         for (p = parameters ; ; p++) {
 262                                 if (p->name == NULL)
 263                                         badparam(*av);
 264
 265                                 if (strcmp(*av, p->name) == 0)
 266                                         break;
 267                         }
 268
 269                         switch(p->type) {
 270                         case P_SET:
 271                                 *(p->opt) = 1;
 272                                 break;
 273
 274                         case P_CLR:
 275                                 *(p->opt) = -1;
 276                                 break;
 277
 278                         case P_STR:
 279                                 if (--ac < 1) badarg(p->name);
 280                                 strlcpy((char *)(p->val), *++av, MAX_STR_SIZE);
 281                                 *(p->opt) = 1;
 282                                 break;
 283
 284                         case P_HEX:
 285                                 if (--ac < 1) badarg(p->name);
 286                                 *(uint32_t *)(p->val) = strtoul(*++av, NULL, 16);
 287                                 *(p->opt) = 1;
 288                                 break;
 289
 290                         case P_NUM:
 291                                 if (--ac < 1) badarg(p->name);
 292                                 *(uint32_t *)(p->val) = strtoul(*++av, NULL, 10);
 293                                 *(p->opt) = 1;
 294                                 break;
 295                         }
 296
 297                         av++, ac--;
 298                 }
 299
 300                 config_unit();
 301                 print_info(verbose);
 302                 print_stats();
 303                 do_inquiry();
 304         }
 305
 306         close(hci);
 307         return EXIT_SUCCESS;
 308 }
 309
 310 void
 311 badparam(const char *param)
 312 {
 313         fprintf(stderr, "unknown parameter '%s'\n", param);
 314         exit(EXIT_FAILURE);
 315 }
 316
 317 void
 318 badarg(const char *param)
 319 {
 320         fprintf(stderr, "parameter '%s' needs argument\n", param);
 321         exit(EXIT_FAILURE);
 322 }
 323
 324 void
 325 usage(void)
 326 {
 327         fprintf(stderr, "usage: %s [-svz] [device [parameters]]\n", getprogname());
 328         fprintf(stderr, "       %s -l\n", getprogname());
 329         exit(EXIT_FAILURE);
 330 }
 331
 332 /*
 333  * pretty printing feature
 334  */
 335 void
 336 tag(const char *f)
 337 {
 338         if (f == NULL) {
 339                 if (width > 0)
 340                         printf("\n");
 341
 342                 width = 0;
 343         } else {
 344                 width += printf("%*s%s",
 345                                 (width == 0 ? (lflag ? 0 : 8) : 1),
 346                                 "", f);
 347
 348                 if (width > MAX_WIDTH) {
 349                         printf("\n");
 350                         width = 0;
 351                 }
 352         }
 353 }
 354
 355 /*
 356  * basic HCI cmd request function with argument return.
 357  *
 358  * Normally, this will return on COMMAND_STATUS or COMMAND_COMPLETE for the given
 359  * opcode, but if event is given then it will ignore COMMAND_STATUS (unless error)
 360  * and wait for the specified event.
 361  *
 362  * if rbuf/rlen is given, results will be copied into the result buffer for
 363  * COMMAND_COMPLETE/event responses.
 364  */
 365 void
 366 hci_req(uint16_t opcode, uint8_t event, void *cbuf, size_t clen, void *rbuf, size_t rlen)
 367 {
 368         uint8_t msg[sizeof(hci_cmd_hdr_t) + HCI_CMD_PKT_SIZE];
 369         hci_event_hdr_t *ep;
 370         hci_cmd_hdr_t *cp;
 371
 372         cp = (hci_cmd_hdr_t *)msg;
 373         cp->type = HCI_CMD_PKT;
 374         cp->opcode = opcode = htole16(opcode);
 375         cp->length = clen = MIN(clen, sizeof(msg) - sizeof(hci_cmd_hdr_t));
 376
 377         if (clen) memcpy((cp + 1), cbuf, clen);
 378
 379         if (send(hci, msg, sizeof(hci_cmd_hdr_t) + clen, 0) < 0)
 380                 err(EXIT_FAILURE, "HCI Send");
 381
 382         ep = (hci_event_hdr_t *)msg;
 383         for(;;) {
 384                 if (recv(hci, msg, sizeof(msg), 0) < 0) {
 385                         if (errno == EAGAIN || errno == EINTR)
 386                                 continue;
 387
 388                         err(EXIT_FAILURE, "HCI Recv");
 389                 }
 390
 391                 if (ep->event == HCI_EVENT_COMMAND_STATUS) {
 392                         hci_command_status_ep *cs;
 393
 394                         cs = (hci_command_status_ep *)(ep + 1);
 395                         if (cs->opcode != opcode)
 396                                 continue;
 397
 398                         if (cs->status)
 399                                 errx(EXIT_FAILURE,
 400                                     "HCI cmd (%4.4x) failed (status %d)",
 401                                     opcode, cs->status);
 402
 403                         if (event == 0)
 404                                 break;
 405
 406                         continue;
 407                 }
 408
 409                 if (ep->event == HCI_EVENT_COMMAND_COMPL) {
 410                         hci_command_compl_ep *cc;
 411                         uint8_t *ptr;
 412
 413                         cc = (hci_command_compl_ep *)(ep + 1);
 414                         if (cc->opcode != opcode)
 415                                 continue;
 416
 417                         if (rbuf == NULL)
 418                                 break;
 419
 420                         ptr = (uint8_t *)(cc + 1);
 421                         if (*ptr)
 422                                 errx(EXIT_FAILURE,
 423                                     "HCI cmd (%4.4x) failed (status %d)",
 424                                     opcode, *ptr);
 425
 426                         memcpy(rbuf, ++ptr, rlen);
 427                         break;
 428                 }
 429
 430                 if (ep->event == event) {
 431                         if (rbuf == NULL)
 432                                 break;
 433
 434                         memcpy(rbuf, (ep + 1), rlen);
 435                         break;
 436                 }
 437         }
 438 }
 439
 440 int
 441 set_unit(unsigned long cmd)
 442 {
 443         if (ioctl(hci, cmd, &btr) == -1)
 444                 return -1;
 445
 446         if (btr.btr_flags & BTF_UP) {
 447                 struct sockaddr_bt sa;
 448
 449                 sa.bt_len = sizeof(sa);
 450                 sa.bt_family = AF_BLUETOOTH;
 451                 bdaddr_copy(&sa.bt_bdaddr, &btr.btr_bdaddr);
 452
 453                 if (bind(hci, (struct sockaddr *)&sa, sizeof(sa)) < 0)
 454                         err(EXIT_FAILURE, "bind");
 455
 456                 if (connect(hci, (struct sockaddr *)&sa, sizeof(sa)) < 0)
 457                         err(EXIT_FAILURE, "connect");
 458         }
 459
 460         return 0;
 461 }
 462
 463 /*
 464  * apply configuration parameters to unit
 465  */
 466 void
 467 config_unit(void)
 468 {
 469         if (opt_enable) {
 470                 if (opt_enable > 0)
 471                         btr.btr_flags |= BTF_UP;
 472                 else
 473                         btr.btr_flags &= ~BTF_UP;
 474
 475                 if (ioctl(hci, SIOCSBTFLAGS, &btr) < 0)
 476                         err(EXIT_FAILURE, "SIOCSBTFLAGS");
 477
 478                 if (set_unit(SIOCGBTINFO) < 0)
 479                         err(EXIT_FAILURE, "%s", btr.btr_name);
 480         }
 481
 482         if (opt_reset) {
 483                 hci_cmd(HCI_CMD_RESET, NULL, 0);
 484
 485                 btr.btr_flags |= BTF_INIT;
 486                 if (ioctl(hci, SIOCSBTFLAGS, &btr) < 0)
 487                         err(EXIT_FAILURE, "SIOCSBTFLAGS");
 488
 489                 /*
 490                  * although the reset command will automatically
 491                  * carry out these commands, we do them manually
 492                  * just so we can wait for completion.
 493                  */
 494                 hci_cmd(HCI_CMD_READ_BDADDR, NULL, 0);
 495                 hci_cmd(HCI_CMD_READ_BUFFER_SIZE, NULL, 0);
 496                 hci_cmd(HCI_CMD_READ_LOCAL_FEATURES, NULL, 0);
 497
 498                 if (set_unit(SIOCGBTINFO) < 0)
 499                         err(EXIT_FAILURE, "%s", btr.btr_name);
 500         }
 501
 502         if (opt_switch || opt_hold || opt_sniff || opt_park) {
 503                 uint16_t val = btr.btr_link_policy;
 504
 505                 if (opt_switch > 0) val |= HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
 506                 if (opt_switch < 0) val &= ~HCI_LINK_POLICY_ENABLE_ROLE_SWITCH;
 507                 if (opt_hold > 0)   val |= HCI_LINK_POLICY_ENABLE_HOLD_MODE;
 508                 if (opt_hold < 0)   val &= ~HCI_LINK_POLICY_ENABLE_HOLD_MODE;
 509                 if (opt_sniff > 0)  val |= HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
 510                 if (opt_sniff < 0)  val &= ~HCI_LINK_POLICY_ENABLE_SNIFF_MODE;
 511                 if (opt_park > 0)   val |= HCI_LINK_POLICY_ENABLE_PARK_MODE;
 512                 if (opt_park < 0)   val &= ~HCI_LINK_POLICY_ENABLE_PARK_MODE;
 513
 514                 btr.btr_link_policy = val;
 515                 if (ioctl(hci, SIOCSBTPOLICY, &btr) < 0)
 516                         err(EXIT_FAILURE, "SIOCSBTPOLICY");
 517         }
 518
 519         if (opt_ptype) {
 520                 btr.btr_packet_type = ptype;
 521                 if (ioctl(hci, SIOCSBTPTYPE, &btr) < 0)
 522                         err(EXIT_FAILURE, "SIOCSBTPTYPE");
 523         }
 524
 525         if (opt_pscan || opt_iscan) {
 526                 uint8_t val;
 527
 528                 load_value(HCI_CMD_READ_SCAN_ENABLE, &val, sizeof(val));
 529                 if (opt_pscan > 0) val |= HCI_PAGE_SCAN_ENABLE;
 530                 if (opt_pscan < 0) val &= ~HCI_PAGE_SCAN_ENABLE;
 531                 if (opt_iscan > 0) val |= HCI_INQUIRY_SCAN_ENABLE;
 532                 if (opt_iscan < 0) val &= ~HCI_INQUIRY_SCAN_ENABLE;
 533                 save_value(HCI_CMD_WRITE_SCAN_ENABLE, &val, sizeof(val));
 534         }
 535
 536         if (opt_auth) {
 537                 uint8_t val = (opt_auth > 0 ? 1 : 0);
 538
 539                 save_value(HCI_CMD_WRITE_AUTH_ENABLE, &val, sizeof(val));
 540         }
 541
 542         if (opt_encrypt) {
 543                 uint8_t val = (opt_encrypt > 0 ? 1 : 0);
 544
 545                 save_value(HCI_CMD_WRITE_ENCRYPTION_MODE, &val, sizeof(val));
 546         }
 547
 548         if (opt_name)
 549                 save_value(HCI_CMD_WRITE_LOCAL_NAME, name, HCI_UNIT_NAME_SIZE);
 550
 551         if (opt_class) {
 552                 uint8_t val[HCI_CLASS_SIZE];
 553
 554                 val[0] = (class >> 0) & 0xff;
 555                 val[1] = (class >> 8) & 0xff;
 556                 val[2] = (class >> 16) & 0xff;
 557
 558                 save_value(HCI_CMD_WRITE_UNIT_CLASS, val, HCI_CLASS_SIZE);
 559         }
 560
 561         if (opt_pin) {
 562                 uint8_t val;
 563
 564                 if (opt_pin > 0)        val = 1;
 565                 else                    val = 0;
 566
 567                 save_value(HCI_CMD_WRITE_PIN_TYPE, &val, sizeof(val));
 568         }
 569
 570         if (opt_voice) {
 571                 uint16_t val;
 572
 573                 val = htole16(voice & 0x03ff);
 574                 save_value(HCI_CMD_WRITE_VOICE_SETTING, &val, sizeof(val));
 575         }
 576
 577         if (opt_pto) {
 578                 uint16_t val;
 579
 580                 val = htole16(pto * 8 / 5);
 581                 save_value(HCI_CMD_WRITE_PAGE_TIMEOUT, &val, sizeof(val));
 582         }
 583
 584         if (opt_scomtu) {
 585                 if (scomtu > 0xff) {
 586                         warnx("Invalid SCO mtu %d", scomtu);
 587                 } else {
 588                         btr.btr_sco_mtu = scomtu;
 589
 590                         if (ioctl(hci, SIOCSBTSCOMTU, &btr) < 0)
 591                                 warn("SIOCSBTSCOMTU");
 592                 }
 593         }
 594
 595         if (opt_rssi) {
 596                 uint8_t val = (opt_rssi > 0 ? 1 : 0);
 597
 598                 save_value(HCI_CMD_WRITE_INQUIRY_MODE, &val, sizeof(val));
 599         }
 600 }
 601
 602 /*
 603  * Print info for Bluetooth Device with varying verbosity levels
 604  */
 605 void
 606 print_info(int level)
 607 {
 608         uint8_t val, buf[MAX_STR_SIZE];
 609         uint16_t val16;
 610
 611         if (lflag) {
 612                 tag(btr.btr_name);
 613                 return;
 614         }
 615
 616         if (level-- < 1)
 617                 return;
 618
 619         printf("%s: bdaddr %s flags %#x", btr.btr_name,
 620                 bt_ntoa(&btr.btr_bdaddr, NULL), btr.btr_flags);
 621         printb(btr.btr_flags, FLAGBITS);
 622         printf("\n");
 623
 624         if (level-- < 1)
 625                 return;
 626
 627         printf("\tnum_cmd = %d\n"
 628                "\tnum_acl = %d, acl_mtu = %d\n"
 629                "\tnum_sco = %d, sco_mtu = %d\n",
 630                btr.btr_num_cmd,
 631                btr.btr_num_acl, btr.btr_acl_mtu,
 632                btr.btr_num_sco, btr.btr_sco_mtu);
 633
 634         if (level-- < 1 || (btr.btr_flags & BTF_UP) == 0)
 635                 return;
 636
 637         load_value(HCI_CMD_READ_UNIT_CLASS, buf, HCI_CLASS_SIZE);
 638         class = (buf[2] << 16) | (buf[1] << 8) | (buf[0]);
 639         print_class("\t");
 640
 641         load_value(HCI_CMD_READ_LOCAL_NAME, buf, HCI_UNIT_NAME_SIZE);
 642         printf("\tname: \"%s\"\n", buf);
 643
 644         load_value(HCI_CMD_READ_VOICE_SETTING, buf, sizeof(uint16_t));
 645         voice = (buf[1] << 8) | buf[0];
 646         print_voice(level);
 647
 648         load_value(HCI_CMD_READ_PIN_TYPE, &val, sizeof(val));
 649         printf("\tpin: %s\n", val ? "fixed" : "variable");
 650
 651         width = printf("\toptions:");
 652
 653         load_value(HCI_CMD_READ_SCAN_ENABLE, &val, sizeof(val));
 654         if (val & HCI_INQUIRY_SCAN_ENABLE)      tag("iscan");
 655         else if (level > 0)                     tag("-iscan");
 656
 657         if (val & HCI_PAGE_SCAN_ENABLE)         tag("pscan");
 658         else if (level > 0)                     tag("-pscan");
 659
 660         load_value(HCI_CMD_READ_AUTH_ENABLE, &val, sizeof(val));
 661         if (val)                                tag("auth");
 662         else if (level > 0)                     tag("-auth");
 663
 664         load_value(HCI_CMD_READ_ENCRYPTION_MODE, &val, sizeof(val));
 665         if (val)                                tag("encrypt");
 666         else if (level > 0)                     tag("-encrypt");
 667
 668         val = btr.btr_link_policy;
 669         if (val & HCI_LINK_POLICY_ENABLE_ROLE_SWITCH)   tag("switch");
 670         else if (level > 0)                             tag("-switch");
 671         if (val & HCI_LINK_POLICY_ENABLE_HOLD_MODE)     tag("hold");
 672         else if (level > 0)                             tag("-hold");
 673         if (val & HCI_LINK_POLICY_ENABLE_SNIFF_MODE)    tag("sniff");
 674         else if (level > 0)                             tag("-sniff");
 675         if (val & HCI_LINK_POLICY_ENABLE_PARK_MODE)     tag("park");
 676         else if (level > 0)                             tag("-park");
 677
 678         load_value(HCI_CMD_READ_INQUIRY_MODE, &val, sizeof(val));
 679         if (val)                                tag("rssi");
 680         else if (level > 0)                     tag("-rssi");
 681
 682         tag(NULL);
 683
 684         if (level-- < 1)
 685                 return;
 686
 687         ptype = btr.btr_packet_type;
 688         width = printf("\tptype: [0x%04x]", ptype);
 689         if (ptype & HCI_PKT_DM1)                tag("DM1");
 690         if (ptype & HCI_PKT_DH1)                tag("DH1");
 691         if (ptype & HCI_PKT_DM3)                tag("DM3");
 692         if (ptype & HCI_PKT_DH3)                tag("DH3");
 693         if (ptype & HCI_PKT_DM5)                tag("DM5");
 694         if (ptype & HCI_PKT_DH5)                tag("DH5");
 695         if ((ptype & HCI_PKT_2MBPS_DH1) == 0)   tag("2-DH1");
 696         if ((ptype & HCI_PKT_3MBPS_DH1) == 0)   tag("3-DH1");
 697         if ((ptype & HCI_PKT_2MBPS_DH3) == 0)   tag("2-DH3");
 698         if ((ptype & HCI_PKT_3MBPS_DH3) == 0)   tag("3-DH3");
 699         if ((ptype & HCI_PKT_2MBPS_DH5) == 0)   tag("2-DH5");
 700         if ((ptype & HCI_PKT_3MBPS_DH5) == 0)   tag("3-DH5");
 701         tag(NULL);
 702
 703         load_value(HCI_CMD_READ_PAGE_TIMEOUT, &val16, sizeof(val16));
 704         printf("\tpage timeout: %d ms\n", val16 * 5 / 8);
 705
 706         if (level-- < 1)
 707                 return;
 708
 709         load_value(HCI_CMD_READ_LOCAL_FEATURES, buf, HCI_FEATURES_SIZE);
 710         print_features("\tfeatures:", buf);
 711 }
 712
 713 void
 714 print_stats(void)
 715 {
 716         if (sflag == 0)
 717                 return;
 718
 719         if (sflag == 1) {
 720                 if (ioctl(hci, SIOCGBTSTATS, &btr) < 0)
 721                         err(EXIT_FAILURE, "SIOCGBTSTATS");
 722         } else  {
 723                 if (ioctl(hci, SIOCZBTSTATS, &btr) < 0)
 724                         err(EXIT_FAILURE, "SIOCZBTSTATS");
 725         }
 726
 727         printf( "\tTotal bytes sent %d, received %d\n"
 728                 "\tCommands sent %d, Events received %d\n"
 729                 "\tACL data packets sent %d, received %d\n"
 730                 "\tSCO data packets sent %d, received %d\n"
 731                 "\tInput errors %d, Output errors %d\n",
 732                 btr.btr_stats.byte_tx, btr.btr_stats.byte_rx,
 733                 btr.btr_stats.cmd_tx, btr.btr_stats.evt_rx,
 734                 btr.btr_stats.acl_tx, btr.btr_stats.acl_rx,
 735                 btr.btr_stats.sco_tx, btr.btr_stats.sco_rx,
 736                 btr.btr_stats.err_rx, btr.btr_stats.err_tx);
 737 }
 738
 739 void
 740 print_features(const char *str, uint8_t *f)
 741 {
 742         width = printf("%s", str);
 743
 744         /* ------------------- byte 0 --------------------*/
 745         if (*f & HCI_LMP_3SLOT)             tag("<3 slot>");
 746         if (*f & HCI_LMP_5SLOT)             tag("<5 slot>");
 747         if (*f & HCI_LMP_ENCRYPTION)        tag("<encryption>");
 748         if (*f & HCI_LMP_SLOT_OFFSET)       tag("<slot offset>");
 749         if (*f & HCI_LMP_TIMIACCURACY)      tag("<timing accuracy>");
 750         if (*f & HCI_LMP_ROLE_SWITCH)       tag("<role switch>");
 751         if (*f & HCI_LMP_HOLD_MODE)         tag("<hold mode>");
 752         if (*f & HCI_LMP_SNIFF_MODE)        tag("<sniff mode>");
 753         f++;
 754
 755         /* ------------------- byte 1 --------------------*/
 756         if (*f & HCI_LMP_PARK_MODE)         tag("<park mode>");
 757         if (*f & HCI_LMP_RSSI)              tag("<RSSI>");
 758         if (*f & HCI_LMP_CHANNEL_QUALITY)   tag("<channel quality>");
 759         if (*f & HCI_LMP_SCO_LINK)          tag("<SCO link>");
 760         if (*f & HCI_LMP_HV2_PKT)           tag("<HV2>");
 761         if (*f & HCI_LMP_HV3_PKT)           tag("<HV3>");
 762         if (*f & HCI_LMP_ULAW_LOG)          tag("<u-Law log>");
 763         if (*f & HCI_LMP_ALAW_LOG)          tag("<A-Law log>");
 764         f++;
 765
 766         /* ------------------- byte 1 --------------------*/
 767         if (*f & HCI_LMP_CVSD)              tag("<CVSD data>");
 768         if (*f & HCI_LMP_PAGISCHEME)        tag("<paging parameter>");
 769         if (*f & HCI_LMP_POWER_CONTROL)     tag("<power control>");
 770         if (*f & HCI_LMP_TRANSPARENT_SCO)   tag("<transparent SCO>");
 771         if (*f & HCI_LMP_FLOW_CONTROL_LAG0) tag("<flow control lag 0>");
 772         if (*f & HCI_LMP_FLOW_CONTROL_LAG1) tag("<flow control lag 1>");
 773         if (*f & HCI_LMP_FLOW_CONTROL_LAG2) tag("<flow control lag 2>");
 774         if (*f & HCI_LMP_BC_ENCRYPTION)     tag("<broadcast encryption>");
 775         f++;
 776
 777         /* ------------------- byte 3 --------------------*/
 778         if (*f & HCI_LMP_EDR_ACL_2MBPS)     tag("<EDR ACL 2Mbps>");
 779         if (*f & HCI_LMP_EDR_ACL_3MBPS)     tag("<EDR ACL 3Mbps>");
 780         if (*f & HCI_LMP_ENHANCED_ISCAN)    tag("<enhanced inquiry scan>");
 781         if (*f & HCI_LMP_INTERLACED_ISCAN)  tag("<interlaced inquiry scan>");
 782         if (*f & HCI_LMP_INTERLACED_PSCAN)  tag("<interlaced page scan>");
 783         if (*f & HCI_LMP_RSSI_INQUIRY)      tag("<RSSI with inquiry result>");
 784         if (*f & HCI_LMP_EV3_PKT)           tag("<EV3 packets>");
 785         f++;
 786
 787         /* ------------------- byte 4 --------------------*/
 788         if (*f & HCI_LMP_EV4_PKT)           tag("<EV4 packets>");
 789         if (*f & HCI_LMP_EV5_PKT)           tag("<EV5 packets>");
 790         if (*f & HCI_LMP_AFH_CAPABLE_SLAVE) tag("<AFH capable slave>");
 791         if (*f & HCI_LMP_AFH_CLASS_SLAVE)   tag("<AFH class slave>");
 792         if (*f & HCI_LMP_3SLOT_EDR_ACL)     tag("<3 slot EDR ACL>");
 793         f++;
 794
 795         /* ------------------- byte 5 --------------------*/
 796         if (*f & HCI_LMP_5SLOT_EDR_ACL)     tag("<5 slot EDR ACL>");
 797         if (*f & HCI_LMP_AFH_CAPABLE_MASTER)tag("<AFH capable master>");
 798         if (*f & HCI_LMP_AFH_CLASS_MASTER)  tag("<AFH class master>");
 799         if (*f & HCI_LMP_EDR_eSCO_2MBPS)    tag("<EDR eSCO 2Mbps>");
 800         if (*f & HCI_LMP_EDR_eSCO_3MBPS)    tag("<EDR eSCO 3Mbps>");
 801         if (*f & HCI_LMP_3SLOT_EDR_eSCO)    tag("<3 slot EDR eSCO>");
 802         f++;
 803
 804         /* ------------------- byte 6 --------------------*/
 805         f++;
 806
 807         /* ------------------- byte 7 --------------------*/
 808         if (*f & HCI_LMP_EXTENDED_FEATURES) tag("<extended features>");
 809
 810         tag(NULL);
 811 }
 812
 813 void
 814 print_class(const char *str)
 815 {
 816         int major, minor;
 817
 818         major = (class & 0x1f00) >> 8;
 819         minor = (class & 0x00fc) >> 2;
 820
 821         width = printf("%sclass: [0x%6.6x]", str, class);
 822
 823         switch (major) {
 824         case 1: /* Computer */
 825                 switch (minor) {
 826                 case 1: tag("Desktop");                         break;
 827                 case 2: tag("Server");                          break;
 828                 case 3: tag("Laptop");                          break;
 829                 case 4: tag("Handheld");                        break;
 830                 case 5: tag("Palm Sized");                      break;
 831                 case 6: tag("Wearable");                        break;
 832                 }
 833                 tag("Computer");
 834                 break;
 835
 836         case 2: /* Phone */
 837                 switch (minor) {
 838                 case 1: tag("Cellular Phone");                  break;
 839                 case 2: tag("Cordless Phone");                  break;
 840                 case 3: tag("Smart Phone");                     break;
 841                 case 4: tag("Wired Modem/Phone Gateway");       break;
 842                 case 5: tag("Common ISDN");                     break;
 843                 default:tag("Phone");                           break;
 844                 }
 845                 break;
 846
 847         case 3: /* LAN */
 848                 tag("LAN");
 849                 switch ((minor & 0x38) >> 3) {
 850                 case 0: tag("[Fully available]");               break;
 851                 case 1: tag("[1-17% utilised]");                break;
 852                 case 2: tag("[17-33% utilised]");               break;
 853                 case 3: tag("[33-50% utilised]");               break;
 854                 case 4: tag("[50-67% utilised]");               break;
 855                 case 5: tag("[67-83% utilised]");               break;
 856                 case 6: tag("[83-99% utilised]");               break;
 857                 case 7: tag("[No service available]");          break;
 858                 }
 859                 break;
 860
 861         case 4: /* Audio/Visual */
 862                 switch (minor) {
 863                 case 1: tag("Wearable Headset");                break;
 864                 case 2: tag("Hands-free Audio");                break;
 865                 case 4: tag("Microphone");                      break;
 866                 case 5: tag("Loudspeaker");                     break;
 867                 case 6: tag("Headphones");                      break;
 868                 case 7: tag("Portable Audio");                  break;
 869                 case 8: tag("Car Audio");                       break;
 870                 case 9: tag("Set-top Box");                     break;
 871                 case 10: tag("HiFi Audio");                     break;
 872                 case 11: tag("VCR");                            break;
 873                 case 12: tag("Video Camera");                   break;
 874                 case 13: tag("Camcorder");                      break;
 875                 case 14: tag("Video Monitor");                  break;
 876                 case 15: tag("Video Display and Loudspeaker");  break;
 877                 case 16: tag("Video Conferencing");             break;
 878                 case 18: tag("A/V [Gaming/Toy]");               break;
 879                 default: tag("Audio/Visual");                   break;
 880                 }
 881                 break;
 882
 883         case 5: /* Peripheral */
 884                 switch (minor & 0x0f) {
 885                 case 1: tag("Joystick");                        break;
 886                 case 2: tag("Gamepad");                         break;
 887                 case 3: tag("Remote Control");                  break;
 888                 case 4: tag("Sensing Device");                  break;
 889                 case 5: tag("Digitiser Tablet");                break;
 890                 case 6: tag("Card Reader");                     break;
 891                 default: tag("Peripheral");                     break;
 892                 }
 893
 894                 if (minor & 0x10) tag("Keyboard");
 895                 if (minor & 0x20) tag("Mouse");
 896                 break;
 897
 898         case 6: /* Imaging */
 899                 if (minor & 0x20) tag("Printer");
 900                 if (minor & 0x10) tag("Scanner");
 901                 if (minor & 0x08) tag("Camera");
 902                 if (minor & 0x04) tag("Display");
 903                 if ((minor & 0x3c) == 0) tag("Imaging");
 904                 break;
 905
 906         case 7: /* Wearable */
 907                 switch (minor) {
 908                 case 1: tag("Wrist Watch");                     break;
 909                 case 2: tag("Pager");                           break;
 910                 case 3: tag("Jacket");                          break;
 911                 case 4: tag("Helmet");                          break;
 912                 case 5: tag("Glasses");                         break;
 913                 default: tag("Wearable");                       break;
 914                 }
 915                 break;
 916
 917         case 8: /* Toy */
 918                 switch (minor) {
 919                 case 1: tag("Robot");                           break;
 920                 case 2: tag("Vehicle");                         break;
 921                 case 3: tag("Doll / Action Figure");            break;
 922                 case 4: tag("Controller");                      break;
 923                 case 5: tag("Game");                            break;
 924                 default: tag("Toy");                            break;
 925                 }
 926                 break;
 927
 928         default:
 929                 break;
 930         }
 931
 932         if (class & 0x002000)   tag("<Limited Discoverable>");
 933         if (class & 0x010000)   tag("<Positioning>");
 934         if (class & 0x020000)   tag("<Networking>");
 935         if (class & 0x040000)   tag("<Rendering>");
 936         if (class & 0x080000)   tag("<Capturing>");
 937         if (class & 0x100000)   tag("<Object Transfer>");
 938         if (class & 0x200000)   tag("<Audio>");
 939         if (class & 0x400000)   tag("<Telephony>");
 940         if (class & 0x800000)   tag("<Information>");
 941         tag(NULL);
 942 }
 943
 944 void
 945 print_voice(int level)
 946 {
 947         printf("\tvoice: [0x%4.4x]\n", voice);
 948
 949         if (level == 0)
 950                 return;
 951
 952         printf("\t\tInput Coding: ");
 953         switch ((voice & 0x0300) >> 8) {
 954         case 0x00:      printf("Linear PCM [%d-bit, pos %d]",
 955                         (voice & 0x0020 ? 16 : 8),
 956                         (voice & 0x001c) >> 2);         break;
 957         case 0x01:      printf("u-Law");                break;
 958         case 0x02:      printf("A-Law");                break;
 959         case 0x03:      printf("unknown");              break;
 960         }
 961
 962         switch ((voice & 0x00c0) >> 6) {
 963         case 0x00:      printf(", 1's complement");     break;
 964         case 0x01:      printf(", 2's complement");     break;
 965         case 0x02:      printf(", sign magnitude");     break;
 966         case 0x03:      printf(", unsigned");           break;
 967         }
 968
 969         printf("\n\t\tAir Coding: ");
 970         switch (voice & 0x0003) {
 971         case 0x00:      printf("CVSD");                 break;
 972         case 0x01:      printf("u-Law");                break;
 973         case 0x02:      printf("A-Law");                break;
 974         case 0x03:      printf("Transparent");          break;
 975         }
 976
 977         printf("\n");
 978 }
 979
 980 void
 981 print_result(int num, struct result *r, int rssi)
 982 {
 983         hci_remote_name_req_cp ncp;
 984         hci_remote_name_req_compl_ep nep;
 985 #if 0
 986         hci_read_remote_features_cp fcp;
 987         hci_read_remote_features_compl_ep fep;
 988         struct hostent *hp;
 989 #endif
 990
 991         printf("%3d: bdaddr %s",
 992                         num,
 993                         bt_ntoa(&r->bdaddr, NULL));
 994
 995 #if 0
 996         hp = bt_gethostbyaddr(&r->bdaddr, sizeof(bdaddr_t), AF_BLUETOOTH);
 997         if (hp != NULL)
 998                 printf(" (%s)", hp->h_name);
 999 #endif
1000         printf("\n");
1001
1002         memset(&ncp, 0, sizeof(ncp));
1003         bdaddr_copy(&ncp.bdaddr, &r->bdaddr);
1004         ncp.page_scan_rep_mode = r->page_scan_rep_mode;
1005         ncp.clock_offset = r->clock_offset;
1006
1007         hci_req(HCI_CMD_REMOTE_NAME_REQ,
1008                 HCI_EVENT_REMOTE_NAME_REQ_COMPL,
1009                 &ncp, sizeof(ncp),
1010                 &nep, sizeof(nep));
1011
1012         printf("   : name \"%s\"\n", nep.name);
1013
1014         class = (r->uclass[2] << 16) | (r->uclass[1] << 8) | (r->uclass[0]);
1015         print_class("   : ");
1016
1017 #if 0
1018         hci_req(HCI_CMD_READ_REMOTE_FEATURES,
1019                 HCI_EVENT_READ_REMOTE_FEATURES_COMPL,
1020                 &fcp, sizeof(fcp),
1021                 &fep, sizeof(fep));
1022
1023         print_features("   : features", fep.features);
1024 #endif
1025
1026         printf("   : page scan rep mode 0x%02x\n", r->page_scan_rep_mode);
1027         printf("   : clock offset %d\n", le16toh(r->clock_offset));
1028
1029         if (rssi)
1030                 printf("   : rssi %d\n", r->rssi);
1031
1032         printf("\n");
1033 }
1034
1035 void
1036 do_inquiry(void)
1037 {
1038         uint8_t buf[HCI_EVENT_PKT_SIZE];
1039         struct result result[INQUIRY_MAX_RESPONSES];
1040         hci_inquiry_cp inq;
1041         struct hci_filter f;
1042         hci_event_hdr_t *hh;
1043         int i, j, num, rssi;
1044
1045         if (opt_inquiry == 0)
1046                 return;
1047
1048         printf("Device Discovery from device: %s ...", btr.btr_name);
1049         fflush(stdout);
1050
1051         memset(&f, 0, sizeof(f));
1052         hci_filter_set(HCI_EVENT_COMMAND_STATUS, &f);
1053         hci_filter_set(HCI_EVENT_COMMAND_COMPL, &f);
1054         hci_filter_set(HCI_EVENT_INQUIRY_RESULT, &f);
1055         hci_filter_set(HCI_EVENT_RSSI_RESULT, &f);
1056         hci_filter_set(HCI_EVENT_INQUIRY_COMPL, &f);
1057         hci_filter_set(HCI_EVENT_REMOTE_NAME_REQ_COMPL, &f);
1058         hci_filter_set(HCI_EVENT_READ_REMOTE_FEATURES_COMPL, &f);
1059         if (setsockopt(hci, BTPROTO_HCI, SO_HCI_EVT_FILTER, &f, sizeof(f)) < 0)
1060                 err(EXIT_FAILURE, "Can't set event filter");
1061
1062         /* General Inquiry LAP is 0x9e8b33 */
1063         inq.lap[0] = 0x33;
1064         inq.lap[1] = 0x8b;
1065         inq.lap[2] = 0x9e;
1066         inq.inquiry_length = INQUIRY_LENGTH;
1067         inq.num_responses = INQUIRY_MAX_RESPONSES;
1068
1069         hci_cmd(HCI_CMD_INQUIRY, &inq, sizeof(inq));
1070
1071         num = 0;
1072         rssi = 0;
1073         hh = (hci_event_hdr_t *)buf;
1074
1075         for (;;) {
1076                 if (recv(hci, buf, sizeof(buf), 0) <= 0)
1077                         err(EXIT_FAILURE, "recv");
1078
1079                 if (hh->event == HCI_EVENT_INQUIRY_COMPL)
1080                         break;
1081
1082                 if (hh->event == HCI_EVENT_INQUIRY_RESULT) {
1083                         hci_inquiry_result_ep *ep = (hci_inquiry_result_ep *)(hh + 1);
1084                         hci_inquiry_response *ir = (hci_inquiry_response *)(ep + 1);
1085
1086                         for (i = 0 ; i < ep->num_responses ; i++) {
1087                                 if (num == INQUIRY_MAX_RESPONSES)
1088                                         break;
1089
1090                                 /* some devices keep responding, ignore dupes */
1091                                 for (j = 0 ; j < num ; j++)
1092                                         if (bdaddr_same(&result[j].bdaddr, &ir[i].bdaddr))
1093                                                 break;
1094
1095                                 if (j < num)
1096                                         continue;
1097
1098                                 bdaddr_copy(&result[num].bdaddr, &ir[i].bdaddr);
1099                                 memcpy(&result[num].uclass, &ir[i].uclass, HCI_CLASS_SIZE);
1100                                 result[num].page_scan_rep_mode = ir[i].page_scan_rep_mode;
1101                                 result[num].clock_offset = ir[i].clock_offset;
1102                                 result[num].rssi = 0;
1103                                 num++;
1104                                 printf(".");
1105                                 fflush(stdout);
1106                         }
1107                         continue;
1108                 }
1109 #if 0
1110                 if (hh->event == HCI_EVENT_RSSI_RESULT) {
1111                         hci_rssi_result_ep *ep = (hci_rssi_result_ep *)(hh + 1);
1112                         hci_rssi_response *rr = (hci_rssi_response *)(ep + 1);
1113
1114                         for (i = 0 ; i < ep->num_responses ; i++) {
1115                                 if (num == INQUIRY_MAX_RESPONSES)
1116                                         break;
1117
1118                                 /* some devices keep responding, ignore dupes */
1119                                 for (j = 0 ; j < num ; j++)
1120                                         if (bdaddr_same(&result[j].bdaddr, &rr[i].bdaddr))
1121                                                 break;
1122
1123                                 if (j < num)
1124                                         continue;
1125
1126                                 bdaddr_copy(&result[num].bdaddr, &rr[i].bdaddr);
1127                                 memcpy(&result[num].uclass, &rr[i].uclass, HCI_CLASS_SIZE);
1128                                 result[num].page_scan_rep_mode = rr[i].page_scan_rep_mode;
1129                                 result[num].clock_offset = rr[i].clock_offset;
1130                                 result[num].rssi = rr[i].rssi;
1131                                 rssi = 1;
1132                                 num++;
1133                                 printf(".");
1134                                 fflush(stdout);
1135                         }
1136                         continue;
1137                 }
1138 #endif
1139         }
1140
1141         printf(" %d response%s\n", num, (num == 1 ? "" : "s"));
1142
1143         for (i = 0 ; i < num ; i++)
1144                 print_result(i + 1, &result[i], rssi);
1145 }
1146
1147 /*
1148  * Print a value a la the %b format of the kernel's printf borrowed
1149  * from ifconfig(8).
1150  */
1151 void
1152 printb(uint16_t v, const char *bits)
1153 {
1154         int i, any = 0;
1155         char c;
1156
1157         if (bits) {
1158                 putchar('<');
1159                 while ((i = *bits++) != '\0') {
1160                         if (v & (1 << (i-1))) {
1161                                 if (any)
1162                                         putchar(',');
1163                                 any = 1;
1164                                 for (; (c = *bits) > 32; bits++)
1165                                         putchar(c);
1166                         } else
1167                                 for (; *bits > 32; bits++)
1168                                         ;
1169                 }
1170                 putchar('>');
1171         }
1172 }
1173