usr.sbin/bluetooth/bthidd/client.c

   1 /*
   2  * client.c
   3  */
   4
   5 /*-
   6  * Copyright (c) 2006 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   7  * All rights reserved.
   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  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $Id: client.c,v 1.7 2006/09/07 21:06:53 max Exp $
  31  * $FreeBSD$
  32  */
  33
  34 #include <sys/queue.h>
  35 #include <assert.h>
  36 #include <bluetooth.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <syslog.h>
  43 #include <unistd.h>
  44 #include <usbhid.h>
  45 #include "bthid_config.h"
  46 #include "bthidd.h"
  47
  48 static int32_t  client_socket(bdaddr_p bdaddr, uint16_t psm);
  49
  50 /*
  51  * Get next config entry and create outbound connection (if required)
  52  *
  53  * XXX  Do only one device at a time. At least one of my devices (3COM
  54  *      Bluetooth PCCARD) rejects Create_Connection command if another
  55  *      Create_Connection command is still pending. Weird...
  56  */
  57
  58 static int32_t  connect_in_progress = 0;
  59
  60 int32_t
  61 client_rescan(bthid_server_p srv)
  62 {
  63         static hid_device_p     d;
  64         bthid_session_p         s;
  65
  66         assert(srv != NULL);
  67
  68         if (connect_in_progress)
  69                 return (0); /* another connect is still pending */
  70
  71         d = get_next_hid_device(d);
  72         if (d == NULL)
  73                 return (0); /* XXX should not happen? empty config? */
  74
  75         if ((s = session_by_bdaddr(srv, &d->bdaddr)) != NULL)
  76                 return (0); /* session already active */
  77
  78         if (!d->new_device) {
  79                 if (d->reconnect_initiate)
  80                         return (0); /* device will initiate reconnect */
  81         }
  82
  83         syslog(LOG_NOTICE, "Opening outbound session for %s " \
  84                 "(new_device=%d, reconnect_initiate=%d)",
  85                 bt_ntoa(&d->bdaddr, NULL), d->new_device, d->reconnect_initiate);
  86
  87         if ((s = session_open(srv, d)) == NULL) {
  88                 syslog(LOG_CRIT, "Could not create outbound session for %s",
  89                         bt_ntoa(&d->bdaddr, NULL));
  90                 return (-1);
  91         }
  92
  93         /* Open control channel */
  94         s->ctrl = client_socket(&s->bdaddr, d->control_psm);
  95         if (s->ctrl < 0) {
  96                 syslog(LOG_ERR, "Could not open control channel to %s. %s (%d)",
  97                         bt_ntoa(&s->bdaddr, NULL), strerror(errno), errno);
  98                 session_close(s);
  99                 return (-1);
 100         }
 101
 102         s->state = W4CTRL;
 103
 104         FD_SET(s->ctrl, &srv->wfdset);
 105         if (s->ctrl > srv->maxfd)
 106                 srv->maxfd = s->ctrl;
 107
 108         connect_in_progress = 1;
 109
 110         return (0);
 111 }
 112
 113 /*
 114  * Process connect on the socket
 115  */
 116
 117 int32_t
 118 client_connect(bthid_server_p srv, int32_t fd)
 119 {
 120         bthid_session_p s;
 121         hid_device_p    d;
 122         int32_t         error;
 123         socklen_t       len;
 124
 125         assert(srv != NULL);
 126         assert(fd >= 0);
 127
 128         s = session_by_fd(srv, fd);
 129         assert(s != NULL);
 130
 131         d = get_hid_device(&s->bdaddr);
 132         assert(d != NULL);
 133
 134         error = 0;
 135         len = sizeof(error);
 136         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
 137                 syslog(LOG_ERR, "Could not get socket error for %s. %s (%d)",
 138                         bt_ntoa(&s->bdaddr, NULL), strerror(errno), errno);
 139                 session_close(s);
 140                 connect_in_progress = 0;
 141
 142                 return (-1);
 143         }
 144
 145         if (error != 0) {
 146                 syslog(LOG_ERR, "Could not connect to %s. %s (%d)",
 147                         bt_ntoa(&s->bdaddr, NULL), strerror(error), error);
 148                 session_close(s);
 149                 connect_in_progress = 0;
 150
 151                 return (0);
 152         }
 153
 154         switch (s->state) {
 155         case W4CTRL: /* Control channel is open */
 156                 assert(s->ctrl == fd);
 157                 assert(s->intr == -1);
 158
 159                 /* Open interrupt channel */
 160                 s->intr = client_socket(&s->bdaddr, d->interrupt_psm);
 161                 if (s->intr < 0) {
 162                         syslog(LOG_ERR, "Could not open interrupt channel " \
 163                                 "to %s. %s (%d)", bt_ntoa(&s->bdaddr, NULL),
 164                                 strerror(errno), errno);
 165                         session_close(s);
 166                         connect_in_progress = 0;
 167
 168                         return (-1);
 169                 }
 170
 171                 s->state = W4INTR;
 172
 173                 FD_SET(s->intr, &srv->wfdset);
 174                 if (s->intr > srv->maxfd)
 175                         srv->maxfd = s->intr;
 176
 177                 d->new_device = 0; /* reset new device flag */
 178                 write_hids_file();
 179                 break;
 180
 181         case W4INTR: /* Interrupt channel is open */
 182                 assert(s->ctrl != -1);
 183                 assert(s->intr == fd);
 184
 185                 s->state = OPEN;
 186                 connect_in_progress = 0;
 187
 188                 /* Register session's vkbd descriptor (if any) for read */
 189                 if (s->state == OPEN && d->keyboard) {
 190                         assert(s->vkbd != -1);
 191
 192                         FD_SET(s->vkbd, &srv->rfdset);
 193                         if (s->vkbd > srv->maxfd)
 194                                 srv->maxfd = s->vkbd;
 195                 }
 196                 break;
 197
 198         default:
 199                 assert(0);
 200                 break;
 201         }
 202
 203         /* Move fd to from the write fd set into read fd set */
 204         FD_CLR(fd, &srv->wfdset);
 205         FD_SET(fd, &srv->rfdset);
 206
 207         return (0);
 208 }
 209
 210 /*
 211  * Create bound non-blocking socket and initiate connect
 212  */
 213
 214 static int
 215 client_socket(bdaddr_p bdaddr, uint16_t psm)
 216 {
 217         struct sockaddr_l2cap   l2addr;
 218         int32_t                 s, m;
 219
 220         s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
 221         if (s < 0)
 222                 return (-1);
 223
 224         m = fcntl(s, F_GETFL);
 225         if (m < 0) {
 226                 close(s);
 227                 return (-1);
 228         }
 229
 230         if (fcntl(s, F_SETFL, (m|O_NONBLOCK)) < 0) {
 231                 close(s);
 232                 return (-1);
 233         }
 234
 235         l2addr.l2cap_len = sizeof(l2addr);
 236         l2addr.l2cap_family = AF_BLUETOOTH;
 237         memset(&l2addr.l2cap_bdaddr, 0, sizeof(l2addr.l2cap_bdaddr));
 238         l2addr.l2cap_psm = 0;
 239
 240         if (bind(s, (struct sockaddr *) &l2addr, sizeof(l2addr)) < 0) {
 241                 close(s);
 242                 return (-1);
 243         }
 244
 245         memcpy(&l2addr.l2cap_bdaddr, bdaddr, sizeof(l2addr.l2cap_bdaddr));
 246         l2addr.l2cap_psm = htole16(psm);
 247
 248         if (connect(s, (struct sockaddr *) &l2addr, sizeof(l2addr)) < 0 &&
 249             errno != EINPROGRESS) {
 250                 close(s);
 251                 return (-1);
 252         }
 253
 254         return (s);
 255 }
 256