uuid.cpp

Go to the documentation of this file.

/**************************************************************************
 *
 * Copyright (C) 2022+ GPL 3 and higher by Ingo Höft, <Ingo@Hoeft-online.de>
 * Redistribution only with this Copyright remark. Last modified: 2025-05-05
 * Copyright (c) 1990- 1993, 1996 Open Software Foundation, Inc.
 * Copyright (c) 1989 by Hewlett-Packard Company, Palo Alto, Ca. &
 * Digital Equipment Corporation, Maynard, Mass.
 * Copyright (c) 1998 Microsoft.
 * To anyone who acknowledges that this file is provided "AS IS"
 * without any express or implied warranty: permission to use, copy,
 * modify, and distribute this file for any purpose is hereby
 * granted without fee, provided that the above copyright notices and
 * this notice appears in all source code copies, and that none of
 * the names of Open Software Foundation, Inc., Hewlett-Packard
 * Company, or Digital Equipment Corporation be used in advertising
 * or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Neither Open Software
 * Foundation, Inc., Hewlett-Packard Company, Microsoft, nor Digital Equipment
 * Corporation makes any representations about the suitability of
 * this software for any purpose.
 *
 **************************************************************************/
#include <uuid.hpp>
#include <UPnPsdk/port_sock.hpp>
#include <UPnPsdk/synclog.hpp>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
namespace {
 
pthread_mutex_t uuid_mutex;
 
struct uuid_state {
    uuid_time_t ts;
    uuid_node_t node;
    uint16_t cs;
};
 
uuid_state st;
int stateInited{0};
 
inline void format_uuid_v1(uuid_upnp* uid, uint16_t clock_seq,
                           uuid_time_t timestamp, uuid_node_t node) {
    /* Construct a version 1 uuid with the information we've gathered
     * plus a few constants. */
    uid->time_low = (uint32_t)(timestamp & 0xFFFFFFFF);
    uid->time_mid = (uint16_t)((timestamp >> 32) & 0xFFFF);
    uid->time_hi_and_version = (uint16_t)((timestamp >> 48) & 0x0FFF);
    uid->time_hi_and_version |= (1 << 12);
    uid->clock_seq_low = (uint8_t)(clock_seq & 0xFF);
    uid->clock_seq_hi_and_reserved = (uint8_t)((clock_seq & 0x3F00) >> 8);
    uid->clock_seq_hi_and_reserved |= 0x80;
    memcpy(&uid->node, &node, sizeof uid->node);
}
 
inline int read_state(uint16_t* clockseq, uuid_time_t* timestamp,
                      uuid_node_t* node) {
    if (!stateInited)
        return 0;
    *clockseq = st.cs;
    *timestamp = st.ts;
    *node = st.node;
 
    return 1;
}
 
inline void write_state(uint16_t clockseq, uuid_time_t timestamp,
                        uuid_node_t node) {
    static uuid_time_t next_save;
 
    if (!stateInited) {
        next_save = timestamp;
        stateInited = 1;
    };
    /* always save state to volatile shared state. */
    st.cs = clockseq;
    st.ts = timestamp;
    st.node = node;
    if (timestamp >= next_save) {
        /* schedule next save for 10 seconds from now. */
        next_save = timestamp + (10 * 10 * 1000 * 1000);
    };
}
 
inline void get_current_time(uuid_time_t* timestamp) {
    uuid_time_t time_now;
    static uuid_time_t time_last;
    static uint16_t uuids_this_tick;
    static int inited = 0;
 
    if (!inited) {
        uuids_this_tick = UUIDS_PER_TICK;
        inited = 1;
    };
    while (1) {
        get_system_time(&time_now);
        /* if clock reading changed since last UUID generated... */
        if (time_last != time_now) {
            /* reset count of uuids gen'd with this clock reading.
             */
            uuids_this_tick = 0;
            break;
        };
        if (uuids_this_tick < UUIDS_PER_TICK) {
            uuids_this_tick++;
            break;
        };
        /* going too fast for our clock; spin. */
    };
    /* add the count of uuids to low order bits of the clock reading. */
    *timestamp = time_now + uuids_this_tick;
    time_last = *timestamp;
}
 
inline uint16_t true_random() {
    static int inited = 0;
    uuid_time_t time_now;
 
    if (!inited) {
        get_system_time(&time_now);
        time_now = time_now / UUIDS_PER_TICK;
        srand((unsigned int)(((time_now >> 32) ^ time_now) & 0xffffffff));
        inited = 1;
    };
 
    return (uint16_t)(rand());
}
 
inline void format_uuid_v3(uuid_upnp* uid, unsigned char hash[16]) {
    /* Construct a version 3 uuid with the (pseudo-)random number plus a few
     * constants. */
    memcpy(uid, hash, sizeof(uuid_upnp));
    /* convert UUID to local byte order. */
    uid->time_low = ntohl(uid->time_low);
    uid->time_mid = ntohs(uid->time_mid);
    uid->time_hi_and_version = ntohs(uid->time_hi_and_version);
    /* put in the variant and version bits. */
    uid->time_hi_and_version &= 0x0FFF;
    uid->time_hi_and_version |= (3 << 12);
    uid->clock_seq_hi_and_reserved &= 0x3F;
    uid->clock_seq_hi_and_reserved |= 0x80;
}
 
#define CHECK(f1, f2)                                                          \
    if (f1 != f2)                                                              \
        return f1 < f2 ? -1 : 1;
 
} // anonymous namespace
 
 
void uuidMutexInit() {
    pthread_mutex_init(&uuid_mutex, NULL); // always returns 0.
}
 
int uuidMutexDestroy() {
    int ret = pthread_mutex_destroy(&uuid_mutex);
    // Returns only EBUSY
    if (ret != 0)
        UPnPsdk_LOGCRIT(
            "MSG1149") "POSIX thread destroy uuid_mutex fails with EBUSY.";
    return ret;
}
 
int uuid_create(uuid_upnp* uid) {
    uuid_time_t timestamp;
    uuid_time_t last_time;
    uint16_t clockseq;
    uuid_node_t node;
    uuid_node_t last_node;
    int f;
 
    /* acquire system wide lock so we're alone. */
    pthread_mutex_lock(&uuid_mutex);
    /* get current time. */
    get_current_time(&timestamp);
    /* get node ID. */
    get_ieee_node_identifier(&node);
    /* get saved state from NV storage. */
    f = read_state(&clockseq, &last_time, &last_node);
    /* if no NV state, or if clock went backwards, or node ID changed
     * (e.g., net card swap) change clockseq. */
    if (!f || memcmp(&node, &last_node, sizeof(uuid_node_t)))
        clockseq = true_random();
    else if (timestamp < last_time)
        clockseq++;
    /* stuff fields into the UUID. */
    format_uuid_v1(uid, clockseq, timestamp, node);
    /* save the state for next time. */
    write_state(clockseq, timestamp, node);
    pthread_mutex_unlock(&uuid_mutex);
 
    return 1;
}
 
void upnp_uuid_unpack(uuid_upnp* u, char* out) {
    snprintf(out, 44,
             "%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
             (unsigned int)u->time_low, u->time_mid, u->time_hi_and_version,
             u->clock_seq_hi_and_reserved, u->clock_seq_low, u->node[0],
             u->node[1], u->node[2], u->node[3], u->node[4], u->node[5]);
}
 
void uuid_create_from_name(
    uuid_upnp* uid,
    uuid_upnp nsid,
    void* name,
    int namelen) {
    MD5_CTX c;
    unsigned char hash[16];
    uuid_upnp net_nsid; /* context UUID in network byte order */
 
    /* put name space ID in network byte order so it hashes the same no
     * matter what endian machine we're on. */
    net_nsid = nsid;
    net_nsid.time_low = htonl(net_nsid.time_low);
    net_nsid.time_mid = htons(net_nsid.time_mid);
    net_nsid.time_hi_and_version = htons(net_nsid.time_hi_and_version);
    MD5Init(&c);
    MD5Update(&c, (unsigned char*)&net_nsid, sizeof(uuid_upnp));
    MD5Update(&c, name, (unsigned int)namelen);
    MD5Final(hash, &c);
    /* the hash is in network byte order at this point. */
    format_uuid_v3(uid, hash);
}
 
int uuid_compare(uuid_upnp* u1, uuid_upnp* u2) {
    int i;
 
    CHECK(u1->time_low, u2->time_low);
    CHECK(u1->time_mid, u2->time_mid);
    CHECK(u1->time_hi_and_version, u2->time_hi_and_version);
    CHECK(u1->clock_seq_hi_and_reserved, u2->clock_seq_hi_and_reserved);
    CHECK(u1->clock_seq_low, u2->clock_seq_low)
    for (i = 0; i < 6; i++) {
        if (u1->node[i] < u2->node[i])
            return -1;
        if (u1->node[i] > u2->node[i])
            return 1;
    }
 
    return 0;
}