tools/ciptool.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #define _GNU_SOURCE
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <getopt.h>
  35 #include <signal.h>
  36 #include <sys/poll.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/socket.h>
  39
  40 #include <bluetooth/bluetooth.h>
  41 #include <bluetooth/hci.h>
  42 #include <bluetooth/hci_lib.h>
  43 #include <bluetooth/l2cap.h>
  44 #include <bluetooth/sdp.h>
  45 #include <bluetooth/sdp_lib.h>
  46 #include <bluetooth/cmtp.h>
  47
  48 #ifdef NEED_PPOLL
  49 #include "ppoll.h"
  50 #endif
  51
  52 static volatile sig_atomic_t __io_canceled = 0;
  53
  54 static void sig_hup(int sig)
  55 {
  56         return;
  57 }
  58
  59 static void sig_term(int sig)
  60 {
  61         __io_canceled = 1;
  62 }
  63
  64 static char *cmtp_state[] = {
  65         "unknown",
  66         "connected",
  67         "open",
  68         "bound",
  69         "listening",
  70         "connecting",
  71         "connecting",
  72         "config",
  73         "disconnecting",
  74         "closed"
  75 };
  76
  77 static char *cmtp_flagstostr(uint32_t flags)
  78 {
  79         static char str[100] = "";
  80
  81         strcat(str, "[");
  82
  83         if (flags & (1 << CMTP_LOOPBACK))
  84                 strcat(str, "loopback");
  85
  86         strcat(str, "]");
  87
  88         return str;
  89 }
  90
  91 static int get_psm(bdaddr_t *src, bdaddr_t *dst, unsigned short *psm)
  92 {
  93         sdp_session_t *s;
  94         sdp_list_t *srch, *attrs, *rsp;
  95         uuid_t svclass;
  96         uint16_t attr;
  97         int err;
  98
  99         if (!(s = sdp_connect(src, dst, 0)))
 100                 return -1;
 101
 102         sdp_uuid16_create(&svclass, CIP_SVCLASS_ID);
 103         srch = sdp_list_append(NULL, &svclass);
 104
 105         attr = SDP_ATTR_PROTO_DESC_LIST;
 106         attrs = sdp_list_append(NULL, &attr);
 107
 108         err = sdp_service_search_attr_req(s, srch, SDP_ATTR_REQ_INDIVIDUAL, attrs, &rsp);
 109
 110         sdp_close(s);
 111
 112         if (err)
 113                 return 0;
 114
 115         for (; rsp; rsp = rsp->next) {
 116                 sdp_record_t *rec = (sdp_record_t *) rsp->data;
 117                 sdp_list_t *protos;
 118
 119                 if (!sdp_get_access_protos(rec, &protos)) {
 120                         unsigned short p = sdp_get_proto_port(protos, L2CAP_UUID);
 121                         if (p > 0) {
 122                                 *psm = p;
 123                                 return 1;
 124                         }
 125                 }
 126         }
 127
 128         return 0;
 129 }
 130
 131 static int do_connect(int ctl, int dev_id, bdaddr_t *src, bdaddr_t *dst, unsigned short psm, uint32_t flags)
 132 {
 133         struct cmtp_connadd_req req;
 134         struct hci_dev_info di;
 135         struct sockaddr_l2 addr;
 136         struct l2cap_options opts;
 137         socklen_t size;
 138         int sk;
 139
 140         hci_devinfo(dev_id, &di);
 141         if (!(di.link_policy & HCI_LP_RSWITCH)) {
 142                 printf("Local device is not accepting role switch\n");
 143         }
 144
 145         if ((sk = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) < 0) {
 146                 perror("Can't create L2CAP socket");
 147                 exit(1);
 148         }
 149
 150         memset(&addr, 0, sizeof(addr));
 151         addr.l2_family = AF_BLUETOOTH;
 152         bacpy(&addr.l2_bdaddr, src);
 153
 154         if (bind(sk, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 155                 perror("Can't bind L2CAP socket");
 156                 close(sk);
 157                 exit(1);
 158         }
 159
 160         memset(&opts, 0, sizeof(opts));
 161         size = sizeof(opts);
 162
 163         if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, &size) < 0) {
 164                 perror("Can't get L2CAP options");
 165                 close(sk);
 166                 exit(1);
 167         }
 168
 169         opts.imtu = CMTP_DEFAULT_MTU;
 170         opts.omtu = CMTP_DEFAULT_MTU;
 171         opts.flush_to = 0xffff;
 172
 173         if (setsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &opts, sizeof(opts)) < 0) {
 174                 perror("Can't set L2CAP options");
 175                 close(sk);
 176                 exit(1);
 177         }
 178
 179         memset(&addr, 0, sizeof(addr));
 180         addr.l2_family = AF_BLUETOOTH;
 181         bacpy(&addr.l2_bdaddr, dst);
 182         addr.l2_psm = htobs(psm);
 183
 184         if (connect(sk, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 185                 perror("Can't connect L2CAP socket");
 186                 close(sk);
 187                 exit(1);
 188         }
 189
 190         req.sock = sk;
 191         req.flags = flags;
 192
 193         if (ioctl(ctl, CMTPCONNADD, &req) < 0) {
 194                 perror("Can't create connection");
 195                 exit(1);
 196         }
 197
 198         return sk;
 199 }
 200
 201 static void cmd_show(int ctl, bdaddr_t *bdaddr, int argc, char **argv)
 202 {
 203         struct cmtp_connlist_req req;
 204         struct cmtp_conninfo ci[16];
 205         char addr[18];
 206         unsigned int i;
 207
 208         req.cnum = 16;
 209         req.ci   = ci;
 210
 211         if (ioctl(ctl, CMTPGETCONNLIST, &req) < 0) {
 212                 perror("Can't get connection list");
 213                 exit(1);
 214         }
 215
 216         for (i = 0; i < req.cnum; i++) {
 217                 ba2str(&ci[i].bdaddr, addr);
 218                 printf("%d %s %s %s\n", ci[i].num, addr,
 219                         cmtp_state[ci[i].state],
 220                         ci[i].flags ? cmtp_flagstostr(ci[i].flags) : "");
 221         }
 222 }
 223
 224 static void cmd_search(int ctl, bdaddr_t *bdaddr, int argc, char **argv)
 225 {
 226         inquiry_info *info = NULL;
 227         bdaddr_t src, dst;
 228         unsigned short psm;
 229         int i, dev_id, num_rsp, length, flags;
 230         char addr[18];
 231         uint8_t class[3];
 232
 233         ba2str(bdaddr, addr);
 234         dev_id = hci_devid(addr);
 235         if (dev_id < 0) {
 236                 dev_id = hci_get_route(NULL);
 237                 hci_devba(dev_id, &src);
 238         } else
 239                 bacpy(&src, bdaddr);
 240
 241         length  = 8;    /* ~10 seconds */
 242         num_rsp = 0;
 243         flags   = 0;
 244
 245         printf("Searching ...\n");
 246
 247         num_rsp = hci_inquiry(dev_id, length, num_rsp, NULL, &info, flags);
 248
 249         for (i = 0; i < num_rsp; i++) {
 250                 memcpy(class, (info+i)->dev_class, 3);
 251                 if ((class[1] == 2) && ((class[0] / 4) == 5)) {
 252                         bacpy(&dst, &(info+i)->bdaddr);
 253                         ba2str(&dst, addr);
 254
 255                         printf("\tChecking service for %s\n", addr);
 256                         if (!get_psm(&src, &dst, &psm))
 257                                 continue;
 258
 259                         bt_free(info);
 260
 261                         printf("\tConnecting to device %s\n", addr);
 262                         do_connect(ctl, dev_id, &src, &dst, psm, 0);
 263                         return;
 264                 }
 265         }
 266
 267         bt_free(info);
 268         fprintf(stderr, "\tNo devices in range or visible\n");
 269         exit(1);
 270 }
 271
 272 static void cmd_create(int ctl, bdaddr_t *bdaddr, int argc, char **argv)
 273 {
 274         bdaddr_t src, dst;
 275         unsigned short psm;
 276         int dev_id;
 277         char addr[18];
 278
 279         if (argc < 2)
 280                 return;
 281
 282         str2ba(argv[1], &dst);
 283
 284         ba2str(bdaddr, addr);
 285         dev_id = hci_devid(addr);
 286         if (dev_id < 0) {
 287                 dev_id = hci_get_route(&dst);
 288                 hci_devba(dev_id, &src);
 289         } else
 290                 bacpy(&src, bdaddr);
 291
 292         if (argc < 3) {
 293                 if (!get_psm(&src, &dst, &psm))
 294                         psm = 4099;
 295         } else
 296                 psm = atoi(argv[2]);
 297
 298         do_connect(ctl, dev_id, &src, &dst, psm, 0);
 299 }
 300
 301 static void cmd_release(int ctl, bdaddr_t *bdaddr, int argc, char **argv)
 302 {
 303         struct cmtp_conndel_req req;
 304         struct cmtp_connlist_req cl;
 305         struct cmtp_conninfo ci[16];
 306
 307         if (argc < 2) {
 308                 cl.cnum = 16;
 309                 cl.ci   = ci;
 310
 311                 if (ioctl(ctl, CMTPGETCONNLIST, &cl) < 0) {
 312                         perror("Can't get connection list");
 313                         exit(1);
 314                 }
 315
 316                 if (cl.cnum == 0)
 317                         return;
 318
 319                 if (cl.cnum != 1) {
 320                         fprintf(stderr, "You have to specifiy the device address.\n");
 321                         exit(1);
 322                 }
 323
 324                 bacpy(&req.bdaddr, &ci[0].bdaddr);
 325         } else
 326                 str2ba(argv[1], &req.bdaddr);
 327
 328         if (ioctl(ctl, CMTPCONNDEL, &req) < 0) {
 329                 perror("Can't release connection");
 330                 exit(1);
 331         }
 332 }
 333
 334 static void cmd_loopback(int ctl, bdaddr_t *bdaddr, int argc, char **argv)
 335 {
 336         struct cmtp_conndel_req req;
 337         struct sigaction sa;
 338         struct pollfd p;
 339         sigset_t sigs;
 340         bdaddr_t src, dst;
 341         unsigned short psm;
 342         int dev_id, sk;
 343         char addr[18];
 344
 345         if (argc < 2)
 346                 return;
 347
 348         str2ba(argv[1], &dst);
 349
 350         ba2str(bdaddr, addr);
 351         dev_id = hci_devid(addr);
 352         if (dev_id < 0) {
 353                 dev_id = hci_get_route(&dst);
 354                 hci_devba(dev_id, &src);
 355         } else
 356                 bacpy(&src, bdaddr);
 357
 358         ba2str(&dst, addr);
 359         printf("Connecting to %s in loopback mode\n", addr);
 360
 361         if (argc < 3) {
 362                 if (!get_psm(&src, &dst, &psm))
 363                         psm = 4099;
 364         } else
 365                 psm = atoi(argv[2]);
 366
 367         sk = do_connect(ctl, dev_id, &src, &dst, psm, (1 << CMTP_LOOPBACK));
 368
 369         printf("Press CTRL-C for hangup\n");
 370
 371         memset(&sa, 0, sizeof(sa));
 372         sa.sa_flags   = SA_NOCLDSTOP;
 373         sa.sa_handler = SIG_IGN;
 374         sigaction(SIGCHLD, &sa, NULL);
 375         sigaction(SIGPIPE, &sa, NULL);
 376
 377         sa.sa_handler = sig_term;
 378         sigaction(SIGTERM, &sa, NULL);
 379         sigaction(SIGINT,  &sa, NULL);
 380
 381         sa.sa_handler = sig_hup;
 382         sigaction(SIGHUP, &sa, NULL);
 383
 384         sigfillset(&sigs);
 385         sigdelset(&sigs, SIGCHLD);
 386         sigdelset(&sigs, SIGPIPE);
 387         sigdelset(&sigs, SIGTERM);
 388         sigdelset(&sigs, SIGINT);
 389         sigdelset(&sigs, SIGHUP);
 390
 391         p.fd = sk;
 392         p.events = POLLERR | POLLHUP;
 393
 394         while (!__io_canceled) {
 395                 p.revents = 0;
 396                 if (ppoll(&p, 1, NULL, &sigs) > 0)
 397                         break;
 398         }
 399
 400         bacpy(&req.bdaddr, &dst);
 401         ioctl(ctl, CMTPCONNDEL, &req);
 402 }
 403
 404 static struct {
 405         char *cmd;
 406         char *alt;
 407         void (*func)(int ctl, bdaddr_t *bdaddr, int argc, char **argv);
 408         char *opt;
 409         char *doc;
 410 } command[] = {
 411         { "show",     "list",       cmd_show,     0,          "Show remote connections"      },
 412         { "search",   "scan",       cmd_search,   0,          "Search for a remote device"   },
 413         { "connect",  "create",     cmd_create,   "<bdaddr>", "Connect a remote device"      },
 414         { "release",  "disconnect", cmd_release,  "[bdaddr]", "Disconnect the remote device" },
 415         { "loopback", "test",       cmd_loopback, "<bdaddr>", "Loopback test of a device"    },
 416         { NULL, NULL, NULL, 0, 0 }
 417 };
 418
 419 static void usage(void)
 420 {
 421         int i;
 422
 423         printf("ciptool - Bluetooth Common ISDN Access Profile (CIP)\n\n");
 424
 425         printf("Usage:\n"
 426                 "\tciptool [options] [command]\n"
 427                 "\n");
 428
 429         printf("Options:\n"
 430                 "\t-i [hciX|bdaddr]   Local HCI device or BD Address\n"
 431                 "\t-h, --help         Display help\n"
 432                 "\n");
 433
 434         printf("Commands:\n");
 435         for (i = 0; command[i].cmd; i++)
 436                 printf("\t%-8s %-10s\t%s\n", command[i].cmd,
 437                 command[i].opt ? command[i].opt : " ",
 438                 command[i].doc);
 439         printf("\n");
 440 }
 441
 442 static struct option main_options[] = {
 443         { "help",       0, 0, 'h' },
 444         { "device",     1, 0, 'i' },
 445         { 0, 0, 0, 0 }
 446 };
 447
 448 int main(int argc, char *argv[])
 449 {
 450         bdaddr_t bdaddr;
 451         int i, opt, ctl;
 452
 453         bacpy(&bdaddr, BDADDR_ANY);
 454
 455         while ((opt = getopt_long(argc, argv, "+i:h", main_options, NULL)) != -1) {
 456                 switch(opt) {
 457                 case 'i':
 458                         if (!strncmp(optarg, "hci", 3))
 459                                 hci_devba(atoi(optarg + 3), &bdaddr);
 460                         else
 461                                 str2ba(optarg, &bdaddr);
 462                         break;
 463                 case 'h':
 464                         usage();
 465                         exit(0);
 466                 default:
 467                         exit(0);
 468                 }
 469         }
 470
 471         argc -= optind;
 472         argv += optind;
 473         optind = 0;
 474
 475         if (argc < 1) {
 476                 usage();
 477                 return 0;
 478         }
 479
 480         if ((ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_CMTP)) < 0 ) {
 481                 perror("Can't open CMTP control socket");
 482                 exit(1);
 483         }
 484
 485         for (i = 0; command[i].cmd; i++) {
 486                 if (strncmp(command[i].cmd, argv[0], 4) && strncmp(command[i].alt, argv[0], 4))
 487                         continue;
 488                 command[i].func(ctl, &bdaddr, argc, argv);
 489                 close(ctl);
 490                 exit(0);
 491         }
 492
 493         usage();
 494
 495         close(ctl);
 496
 497         return 0;
 498 }