VirtualBox

source: vbox/trunk/src/VBox/Runtime/generic/uuid-generic.cpp@ 64247

Last change on this file since 64247 was 62477, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 22.2 KB
Line 
1/* $Id: uuid-generic.cpp 62477 2016-07-22 18:27:37Z vboxsync $ */
2/** @file
3 * IPRT - UUID, Generic.
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/uuid.h>
32#include "internal/iprt.h"
33
34#include <iprt/assert.h>
35#include <iprt/err.h>
36#include <iprt/asm.h>
37
38
39/*********************************************************************************************************************************
40* Global Variables *
41*********************************************************************************************************************************/
42/** Conversion table used by the conversion functions.
43 * 0xff if not a hex number, otherwise the value. */
44static const uint8_t g_au8Digits[256] =
45{
46 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 0..0f */
47 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 10..1f */
48 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 20..2f */
49 0x00,0x01,0x02,0x03, 0x04,0x05,0x06,0x07, 0x08,0x09,0xff,0xff, 0xff,0xff,0xff,0xff, /* 30..3f */
50 0xff,0x0a,0x0b,0x0c, 0x0d,0x0e,0x0f,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 40..4f */
51 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 50..5f */
52 0xff,0x0a,0x0b,0x0c, 0x0d,0x0e,0x0f,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 60..6f */
53 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 70..7f */
54 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 80..8f */
55 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* 90..9f */
56 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* a0..af */
57 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* b0..bf */
58 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* c0..cf */
59 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* d0..df */
60 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* e0..ef */
61 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, /* f0..ff */
62};
63/** Conversion to string. */
64static const char g_achDigits[17] = "0123456789abcdef";
65
66
67
68/* WARNING: This implementation ASSUMES little endian. Does not work on big endian! */
69
70/* Remember, the time fields in the UUID must be little endian. */
71
72
73RTDECL(int) RTUuidClear(PRTUUID pUuid)
74{
75 AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
76 pUuid->au64[0] = 0;
77 pUuid->au64[1] = 0;
78 return VINF_SUCCESS;
79}
80RT_EXPORT_SYMBOL(RTUuidClear);
81
82
83RTDECL(bool) RTUuidIsNull(PCRTUUID pUuid)
84{
85 AssertPtrReturn(pUuid, true);
86 return !pUuid->au64[0]
87 && !pUuid->au64[1];
88}
89RT_EXPORT_SYMBOL(RTUuidIsNull);
90
91
92RTDECL(int) RTUuidCompare(PCRTUUID pUuid1, PCRTUUID pUuid2)
93{
94 /*
95 * Special cases.
96 */
97 if (pUuid1 == pUuid2)
98 return 0;
99 if (!pUuid1)
100 return RTUuidIsNull(pUuid2) ? 0 : -1;
101 if (!pUuid2)
102 return RTUuidIsNull(pUuid1) ? 0 : 1;
103 AssertPtrReturn(pUuid1, -1);
104 AssertPtrReturn(pUuid2, 1);
105
106 /*
107 * Standard cases.
108 */
109 if (pUuid1->Gen.u32TimeLow != pUuid2->Gen.u32TimeLow)
110 return pUuid1->Gen.u32TimeLow < pUuid2->Gen.u32TimeLow ? -1 : 1;
111 if (pUuid1->Gen.u16TimeMid != pUuid2->Gen.u16TimeMid)
112 return pUuid1->Gen.u16TimeMid < pUuid2->Gen.u16TimeMid ? -1 : 1;
113 if (pUuid1->Gen.u16TimeHiAndVersion != pUuid2->Gen.u16TimeHiAndVersion)
114 return pUuid1->Gen.u16TimeHiAndVersion < pUuid2->Gen.u16TimeHiAndVersion ? -1 : 1;
115 if (pUuid1->Gen.u8ClockSeqHiAndReserved != pUuid2->Gen.u8ClockSeqHiAndReserved)
116 return pUuid1->Gen.u8ClockSeqHiAndReserved < pUuid2->Gen.u8ClockSeqHiAndReserved ? -1 : 1;
117 if (pUuid1->Gen.u8ClockSeqLow != pUuid2->Gen.u8ClockSeqLow)
118 return pUuid1->Gen.u8ClockSeqLow < pUuid2->Gen.u8ClockSeqLow ? -1 : 1;
119 if (pUuid1->Gen.au8Node[0] != pUuid2->Gen.au8Node[0])
120 return pUuid1->Gen.au8Node[0] < pUuid2->Gen.au8Node[0] ? -1 : 1;
121 if (pUuid1->Gen.au8Node[1] != pUuid2->Gen.au8Node[1])
122 return pUuid1->Gen.au8Node[1] < pUuid2->Gen.au8Node[1] ? -1 : 1;
123 if (pUuid1->Gen.au8Node[2] != pUuid2->Gen.au8Node[2])
124 return pUuid1->Gen.au8Node[2] < pUuid2->Gen.au8Node[2] ? -1 : 1;
125 if (pUuid1->Gen.au8Node[3] != pUuid2->Gen.au8Node[3])
126 return pUuid1->Gen.au8Node[3] < pUuid2->Gen.au8Node[3] ? -1 : 1;
127 if (pUuid1->Gen.au8Node[4] != pUuid2->Gen.au8Node[4])
128 return pUuid1->Gen.au8Node[4] < pUuid2->Gen.au8Node[4] ? -1 : 1;
129 if (pUuid1->Gen.au8Node[5] != pUuid2->Gen.au8Node[5])
130 return pUuid1->Gen.au8Node[5] < pUuid2->Gen.au8Node[5] ? -1 : 1;
131 return 0;
132}
133RT_EXPORT_SYMBOL(RTUuidCompare);
134
135
136RTDECL(int) RTUuidCompareStr(PCRTUUID pUuid1, const char *pszString2)
137{
138 RTUUID Uuid2;
139 int rc;
140
141 /* check params */
142 AssertPtrReturn(pUuid1, -1);
143 AssertPtrReturn(pszString2, 1);
144
145 /*
146 * Try convert the string to a UUID and then compare the two.
147 */
148 rc = RTUuidFromStr(&Uuid2, pszString2);
149 AssertRCReturn(rc, 1);
150
151 return RTUuidCompare(pUuid1, &Uuid2);
152}
153RT_EXPORT_SYMBOL(RTUuidCompareStr);
154
155
156RTDECL(int) RTUuidCompare2Strs(const char *pszString1, const char *pszString2)
157{
158 RTUUID Uuid1;
159 RTUUID Uuid2;
160 int rc;
161
162 /* check params */
163 AssertPtrReturn(pszString1, -1);
164 AssertPtrReturn(pszString2, 1);
165
166 /*
167 * Try convert the strings to UUIDs and then compare them.
168 */
169 rc = RTUuidFromStr(&Uuid1, pszString1);
170 AssertRCReturn(rc, -1);
171
172 rc = RTUuidFromStr(&Uuid2, pszString2);
173 AssertRCReturn(rc, 1);
174
175 return RTUuidCompare(&Uuid1, &Uuid2);
176}
177RT_EXPORT_SYMBOL(RTUuidCompare2Strs);
178
179
180RTDECL(int) RTUuidToStr(PCRTUUID pUuid, char *pszString, size_t cchString)
181{
182 uint32_t u32TimeLow;
183 unsigned u;
184
185 /* validate parameters */
186 AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
187 AssertPtrReturn(pszString, VERR_INVALID_PARAMETER);
188 AssertReturn(cchString >= RTUUID_STR_LENGTH, VERR_INVALID_PARAMETER);
189
190 /*
191 * RTStrPrintf(,,"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
192 * pUuid->Gen.u32TimeLow,
193 * pUuid->Gen.u16TimeMin,
194 * pUuid->Gen.u16TimeHiAndVersion,
195 * pUuid->Gen.u16ClockSeq & 0xff,
196 * pUuid->Gen.u16ClockSeq >> 8,
197 * pUuid->Gen.au8Node[0],
198 * pUuid->Gen.au8Node[1],
199 * pUuid->Gen.au8Node[2],
200 * pUuid->Gen.au8Node[3],
201 * pUuid->Gen.au8Node[4],
202 * pUuid->Gen.au8Node[5]);
203 */
204 u32TimeLow = RT_H2LE_U32(pUuid->Gen.u32TimeLow);
205 pszString[ 0] = g_achDigits[(u32TimeLow >> 28)/*& 0xf*/];
206 pszString[ 1] = g_achDigits[(u32TimeLow >> 24) & 0xf];
207 pszString[ 2] = g_achDigits[(u32TimeLow >> 20) & 0xf];
208 pszString[ 3] = g_achDigits[(u32TimeLow >> 16) & 0xf];
209 pszString[ 4] = g_achDigits[(u32TimeLow >> 12) & 0xf];
210 pszString[ 5] = g_achDigits[(u32TimeLow >> 8) & 0xf];
211 pszString[ 6] = g_achDigits[(u32TimeLow >> 4) & 0xf];
212 pszString[ 7] = g_achDigits[(u32TimeLow/*>>0*/)& 0xf];
213 pszString[ 8] = '-';
214 u = RT_H2LE_U16(pUuid->Gen.u16TimeMid);
215 pszString[ 9] = g_achDigits[(u >> 12)/*& 0xf*/];
216 pszString[10] = g_achDigits[(u >> 8) & 0xf];
217 pszString[11] = g_achDigits[(u >> 4) & 0xf];
218 pszString[12] = g_achDigits[(u/*>>0*/)& 0xf];
219 pszString[13] = '-';
220 u = RT_H2LE_U16(pUuid->Gen.u16TimeHiAndVersion);
221 pszString[14] = g_achDigits[(u >> 12)/*& 0xf*/];
222 pszString[15] = g_achDigits[(u >> 8) & 0xf];
223 pszString[16] = g_achDigits[(u >> 4) & 0xf];
224 pszString[17] = g_achDigits[(u/*>>0*/)& 0xf];
225 pszString[18] = '-';
226 pszString[19] = g_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved >> 4];
227 pszString[20] = g_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved & 0xf];
228 pszString[21] = g_achDigits[pUuid->Gen.u8ClockSeqLow >> 4];
229 pszString[22] = g_achDigits[pUuid->Gen.u8ClockSeqLow & 0xf];
230 pszString[23] = '-';
231 pszString[24] = g_achDigits[pUuid->Gen.au8Node[0] >> 4];
232 pszString[25] = g_achDigits[pUuid->Gen.au8Node[0] & 0xf];
233 pszString[26] = g_achDigits[pUuid->Gen.au8Node[1] >> 4];
234 pszString[27] = g_achDigits[pUuid->Gen.au8Node[1] & 0xf];
235 pszString[28] = g_achDigits[pUuid->Gen.au8Node[2] >> 4];
236 pszString[29] = g_achDigits[pUuid->Gen.au8Node[2] & 0xf];
237 pszString[30] = g_achDigits[pUuid->Gen.au8Node[3] >> 4];
238 pszString[31] = g_achDigits[pUuid->Gen.au8Node[3] & 0xf];
239 pszString[32] = g_achDigits[pUuid->Gen.au8Node[4] >> 4];
240 pszString[33] = g_achDigits[pUuid->Gen.au8Node[4] & 0xf];
241 pszString[34] = g_achDigits[pUuid->Gen.au8Node[5] >> 4];
242 pszString[35] = g_achDigits[pUuid->Gen.au8Node[5] & 0xf];
243 pszString[36] = '\0';
244
245 return VINF_SUCCESS;
246}
247RT_EXPORT_SYMBOL(RTUuidToStr);
248
249
250RTDECL(int) RTUuidFromStr(PRTUUID pUuid, const char *pszString)
251{
252 bool fHaveBraces;
253
254 /*
255 * Validate parameters.
256 */
257 AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
258 AssertPtrReturn(pszString, VERR_INVALID_PARAMETER);
259
260 fHaveBraces = pszString[0] == '{';
261 pszString += fHaveBraces;
262
263#define MY_CHECK(expr) do { if (RT_UNLIKELY(!(expr))) return VERR_INVALID_UUID_FORMAT; } while (0)
264#define MY_ISXDIGIT(ch) (g_au8Digits[(ch) & 0xff] != 0xff)
265 MY_CHECK(MY_ISXDIGIT(pszString[ 0]));
266 MY_CHECK(MY_ISXDIGIT(pszString[ 1]));
267 MY_CHECK(MY_ISXDIGIT(pszString[ 2]));
268 MY_CHECK(MY_ISXDIGIT(pszString[ 3]));
269 MY_CHECK(MY_ISXDIGIT(pszString[ 4]));
270 MY_CHECK(MY_ISXDIGIT(pszString[ 5]));
271 MY_CHECK(MY_ISXDIGIT(pszString[ 6]));
272 MY_CHECK(MY_ISXDIGIT(pszString[ 7]));
273 MY_CHECK(pszString[ 8] == '-');
274 MY_CHECK(MY_ISXDIGIT(pszString[ 9]));
275 MY_CHECK(MY_ISXDIGIT(pszString[10]));
276 MY_CHECK(MY_ISXDIGIT(pszString[11]));
277 MY_CHECK(MY_ISXDIGIT(pszString[12]));
278 MY_CHECK(pszString[13] == '-');
279 MY_CHECK(MY_ISXDIGIT(pszString[14]));
280 MY_CHECK(MY_ISXDIGIT(pszString[15]));
281 MY_CHECK(MY_ISXDIGIT(pszString[16]));
282 MY_CHECK(MY_ISXDIGIT(pszString[17]));
283 MY_CHECK(pszString[18] == '-');
284 MY_CHECK(MY_ISXDIGIT(pszString[19]));
285 MY_CHECK(MY_ISXDIGIT(pszString[20]));
286 MY_CHECK(MY_ISXDIGIT(pszString[21]));
287 MY_CHECK(MY_ISXDIGIT(pszString[22]));
288 MY_CHECK(pszString[23] == '-');
289 MY_CHECK(MY_ISXDIGIT(pszString[24]));
290 MY_CHECK(MY_ISXDIGIT(pszString[25]));
291 MY_CHECK(MY_ISXDIGIT(pszString[26]));
292 MY_CHECK(MY_ISXDIGIT(pszString[27]));
293 MY_CHECK(MY_ISXDIGIT(pszString[28]));
294 MY_CHECK(MY_ISXDIGIT(pszString[29]));
295 MY_CHECK(MY_ISXDIGIT(pszString[30]));
296 MY_CHECK(MY_ISXDIGIT(pszString[31]));
297 MY_CHECK(MY_ISXDIGIT(pszString[32]));
298 MY_CHECK(MY_ISXDIGIT(pszString[33]));
299 MY_CHECK(MY_ISXDIGIT(pszString[34]));
300 MY_CHECK(MY_ISXDIGIT(pszString[35]));
301 if (fHaveBraces)
302 MY_CHECK(pszString[36] == '}');
303 MY_CHECK(!pszString[36 + fHaveBraces]);
304#undef MY_ISXDIGIT
305#undef MY_CHECK
306
307 /*
308 * Inverse of RTUuidToStr (see above).
309 */
310#define MY_TONUM(ch) (g_au8Digits[(ch) & 0xff])
311 pUuid->Gen.u32TimeLow = RT_LE2H_U32((uint32_t)MY_TONUM(pszString[ 0]) << 28
312 | (uint32_t)MY_TONUM(pszString[ 1]) << 24
313 | (uint32_t)MY_TONUM(pszString[ 2]) << 20
314 | (uint32_t)MY_TONUM(pszString[ 3]) << 16
315 | (uint32_t)MY_TONUM(pszString[ 4]) << 12
316 | (uint32_t)MY_TONUM(pszString[ 5]) << 8
317 | (uint32_t)MY_TONUM(pszString[ 6]) << 4
318 | (uint32_t)MY_TONUM(pszString[ 7]));
319 pUuid->Gen.u16TimeMid = RT_LE2H_U16((uint16_t)MY_TONUM(pszString[ 9]) << 12
320 | (uint16_t)MY_TONUM(pszString[10]) << 8
321 | (uint16_t)MY_TONUM(pszString[11]) << 4
322 | (uint16_t)MY_TONUM(pszString[12]));
323 pUuid->Gen.u16TimeHiAndVersion = RT_LE2H_U16(
324 (uint16_t)MY_TONUM(pszString[14]) << 12
325 | (uint16_t)MY_TONUM(pszString[15]) << 8
326 | (uint16_t)MY_TONUM(pszString[16]) << 4
327 | (uint16_t)MY_TONUM(pszString[17]));
328 pUuid->Gen.u8ClockSeqHiAndReserved =
329 (uint16_t)MY_TONUM(pszString[19]) << 4
330 | (uint16_t)MY_TONUM(pszString[20]);
331 pUuid->Gen.u8ClockSeqLow =
332 (uint16_t)MY_TONUM(pszString[21]) << 4
333 | (uint16_t)MY_TONUM(pszString[22]);
334 pUuid->Gen.au8Node[0] = (uint8_t)MY_TONUM(pszString[24]) << 4
335 | (uint8_t)MY_TONUM(pszString[25]);
336 pUuid->Gen.au8Node[1] = (uint8_t)MY_TONUM(pszString[26]) << 4
337 | (uint8_t)MY_TONUM(pszString[27]);
338 pUuid->Gen.au8Node[2] = (uint8_t)MY_TONUM(pszString[28]) << 4
339 | (uint8_t)MY_TONUM(pszString[29]);
340 pUuid->Gen.au8Node[3] = (uint8_t)MY_TONUM(pszString[30]) << 4
341 | (uint8_t)MY_TONUM(pszString[31]);
342 pUuid->Gen.au8Node[4] = (uint8_t)MY_TONUM(pszString[32]) << 4
343 | (uint8_t)MY_TONUM(pszString[33]);
344 pUuid->Gen.au8Node[5] = (uint8_t)MY_TONUM(pszString[34]) << 4
345 | (uint8_t)MY_TONUM(pszString[35]);
346#undef MY_TONUM
347 return VINF_SUCCESS;
348}
349RT_EXPORT_SYMBOL(RTUuidFromStr);
350
351
352RTDECL(int) RTUuidToUtf16(PCRTUUID pUuid, PRTUTF16 pwszString, size_t cwcString)
353{
354 uint32_t u32TimeLow;
355 unsigned u;
356
357 /* validate parameters */
358 AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
359 AssertPtrReturn(pwszString, VERR_INVALID_PARAMETER);
360 AssertReturn(cwcString >= RTUUID_STR_LENGTH, VERR_INVALID_PARAMETER);
361
362 /*
363 * RTStrPrintf(,,"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
364 * pUuid->Gen.u32TimeLow,
365 * pUuid->Gen.u16TimeMin,
366 * pUuid->Gen.u16TimeHiAndVersion,
367 * pUuid->Gen.u16ClockSeq & 0xff,
368 * pUuid->Gen.u16ClockSeq >> 8,
369 * pUuid->Gen.au8Node[0],
370 * pUuid->Gen.au8Node[1],
371 * pUuid->Gen.au8Node[2],
372 * pUuid->Gen.au8Node[3],
373 * pUuid->Gen.au8Node[4],
374 * pUuid->Gen.au8Node[5]);
375 */
376 u32TimeLow = RT_H2LE_U32(pUuid->Gen.u32TimeLow);
377 pwszString[ 0] = g_achDigits[(u32TimeLow >> 28)/*& 0xf*/];
378 pwszString[ 1] = g_achDigits[(u32TimeLow >> 24) & 0xf];
379 pwszString[ 2] = g_achDigits[(u32TimeLow >> 20) & 0xf];
380 pwszString[ 3] = g_achDigits[(u32TimeLow >> 16) & 0xf];
381 pwszString[ 4] = g_achDigits[(u32TimeLow >> 12) & 0xf];
382 pwszString[ 5] = g_achDigits[(u32TimeLow >> 8) & 0xf];
383 pwszString[ 6] = g_achDigits[(u32TimeLow >> 4) & 0xf];
384 pwszString[ 7] = g_achDigits[(u32TimeLow/*>>0*/)& 0xf];
385 pwszString[ 8] = '-';
386 u = RT_H2LE_U16(pUuid->Gen.u16TimeMid);
387 pwszString[ 9] = g_achDigits[(u >> 12)/*& 0xf*/];
388 pwszString[10] = g_achDigits[(u >> 8) & 0xf];
389 pwszString[11] = g_achDigits[(u >> 4) & 0xf];
390 pwszString[12] = g_achDigits[(u/*>>0*/)& 0xf];
391 pwszString[13] = '-';
392 u = RT_H2LE_U16(pUuid->Gen.u16TimeHiAndVersion);
393 pwszString[14] = g_achDigits[(u >> 12)/*& 0xf*/];
394 pwszString[15] = g_achDigits[(u >> 8) & 0xf];
395 pwszString[16] = g_achDigits[(u >> 4) & 0xf];
396 pwszString[17] = g_achDigits[(u/*>>0*/)& 0xf];
397 pwszString[18] = '-';
398 pwszString[19] = g_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved >> 4];
399 pwszString[20] = g_achDigits[pUuid->Gen.u8ClockSeqHiAndReserved & 0xf];
400 pwszString[21] = g_achDigits[pUuid->Gen.u8ClockSeqLow >> 4];
401 pwszString[22] = g_achDigits[pUuid->Gen.u8ClockSeqLow & 0xf];
402 pwszString[23] = '-';
403 pwszString[24] = g_achDigits[pUuid->Gen.au8Node[0] >> 4];
404 pwszString[25] = g_achDigits[pUuid->Gen.au8Node[0] & 0xf];
405 pwszString[26] = g_achDigits[pUuid->Gen.au8Node[1] >> 4];
406 pwszString[27] = g_achDigits[pUuid->Gen.au8Node[1] & 0xf];
407 pwszString[28] = g_achDigits[pUuid->Gen.au8Node[2] >> 4];
408 pwszString[29] = g_achDigits[pUuid->Gen.au8Node[2] & 0xf];
409 pwszString[30] = g_achDigits[pUuid->Gen.au8Node[3] >> 4];
410 pwszString[31] = g_achDigits[pUuid->Gen.au8Node[3] & 0xf];
411 pwszString[32] = g_achDigits[pUuid->Gen.au8Node[4] >> 4];
412 pwszString[33] = g_achDigits[pUuid->Gen.au8Node[4] & 0xf];
413 pwszString[34] = g_achDigits[pUuid->Gen.au8Node[5] >> 4];
414 pwszString[35] = g_achDigits[pUuid->Gen.au8Node[5] & 0xf];
415 pwszString[36] = '\0';
416
417 return VINF_SUCCESS;
418}
419RT_EXPORT_SYMBOL(RTUuidToUtf16);
420
421
422RTDECL(int) RTUuidFromUtf16(PRTUUID pUuid, PCRTUTF16 pwszString)
423{
424 bool fHaveBraces;
425
426 /*
427 * Validate parameters.
428 */
429 AssertPtrReturn(pUuid, VERR_INVALID_PARAMETER);
430 AssertPtrReturn(pwszString, VERR_INVALID_PARAMETER);
431
432 fHaveBraces = pwszString[0] == '{';
433 pwszString += fHaveBraces;
434
435#define MY_CHECK(expr) do { if (RT_UNLIKELY(!(expr))) return VERR_INVALID_UUID_FORMAT; } while (0)
436#define MY_ISXDIGIT(ch) (!((ch) & 0xff00) && g_au8Digits[(ch) & 0xff] != 0xff)
437 MY_CHECK(MY_ISXDIGIT(pwszString[ 0]));
438 MY_CHECK(MY_ISXDIGIT(pwszString[ 1]));
439 MY_CHECK(MY_ISXDIGIT(pwszString[ 2]));
440 MY_CHECK(MY_ISXDIGIT(pwszString[ 3]));
441 MY_CHECK(MY_ISXDIGIT(pwszString[ 4]));
442 MY_CHECK(MY_ISXDIGIT(pwszString[ 5]));
443 MY_CHECK(MY_ISXDIGIT(pwszString[ 6]));
444 MY_CHECK(MY_ISXDIGIT(pwszString[ 7]));
445 MY_CHECK(pwszString[ 8] == '-');
446 MY_CHECK(MY_ISXDIGIT(pwszString[ 9]));
447 MY_CHECK(MY_ISXDIGIT(pwszString[10]));
448 MY_CHECK(MY_ISXDIGIT(pwszString[11]));
449 MY_CHECK(MY_ISXDIGIT(pwszString[12]));
450 MY_CHECK(pwszString[13] == '-');
451 MY_CHECK(MY_ISXDIGIT(pwszString[14]));
452 MY_CHECK(MY_ISXDIGIT(pwszString[15]));
453 MY_CHECK(MY_ISXDIGIT(pwszString[16]));
454 MY_CHECK(MY_ISXDIGIT(pwszString[17]));
455 MY_CHECK(pwszString[18] == '-');
456 MY_CHECK(MY_ISXDIGIT(pwszString[19]));
457 MY_CHECK(MY_ISXDIGIT(pwszString[20]));
458 MY_CHECK(MY_ISXDIGIT(pwszString[21]));
459 MY_CHECK(MY_ISXDIGIT(pwszString[22]));
460 MY_CHECK(pwszString[23] == '-');
461 MY_CHECK(MY_ISXDIGIT(pwszString[24]));
462 MY_CHECK(MY_ISXDIGIT(pwszString[25]));
463 MY_CHECK(MY_ISXDIGIT(pwszString[26]));
464 MY_CHECK(MY_ISXDIGIT(pwszString[27]));
465 MY_CHECK(MY_ISXDIGIT(pwszString[28]));
466 MY_CHECK(MY_ISXDIGIT(pwszString[29]));
467 MY_CHECK(MY_ISXDIGIT(pwszString[30]));
468 MY_CHECK(MY_ISXDIGIT(pwszString[31]));
469 MY_CHECK(MY_ISXDIGIT(pwszString[32]));
470 MY_CHECK(MY_ISXDIGIT(pwszString[33]));
471 MY_CHECK(MY_ISXDIGIT(pwszString[34]));
472 MY_CHECK(MY_ISXDIGIT(pwszString[35]));
473 if (fHaveBraces)
474 MY_CHECK(pwszString[36] == '}');
475 MY_CHECK(!pwszString[36 + fHaveBraces]);
476#undef MY_ISXDIGIT
477#undef MY_CHECK
478
479 /*
480 * Inverse of RTUuidToUtf8 (see above).
481 */
482#define MY_TONUM(ch) (g_au8Digits[(ch) & 0xff])
483 pUuid->Gen.u32TimeLow = RT_LE2H_U32((uint32_t)MY_TONUM(pwszString[ 0]) << 28
484 | (uint32_t)MY_TONUM(pwszString[ 1]) << 24
485 | (uint32_t)MY_TONUM(pwszString[ 2]) << 20
486 | (uint32_t)MY_TONUM(pwszString[ 3]) << 16
487 | (uint32_t)MY_TONUM(pwszString[ 4]) << 12
488 | (uint32_t)MY_TONUM(pwszString[ 5]) << 8
489 | (uint32_t)MY_TONUM(pwszString[ 6]) << 4
490 | (uint32_t)MY_TONUM(pwszString[ 7]));
491 pUuid->Gen.u16TimeMid = RT_LE2H_U16((uint16_t)MY_TONUM(pwszString[ 9]) << 12
492 | (uint16_t)MY_TONUM(pwszString[10]) << 8
493 | (uint16_t)MY_TONUM(pwszString[11]) << 4
494 | (uint16_t)MY_TONUM(pwszString[12]));
495 pUuid->Gen.u16TimeHiAndVersion = RT_LE2H_U16(
496 (uint16_t)MY_TONUM(pwszString[14]) << 12
497 | (uint16_t)MY_TONUM(pwszString[15]) << 8
498 | (uint16_t)MY_TONUM(pwszString[16]) << 4
499 | (uint16_t)MY_TONUM(pwszString[17]));
500 pUuid->Gen.u8ClockSeqHiAndReserved =
501 (uint16_t)MY_TONUM(pwszString[19]) << 4
502 | (uint16_t)MY_TONUM(pwszString[20]);
503 pUuid->Gen.u8ClockSeqLow =
504 (uint16_t)MY_TONUM(pwszString[21]) << 4
505 | (uint16_t)MY_TONUM(pwszString[22]);
506 pUuid->Gen.au8Node[0] = (uint8_t)MY_TONUM(pwszString[24]) << 4
507 | (uint8_t)MY_TONUM(pwszString[25]);
508 pUuid->Gen.au8Node[1] = (uint8_t)MY_TONUM(pwszString[26]) << 4
509 | (uint8_t)MY_TONUM(pwszString[27]);
510 pUuid->Gen.au8Node[2] = (uint8_t)MY_TONUM(pwszString[28]) << 4
511 | (uint8_t)MY_TONUM(pwszString[29]);
512 pUuid->Gen.au8Node[3] = (uint8_t)MY_TONUM(pwszString[30]) << 4
513 | (uint8_t)MY_TONUM(pwszString[31]);
514 pUuid->Gen.au8Node[4] = (uint8_t)MY_TONUM(pwszString[32]) << 4
515 | (uint8_t)MY_TONUM(pwszString[33]);
516 pUuid->Gen.au8Node[5] = (uint8_t)MY_TONUM(pwszString[34]) << 4
517 | (uint8_t)MY_TONUM(pwszString[35]);
518#undef MY_TONUM
519 return VINF_SUCCESS;
520}
521RT_EXPORT_SYMBOL(RTUuidFromUtf16);
522
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette