1 /******************************************************************************
2 *
3 * Copyright (C) 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 <assert.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23
24 #include "btcore/include/uuid.h"
25 #include "osi/include/allocator.h"
26
27 static const size_t UUID_WELL_FORMED_STRING_LEN = 36;
28 static const size_t UUID_WELL_FORMED_STRING_LEN_WITH_NULL = 36 + 1;
29
30 typedef struct uuid_string_t {
31 char string[0];
32 } uuid_string_t;
33
34 static const bt_uuid_t empty_uuid = {{ 0 }};
35
36 // The base UUID is used for calculating 128-bit UUIDs from 16 and
37 // 32 bit UUIDs as described in the SDP specification.
38 static const bt_uuid_t base_uuid = {
39 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
40 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb, }};
41
42 static bool uuid_is_base(const bt_uuid_t *uuid);
43
uuid_string_new(void)44 uuid_string_t *uuid_string_new(void) {
45 return osi_calloc(UUID_WELL_FORMED_STRING_LEN_WITH_NULL);
46 }
47
uuid_string_free(uuid_string_t * uuid_string)48 void uuid_string_free(uuid_string_t *uuid_string) {
49 osi_free(uuid_string);
50 }
51
uuid_string_data(const uuid_string_t * uuid_string)52 const char *uuid_string_data(const uuid_string_t *uuid_string) {
53 assert(uuid_string != NULL);
54 return (const char *)uuid_string->string;
55 }
56
uuid_new(const char * uuid_string)57 bt_uuid_t *uuid_new(const char *uuid_string) {
58 assert(uuid_string != NULL);
59
60 if (strlen(uuid_string) < UUID_WELL_FORMED_STRING_LEN)
61 return NULL;
62 if (uuid_string[8] != '-' || uuid_string[13] != '-' || uuid_string[18] != '-' || uuid_string[23] != '-')
63 return NULL;
64
65 bt_uuid_t *uuid = osi_calloc(sizeof(bt_uuid_t));
66 if (uuid == NULL)
67 return NULL;
68
69 const char *s = uuid_string;
70 for (size_t i = 0; i < sizeof(bt_uuid_t); ++i, s+=2) {
71 char buf[2];
72 buf[0] = s[0];
73 buf[1] = s[1];
74 uuid->uu[i] = strtoul(buf, NULL, 16);
75 // Adjust by skipping the dashes
76 switch(i) {
77 case 3:
78 case 5:
79 case 7:
80 case 9:
81 s++;
82 break;
83 }
84 }
85 return uuid;
86 }
87
uuid_free(bt_uuid_t * uuid)88 void uuid_free(bt_uuid_t *uuid) {
89 osi_free(uuid);
90 }
91
uuid_is_empty(const bt_uuid_t * uuid)92 bool uuid_is_empty(const bt_uuid_t *uuid) {
93 return !uuid || !memcmp(uuid, &empty_uuid, sizeof(bt_uuid_t));
94 }
95
uuid_is_equal(const bt_uuid_t * first,const bt_uuid_t * second)96 bool uuid_is_equal(const bt_uuid_t *first, const bt_uuid_t *second) {
97 assert(first != NULL);
98 assert(second != NULL);
99 return !memcmp(first, second, sizeof(bt_uuid_t));
100 }
101
uuid_copy(bt_uuid_t * dest,const bt_uuid_t * src)102 bt_uuid_t *uuid_copy(bt_uuid_t *dest, const bt_uuid_t *src) {
103 assert(dest != NULL);
104 assert(src != NULL);
105 return (bt_uuid_t *)memcpy(dest, src, sizeof(bt_uuid_t));
106 }
107
uuid_128_to_16(const bt_uuid_t * uuid,uint16_t * uuid16)108 bool uuid_128_to_16(const bt_uuid_t *uuid, uint16_t *uuid16) {
109 assert(uuid != NULL);
110 assert(uuid16 != NULL);
111
112 if (!uuid_is_base(uuid))
113 return false;
114
115 *uuid16 = (uuid->uu[2] << 8) + uuid->uu[3];
116 return true;
117 }
118
uuid_128_to_32(const bt_uuid_t * uuid,uint32_t * uuid32)119 bool uuid_128_to_32(const bt_uuid_t *uuid, uint32_t *uuid32) {
120 assert(uuid != NULL);
121 assert(uuid32 != NULL);
122
123 if (!uuid_is_base(uuid))
124 return false;
125
126 *uuid32 = (uuid->uu[0] << 24) + (uuid->uu[1] << 16) + (uuid->uu[2] << 8) + uuid->uu[3];
127 return true;
128 }
129
uuid_to_string(const bt_uuid_t * uuid,uuid_string_t * uuid_string)130 void uuid_to_string(const bt_uuid_t *uuid, uuid_string_t *uuid_string) {
131 assert(uuid != NULL);
132 assert(uuid_string != NULL);
133
134 char *string = uuid_string->string;
135
136 for (int i = 0; i < 4; i++) {
137 string += sprintf(string, "%02x", uuid->uu[i]);
138 }
139 string += sprintf(string, "-");
140 for (int i = 4; i < 6; i++) {
141 string += sprintf(string, "%02x", uuid->uu[i]);
142 }
143 string += sprintf(string, "-");
144 for (int i = 6; i < 8; i++) {
145 string += sprintf(string, "%02x", uuid->uu[i]);
146 }
147 string += sprintf(string, "-");
148 for (int i = 8; i < 10; i++) {
149 string += sprintf(string, "%02x", uuid->uu[i]);
150 }
151 string += sprintf(string, "-");
152 for (int i = 10; i < 16; i++) {
153 string += sprintf(string, "%02x", uuid->uu[i]);
154 }
155 }
156
uuid_is_base(const bt_uuid_t * uuid)157 static bool uuid_is_base(const bt_uuid_t *uuid) {
158 if (!uuid)
159 return false;
160
161 for (int i = 4; i < 16; i++) {
162 if (uuid->uu[i] != base_uuid.uu[i])
163 return false;
164 }
165 return true;
166 }
167