source: mainline/uspace/lib/c/generic/uuid.c@ d85d4f2

/*
 * Copyright (c) 2015 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libc
 * @{
 */
/** @file Universaly Unique Identifier (see RFC 4122)
 */

#include <errno.h>
#include <uuid.h>
#include <rndgen.h>
#include <stdlib.h>
#include <stddef.h>
#include <str.h>
#include <stdio.h>

static void encode16_be(uint8_t *, uint16_t);
static void encode16_le(uint8_t *, uint16_t);
static void encode32_be(uint8_t *, uint32_t);
static void encode32_le(uint8_t *, uint32_t);
static uint16_t decode16_be(uint8_t *);
static uint16_t decode16_le(uint8_t *);
static uint32_t decode32_be(uint8_t *);
static uint32_t decode32_le(uint8_t *);

/** Generate UUID.
 *
 * @param uuid Place to store generated UUID
 * @return EOK on success or an error code
 */
errno_t uuid_generate(uuid_t *uuid)
{
        int i;
        rndgen_t *rndgen;
        errno_t rc;

        rc = rndgen_create(&rndgen);
        if (rc != EOK)
                return EIO;

        rc = rndgen_uint32(rndgen, &uuid->time_low);
        if (rc != EOK) {
                rc = EIO;
                goto error;
        }

        rc = rndgen_uint16(rndgen, &uuid->time_mid);
        if (rc != EOK) {
                rc = EIO;
                goto error;
        }

        rc = rndgen_uint16(rndgen, &uuid->time_hi_and_version);
        if (rc != EOK) {
                rc = EIO;
                goto error;
        }

        rc = rndgen_uint8(rndgen, &uuid->clock_seq_hi_and_reserved);
        if (rc != EOK) {
                rc = EIO;
                goto error;
        }

        rc = rndgen_uint8(rndgen, &uuid->clock_seq_low);
        if (rc != EOK) {
                rc = EIO;
                goto error;
        }

        for (i = 0; i < _UUID_NODE_LEN; i++) {
                rc = rndgen_uint8(rndgen, &uuid->node[i]);
                if (rc != EOK) {
                        rc = EIO;
                        goto error;
                }
        }

        /* Version 4 UUID from random or pseudo-random numbers */
        uuid->time_hi_and_version = (uuid->time_hi_and_version & 0x0fff) | 0x4000;
        uuid->clock_seq_hi_and_reserved = (uuid->clock_seq_hi_and_reserved & 0x3f) | 0x80;

error:
        rndgen_destroy(rndgen);
        return rc;
}


/** Encode UUID into binary form per RFC 4122.
 *
 * @param uuid UUID
 * @param buf 16-byte destination buffer
 */
void uuid_encode(uuid_t *uuid, uint8_t *buf)
{
        int i;

        encode32_be(buf, uuid->time_low);
        encode16_be(buf + 4, uuid->time_mid);
        encode16_be(buf + 6, uuid->time_hi_and_version);
        buf[8] = uuid->clock_seq_hi_and_reserved;
        buf[9] = uuid->clock_seq_low;

        for (i = 0; i < _UUID_NODE_LEN; i++)
                buf[10 + i] = uuid->node[i];
}

/** Decode UUID from binary form per RFC 4122.
 *
 * @param buf 16-byte source buffer
 * @param uuid Place to store UUID
 */
void uuid_decode(uint8_t *buf, uuid_t *uuid)
{
        int i;

        uuid->time_low = decode32_be(buf);
        uuid->time_mid = decode16_be(buf + 4);
        uuid->time_hi_and_version = decode16_be(buf + 6);
        uuid->clock_seq_hi_and_reserved = buf[8];
        uuid->clock_seq_low = buf[9];

        for (i = 0; i < _UUID_NODE_LEN; i++)
                uuid->node[i] = buf[10 + i];
}

/** Encode UUID into little-endian (GPT) binary form.
 *
 * @param uuid UUID
 * @param buf 16-byte destination buffer
 */
void uuid_encode_le(uuid_t *uuid, uint8_t *buf)
{
        int i;

        encode32_le(buf, uuid->time_low);
        encode16_le(buf + 4, uuid->time_mid);
        encode16_le(buf + 6, uuid->time_hi_and_version);
        buf[8] = uuid->clock_seq_hi_and_reserved;
        buf[9] = uuid->clock_seq_low;

        for (i = 0; i < _UUID_NODE_LEN; i++)
                buf[10 + i] = uuid->node[i];
}

/** Decode UUID from little-endian (GPT) binary form.
 *
 * @param buf 16-byte source buffer
 * @param uuid Place to store UUID
 */
void uuid_decode_le(uint8_t *buf, uuid_t *uuid)
{
        int i;

        uuid->time_low = decode32_le(buf);
        uuid->time_mid = decode16_le(buf + 4);
        uuid->time_hi_and_version = decode16_le(buf + 6);
        uuid->clock_seq_hi_and_reserved = buf[8];
        uuid->clock_seq_low = buf[9];

        for (i = 0; i < _UUID_NODE_LEN; i++)
                uuid->node[i] = buf[10 + i];
}

/** Parse string UUID.
 *
 * If @a endptr is not NULL, it is set to point to the first character
 * following the UUID. If @a endptr is NULL, the string must not contain
 * any characters following the UUID, otherwise an error is returned.
 *
 * @param str    String beginning with UUID string representation
 * @param uuid   Place to store UUID
 * @param endptr Place to store pointer to end of UUID or @c NULL
 *
 * @return EOK on success or an error code
 */
errno_t uuid_parse(const char *str, uuid_t *uuid, const char **endptr)
{
        errno_t rc;
        const char *eptr;
        uint32_t time_low;
        uint16_t time_mid;
        uint16_t time_ver;
        uint16_t clock;
        uint64_t node;
        int i;

        rc = str_uint32_t(str, &eptr, 16, false, &time_low);
        if (rc != EOK || eptr != str + 8 || *eptr != '-')
                return EINVAL;

        rc = str_uint16_t(str + 9, &eptr, 16, false, &time_mid);
        if (rc != EOK || eptr != str + 13 || *eptr != '-')
                return EINVAL;

        rc = str_uint16_t(str + 14, &eptr, 16, false, &time_ver);
        if (rc != EOK || eptr != str + 18 || *eptr != '-')
                return EINVAL;

        rc = str_uint16_t(str + 19, &eptr, 16, false, &clock);
        if (rc != EOK || eptr != str + 23 || *eptr != '-')
                return EINVAL;

        rc = str_uint64_t(str + 24, &eptr, 16, false, &node);
        if (rc != EOK || eptr != str + 36)
                return EINVAL;

        uuid->time_low = time_low;

        uuid->time_mid = time_mid;

        uuid->time_hi_and_version = time_ver;

        uuid->clock_seq_hi_and_reserved = clock >> 8;

        uuid->clock_seq_low = clock & 0xff;

        for (i = 0; i < _UUID_NODE_LEN; i++)
                uuid->node[i] = (node >> 8 * (5 - i)) & 0xff;

        if (endptr != NULL) {
                *endptr = str + 36;
        } else {
                if (*(str + 36) != '\0')
                        return EINVAL;
        }

        return EOK;
}

/** Format UUID into string representation.
 *
 * @param uuid UUID
 * @param rstr Place to store pointer to newly allocated string
 *
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t uuid_format(uuid_t *uuid, char **rstr, bool uppercase)
{
        size_t size = 37;
        char *str = malloc(sizeof(char) * size);
        if (str == NULL)
                return ENOMEM;

        const char *format = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
        if (uppercase)
                format = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X";

        int ret = snprintf(str, size, format, uuid->time_low, uuid->time_mid,
            uuid->time_hi_and_version, uuid->clock_seq_hi_and_reserved,
            uuid->clock_seq_low, uuid->node[0], uuid->node[1], uuid->node[2],
            uuid->node[3], uuid->node[4], uuid->node[5]);

        if (ret != 36) {
                free(str);
                return EINVAL;
        }

        *rstr = str;
        return EOK;
}

static void encode16_be(uint8_t *buf, uint16_t value)
{
        buf[0] = (value >> 8) & 0xff;
        buf[1] = value & 0xff;
}

static void encode16_le(uint8_t *buf, uint16_t value)
{
        buf[0] = value & 0xff;
        buf[1] = (value >> 8) & 0xff;
}

static void encode32_be(uint8_t *buf, uint32_t value)
{
        buf[0] = (value >> 24) & 0xff;
        buf[1] = (value >> 16) & 0xff;
        buf[2] = (value >> 8) & 0xff;
        buf[3] = value & 0xff;
}

static void encode32_le(uint8_t *buf, uint32_t value)
{
        buf[0] = value & 0xff;
        buf[1] = (value >> 8) & 0xff;
        buf[2] = (value >> 16) & 0xff;
        buf[3] = (value >> 24) & 0xff;
}

static uint16_t decode16_be(uint8_t *buf)
{
        return ((buf[0] << 8) | buf[1]);
}

static uint16_t decode16_le(uint8_t *buf)
{
        return ((buf[1] << 8) | buf[0]);
}

static uint32_t decode32_be(uint8_t *buf)
{
        return ((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]);
}

static uint32_t decode32_le(uint8_t *buf)
{
        return ((buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]);
}

/** @}
 */