blob: 37687af77ff847aeb47f88c8ea5d9b6cda8ac5b3
1 | /* |
2 | * Unified UUID/GUID definition |
3 | * |
4 | * Copyright (C) 2009, 2016 Intel Corp. |
5 | * Huang Ying <ying.huang@intel.com> |
6 | * |
7 | * This program is free software; you can redistribute it and/or |
8 | * modify it under the terms of the GNU General Public License version |
9 | * 2 as published by the Free Software Foundation; |
10 | * |
11 | * This program is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | * GNU General Public License for more details. |
15 | */ |
16 | |
17 | #include <linux/kernel.h> |
18 | #include <linux/ctype.h> |
19 | #include <linux/errno.h> |
20 | #include <linux/export.h> |
21 | #include <linux/uuid.h> |
22 | #include <linux/random.h> |
23 | |
24 | const u8 uuid_le_index[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15}; |
25 | EXPORT_SYMBOL(uuid_le_index); |
26 | const u8 uuid_be_index[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; |
27 | EXPORT_SYMBOL(uuid_be_index); |
28 | |
29 | /*************************************************************** |
30 | * Random UUID interface |
31 | * |
32 | * Used here for a Boot ID, but can be useful for other kernel |
33 | * drivers. |
34 | ***************************************************************/ |
35 | |
36 | /* |
37 | * Generate random UUID |
38 | */ |
39 | void generate_random_uuid(unsigned char uuid[16]) |
40 | { |
41 | get_random_bytes(uuid, 16); |
42 | /* Set UUID version to 4 --- truly random generation */ |
43 | uuid[6] = (uuid[6] & 0x0F) | 0x40; |
44 | /* Set the UUID variant to DCE */ |
45 | uuid[8] = (uuid[8] & 0x3F) | 0x80; |
46 | } |
47 | EXPORT_SYMBOL(generate_random_uuid); |
48 | |
49 | static void __uuid_gen_common(__u8 b[16]) |
50 | { |
51 | prandom_bytes(b, 16); |
52 | /* reversion 0b10 */ |
53 | b[8] = (b[8] & 0x3F) | 0x80; |
54 | } |
55 | |
56 | void uuid_le_gen(uuid_le *lu) |
57 | { |
58 | __uuid_gen_common(lu->b); |
59 | /* version 4 : random generation */ |
60 | lu->b[7] = (lu->b[7] & 0x0F) | 0x40; |
61 | } |
62 | EXPORT_SYMBOL_GPL(uuid_le_gen); |
63 | |
64 | void uuid_be_gen(uuid_be *bu) |
65 | { |
66 | __uuid_gen_common(bu->b); |
67 | /* version 4 : random generation */ |
68 | bu->b[6] = (bu->b[6] & 0x0F) | 0x40; |
69 | } |
70 | EXPORT_SYMBOL_GPL(uuid_be_gen); |
71 | |
72 | /** |
73 | * uuid_is_valid - checks if UUID string valid |
74 | * @uuid: UUID string to check |
75 | * |
76 | * Description: |
77 | * It checks if the UUID string is following the format: |
78 | * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
79 | * where x is a hex digit. |
80 | * |
81 | * Return: true if input is valid UUID string. |
82 | */ |
83 | bool uuid_is_valid(const char *uuid) |
84 | { |
85 | unsigned int i; |
86 | |
87 | for (i = 0; i < UUID_STRING_LEN; i++) { |
88 | if (i == 8 || i == 13 || i == 18 || i == 23) { |
89 | if (uuid[i] != '-') |
90 | return false; |
91 | } else if (!isxdigit(uuid[i])) { |
92 | return false; |
93 | } |
94 | } |
95 | |
96 | return true; |
97 | } |
98 | EXPORT_SYMBOL(uuid_is_valid); |
99 | |
100 | static int __uuid_to_bin(const char *uuid, __u8 b[16], const u8 ei[16]) |
101 | { |
102 | static const u8 si[16] = {0,2,4,6,9,11,14,16,19,21,24,26,28,30,32,34}; |
103 | unsigned int i; |
104 | |
105 | if (!uuid_is_valid(uuid)) |
106 | return -EINVAL; |
107 | |
108 | for (i = 0; i < 16; i++) { |
109 | int hi = hex_to_bin(uuid[si[i] + 0]); |
110 | int lo = hex_to_bin(uuid[si[i] + 1]); |
111 | |
112 | b[ei[i]] = (hi << 4) | lo; |
113 | } |
114 | |
115 | return 0; |
116 | } |
117 | |
118 | int uuid_le_to_bin(const char *uuid, uuid_le *u) |
119 | { |
120 | return __uuid_to_bin(uuid, u->b, uuid_le_index); |
121 | } |
122 | EXPORT_SYMBOL(uuid_le_to_bin); |
123 | |
124 | int uuid_be_to_bin(const char *uuid, uuid_be *u) |
125 | { |
126 | return __uuid_to_bin(uuid, u->b, uuid_be_index); |
127 | } |
128 | EXPORT_SYMBOL(uuid_be_to_bin); |
129 |