1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Unified UUID/GUID definition |
4 | * |
5 | * Copyright (C) 2009, 2016 Intel Corp. |
6 | * Huang Ying <ying.huang@intel.com> |
7 | */ |
8 | |
9 | #include <linux/kernel.h> |
10 | #include <linux/ctype.h> |
11 | #include <linux/errno.h> |
12 | #include <linux/export.h> |
13 | #include <linux/uuid.h> |
14 | #include <linux/random.h> |
15 | |
16 | const guid_t guid_null; |
17 | EXPORT_SYMBOL(guid_null); |
18 | const uuid_t uuid_null; |
19 | EXPORT_SYMBOL(uuid_null); |
20 | |
21 | const u8 guid_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15}; |
22 | const u8 uuid_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; |
23 | |
24 | /** |
25 | * generate_random_uuid - generate a random UUID |
26 | * @uuid: where to put the generated UUID |
27 | * |
28 | * Random UUID interface |
29 | * |
30 | * Used to create a Boot ID or a filesystem UUID/GUID, but can be |
31 | * useful for other kernel drivers. |
32 | */ |
33 | void generate_random_uuid(unsigned char uuid[16]) |
34 | { |
35 | get_random_bytes(buf: uuid, len: 16); |
36 | /* Set UUID version to 4 --- truly random generation */ |
37 | uuid[6] = (uuid[6] & 0x0F) | 0x40; |
38 | /* Set the UUID variant to DCE */ |
39 | uuid[8] = (uuid[8] & 0x3F) | 0x80; |
40 | } |
41 | EXPORT_SYMBOL(generate_random_uuid); |
42 | |
43 | void generate_random_guid(unsigned char guid[16]) |
44 | { |
45 | get_random_bytes(buf: guid, len: 16); |
46 | /* Set GUID version to 4 --- truly random generation */ |
47 | guid[7] = (guid[7] & 0x0F) | 0x40; |
48 | /* Set the GUID variant to DCE */ |
49 | guid[8] = (guid[8] & 0x3F) | 0x80; |
50 | } |
51 | EXPORT_SYMBOL(generate_random_guid); |
52 | |
53 | static void __uuid_gen_common(__u8 b[16]) |
54 | { |
55 | get_random_bytes(buf: b, len: 16); |
56 | /* reversion 0b10 */ |
57 | b[8] = (b[8] & 0x3F) | 0x80; |
58 | } |
59 | |
60 | void guid_gen(guid_t *lu) |
61 | { |
62 | __uuid_gen_common(b: lu->b); |
63 | /* version 4 : random generation */ |
64 | lu->b[7] = (lu->b[7] & 0x0F) | 0x40; |
65 | } |
66 | EXPORT_SYMBOL_GPL(guid_gen); |
67 | |
68 | void uuid_gen(uuid_t *bu) |
69 | { |
70 | __uuid_gen_common(b: bu->b); |
71 | /* version 4 : random generation */ |
72 | bu->b[6] = (bu->b[6] & 0x0F) | 0x40; |
73 | } |
74 | EXPORT_SYMBOL_GPL(uuid_gen); |
75 | |
76 | /** |
77 | * uuid_is_valid - checks if a UUID string is valid |
78 | * @uuid: UUID string to check |
79 | * |
80 | * Description: |
81 | * It checks if the UUID string is following the format: |
82 | * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
83 | * |
84 | * where x is a hex digit. |
85 | * |
86 | * Return: true if input is valid UUID string. |
87 | */ |
88 | bool uuid_is_valid(const char *uuid) |
89 | { |
90 | unsigned int i; |
91 | |
92 | for (i = 0; i < UUID_STRING_LEN; i++) { |
93 | if (i == 8 || i == 13 || i == 18 || i == 23) { |
94 | if (uuid[i] != '-') |
95 | return false; |
96 | } else if (!isxdigit(uuid[i])) { |
97 | return false; |
98 | } |
99 | } |
100 | |
101 | return true; |
102 | } |
103 | EXPORT_SYMBOL(uuid_is_valid); |
104 | |
105 | static int __uuid_parse(const char *uuid, __u8 b[16], const u8 ei[16]) |
106 | { |
107 | static const u8 si[16] = {0,2,4,6,9,11,14,16,19,21,24,26,28,30,32,34}; |
108 | unsigned int i; |
109 | |
110 | if (!uuid_is_valid(uuid)) |
111 | return -EINVAL; |
112 | |
113 | for (i = 0; i < 16; i++) { |
114 | int hi = hex_to_bin(ch: uuid[si[i] + 0]); |
115 | int lo = hex_to_bin(ch: uuid[si[i] + 1]); |
116 | |
117 | b[ei[i]] = (hi << 4) | lo; |
118 | } |
119 | |
120 | return 0; |
121 | } |
122 | |
123 | int guid_parse(const char *uuid, guid_t *u) |
124 | { |
125 | return __uuid_parse(uuid, b: u->b, ei: guid_index); |
126 | } |
127 | EXPORT_SYMBOL(guid_parse); |
128 | |
129 | int uuid_parse(const char *uuid, uuid_t *u) |
130 | { |
131 | return __uuid_parse(uuid, b: u->b, ei: uuid_index); |
132 | } |
133 | EXPORT_SYMBOL(uuid_parse); |
134 | |