glib/glib/guuid.c
Thomas Haller 10027a7cb6 guuid: fix shift operation to parse hex string in uuid_parse_string()
The actually parsed `@bytes` are not used because the only caller
does not provide an output parameter to request them. So this bug had
no effect in practice.
2021-05-03 15:09:31 +02:00

212 lines
5.1 KiB
C

/* guuid.c - UUID functions
*
* Copyright (C) 2013-2015, 2017 Red Hat, Inc.
*
* 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
* licence, or (at your option) any later version.
*
* This 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
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
* USA.
*
* Authors: Marc-André Lureau <marcandre.lureau@redhat.com>
*/
#include "config.h"
#include <string.h>
#include "gi18n.h"
#include "gstrfuncs.h"
#include "grand.h"
#include "gmessages.h"
#include "gchecksum.h"
#include "guuid.h"
typedef struct {
guint8 bytes[16];
} GUuid;
/**
* SECTION:uuid
* @title: GUuid
* @short_description: a universally unique identifier
*
* A UUID, or Universally unique identifier, is intended to uniquely
* identify information in a distributed environment. For the
* definition of UUID, see [RFC 4122](https://tools.ietf.org/html/rfc4122.html).
*
* The creation of UUIDs does not require a centralized authority.
*
* UUIDs are of relatively small size (128 bits, or 16 bytes). The
* common string representation (ex:
* 1d6c0810-2bd6-45f3-9890-0268422a6f14) needs 37 bytes.
*
* The UUID specification defines 5 versions, and calling
* g_uuid_string_random() will generate a unique (or rather random)
* UUID of the most common version, version 4.
*
* Since: 2.52
*/
/*
* g_uuid_to_string:
* @uuid: a #GUuid
*
* Creates a string representation of @uuid, of the form
* 06e023d5-86d8-420e-8103-383e4566087a (no braces nor urn:uuid:
* prefix).
*
* Returns: (transfer full): A string that should be freed with g_free().
* Since: STATIC
*/
static gchar *
g_uuid_to_string (const GUuid *uuid)
{
const guint8 *bytes;
g_return_val_if_fail (uuid != NULL, NULL);
bytes = uuid->bytes;
return g_strdup_printf ("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x"
"-%02x%02x%02x%02x%02x%02x",
bytes[0], bytes[1], bytes[2], bytes[3],
bytes[4], bytes[5], bytes[6], bytes[7],
bytes[8], bytes[9], bytes[10], bytes[11],
bytes[12], bytes[13], bytes[14], bytes[15]);
}
static gboolean
uuid_parse_string (const gchar *str,
GUuid *uuid)
{
GUuid tmp;
guint8 *bytes = tmp.bytes;
gint i, j, hi, lo;
guint expected_len = 36;
if (strlen (str) != expected_len)
return FALSE;
for (i = 0, j = 0; i < 16;)
{
if (j == 8 || j == 13 || j == 18 || j == 23)
{
if (str[j++] != '-')
return FALSE;
continue;
}
hi = g_ascii_xdigit_value (str[j++]);
lo = g_ascii_xdigit_value (str[j++]);
if (hi == -1 || lo == -1)
return FALSE;
bytes[i++] = hi << 4 | lo;
}
if (uuid != NULL)
*uuid = tmp;
return TRUE;
}
/**
* g_uuid_string_is_valid:
* @str: a string representing a UUID
*
* Parses the string @str and verify if it is a UUID.
*
* The function accepts the following syntax:
*
* - simple forms (e.g. `f81d4fae-7dec-11d0-a765-00a0c91e6bf6`)
*
* Note that hyphens are required within the UUID string itself,
* as per the aforementioned RFC.
*
* Returns: %TRUE if @str is a valid UUID, %FALSE otherwise.
* Since: 2.52
*/
gboolean
g_uuid_string_is_valid (const gchar *str)
{
g_return_val_if_fail (str != NULL, FALSE);
return uuid_parse_string (str, NULL);
}
static void
uuid_set_version (GUuid *uuid, guint version)
{
guint8 *bytes = uuid->bytes;
/*
* Set the four most significant bits (bits 12 through 15) of the
* time_hi_and_version field to the 4-bit version number from
* Section 4.1.3.
*/
bytes[6] &= 0x0f;
bytes[6] |= version << 4;
/*
* Set the two most significant bits (bits 6 and 7) of the
* clock_seq_hi_and_reserved to zero and one, respectively.
*/
bytes[8] &= 0x3f;
bytes[8] |= 0x80;
}
/*
* g_uuid_generate_v4:
* @uuid: a #GUuid
*
* Generates a random UUID (RFC 4122 version 4).
* Since: STATIC
*/
static void
g_uuid_generate_v4 (GUuid *uuid)
{
int i;
guint8 *bytes;
guint32 *ints;
g_return_if_fail (uuid != NULL);
bytes = uuid->bytes;
ints = (guint32 *) bytes;
for (i = 0; i < 4; i++)
ints[i] = g_random_int ();
uuid_set_version (uuid, 4);
}
/**
* g_uuid_string_random:
*
* Generates a random UUID (RFC 4122 version 4) as a string. It has the same
* randomness guarantees as #GRand, so must not be used for cryptographic
* purposes such as key generation, nonces, salts or one-time pads.
*
* Returns: (transfer full): A string that should be freed with g_free().
* Since: 2.52
*/
gchar *
g_uuid_string_random (void)
{
GUuid uuid;
g_uuid_generate_v4 (&uuid);
return g_uuid_to_string (&uuid);
}