usr.sbin/btpand/client.c

   1 /*      $NetBSD: client.c,v 1.3 2009/05/12 21:08:30 plunky Exp $        */
   2
   3 /*-
   4  * Copyright (c) 2008-2009 Iain Hibbert
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __RCSID("$NetBSD: client.c,v 1.3 2009/05/12 21:08:30 plunky Exp $");
  30
  31 #include <bluetooth.h>
  32 #include <errno.h>
  33 #include <sdp.h>
  34 #include <unistd.h>
  35
  36 #include "btpand.h"
  37 #include "bnep.h"
  38
  39 static void client_down(channel_t *);
  40 static void client_query(void);
  41
  42 void
  43 client_init(void)
  44 {
  45         struct sockaddr_bt sa;
  46         channel_t *chan;
  47         socklen_t len;
  48         int fd;
  49         uint16_t mru, mtu;
  50
  51         if (bdaddr_any(&remote_bdaddr))
  52                 return;
  53
  54         if (service_type)
  55                 client_query();
  56
  57         fd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
  58         if (fd == -1) {
  59                 log_err("Could not open L2CAP socket: %m");
  60                 exit(EXIT_FAILURE);
  61         }
  62
  63         memset(&sa, 0, sizeof(sa));
  64         sa.bt_family = AF_BLUETOOTH;
  65         sa.bt_len = sizeof(sa);
  66         bdaddr_copy(&sa.bt_bdaddr, &local_bdaddr);
  67         if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
  68                 log_err("Could not bind client socket: %m");
  69                 exit(EXIT_FAILURE);
  70         }
  71
  72         if (setsockopt(fd, BTPROTO_L2CAP, SO_L2CAP_LM,
  73             &l2cap_mode, sizeof(l2cap_mode)) == -1) {
  74                 log_err("Could not set link mode (0x%4.4x): %m", l2cap_mode);
  75                 exit(EXIT_FAILURE);
  76         }
  77
  78         mru = BNEP_MTU_MIN;
  79         if (setsockopt(fd, BTPROTO_L2CAP, SO_L2CAP_IMTU,
  80             &mru, sizeof(mru)) == -1) {
  81                 log_err("Could not set L2CAP IMTU (%d): %m", mru);
  82                 exit(EXIT_FAILURE);
  83         }
  84
  85         log_info("Opening connection to service 0x%4.4x at %s",
  86             service_class, bt_ntoa(&remote_bdaddr, NULL));
  87
  88         sa.bt_psm = l2cap_psm;
  89         bdaddr_copy(&sa.bt_bdaddr, &remote_bdaddr);
  90         if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) {
  91                 log_err("Could not connect: %m");
  92                 exit(EXIT_FAILURE);
  93         }
  94
  95         len = sizeof(mru);
  96         if (getsockopt(fd, BTPROTO_L2CAP, SO_L2CAP_IMTU, &mru, &len) == -1) {
  97                 log_err("Could not get IMTU: %m");
  98                 exit(EXIT_FAILURE);
  99         }
 100         if (mru < BNEP_MTU_MIN) {
 101                 log_err("L2CAP IMTU too small (%d)", mru);
 102                 exit(EXIT_FAILURE);
 103         }
 104
 105         len = sizeof(mtu);
 106         if (getsockopt(fd, BTPROTO_L2CAP, SO_L2CAP_OMTU, &mtu, &len) == -1) {
 107                 log_err("Could not get L2CAP OMTU: %m");
 108                 exit(EXIT_FAILURE);
 109         }
 110         if (mtu < BNEP_MTU_MIN) {
 111                 log_err("L2CAP OMTU too small (%d)", mtu);
 112                 exit(EXIT_FAILURE);
 113         }
 114
 115         chan = channel_alloc();
 116         if (chan == NULL)
 117                 exit(EXIT_FAILURE);
 118
 119         chan->send = bnep_send;
 120         chan->recv = bnep_recv;
 121         chan->down = client_down;
 122         chan->mru = mru;
 123         chan->mtu = mtu;
 124         b2eaddr(chan->raddr, &remote_bdaddr);
 125         b2eaddr(chan->laddr, &local_bdaddr);
 126         chan->state = CHANNEL_WAIT_CONNECT_RSP;
 127         channel_timeout(chan, 10);
 128         if (!channel_open(chan, fd))
 129                 exit(EXIT_FAILURE);
 130
 131         bnep_send_control(chan, BNEP_SETUP_CONNECTION_REQUEST,
 132             2, service_class, SDP_SERVICE_CLASS_PANU);
 133 }
 134
 135 static void
 136 client_down(channel_t *chan)
 137 {
 138
 139         log_err("Client connection shut down, exiting");
 140         exit(EXIT_FAILURE);
 141 }
 142
 143 static void
 144 client_query(void)
 145 {
 146         uint8_t buf[12];        /* enough for SSP and AIL both */
 147         sdp_session_t ss;
 148         sdp_data_t ssp, ail, rsp, rec, value, pdl, seq;
 149         uintmax_t psm;
 150         uint16_t attr;
 151         bool rv;
 152
 153         ss = sdp_open(&local_bdaddr, &remote_bdaddr);
 154         if (ss == NULL) {
 155                 log_err("%s: %m", service_type);
 156                 exit(EXIT_FAILURE);
 157         }
 158
 159         log_info("Searching for %s service at %s",
 160             service_type, bt_ntoa(&remote_bdaddr, NULL));
 161
 162         seq.next = buf;
 163         seq.end = buf + sizeof(buf);
 164
 165         /*
 166          * build ServiceSearchPattern (9 bytes)
 167          *
 168          *      uuid16  "service_class"
 169          *      uuid16  L2CAP
 170          *      uuid16  BNEP
 171          */
 172         ssp.next = seq.next;
 173         sdp_put_uuid16(&seq, service_class);
 174         sdp_put_uuid16(&seq, SDP_UUID_PROTOCOL_L2CAP);
 175         sdp_put_uuid16(&seq, SDP_UUID_PROTOCOL_BNEP);
 176         ssp.end = seq.next;
 177
 178         /*
 179          * build AttributeIDList (3 bytes)
 180          *
 181          *      uint16  ProtocolDescriptorList
 182          */
 183         ail.next = seq.next;
 184         sdp_put_uint16(&seq, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
 185         ail.end = seq.next;
 186
 187         rv = sdp_service_search_attribute(ss, &ssp, &ail, &rsp);
 188         if (!rv) {
 189                 log_err("%s: %m", service_type);
 190                 exit(EXIT_FAILURE);
 191         }
 192
 193         /*
 194          * we expect the response to contain a list of records
 195          * containing a ProtocolDescriptorList. Find the first
 196          * one containing L2CAP and BNEP protocols and extract
 197          * the PSM.
 198          */
 199         rv = false;
 200         while (!rv && sdp_get_seq(&rsp, &rec)) {
 201                 if (!sdp_get_attr(&rec, &attr, &value)
 202                     || attr != SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST)
 203                         continue;
 204
 205                 sdp_get_alt(&value, &value);    /* drop any alt header */
 206                 while (!rv && sdp_get_seq(&value, &pdl)) {
 207                         if (sdp_get_seq(&pdl, &seq)
 208                             && sdp_match_uuid16(&seq, SDP_UUID_PROTOCOL_L2CAP)
 209                             && sdp_get_uint(&seq, &psm)
 210                             && sdp_get_seq(&pdl, &seq)
 211                             && sdp_match_uuid16(&seq, SDP_UUID_PROTOCOL_BNEP))
 212                                 rv = true;
 213                 }
 214         }
 215
 216         sdp_close(ss);
 217
 218         if (!rv) {
 219                 log_err("%s query failed", service_type);
 220                 exit(EXIT_FAILURE);
 221         }
 222
 223         l2cap_psm = (uint16_t)psm;
 224         log_info("Found PSM %u for service %s", l2cap_psm, service_type);
 225 }