2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
2002-05-28 06:16:08 +00:00
|
|
|
* Copyright (c) 2002 Marcel Moolenaar
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. 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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2002-05-28 06:16:08 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/endian.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/sbuf.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/sysproto.h>
|
2002-08-22 12:47:22 +00:00
|
|
|
#include <sys/systm.h>
|
2002-05-28 06:16:08 +00:00
|
|
|
#include <sys/uuid.h>
|
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_types.h>
|
2008-12-02 21:37:28 +00:00
|
|
|
#include <net/vnet.h>
|
2002-05-28 06:16:08 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* See also:
|
|
|
|
* http://www.opengroup.org/dce/info/draft-leach-uuids-guids-01.txt
|
|
|
|
* http://www.opengroup.org/onlinepubs/009629399/apdxa.htm
|
|
|
|
*
|
|
|
|
* Note that the generator state is itself an UUID, but the time and clock
|
|
|
|
* sequence fields are written in the native byte order.
|
|
|
|
*/
|
|
|
|
|
|
|
|
CTASSERT(sizeof(struct uuid) == 16);
|
|
|
|
|
|
|
|
/* We use an alternative, more convenient representation in the generator. */
|
|
|
|
struct uuid_private {
|
|
|
|
union {
|
|
|
|
uint64_t ll; /* internal. */
|
|
|
|
struct {
|
|
|
|
uint32_t low;
|
|
|
|
uint16_t mid;
|
|
|
|
uint16_t hi;
|
|
|
|
} x;
|
|
|
|
} time;
|
|
|
|
uint16_t seq; /* Big-endian. */
|
|
|
|
uint16_t node[UUID_NODE_LEN>>1];
|
|
|
|
};
|
|
|
|
|
|
|
|
CTASSERT(sizeof(struct uuid_private) == 16);
|
|
|
|
|
|
|
|
static struct uuid_private uuid_last;
|
|
|
|
|
|
|
|
static struct mtx uuid_mutex;
|
|
|
|
MTX_SYSINIT(uuid_lock, &uuid_mutex, "UUID generator mutex lock", MTX_DEF);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the first MAC address we encounter or, if none was found,
|
|
|
|
* construct a sufficiently random multicast address. We don't try
|
|
|
|
* to return the same MAC address as previously returned. We always
|
|
|
|
* generate a new multicast address if no MAC address exists in the
|
|
|
|
* system.
|
|
|
|
* It would be nice to know if 'ifnet' or any of its sub-structures
|
|
|
|
* has been changed in any way. If not, we could simply skip the
|
|
|
|
* scan and safely return the MAC address we returned before.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
uuid_node(uint16_t *node)
|
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
struct sockaddr_dl *sdl;
|
|
|
|
int i;
|
|
|
|
|
2002-12-22 05:35:03 +00:00
|
|
|
IFNET_RLOCK();
|
Commit step 1 of the vimage project, (network stack)
virtualization work done by Marko Zec (zec@).
This is the first in a series of commits over the course
of the next few weeks.
Mark all uses of global variables to be virtualized
with a V_ prefix.
Use macros to map them back to their global names for
now, so this is a NOP change only.
We hope to have caught at least 85-90% of what is needed
so we do not invalidate a lot of outstanding patches again.
Obtained from: //depot/projects/vimage-commit2/...
Reviewed by: brooks, des, ed, mav, julian,
jamie, kris, rwatson, zec, ...
(various people I forgot, different versions)
md5 (with a bit of help)
Sponsored by: NLnet Foundation, The FreeBSD Foundation
X-MFC after: never
V_Commit_Message_Reviewed_By: more people than the patch
2008-08-17 23:27:27 +00:00
|
|
|
TAILQ_FOREACH(ifp, &V_ifnet, if_link) {
|
2002-05-28 06:16:08 +00:00
|
|
|
/* Walk the address list */
|
2009-04-19 21:36:18 +00:00
|
|
|
IF_ADDR_LOCK(ifp);
|
2002-05-28 06:16:08 +00:00
|
|
|
TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
|
|
|
|
sdl = (struct sockaddr_dl*)ifa->ifa_addr;
|
|
|
|
if (sdl != NULL && sdl->sdl_family == AF_LINK &&
|
|
|
|
sdl->sdl_type == IFT_ETHER) {
|
|
|
|
/* Got a MAC address. */
|
|
|
|
bcopy(LLADDR(sdl), node, UUID_NODE_LEN);
|
2009-04-19 21:36:18 +00:00
|
|
|
IF_ADDR_UNLOCK(ifp);
|
2002-12-22 05:35:03 +00:00
|
|
|
IFNET_RUNLOCK();
|
2002-05-28 06:16:08 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2009-04-19 21:36:18 +00:00
|
|
|
IF_ADDR_UNLOCK(ifp);
|
2002-05-28 06:16:08 +00:00
|
|
|
}
|
2002-12-22 05:35:03 +00:00
|
|
|
IFNET_RUNLOCK();
|
2002-05-28 06:16:08 +00:00
|
|
|
|
|
|
|
for (i = 0; i < (UUID_NODE_LEN>>1); i++)
|
|
|
|
node[i] = (uint16_t)arc4random();
|
Fix generation of random multicast MAC address.
In case no real/physical IEEE 802 address is available, both the expired
"draft-leach-uuids-guids-01" (section "4. Node IDs when no IEEE 802
network card is available") and RFC 2518 (section "6.4.1 Node Field
Generation Without the IEEE 802 Address") recommend (quoted from RFC
2518):
"The ideal solution is to obtain a 47 bit cryptographic quality random
number, and use it as the low 47 bits of the node ID, with the _most_
significant bit of the first octet of the node ID set to 1. This bit
is the unicast/multicast bit, which will never be set in IEEE 802
addresses obtained from network cards; hence, there can never be a
conflict between UUIDs generated by machines with and without network
cards."
Unfortunately, this incorrectly explains how to implement this and
the FreeBSD UUID generator code inherited this generation bug from
the broken reference code in the standards draft. They should instead
specify the "_least_ significant bit of the first octet of the node ID"
as the multicast bit in a memory and hexadecimal string representation
of a 48-bit IEEE 802 MAC address.
This standards bug arised from a false interpretation, as the multicast
bit is actually the _most_ significant bit in IEEE 802.3 (Ethernet)
_transmission order_ of an IEEE 802 MAC address. The standards authors
forgot that the bitwise order of an _octet_ from a MAC address _memory_
and hexadecimal string representation is still always from left (MSB,
bit 7) to right (LSB, bit 0).
Fortunately, this UUID generation bug could have occurred on systems
without any Ethernet NICs only.
2004-01-22 13:34:11 +00:00
|
|
|
*((uint8_t*)node) |= 0x01;
|
2002-05-28 06:16:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the current time as a 60 bit count of 100-nanosecond intervals
|
|
|
|
* since 00:00:00.00, October 15,1582. We apply a magic offset to convert
|
2007-04-23 12:53:00 +00:00
|
|
|
* the Unix time since 00:00:00.00, January 1, 1970 to the date of the
|
2002-05-28 06:16:08 +00:00
|
|
|
* Gregorian reform to the Christian calendar.
|
|
|
|
*/
|
|
|
|
static uint64_t
|
|
|
|
uuid_time(void)
|
|
|
|
{
|
|
|
|
struct bintime bt;
|
|
|
|
uint64_t time = 0x01B21DD213814000LL;
|
|
|
|
|
|
|
|
bintime(&bt);
|
|
|
|
time += (uint64_t)bt.sec * 10000000LL;
|
|
|
|
time += (10000000LL * (uint32_t)(bt.frac >> 32)) >> 32;
|
|
|
|
return (time & ((1LL << 60) - 1LL));
|
|
|
|
}
|
|
|
|
|
2005-09-18 21:40:15 +00:00
|
|
|
struct uuid *
|
|
|
|
kern_uuidgen(struct uuid *store, size_t count)
|
2002-05-28 06:16:08 +00:00
|
|
|
{
|
|
|
|
struct uuid_private uuid;
|
|
|
|
uint64_t time;
|
2005-09-18 21:40:15 +00:00
|
|
|
size_t n;
|
2002-05-28 06:16:08 +00:00
|
|
|
|
|
|
|
mtx_lock(&uuid_mutex);
|
|
|
|
|
|
|
|
uuid_node(uuid.node);
|
|
|
|
time = uuid_time();
|
|
|
|
|
|
|
|
if (uuid_last.time.ll == 0LL || uuid_last.node[0] != uuid.node[0] ||
|
|
|
|
uuid_last.node[1] != uuid.node[1] ||
|
|
|
|
uuid_last.node[2] != uuid.node[2])
|
|
|
|
uuid.seq = (uint16_t)arc4random() & 0x3fff;
|
|
|
|
else if (uuid_last.time.ll >= time)
|
|
|
|
uuid.seq = (uuid_last.seq + 1) & 0x3fff;
|
|
|
|
else
|
|
|
|
uuid.seq = uuid_last.seq;
|
|
|
|
|
|
|
|
uuid_last = uuid;
|
2005-09-18 21:40:15 +00:00
|
|
|
uuid_last.time.ll = (time + count - 1) & ((1LL << 60) - 1LL);
|
2002-05-28 06:16:08 +00:00
|
|
|
|
|
|
|
mtx_unlock(&uuid_mutex);
|
|
|
|
|
|
|
|
/* Set sequence and variant and deal with byte order. */
|
|
|
|
uuid.seq = htobe16(uuid.seq | 0x8000);
|
|
|
|
|
2005-09-18 21:40:15 +00:00
|
|
|
for (n = 0; n < count; n++) {
|
|
|
|
/* Set time and version (=1). */
|
2002-05-28 06:16:08 +00:00
|
|
|
uuid.time.x.low = (uint32_t)time;
|
|
|
|
uuid.time.x.mid = (uint16_t)(time >> 32);
|
|
|
|
uuid.time.x.hi = ((uint16_t)(time >> 48) & 0xfff) | (1 << 12);
|
2005-09-18 21:40:15 +00:00
|
|
|
store[n] = *(struct uuid *)&uuid;
|
2002-05-28 06:16:08 +00:00
|
|
|
time++;
|
2005-09-18 21:40:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (store);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct uuidgen_args {
|
|
|
|
struct uuid *store;
|
|
|
|
int count;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int
|
|
|
|
uuidgen(struct thread *td, struct uuidgen_args *uap)
|
|
|
|
{
|
|
|
|
struct uuid *store;
|
|
|
|
size_t count;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Limit the number of UUIDs that can be created at the same time
|
|
|
|
* to some arbitrary number. This isn't really necessary, but I
|
|
|
|
* like to have some sort of upper-bound that's less than 2G :-)
|
|
|
|
* XXX probably needs to be tunable.
|
|
|
|
*/
|
|
|
|
if (uap->count < 1 || uap->count > 2048)
|
|
|
|
return (EINVAL);
|
2002-05-28 06:16:08 +00:00
|
|
|
|
2005-09-18 21:40:15 +00:00
|
|
|
count = uap->count;
|
|
|
|
store = malloc(count * sizeof(struct uuid), M_TEMP, M_WAITOK);
|
|
|
|
kern_uuidgen(store, count);
|
|
|
|
error = copyout(store, uap->store, count * sizeof(struct uuid));
|
|
|
|
free(store, M_TEMP);
|
2002-05-28 06:16:08 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
snprintf_uuid(char *buf, size_t sz, struct uuid *uuid)
|
|
|
|
{
|
|
|
|
struct uuid_private *id;
|
|
|
|
int cnt;
|
|
|
|
|
|
|
|
id = (struct uuid_private *)uuid;
|
|
|
|
cnt = snprintf(buf, sz, "%08x-%04x-%04x-%04x-%04x%04x%04x",
|
|
|
|
id->time.x.low, id->time.x.mid, id->time.x.hi, be16toh(id->seq),
|
|
|
|
be16toh(id->node[0]), be16toh(id->node[1]), be16toh(id->node[2]));
|
|
|
|
return (cnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
printf_uuid(struct uuid *uuid)
|
|
|
|
{
|
|
|
|
char buf[38];
|
|
|
|
|
|
|
|
snprintf_uuid(buf, sizeof(buf), uuid);
|
|
|
|
return (printf("%s", buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
sbuf_printf_uuid(struct sbuf *sb, struct uuid *uuid)
|
|
|
|
{
|
|
|
|
char buf[38];
|
|
|
|
|
|
|
|
snprintf_uuid(buf, sizeof(buf), uuid);
|
|
|
|
return (sbuf_printf(sb, "%s", buf));
|
|
|
|
}
|
2003-05-31 16:47:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode/Decode UUID into byte-stream.
|
|
|
|
* http://www.opengroup.org/dce/info/draft-leach-uuids-guids-01.txt
|
|
|
|
*
|
|
|
|
* 0 1 2 3
|
|
|
|
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* | time_low |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* | time_mid | time_hi_and_version |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* |clk_seq_hi_res | clk_seq_low | node (0-1) |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
* | node (2-5) |
|
|
|
|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
le_uuid_enc(void *buf, struct uuid const *uuid)
|
|
|
|
{
|
|
|
|
u_char *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
le32enc(p, uuid->time_low);
|
|
|
|
le16enc(p + 4, uuid->time_mid);
|
|
|
|
le16enc(p + 6, uuid->time_hi_and_version);
|
|
|
|
p[8] = uuid->clock_seq_hi_and_reserved;
|
|
|
|
p[9] = uuid->clock_seq_low;
|
|
|
|
for (i = 0; i < _UUID_NODE_LEN; i++)
|
|
|
|
p[10 + i] = uuid->node[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
le_uuid_dec(void const *buf, struct uuid *uuid)
|
|
|
|
{
|
|
|
|
u_char const *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
uuid->time_low = le32dec(p);
|
|
|
|
uuid->time_mid = le16dec(p + 4);
|
|
|
|
uuid->time_hi_and_version = le16dec(p + 6);
|
|
|
|
uuid->clock_seq_hi_and_reserved = p[8];
|
|
|
|
uuid->clock_seq_low = p[9];
|
|
|
|
for (i = 0; i < _UUID_NODE_LEN; i++)
|
|
|
|
uuid->node[i] = p[10 + i];
|
|
|
|
}
|
2006-07-17 21:00:42 +00:00
|
|
|
|
2003-05-31 16:47:07 +00:00
|
|
|
void
|
|
|
|
be_uuid_enc(void *buf, struct uuid const *uuid)
|
|
|
|
{
|
|
|
|
u_char *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
be32enc(p, uuid->time_low);
|
|
|
|
be16enc(p + 4, uuid->time_mid);
|
|
|
|
be16enc(p + 6, uuid->time_hi_and_version);
|
|
|
|
p[8] = uuid->clock_seq_hi_and_reserved;
|
|
|
|
p[9] = uuid->clock_seq_low;
|
|
|
|
for (i = 0; i < _UUID_NODE_LEN; i++)
|
|
|
|
p[10 + i] = uuid->node[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
be_uuid_dec(void const *buf, struct uuid *uuid)
|
|
|
|
{
|
|
|
|
u_char const *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
uuid->time_low = be32dec(p);
|
|
|
|
uuid->time_mid = le16dec(p + 4);
|
|
|
|
uuid->time_hi_and_version = be16dec(p + 6);
|
|
|
|
uuid->clock_seq_hi_and_reserved = p[8];
|
|
|
|
uuid->clock_seq_low = p[9];
|
|
|
|
for (i = 0; i < _UUID_NODE_LEN; i++)
|
|
|
|
uuid->node[i] = p[10 + i];
|
|
|
|
}
|
2005-10-07 13:37:10 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
parse_uuid(const char *str, struct uuid *uuid)
|
|
|
|
{
|
|
|
|
u_int c[11];
|
|
|
|
int n;
|
|
|
|
|
|
|
|
/* An empty string represents a nil UUID. */
|
|
|
|
if (*str == '\0') {
|
|
|
|
bzero(uuid, sizeof(*uuid));
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The UUID string representation has a fixed length. */
|
|
|
|
if (strlen(str) != 36)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only work with "new" UUIDs. New UUIDs have the form:
|
|
|
|
* 01234567-89ab-cdef-0123-456789abcdef
|
|
|
|
* The so called "old" UUIDs, which we don't support, have the form:
|
|
|
|
* 0123456789ab.cd.ef.01.23.45.67.89.ab
|
|
|
|
*/
|
|
|
|
if (str[8] != '-')
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
n = sscanf(str, "%8x-%4x-%4x-%2x%2x-%2x%2x%2x%2x%2x%2x", c + 0, c + 1,
|
|
|
|
c + 2, c + 3, c + 4, c + 5, c + 6, c + 7, c + 8, c + 9, c + 10);
|
|
|
|
/* Make sure we have all conversions. */
|
|
|
|
if (n != 11)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
/* Successful scan. Build the UUID. */
|
|
|
|
uuid->time_low = c[0];
|
|
|
|
uuid->time_mid = c[1];
|
|
|
|
uuid->time_hi_and_version = c[2];
|
|
|
|
uuid->clock_seq_hi_and_reserved = c[3];
|
|
|
|
uuid->clock_seq_low = c[4];
|
|
|
|
for (n = 0; n < 6; n++)
|
|
|
|
uuid->node[n] = c[n + 5];
|
|
|
|
|
|
|
|
/* Check semantics... */
|
|
|
|
return (((c[3] & 0x80) != 0x00 && /* variant 0? */
|
|
|
|
(c[3] & 0xc0) != 0x80 && /* variant 1? */
|
|
|
|
(c[3] & 0xe0) != 0xc0) ? EINVAL : 0); /* variant 2? */
|
|
|
|
}
|