uuid.c 2.9 KB

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