1 /****************************************************************************** 2 * 3 * Copyright 2014 Google, Inc. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 #include "btcore/include/property.h" 20 #include <base/logging.h> 21 #include <string.h> 22 #include "btcore/include/device_class.h" 23 #include "osi/include/allocator.h" 24 #include "osi/include/compat.h" 25 26 using bluetooth::Uuid; 27 28 static bt_property_t* property_new_(void* val, size_t len, 29 bt_property_type_t type); 30 31 bt_property_t* property_copy_array(const bt_property_t* properties, 32 size_t count) { 33 CHECK(properties != NULL); 34 bt_property_t* clone = 35 static_cast<bt_property_t*>(osi_calloc(sizeof(bt_property_t) * count)); 36 37 memcpy(&clone[0], &properties[0], sizeof(bt_property_t) * count); 38 for (size_t i = 0; i < count; ++i) { 39 clone[i].val = osi_calloc(clone[i].len); 40 memcpy(clone[i].val, properties[i].val, clone[i].len); 41 } 42 43 return clone; 44 } 45 46 bt_property_t* property_copy(bt_property_t* dest, const bt_property_t* src) { 47 CHECK(dest != NULL); 48 CHECK(src != NULL); 49 return (bt_property_t*)memcpy(dest, src, sizeof(bt_property_t)); 50 } 51 52 bool property_equals(const bt_property_t* p1, const bt_property_t* p2) { 53 // Two null properties are not the same. May need to revisit that 54 // decision when we have a test case that exercises that condition. 55 if (!p1 || !p2 || p1->type != p2->type) { 56 return false; 57 } 58 59 // Although the Bluetooth name is a 249-byte array, the implementation 60 // treats it like a variable-length array with its size specified in the 61 // property's `len` field. We special-case the equivalence of BDNAME 62 // types here by truncating the larger, zero-padded name to its string 63 // length and comparing against the shorter name. 64 // 65 // Note: it may be the case that both strings are zero-padded but that 66 // hasn't come up yet so this implementation doesn't handle it. 67 if (p1->type == BT_PROPERTY_BDNAME && p1->len != p2->len) { 68 const bt_property_t *shorter = p1, *longer = p2; 69 if (p1->len > p2->len) { 70 shorter = p2; 71 longer = p1; 72 } 73 return strlen((const char*)longer->val) == (size_t)shorter->len && 74 !memcmp(longer->val, shorter->val, shorter->len); 75 } 76 77 return p1->len == p2->len && !memcmp(p1->val, p2->val, p1->len); 78 } 79 80 bt_property_t* property_new_addr(const RawAddress* addr) { 81 CHECK(addr != NULL); 82 return property_new_((void*)addr, sizeof(RawAddress), BT_PROPERTY_BDADDR); 83 } 84 85 bt_property_t* property_new_device_class(const bt_device_class_t* dc) { 86 CHECK(dc != NULL); 87 return property_new_((void*)dc, sizeof(bt_device_class_t), 88 BT_PROPERTY_CLASS_OF_DEVICE); 89 } 90 91 bt_property_t* property_new_device_type(bt_device_type_t type) { 92 return property_new_((void*)&type, sizeof(bt_device_type_t), 93 BT_PROPERTY_TYPE_OF_DEVICE); 94 } 95 96 bt_property_t* property_new_discovery_timeout(const uint32_t timeout) { 97 return property_new_((void*)&timeout, sizeof(uint32_t), 98 BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT); 99 } 100 101 bt_property_t* property_new_name(const char* name) { 102 CHECK(name != NULL); 103 return property_new_((void*)name, sizeof(bt_bdname_t), BT_PROPERTY_BDNAME); 104 } 105 106 bt_property_t* property_new_rssi(int8_t rssi) { 107 return property_new_((void*)&rssi, sizeof(int8_t), BT_PROPERTY_REMOTE_RSSI); 108 } 109 110 bt_property_t* property_new_scan_mode(bt_scan_mode_t scan_mode) { 111 return property_new_((void*)&scan_mode, sizeof(bt_scan_mode_t), 112 BT_PROPERTY_ADAPTER_SCAN_MODE); 113 } 114 115 bt_property_t* property_new_uuids(const Uuid* uuid, size_t count) { 116 CHECK(uuid != NULL); 117 return property_new_((void*)uuid, sizeof(Uuid) * count, BT_PROPERTY_UUIDS); 118 } 119 120 void property_free(bt_property_t* property) { 121 property_free_array(property, 1); 122 } 123 124 void property_free_array(bt_property_t* properties, size_t count) { 125 if (properties == NULL) return; 126 127 for (size_t i = 0; i < count; ++i) { 128 osi_free(properties[i].val); 129 } 130 131 osi_free(properties); 132 } 133 134 bool property_is_addr(const bt_property_t* property) { 135 CHECK(property != NULL); 136 return property->type == BT_PROPERTY_BDADDR; 137 } 138 139 bool property_is_device_class(const bt_property_t* property) { 140 CHECK(property != NULL); 141 return property->type == BT_PROPERTY_CLASS_OF_DEVICE; 142 } 143 144 bool property_is_device_type(const bt_property_t* property) { 145 CHECK(property != NULL); 146 return property->type == BT_PROPERTY_TYPE_OF_DEVICE; 147 } 148 149 bool property_is_discovery_timeout(const bt_property_t* property) { 150 CHECK(property != NULL); 151 return property->type == BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT; 152 } 153 154 bool property_is_name(const bt_property_t* property) { 155 CHECK(property != NULL); 156 return property->type == BT_PROPERTY_BDNAME; 157 } 158 159 bool property_is_rssi(const bt_property_t* property) { 160 CHECK(property != NULL); 161 return property->type == BT_PROPERTY_REMOTE_RSSI; 162 } 163 164 bool property_is_scan_mode(const bt_property_t* property) { 165 CHECK(property != NULL); 166 return property->type == BT_PROPERTY_ADAPTER_SCAN_MODE; 167 } 168 169 bool property_is_uuids(const bt_property_t* property) { 170 CHECK(property != NULL); 171 return property->type == BT_PROPERTY_UUIDS; 172 } 173 174 // Convenience conversion methods to property values 175 const RawAddress* property_as_addr(const bt_property_t* property) { 176 CHECK(property_is_addr(property)); 177 return (const RawAddress*)property->val; 178 } 179 180 const bt_device_class_t* property_as_device_class( 181 const bt_property_t* property) { 182 CHECK(property_is_device_class(property)); 183 return (const bt_device_class_t*)property->val; 184 } 185 186 bt_device_type_t property_as_device_type(const bt_property_t* property) { 187 CHECK(property_is_device_type(property)); 188 return *(const bt_device_type_t*)property->val; 189 } 190 191 uint32_t property_as_discovery_timeout(const bt_property_t* property) { 192 CHECK(property_is_discovery_timeout(property)); 193 return *(const uint32_t*)property->val; 194 } 195 196 const bt_bdname_t* property_as_name(const bt_property_t* property) { 197 CHECK(property_is_name(property)); 198 return (const bt_bdname_t*)property->val; 199 } 200 201 int8_t property_as_rssi(const bt_property_t* property) { 202 CHECK(property_is_rssi(property)); 203 return *(const int8_t*)property->val; 204 } 205 206 bt_scan_mode_t property_as_scan_mode(const bt_property_t* property) { 207 CHECK(property_is_scan_mode(property)); 208 return *(const bt_scan_mode_t*)property->val; 209 } 210 211 const Uuid* property_as_uuids(const bt_property_t* property, size_t* count) { 212 CHECK(property_is_uuids(property)); 213 *count = sizeof(Uuid) / property->len; 214 return (const Uuid*)property->val; 215 } 216 217 static bt_property_t* property_new_(void* val, size_t len, 218 bt_property_type_t type) { 219 bt_property_t* property = 220 static_cast<bt_property_t*>(osi_calloc(sizeof(bt_property_t))); 221 222 property->val = osi_calloc(len + 1); 223 if (type == BT_PROPERTY_BDNAME) { 224 strlcpy((char*)property->val, (const char*)val, len); 225 } else { 226 memcpy(property->val, val, len); 227 } 228 229 property->type = type; 230 property->len = len; 231 232 return property; 233 } 234