2007-02-26 15:32:27 +00:00
|
|
|
/*
|
2014-03-07 13:38:51 +00:00
|
|
|
* viruuid.c: helper APIs for dealing with UUIDs
|
2012-12-13 18:01:25 +00:00
|
|
|
*
|
2014-03-18 08:14:35 +00:00
|
|
|
* Copyright (C) 2007-2014 Red Hat, Inc.
|
2007-02-26 15:32:27 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2007-02-26 15:32:27 +00:00
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-02-26 15:32:27 +00:00
|
|
|
|
2012-12-13 18:01:25 +00:00
|
|
|
#include "viruuid.h"
|
2007-02-26 15:32:27 +00:00
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
#include "c-ctype.h"
|
2007-02-26 15:32:27 +00:00
|
|
|
#include "internal.h"
|
2012-12-13 17:44:57 +00:00
|
|
|
#include "virutil.h"
|
2012-12-13 18:21:53 +00:00
|
|
|
#include "virerror.h"
|
2012-12-12 17:59:27 +00:00
|
|
|
#include "virlog.h"
|
2012-12-12 18:06:53 +00:00
|
|
|
#include "viralloc.h"
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2012-01-25 15:17:46 +00:00
|
|
|
#include "virrandom.h"
|
2007-06-26 23:48:46 +00:00
|
|
|
|
2014-02-28 12:16:17 +00:00
|
|
|
VIR_LOG_INIT("util.uuid");
|
|
|
|
|
2010-05-25 14:33:51 +00:00
|
|
|
static unsigned char host_uuid[VIR_UUID_BUFLEN];
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* virUUIDGenerate:
|
2007-08-09 20:19:12 +00:00
|
|
|
* @uuid: array of VIR_UUID_BUFLEN bytes to store the new UUID
|
2007-06-29 13:23:13 +00:00
|
|
|
*
|
|
|
|
* Generates a randomized unique identifier.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of failure
|
|
|
|
*/
|
2007-02-26 15:32:27 +00:00
|
|
|
int
|
2007-06-26 22:19:38 +00:00
|
|
|
virUUIDGenerate(unsigned char *uuid)
|
2007-02-26 15:32:27 +00:00
|
|
|
{
|
2007-06-29 13:23:13 +00:00
|
|
|
if (uuid == NULL)
|
2012-03-22 11:33:35 +00:00
|
|
|
return -1;
|
2007-06-29 13:23:13 +00:00
|
|
|
|
2018-05-29 06:35:13 +00:00
|
|
|
if (virRandomBytes(uuid, VIR_UUID_BUFLEN) < 0)
|
|
|
|
return -1;
|
2007-02-26 15:32:27 +00:00
|
|
|
|
2013-04-08 18:10:54 +00:00
|
|
|
/*
|
|
|
|
* Make UUID RFC 4122 compliant. Following form will be used:
|
|
|
|
*
|
|
|
|
* xxxxxxxx-xxxx-Axxx-Bxxx-xxxxxxxxxxxx
|
|
|
|
*
|
|
|
|
* where
|
|
|
|
* A is version defined in 4.1.3 of RFC
|
|
|
|
* Msb0 Msb1 Msb2 Msb3 Version Description
|
|
|
|
* 0 1 0 0 4 The randomly or pseudo-
|
|
|
|
* randomly generated version
|
|
|
|
* specified in this document.
|
|
|
|
*
|
|
|
|
* B is variant defined in 4.1.1 of RFC
|
|
|
|
* Msb0 Msb1 Msb2 Description
|
|
|
|
* 1 0 x The variant specified in this document.
|
|
|
|
*/
|
|
|
|
uuid[6] = (uuid[6] & 0x0F) | (4 << 4);
|
|
|
|
uuid[8] = (uuid[8] & 0x3F) | (2 << 6);
|
|
|
|
|
2018-05-29 06:35:13 +00:00
|
|
|
return 0;
|
2007-02-26 15:32:27 +00:00
|
|
|
}
|
|
|
|
|
2007-06-29 13:23:13 +00:00
|
|
|
/**
|
|
|
|
* virUUIDParse:
|
2007-08-09 20:19:12 +00:00
|
|
|
* @uuidstr: zero terminated string representation of the UUID
|
|
|
|
* @uuid: array of VIR_UUID_BUFLEN bytes to store the raw UUID
|
2007-06-29 13:23:13 +00:00
|
|
|
*
|
|
|
|
* Parses the external string representation, allowing spaces and '-'
|
|
|
|
* character in the sequence, and storing the result as a raw UUID
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
2007-02-26 15:34:24 +00:00
|
|
|
int
|
2014-03-18 08:14:35 +00:00
|
|
|
virUUIDParse(const char *uuidstr, unsigned char *uuid)
|
|
|
|
{
|
2007-02-26 15:34:24 +00:00
|
|
|
const char *cur;
|
Convert 'int i' to 'size_t i' in src/util/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
2007-02-26 15:34:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* do a liberal scan allowing '-' and ' ' anywhere between character
|
2010-01-21 14:28:56 +00:00
|
|
|
* pairs, and surrounding whitespace, as long as there are exactly
|
|
|
|
* 32 hexadecimal digits the end.
|
2007-02-26 15:34:24 +00:00
|
|
|
*/
|
2007-08-09 20:19:12 +00:00
|
|
|
cur = uuidstr;
|
2010-01-21 14:28:56 +00:00
|
|
|
while (c_isspace(*cur))
|
|
|
|
cur++;
|
|
|
|
|
2013-05-24 16:58:25 +00:00
|
|
|
for (i = 0; i < VIR_UUID_BUFLEN;) {
|
2007-08-09 20:19:12 +00:00
|
|
|
uuid[i] = 0;
|
2007-02-26 15:34:24 +00:00
|
|
|
if (*cur == 0)
|
|
|
|
goto error;
|
|
|
|
if ((*cur == '-') || (*cur == ' ')) {
|
|
|
|
cur++;
|
|
|
|
continue;
|
|
|
|
}
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
if (!c_isxdigit(*cur))
|
2007-02-26 15:34:24 +00:00
|
|
|
goto error;
|
2010-08-27 21:13:45 +00:00
|
|
|
uuid[i] = virHexToBin(*cur);
|
2007-08-09 20:19:12 +00:00
|
|
|
uuid[i] *= 16;
|
2007-02-26 15:34:24 +00:00
|
|
|
cur++;
|
|
|
|
if (*cur == 0)
|
|
|
|
goto error;
|
start using c-ctype functions
Up to now, we've been avoiding ctype functions like isspace, isdigit,
etc. because they are locale-dependent. Now that we have the c-ctype
functions, we can start using *them*, to make the code more readable
with changes like these:
- /* This may not work on EBCDIC. */
- if ((*p >= 'a' && *p <= 'z') ||
- (*p >= 'A' && *p <= 'Z') ||
- (*p >= '0' && *p <= '9'))
+ if (c_isalnum(*p))
- while ((*cur >= '0') && (*cur <= '9')) {
+ while (c_isdigit(*cur)) {
Also, some macros in conf.c used names that conflicted with
standard meaning of "BLANK" and "SPACE", so I've adjusted them
to be in line with the definition of e.g., isblank.
In addition, I've wrapped those statement macros with do {...} while (0),
so that we can't forget the ";" after a use. There was one like that
already (fixed below). The missing semicolon would mess up automatic
indenting.
* src/buf.c (virBufferURIEncodeString):
* src/conf.c (IS_EOL, SKIP_BLANKS_AND_EOL, SKIP_BLANKS)
(virConfParseLong, virConfParseValue, virConfParseName)
(virConfParseSeparator, virConfParseStatement, IS_BLANK, IS_CHAR)
(IS_DIGIT, IS_SPACE, SKIP_SPACES):
* src/nodeinfo.c:
* src/qemu_conf.c (qemudParseInterfaceXML):
* src/qemu_driver.c (qemudDomainBlockStats):
* src/sexpr.c:
* src/stats_linux.c:
* src/util.c (virParseNumber, virDiskNameToIndex):
* src/uuid.c (hextobin, virUUIDParse):
* src/virsh.c:
* src/xml.c (parseCpuNumber, virParseCpuSet):
2008-05-16 09:37:44 +00:00
|
|
|
if (!c_isxdigit(*cur))
|
2007-02-26 15:34:24 +00:00
|
|
|
goto error;
|
2010-08-27 21:13:45 +00:00
|
|
|
uuid[i] += virHexToBin(*cur);
|
2007-02-26 15:34:24 +00:00
|
|
|
i++;
|
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
|
2010-01-21 14:28:56 +00:00
|
|
|
while (*cur) {
|
|
|
|
if (!c_isspace(*cur))
|
|
|
|
goto error;
|
|
|
|
cur++;
|
|
|
|
}
|
|
|
|
|
2007-02-26 15:34:24 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-08-09 20:19:12 +00:00
|
|
|
/**
|
|
|
|
* virUUIDFormat:
|
|
|
|
* @uuid: array of VIR_UUID_RAW_LEN bytes to store the raw UUID
|
|
|
|
* @uuidstr: array of VIR_UUID_STRING_BUFLEN bytes to store the
|
|
|
|
* string representation of the UUID in. The resulting string
|
|
|
|
* will be NULL terminated.
|
|
|
|
*
|
|
|
|
* Converts the raw UUID into printable format, with embedded '-'
|
|
|
|
*
|
2012-08-02 18:06:58 +00:00
|
|
|
* Returns a pointer to the resulting character string.
|
2007-08-09 20:19:12 +00:00
|
|
|
*/
|
2012-08-02 18:06:58 +00:00
|
|
|
const char *
|
|
|
|
virUUIDFormat(const unsigned char *uuid, char *uuidstr)
|
2007-08-09 20:19:12 +00:00
|
|
|
{
|
|
|
|
snprintf(uuidstr, VIR_UUID_STRING_BUFLEN,
|
|
|
|
"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
|
|
|
uuid[0], uuid[1], uuid[2], uuid[3],
|
|
|
|
uuid[4], uuid[5], uuid[6], uuid[7],
|
|
|
|
uuid[8], uuid[9], uuid[10], uuid[11],
|
|
|
|
uuid[12], uuid[13], uuid[14], uuid[15]);
|
|
|
|
uuidstr[VIR_UUID_STRING_BUFLEN-1] = '\0';
|
2012-08-02 18:06:58 +00:00
|
|
|
return uuidstr;
|
2007-08-09 20:19:12 +00:00
|
|
|
}
|
2010-05-25 14:33:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* virUUIDIsValid
|
|
|
|
*
|
|
|
|
* @uuid: The UUID to test
|
|
|
|
*
|
|
|
|
* Do some basic tests to check whether the given UUID is
|
|
|
|
* valid as a host UUID.
|
|
|
|
* Basic tests:
|
|
|
|
* - Not all of the digits may be equal
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
virUUIDIsValid(unsigned char *uuid)
|
|
|
|
{
|
Convert 'int i' to 'size_t i' in src/util/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
|
|
|
unsigned int ctr = 1;
|
2010-05-25 14:33:51 +00:00
|
|
|
unsigned char c;
|
|
|
|
|
|
|
|
if (!uuid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
c = uuid[0];
|
|
|
|
|
|
|
|
for (i = 1; i < VIR_UUID_BUFLEN; i++)
|
|
|
|
if (uuid[i] == c)
|
|
|
|
ctr++;
|
|
|
|
|
2012-03-22 11:33:35 +00:00
|
|
|
return ctr != VIR_UUID_BUFLEN;
|
2010-05-25 14:33:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
getDMISystemUUID(char *uuid, int len)
|
|
|
|
{
|
Convert 'int i' to 'size_t i' in src/util/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i = 0;
|
2010-05-25 14:33:51 +00:00
|
|
|
const char *paths[] = {
|
|
|
|
"/sys/devices/virtual/dmi/id/product_uuid",
|
|
|
|
"/sys/class/dmi/id/product_uuid",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
while (paths[i]) {
|
2016-05-03 09:12:40 +00:00
|
|
|
if (virFileReadBufQuiet(paths[i], uuid, len) == len - 1)
|
|
|
|
return 0;
|
2010-05-25 14:33:51 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* setHostUUID
|
|
|
|
*
|
|
|
|
* @host_uuid: UUID that the host is supposed to have
|
|
|
|
*
|
|
|
|
* Set the UUID of the host if it hasn't been set, yet
|
|
|
|
* Returns 0 in case of success, an error code in case of error.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
virSetHostUUIDStr(const char *uuid)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
char dmiuuid[VIR_UUID_STRING_BUFLEN];
|
|
|
|
|
|
|
|
if (virUUIDIsValid(host_uuid))
|
|
|
|
return EEXIST;
|
|
|
|
|
|
|
|
if (!uuid) {
|
2010-07-30 14:19:51 +00:00
|
|
|
memset(dmiuuid, 0, sizeof(dmiuuid));
|
2012-05-04 17:22:22 +00:00
|
|
|
if (!getDMISystemUUID(dmiuuid, sizeof(dmiuuid))) {
|
2010-05-25 14:33:51 +00:00
|
|
|
if (!virUUIDParse(dmiuuid, host_uuid))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!virUUIDIsValid(host_uuid))
|
|
|
|
return virUUIDGenerate(host_uuid);
|
|
|
|
} else {
|
|
|
|
rc = virUUIDParse(uuid, host_uuid);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
if (!virUUIDIsValid(host_uuid))
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* getHostUUID:
|
|
|
|
*
|
|
|
|
* @host_uuid: memory to store the host_uuid into
|
|
|
|
*
|
|
|
|
* Get the UUID of the host. Returns 0 in case of success,
|
|
|
|
* an error code otherwise.
|
|
|
|
* Returns 0 in case of success, an error code in case of error.
|
|
|
|
*/
|
|
|
|
int virGetHostUUID(unsigned char *uuid)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!virUUIDIsValid(host_uuid))
|
|
|
|
ret = virSetHostUUIDStr(NULL);
|
|
|
|
|
|
|
|
memcpy(uuid, host_uuid, sizeof(host_uuid));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|