usr.sbin/btpand/sdp.c

   1 /*      $NetBSD: sdp.c,v 1.1 2008/08/17 13:20:57 plunky Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2008 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: sdp.c,v 1.1 2008/08/17 13:20:57 plunky Exp $");
  30
  31 #include <string.h>
  32
  33 #include "sdp.h"
  34
  35 /*
  36  * SDP data stream manipulation routines
  37  */
  38
  39 /* Bluetooth Base UUID */
  40 static const uuid_t BASE_UUID = {
  41         0x00000000,
  42         0x0000,
  43         0x1000,
  44         0x80,
  45         0x00,
  46         { 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
  47 };
  48
  49 /*
  50  * _sdp_match_uuid16(ptr, limit, uuid)
  51  *
  52  *      examine SDP data stream at ptr for a UUID, and return
  53  *      true if it matches the supplied short alias bluetooth UUID.
  54  *      limit is the first address past the end of valid data.
  55  */
  56 bool
  57 _sdp_match_uuid16(uint8_t **ptr, uint8_t *limit, uint16_t uuid)
  58 {
  59         uint8_t *p = *ptr;
  60         uuid_t u1, u2;
  61
  62         memcpy(&u1, &BASE_UUID, sizeof(uuid_t));
  63         u1.time_low = uuid;
  64
  65         if (!_sdp_get_uuid(&p, limit, &u2)
  66             || !uuid_equal(&u1, &u2, NULL))
  67                 return false;
  68
  69         *ptr = p;
  70         return true;
  71 }
  72
  73 /*
  74  * _sdp_get_uuid(ptr, limit, uuid)
  75  *
  76  *      examine SDP data stream at ptr for a UUID, and extract
  77  *      to given storage, advancing ptr.
  78  *      limit is the first address past the end of valid data.
  79  */
  80 bool
  81 _sdp_get_uuid(uint8_t **ptr, uint8_t *limit, uuid_t *uuid)
  82 {
  83         uint8_t *p = *ptr;
  84
  85         if (p + 1 > limit)
  86                 return false;
  87
  88         switch (*p++) {
  89         case SDP_DATA_UUID16:
  90                 if (p + 2 > limit)
  91                         return false;
  92
  93                 memcpy(uuid, &BASE_UUID, sizeof(uuid_t));
  94                 uuid->time_low = be16dec(p);
  95                 p += 2;
  96                 break;
  97
  98         case SDP_DATA_UUID32:
  99                 if (p + 4 > limit)
 100                         return false;
 101
 102                 memcpy(uuid, &BASE_UUID, sizeof(uuid_t));
 103                 uuid->time_low = be32dec(p);
 104                 p += 4;
 105                 break;
 106
 107         case SDP_DATA_UUID128:
 108                 if (p + 16 > limit)
 109                         return false;
 110
 111                 uuid_dec_be(p, uuid);
 112                 p += 16;
 113                 break;
 114
 115         default:
 116                 return false;
 117         }
 118
 119         *ptr = p;
 120         return true;
 121 }
 122
 123 /*
 124  * _sdp_get_seq(ptr, limit, seq)
 125  *
 126  *      examine SDP data stream at ptr for a sequence. return
 127  *      seq pointer if found and advance ptr to next object.
 128  *      limit is the first address past the end of valid data.
 129  */
 130 bool
 131 _sdp_get_seq(uint8_t **ptr, uint8_t *limit, uint8_t **seq)
 132 {
 133         uint8_t *p = *ptr;
 134         int32_t l;
 135
 136         if (p + 1 > limit)
 137                 return false;
 138
 139         switch (*p++) {
 140         case SDP_DATA_SEQ8:
 141                 if (p + 1 > limit)
 142                         return false;
 143
 144                 l = *p;
 145                 p += 1;
 146                 break;
 147
 148         case SDP_DATA_SEQ16:
 149                 if (p + 2 > limit)
 150                         return false;
 151
 152                 l = be16dec(p);
 153                 p += 2;
 154                 break;
 155
 156         case SDP_DATA_SEQ32:
 157                 if (p + 4 > limit)
 158                         return false;
 159
 160                 l = be32dec(p);
 161                 p += 4;
 162                 break;
 163
 164         default:
 165                 return false;
 166         }
 167         if (p + l > limit)
 168                 return false;
 169
 170         *seq = p;
 171         *ptr = p + l;
 172         return true;
 173 }
 174
 175 /*
 176  * _sdp_get_uint16(ptr, limit, value)
 177  *
 178  *      examine SDP data stream at ptr for a uint16_t, and
 179  *      extract to given storage, advancing ptr.
 180  *      limit is the first address past the end of valid data.
 181  */
 182 bool
 183 _sdp_get_uint16(uint8_t **ptr, uint8_t *limit, uint16_t *value)
 184 {
 185         uint8_t *p = *ptr;
 186         uint16_t v;
 187
 188         if (p + 1 > limit)
 189                 return false;
 190
 191         switch (*p++) {
 192         case SDP_DATA_UINT16:
 193                 if (p + 2 > limit)
 194                         return false;
 195
 196                 v = be16dec(p);
 197                 p += 2;
 198                 break;
 199
 200         default:
 201                 return false;
 202         }
 203
 204         *value = v;
 205         *ptr = p;
 206         return true;
 207 }