lib/uuid.c

   1 /*
   2  * Copyright 2011 Calxeda, Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <linux/ctype.h>
   8 #include <errno.h>
   9 #include <common.h>
  10 #include <asm/io.h>
  11 #include <part_efi.h>
  12 #include <malloc.h>
  13
  14 /*
  15  * UUID - Universally Unique IDentifier - 128 bits unique number.
  16  *        There are 5 versions and one variant of UUID defined by RFC4122
  17  *        specification. Depends on version uuid number base on a time,
  18  *        host name, MAC address or random data.
  19  *
  20  * UUID binary format (16 bytes):
  21  *
  22  * 4B-2B-2B-2B-6B (big endian - network byte order)
  23  *
  24  * UUID string is 36 length of characters (36 bytes):
  25  *
  26  * 0        9    14   19   24
  27  * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
  28  *    be     be   be   be       be
  29  *
  30  * where x is a hexadecimal character. Fields are separated by '-'s.
  31  * When converting to a binary UUID, le means the field should be converted
  32  * to little endian and be means it should be converted to big endian.
  33  *
  34  * UUID is also used as GUID (Globally Unique Identifier) with the same binary
  35  * format but it differs in string format like below.
  36  *
  37  * GUID:
  38  * 0        9    14   19   24
  39  * xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
  40  *    le     le   le   be       be
  41  *
  42  * GUID is used e.g. in GPT (GUID Partition Table) as a partiions unique id.
  43  */
  44 int uuid_str_valid(const char *uuid)
  45 {
  46         int i, valid;
  47
  48         if (uuid == NULL)
  49                 return 0;
  50
  51         for (i = 0, valid = 1; uuid[i] && valid; i++) {
  52                 switch (i) {
  53                 case 8: case 13: case 18: case 23:
  54                         valid = (uuid[i] == '-');
  55                         break;
  56                 default:
  57                         valid = isxdigit(uuid[i]);
  58                         break;
  59                 }
  60         }
  61
  62         if (i != UUID_STR_LEN || !valid)
  63                 return 0;
  64
  65         return 1;
  66 }
  67
  68 /*
  69  * uuid_str_to_bin() - convert string UUID or GUID to big endian binary data.
  70  *
  71  * @param uuid_str - pointer to UUID or GUID string [37B]
  72  * @param uuid_bin - pointer to allocated array for big endian output [16B]
  73  * @str_format     - UUID string format: 0 - UUID; 1 - GUID
  74  */
  75 int uuid_str_to_bin(char *uuid_str, unsigned char *uuid_bin, int str_format)
  76 {
  77         uint16_t tmp16;
  78         uint32_t tmp32;
  79         uint64_t tmp64;
  80
  81         if (!uuid_str_valid(uuid_str))
  82                 return -EINVAL;
  83
  84         if (str_format == UUID_STR_FORMAT_STD) {
  85                 tmp32 = cpu_to_be32(simple_strtoul(uuid_str, NULL, 16));
  86                 memcpy(uuid_bin, &tmp32, 4);
  87
  88                 tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 9, NULL, 16));
  89                 memcpy(uuid_bin + 4, &tmp16, 2);
  90
  91                 tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 14, NULL, 16));
  92                 memcpy(uuid_bin + 6, &tmp16, 2);
  93         } else {
  94                 tmp32 = cpu_to_le32(simple_strtoul(uuid_str, NULL, 16));
  95                 memcpy(uuid_bin, &tmp32, 4);
  96
  97                 tmp16 = cpu_to_le16(simple_strtoul(uuid_str + 9, NULL, 16));
  98                 memcpy(uuid_bin + 4, &tmp16, 2);
  99
 100                 tmp16 = cpu_to_le16(simple_strtoul(uuid_str + 14, NULL, 16));
 101                 memcpy(uuid_bin + 6, &tmp16, 2);
 102         }
 103
 104         tmp16 = cpu_to_be16(simple_strtoul(uuid_str + 19, NULL, 16));
 105         memcpy(uuid_bin + 8, &tmp16, 2);
 106
 107         tmp64 = cpu_to_be64(simple_strtoull(uuid_str + 24, NULL, 16));
 108         memcpy(uuid_bin + 10, (char *)&tmp64 + 2, 6);
 109
 110         return 0;
 111 }
 112
 113 /*
 114  * uuid_bin_to_str() - convert big endian binary data to string UUID or GUID.
 115  *
 116  * @param uuid_bin - pointer to binary data of UUID (big endian) [16B]
 117  * @param uuid_str - pointer to allocated array for output string [37B]
 118  * @str_format     - UUID string format: 0 - UUID; 1 - GUID
 119  */
 120 void uuid_bin_to_str(unsigned char *uuid_bin, char *uuid_str, int str_format)
 121 {
 122         const u8 uuid_char_order[UUID_BIN_LEN] = {0, 1, 2, 3, 4, 5, 6, 7, 8,
 123                                                   9, 10, 11, 12, 13, 14, 15};
 124         const u8 guid_char_order[UUID_BIN_LEN] = {3, 2, 1, 0, 5, 4, 7, 6, 8,
 125                                                   9, 10, 11, 12, 13, 14, 15};
 126         const u8 *char_order;
 127         int i;
 128
 129         /*
 130          * UUID and GUID bin data - always in big endian:
 131          * 4B-2B-2B-2B-6B
 132          * be be be be be
 133          */
 134         if (str_format == UUID_STR_FORMAT_STD)
 135                 char_order = uuid_char_order;
 136         else
 137                 char_order = guid_char_order;
 138
 139         for (i = 0; i < 16; i++) {
 140                 sprintf(uuid_str, "%02x", uuid_bin[char_order[i]]);
 141                 uuid_str += 2;
 142                 switch (i) {
 143                 case 3:
 144                 case 5:
 145                 case 7:
 146                 case 9:
 147                         *uuid_str++ = '-';
 148                         break;
 149                 }
 150         }
 151 }