source: code/trunk/vendor/github.com/google/uuid/node.go@ 822

// Copyright 2016 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package uuid

import (
        "sync"
)

var (
        nodeMu sync.Mutex
        ifname string  // name of interface being used
        nodeID [6]byte // hardware for version 1 UUIDs
        zeroID [6]byte // nodeID with only 0's
)

// NodeInterface returns the name of the interface from which the NodeID was
// derived.  The interface "user" is returned if the NodeID was set by
// SetNodeID.
func NodeInterface() string {
        defer nodeMu.Unlock()
        nodeMu.Lock()
        return ifname
}

// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
// If name is "" then the first usable interface found will be used or a random
// Node ID will be generated.  If a named interface cannot be found then false
// is returned.
//
// SetNodeInterface never fails when name is "".
func SetNodeInterface(name string) bool {
        defer nodeMu.Unlock()
        nodeMu.Lock()
        return setNodeInterface(name)
}

func setNodeInterface(name string) bool {
        iname, addr := getHardwareInterface(name) // null implementation for js
        if iname != "" && addr != nil {
                ifname = iname
                copy(nodeID[:], addr)
                return true
        }

        // We found no interfaces with a valid hardware address.  If name
        // does not specify a specific interface generate a random Node ID
        // (section 4.1.6)
        if name == "" {
                ifname = "random"
                randomBits(nodeID[:])
                return true
        }
        return false
}

// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
// if not already set.
func NodeID() []byte {
        defer nodeMu.Unlock()
        nodeMu.Lock()
        if nodeID == zeroID {
                setNodeInterface("")
        }
        nid := nodeID
        return nid[:]
}

// SetNodeID sets the Node ID to be used for Version 1 UUIDs.  The first 6 bytes
// of id are used.  If id is less than 6 bytes then false is returned and the
// Node ID is not set.
func SetNodeID(id []byte) bool {
        if len(id) < 6 {
                return false
        }
        defer nodeMu.Unlock()
        nodeMu.Lock()
        copy(nodeID[:], id)
        ifname = "user"
        return true
}

// NodeID returns the 6 byte node id encoded in uuid.  It returns nil if uuid is
// not valid.  The NodeID is only well defined for version 1 and 2 UUIDs.
func (uuid UUID) NodeID() []byte {
        var node [6]byte
        copy(node[:], uuid[10:])
        return node[:]
}