usr.sbin/bluetooth/sdpd/ssr.c

   1 /*
   2  * ssr.c
   3  *
   4  * Copyright (c) 2004 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   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 AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $Id: ssr.c,v 1.5 2004/01/13 01:54:39 max Exp $
  29  * $FreeBSD$
  30  */
  31
  32 #include <sys/queue.h>
  33 #include <sys/uio.h>
  34 #include <netinet/in.h>
  35 #include <arpa/inet.h>
  36 #include <assert.h>
  37 #include <bluetooth.h>
  38 #include <errno.h>
  39 #include <sdp.h>
  40 #include <string.h>
  41 #include "profile.h"
  42 #include "provider.h"
  43 #include "server.h"
  44
  45 /*
  46  * Prepare SDP Service Search Response
  47  */
  48
  49 int32_t
  50 server_prepare_service_search_response(server_p srv, int32_t fd)
  51 {
  52         uint8_t const   *req = srv->req + sizeof(sdp_pdu_t);
  53         uint8_t const   *req_end = req + ((sdp_pdu_p)(srv->req))->len;
  54         uint8_t         *rsp = srv->fdidx[fd].rsp;
  55         uint8_t const   *rsp_end = rsp + NG_L2CAP_MTU_MAXIMUM;
  56
  57         uint8_t         *ptr = NULL;
  58         provider_t      *provider = NULL;
  59         int32_t          type, ssplen, rsp_limit, rcount, cslen, cs, uuid;
  60
  61         /*
  62          * Minimal SDP Service Search Request
  63          *
  64          * seq8 len8            - 2 bytes
  65          *      uuid16 value16  - 3 bytes ServiceSearchPattern
  66          * value16              - 2 bytes MaximumServiceRecordCount
  67          * value8               - 1 byte  ContinuationState
  68          */
  69
  70         if (req_end - req < 8)
  71                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
  72
  73         /* Get size of ServiceSearchPattern */
  74         ssplen = 0;
  75         SDP_GET8(type, req);
  76         switch (type) {
  77         case SDP_DATA_SEQ8:
  78                 SDP_GET8(ssplen, req);
  79                 break;
  80
  81         case SDP_DATA_SEQ16:
  82                 SDP_GET16(ssplen, req);
  83                 break;
  84
  85         case SDP_DATA_SEQ32:
  86                 SDP_GET32(ssplen, req);
  87                 break;
  88         }
  89         if (ssplen <= 0)
  90                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
  91
  92         ptr = (uint8_t *) req + ssplen;
  93
  94         /* Get MaximumServiceRecordCount */
  95         if (ptr + 2 > req_end)
  96                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
  97
  98         SDP_GET16(rsp_limit, ptr);
  99         if (rsp_limit <= 0)
 100                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 101
 102         /* Get ContinuationState */
 103         if (ptr + 1 > req_end)
 104                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 105
 106         SDP_GET8(cslen, ptr);
 107         if (cslen != 0) {
 108                 if (cslen != 2 || req_end - ptr != 2)
 109                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 110
 111                 SDP_GET16(cs, ptr);
 112         } else
 113                 cs = 0;
 114
 115         /* Process the request. First, check continuation state */
 116         if (srv->fdidx[fd].rsp_cs != cs)
 117                 return (SDP_ERROR_CODE_INVALID_CONTINUATION_STATE);
 118         if (srv->fdidx[fd].rsp_size > 0)
 119                 return (0);
 120
 121         /*
 122          * Service Search Response format
 123          *
 124          * value16      - 2 bytes TotalServiceRecordCount (not incl.)
 125          * value16      - 2 bytes CurrentServiceRecordCount (not incl.)
 126          * value32      - 4 bytes handle
 127          * [ value32 ]
 128          *
 129          * Calculate how many record handles we can fit
 130          * in our reply buffer and adjust rlimit.
 131          */
 132
 133         ptr = rsp;
 134         rcount = (rsp_end - ptr) / 4;
 135         if (rcount < rsp_limit)
 136                 rsp_limit = rcount;
 137
 138         /* Look for the record handles */
 139         for (rcount = 0; ssplen > 0 && rcount < rsp_limit; ) {
 140                 SDP_GET8(type, req);
 141                 ssplen --;
 142
 143                 switch (type) {
 144                 case SDP_DATA_UUID16:
 145                         if (ssplen < 2)
 146                                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 147
 148                         SDP_GET16(uuid, req);
 149                         ssplen -= 2;
 150                         break;
 151
 152                 case SDP_DATA_UUID32: /* XXX FIXME */
 153                 case SDP_DATA_UUID128: /* XXX FIXME */
 154                 default:
 155                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 156                         /* NOT REACHED */
 157                 }
 158
 159                 for (provider = provider_get_first();
 160                      provider != NULL && rcount < rsp_limit;
 161                      provider = provider_get_next(provider)) {
 162                         if (!provider_match_bdaddr(provider, &srv->req_sa.l2cap_bdaddr))
 163                                 continue;
 164
 165                         if (provider->profile->uuid == uuid ||
 166                             SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP == uuid) {
 167                                 SDP_PUT32(provider->handle, ptr);
 168                                 rcount ++;
 169                         }
 170                 }
 171         }
 172
 173         /* Set reply size (not counting PDU header and continuation state) */
 174         srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t) - 4;
 175         srv->fdidx[fd].rsp_size = ptr - rsp;
 176         srv->fdidx[fd].rsp_cs = 0;
 177
 178         return (0);
 179 }
 180
 181 /*
 182  * Send SDP Service Search Response
 183  */
 184
 185 int32_t
 186 server_send_service_search_response(server_p srv, int32_t fd)
 187 {
 188         uint8_t         *rsp = srv->fdidx[fd].rsp + srv->fdidx[fd].rsp_cs;
 189         uint8_t         *rsp_end = srv->fdidx[fd].rsp + srv->fdidx[fd].rsp_size;
 190
 191         struct iovec    iov[4];
 192         sdp_pdu_t       pdu;
 193         uint16_t        rcounts[2];
 194         uint8_t         cs[3];
 195         int32_t         size;
 196
 197         /* First update continuation state (assume we will send all data) */
 198         size = rsp_end - rsp;
 199         srv->fdidx[fd].rsp_cs += size;
 200
 201         if (size + 1 > srv->fdidx[fd].rsp_limit) {
 202                 /*
 203                  * We need to split out response. Add 3 more bytes for the
 204                  * continuation state and move rsp_end and rsp_cs backwards.
 205                  */
 206
 207                 while ((rsp_end - rsp) + 3 > srv->fdidx[fd].rsp_limit) {
 208                         rsp_end -= 4;
 209                         srv->fdidx[fd].rsp_cs -= 4;
 210                 }
 211
 212                 cs[0] = 2;
 213                 cs[1] = srv->fdidx[fd].rsp_cs >> 8;
 214                 cs[2] = srv->fdidx[fd].rsp_cs & 0xff;
 215         } else
 216                 cs[0] = 0;
 217
 218         assert(rsp_end >= rsp);
 219
 220         rcounts[0] = srv->fdidx[fd].rsp_size / 4; /* TotalServiceRecordCount */
 221         rcounts[1] = (rsp_end - rsp) / 4; /* CurrentServiceRecordCount */
 222
 223         pdu.pid = SDP_PDU_SERVICE_SEARCH_RESPONSE;
 224         pdu.tid = ((sdp_pdu_p)(srv->req))->tid;
 225         pdu.len = htons(sizeof(rcounts) + rcounts[1] * 4 + 1 + cs[0]);
 226
 227         rcounts[0] = htons(rcounts[0]);
 228         rcounts[1] = htons(rcounts[1]);
 229
 230         iov[0].iov_base = &pdu;
 231         iov[0].iov_len = sizeof(pdu);
 232
 233         iov[1].iov_base = rcounts;
 234         iov[1].iov_len = sizeof(rcounts);
 235
 236         iov[2].iov_base = rsp;
 237         iov[2].iov_len = rsp_end - rsp;
 238
 239         iov[3].iov_base = cs;
 240         iov[3].iov_len = 1 + cs[0];
 241
 242         do {
 243                 size = writev(fd, (struct iovec const *) &iov, sizeof(iov)/sizeof(iov[0]));
 244         } while (size < 0 && errno == EINTR);
 245
 246         /* Check if we have sent (or failed to sent) last response chunk */
 247         if (srv->fdidx[fd].rsp_cs == srv->fdidx[fd].rsp_size) {
 248                 srv->fdidx[fd].rsp_cs = 0;
 249                 srv->fdidx[fd].rsp_size = 0;
 250                 srv->fdidx[fd].rsp_limit = 0;
 251         }
 252
 253         return ((size < 0)? errno : 0);
 254 }
 255