usr.sbin/bluetooth/sdpd/ssar.c

   1 /*
   2  * ssar.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: ssar.c,v 1.4 2004/01/12 22:54:31 max Exp $
  29  * $FreeBSD$
  30  */
  31
  32 #include <sys/queue.h>
  33 #include <bluetooth.h>
  34 #include <sdp.h>
  35 #include <string.h>
  36 #include "profile.h"
  37 #include "provider.h"
  38 #include "server.h"
  39
  40 /* from sar.c */
  41 int32_t server_prepare_attr_list(provider_p const provider,
  42                 uint8_t const *req, uint8_t const * const req_end,
  43                 uint8_t *rsp, uint8_t const * const rsp_end);
  44
  45 /*
  46  * Prepare SDP Service Search Attribute Response
  47  */
  48
  49 int32_t
  50 server_prepare_service_search_attribute_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 const   *sspptr = NULL, *aidptr = NULL;
  58         uint8_t         *ptr = NULL;
  59
  60         provider_t      *provider = NULL;
  61         int32_t          type, rsp_limit, ssplen, aidlen, cslen, cs, uuid;
  62
  63         /*
  64          * Minimal Service Search Attribute Request request
  65          *
  66          * seq8 len8            - 2 bytes
  67          *      uuid16 value16  - 3 bytes ServiceSearchPattern
  68          * value16              - 2 bytes MaximumAttributeByteCount
  69          * seq8 len8            - 2 bytes
  70          *      uint16 value16  - 3 bytes AttributeIDList
  71          * value8               - 1 byte  ContinuationState
  72          */
  73
  74         if (req_end - req < 13)
  75                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
  76
  77         /* Get size of ServiceSearchPattern */
  78         ssplen = 0;
  79         SDP_GET8(type, req);
  80         switch (type) {
  81         case SDP_DATA_SEQ8:
  82                 SDP_GET8(ssplen, req);
  83                 break;
  84
  85         case SDP_DATA_SEQ16:
  86                 SDP_GET16(ssplen, req);
  87                 break;
  88
  89         case SDP_DATA_SEQ32:
  90                 SDP_GET32(ssplen, req);
  91                 break;
  92         }
  93         if (ssplen <= 0)
  94                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
  95
  96         sspptr = req;
  97         req += ssplen;
  98
  99         /* Get MaximumAttributeByteCount */
 100         if (req + 2 > req_end)
 101                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 102
 103         SDP_GET16(rsp_limit, req);
 104         if (rsp_limit <= 0)
 105                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 106
 107         /* Get size of AttributeIDList */
 108         if (req + 1 > req_end)
 109                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 110
 111         aidlen = 0;
 112         SDP_GET8(type, req);
 113         switch (type) {
 114         case SDP_DATA_SEQ8:
 115                 if (req + 1 > req_end)
 116                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 117
 118                 SDP_GET8(aidlen, req);
 119                 break;
 120
 121         case SDP_DATA_SEQ16:
 122                 if (req + 2 > req_end)
 123                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 124
 125                 SDP_GET16(aidlen, req);
 126                 break;
 127
 128         case SDP_DATA_SEQ32:
 129                 if (req + 4 > req_end)
 130                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 131
 132                 SDP_GET32(aidlen, req);
 133                 break;
 134         }
 135         if (aidlen <= 0)
 136                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 137
 138         aidptr = req;
 139         req += aidlen;
 140
 141         /* Get ContinuationState */
 142         if (req + 1 > req_end)
 143                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 144
 145         SDP_GET8(cslen, req);
 146         if (cslen != 0) {
 147                 if (cslen != 2 || req_end - req != 2)
 148                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 149
 150                 SDP_GET16(cs, req);
 151         } else
 152                 cs = 0;
 153
 154         /* Process the request. First, check continuation state */
 155         if (srv->fdidx[fd].rsp_cs != cs)
 156                 return (SDP_ERROR_CODE_INVALID_CONTINUATION_STATE);
 157         if (srv->fdidx[fd].rsp_size > 0)
 158                 return (0);
 159
 160         /*
 161          * Service Search Attribute Response format
 162          *
 163          * value16              - 2 bytes  AttributeListByteCount (not incl.)
 164          * seq8 len16           - 3 bytes
 165          *      attr list       - 3+ bytes AttributeLists
 166          *      [ attr list ]
 167          */
 168
 169         ptr = rsp + 3;
 170
 171         while (ssplen > 0) {
 172                 SDP_GET8(type, sspptr);
 173                 ssplen --;
 174
 175                 switch (type) {
 176                 case SDP_DATA_UUID16:
 177                         if (ssplen < 2)
 178                                 return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 179
 180                         SDP_GET16(uuid, sspptr);
 181                         ssplen -= 2;
 182                         break;
 183
 184                 case SDP_DATA_UUID32: /* XXX FIXME */
 185                 case SDP_DATA_UUID128: /* XXX FIXME */
 186                 default:
 187                         return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
 188                         /* NOT REACHED */
 189                 }
 190
 191                 for (provider = provider_get_first();
 192                      provider != NULL;
 193                      provider = provider_get_next(provider)) {
 194                         if (!provider_match_bdaddr(provider, &srv->req_sa.l2cap_bdaddr))
 195                                 continue;
 196
 197                         if (provider->profile->uuid != uuid &&
 198                             SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP != uuid)
 199                                 continue;
 200
 201                         cs = server_prepare_attr_list(provider,
 202                                 aidptr, aidptr + aidlen, ptr, rsp_end);
 203                         if (cs < 0)
 204                                 return (SDP_ERROR_CODE_INSUFFICIENT_RESOURCES);
 205
 206                         ptr += cs;
 207                 }
 208         }
 209
 210         /* Set reply size (not counting PDU header and continuation state) */
 211         srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t) - 2;
 212         if (srv->fdidx[fd].rsp_limit > rsp_limit)
 213                 srv->fdidx[fd].rsp_limit = rsp_limit;
 214
 215         srv->fdidx[fd].rsp_size = ptr - rsp;
 216         srv->fdidx[fd].rsp_cs = 0;
 217
 218         /* Fix AttributeLists sequence header */
 219         ptr = rsp;
 220         SDP_PUT8(SDP_DATA_SEQ16, ptr);
 221         SDP_PUT16(srv->fdidx[fd].rsp_size - 3, ptr);
 222
 223         return (0);
 224 }
 225