podman

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

5
package uuid
6

7
import (
8
	"encoding/binary"
9
	"sync"
10
	"time"
11
)
12

13
// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
14
// 1582.
15
type Time int64
16

17
const (
18
	lillian    = 2299160          // Julian day of 15 Oct 1582
19
	unix       = 2440587          // Julian day of 1 Jan 1970
20
	epoch      = unix - lillian   // Days between epochs
21
	g1582      = epoch * 86400    // seconds between epochs
22
	g1582ns100 = g1582 * 10000000 // 100s of a nanoseconds between epochs
23
)
24

25
var (
26
	timeMu   sync.Mutex
27
	lasttime uint64 // last time we returned
28
	clockSeq uint16 // clock sequence for this run
29

30
	timeNow = time.Now // for testing
31
)
32

33
// UnixTime converts t the number of seconds and nanoseconds using the Unix
34
// epoch of 1 Jan 1970.
35
func (t Time) UnixTime() (sec, nsec int64) {
36
	sec = int64(t - g1582ns100)
37
	nsec = (sec % 10000000) * 100
38
	sec /= 10000000
39
	return sec, nsec
40
}
41

42
// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
43
// clock sequence as well as adjusting the clock sequence as needed.  An error
44
// is returned if the current time cannot be determined.
45
func GetTime() (Time, uint16, error) {
46
	defer timeMu.Unlock()
47
	timeMu.Lock()
48
	return getTime()
49
}
50

51
func getTime() (Time, uint16, error) {
52
	t := timeNow()
53

54
	// If we don't have a clock sequence already, set one.
55
	if clockSeq == 0 {
56
		setClockSequence(-1)
57
	}
58
	now := uint64(t.UnixNano()/100) + g1582ns100
59

60
	// If time has gone backwards with this clock sequence then we
61
	// increment the clock sequence
62
	if now <= lasttime {
63
		clockSeq = ((clockSeq + 1) & 0x3fff) | 0x8000
64
	}
65
	lasttime = now
66
	return Time(now), clockSeq, nil
67
}
68

69
// ClockSequence returns the current clock sequence, generating one if not
70
// already set.  The clock sequence is only used for Version 1 UUIDs.
71
//
72
// The uuid package does not use global static storage for the clock sequence or
73
// the last time a UUID was generated.  Unless SetClockSequence is used, a new
74
// random clock sequence is generated the first time a clock sequence is
75
// requested by ClockSequence, GetTime, or NewUUID.  (section 4.2.1.1)
76
func ClockSequence() int {
77
	defer timeMu.Unlock()
78
	timeMu.Lock()
79
	return clockSequence()
80
}
81

82
func clockSequence() int {
83
	if clockSeq == 0 {
84
		setClockSequence(-1)
85
	}
86
	return int(clockSeq & 0x3fff)
87
}
88

89
// SetClockSequence sets the clock sequence to the lower 14 bits of seq.  Setting to
90
// -1 causes a new sequence to be generated.
91
func SetClockSequence(seq int) {
92
	defer timeMu.Unlock()
93
	timeMu.Lock()
94
	setClockSequence(seq)
95
}
96

97
func setClockSequence(seq int) {
98
	if seq == -1 {
99
		var b [2]byte
100
		randomBits(b[:]) // clock sequence
101
		seq = int(b[0])<<8 | int(b[1])
102
	}
103
	oldSeq := clockSeq
104
	clockSeq = uint16(seq&0x3fff) | 0x8000 // Set our variant
105
	if oldSeq != clockSeq {
106
		lasttime = 0
107
	}
108
}
109

110
// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
111
// uuid.  The time is only defined for version 1 and 2 UUIDs.
112
func (uuid UUID) Time() Time {
113
	time := int64(binary.BigEndian.Uint32(uuid[0:4]))
114
	time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
115
	time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
116
	return Time(time)
117
}
118

119
// ClockSequence returns the clock sequence encoded in uuid.
120
// The clock sequence is only well defined for version 1 and 2 UUIDs.
121
func (uuid UUID) ClockSequence() int {
122
	return int(binary.BigEndian.Uint16(uuid[8:10])) & 0x3fff
123
}
124