| /****************************************************************************** |
| * |
| * Copyright (C) 2014 Google, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "btcore/include/uuid.h" |
| #include "osi/include/allocator.h" |
| |
| static const size_t UUID_WELL_FORMED_STRING_LEN = 36; |
| static const size_t UUID_WELL_FORMED_STRING_LEN_WITH_NULL = 36 + 1; |
| |
| typedef struct uuid_string_t { |
| char string[0]; |
| } uuid_string_t; |
| |
| static const bt_uuid_t empty_uuid = {{ 0 }}; |
| |
| // The base UUID is used for calculating 128-bit UUIDs from 16 and |
| // 32 bit UUIDs as described in the SDP specification. |
| static const bt_uuid_t base_uuid = { |
| { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, |
| 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }}; |
| |
| static bool uuid_is_base(const bt_uuid_t *uuid); |
| |
| uuid_string_t *uuid_string_new(void) { |
| return static_cast<uuid_string_t *>(osi_calloc(UUID_WELL_FORMED_STRING_LEN_WITH_NULL)); |
| } |
| |
| void uuid_string_free(uuid_string_t *uuid_string) { |
| osi_free(uuid_string); |
| } |
| |
| const char *uuid_string_data(const uuid_string_t *uuid_string) { |
| assert(uuid_string != NULL); |
| return (const char *)uuid_string->string; |
| } |
| |
| bt_uuid_t *uuid_new(const char *uuid_string) { |
| assert(uuid_string != NULL); |
| |
| if (strlen(uuid_string) < UUID_WELL_FORMED_STRING_LEN) |
| return NULL; |
| if (uuid_string[8] != '-' || uuid_string[13] != '-' || uuid_string[18] != '-' || uuid_string[23] != '-') |
| return NULL; |
| |
| bt_uuid_t *uuid = static_cast<bt_uuid_t *>(osi_calloc(sizeof(bt_uuid_t))); |
| |
| const char *s = uuid_string; |
| for (size_t i = 0; i < sizeof(bt_uuid_t); ++i, s+=2) { |
| char buf[3] = {0}; |
| buf[0] = s[0]; |
| buf[1] = s[1]; |
| uuid->uu[i] = strtoul(buf, NULL, 16); |
| // Adjust by skipping the dashes |
| switch(i) { |
| case 3: |
| case 5: |
| case 7: |
| case 9: |
| s++; |
| break; |
| } |
| } |
| return uuid; |
| } |
| |
| void uuid_free(bt_uuid_t *uuid) { |
| osi_free(uuid); |
| } |
| |
| bool uuid_is_empty(const bt_uuid_t *uuid) { |
| return !uuid || !memcmp(uuid, &empty_uuid, sizeof(bt_uuid_t)); |
| } |
| |
| bool uuid_is_equal(const bt_uuid_t *first, const bt_uuid_t *second) { |
| assert(first != NULL); |
| assert(second != NULL); |
| return !memcmp(first, second, sizeof(bt_uuid_t)); |
| } |
| |
| bt_uuid_t *uuid_copy(bt_uuid_t *dest, const bt_uuid_t *src) { |
| assert(dest != NULL); |
| assert(src != NULL); |
| return (bt_uuid_t *)memcpy(dest, src, sizeof(bt_uuid_t)); |
| } |
| |
| bool uuid_128_to_16(const bt_uuid_t *uuid, uint16_t *uuid16) { |
| assert(uuid != NULL); |
| assert(uuid16 != NULL); |
| |
| if (!uuid_is_base(uuid)) |
| return false; |
| |
| *uuid16 = (uuid->uu[2] << 8) + uuid->uu[3]; |
| return true; |
| } |
| |
| bool uuid_128_to_32(const bt_uuid_t *uuid, uint32_t *uuid32) { |
| assert(uuid != NULL); |
| assert(uuid32 != NULL); |
| |
| if (!uuid_is_base(uuid)) |
| return false; |
| |
| *uuid32 = (uuid->uu[0] << 24) + (uuid->uu[1] << 16) + (uuid->uu[2] << 8) + uuid->uu[3]; |
| return true; |
| } |
| |
| void uuid_128_from_16(bt_uuid_t *uuid, uint16_t uuid16) { |
| assert(uuid != NULL); |
| |
| memcpy(uuid, &base_uuid, sizeof(bt_uuid_t)); |
| |
| uuid->uu[2] = (uint8_t)((0xFF00 & uuid16)>>8); |
| uuid->uu[3] = (uint8_t)(0x00FF & uuid16); |
| } |
| |
| void uuid_to_string(const bt_uuid_t *uuid, uuid_string_t *uuid_string) { |
| assert(uuid != NULL); |
| assert(uuid_string != NULL); |
| |
| char *string = uuid_string->string; |
| char *end = string + UUID_WELL_FORMED_STRING_LEN_WITH_NULL; |
| |
| // XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXX |
| for (int i = 0; i < 4; i++) { |
| string += snprintf(string, end - string, "%02x", uuid->uu[i]); |
| } |
| *string = '-'; |
| ++string; |
| for (int i = 4; i < 6; i++) { |
| string += snprintf(string, end - string, "%02x", uuid->uu[i]); |
| } |
| *string = '-'; |
| ++string; |
| for (int i = 6; i < 8; i++) { |
| string += snprintf(string, end - string, "%02x", uuid->uu[i]); |
| } |
| *string = '-'; |
| ++string; |
| for (int i = 8; i < 10; i++) { |
| string += snprintf(string, end - string, "%02x", uuid->uu[i]); |
| } |
| *string = '-'; |
| ++string; |
| for (int i = 10; i < 16; i++) { |
| string += snprintf(string, end - string, "%02x", uuid->uu[i]); |
| } |
| } |
| |
| static bool uuid_is_base(const bt_uuid_t *uuid) { |
| if (!uuid) |
| return false; |
| |
| for (int i = 4; i < 16; i++) { |
| if (uuid->uu[i] != base_uuid.uu[i]) |
| return false; |
| } |
| return true; |
| } |