lib/uuid.c

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