| 1 |
|
| #ifdef __cplusplus |
| 2 |
|
| extern "C" { |
| 3 |
|
| #endif |
| 4 |
|
| |
| 5 |
|
| #include "ulib/chacha.h" |
| 6 |
|
| #include "ulib/clock.h" |
| 7 |
|
| #include "ulib/gen.h" |
| 8 |
|
| #include "ulib/hash.h" |
| 9 |
|
| #include "ulib/node.h" |
| 10 |
|
| |
| 11 |
|
| #ifdef __cplusplus |
| 12 |
|
| } |
| 13 |
|
| #endif |
| 14 |
|
| |
| 15 |
|
| |
| 16 |
|
| /* randomize uu_node */ |
| 17 |
28 |
| static void uu_gen_randomize(pUCXT) { |
| 18 |
28 |
| uu_chacha_rand32(aUCXT, (U32*)&SMEM->gen_node[0]); |
| 19 |
28 |
| uu_chacha_rand16(aUCXT, (U16*)&SMEM->gen_node[4]); |
| 20 |
28 |
| SMEM->gen_node[0] |= 0x01; /* set mcast */ |
| 21 |
28 |
| } |
| 22 |
|
| |
| 23 |
|
| /* call at boot */ |
| 24 |
204 |
| void uu_gen_init(pUCXT) { |
| 25 |
204 |
| SMEM->gen_epoch = (((U64) 0x01B21DD2) << 32) | 0x13814000; /* unused */ |
| 26 |
204 |
| SMEM->gen_use_unique = 0; |
| 27 |
204 |
| SMEM->gen_has_real_node = 0; |
| 28 |
204 |
| SMEM->gen_node[0] = 0;; |
| 29 |
204 |
| SMEM->gen_node[1] = 0;; |
| 30 |
204 |
| SMEM->gen_node[2] = 0;; |
| 31 |
204 |
| SMEM->gen_node[3] = 0;; |
| 32 |
204 |
| SMEM->gen_node[4] = 0;; |
| 33 |
204 |
| SMEM->gen_node[5] = 0;; |
| 34 |
204 |
| SMEM->gen_real_node[0] = 0; |
| 35 |
204 |
| SMEM->gen_real_node[1] = 0; |
| 36 |
204 |
| SMEM->gen_real_node[2] = 0; |
| 37 |
204 |
| SMEM->gen_real_node[3] = 0; |
| 38 |
204 |
| SMEM->gen_real_node[4] = 0; |
| 39 |
204 |
| SMEM->gen_real_node[5] = 0; |
| 40 |
|
| |
| 41 |
|
| /* get the real node or randomize it */ |
| 42 |
204 |
▶ | if (uu_node_getid(aUCXT, (U8*)&SMEM->gen_node) == 1) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (uu_node_getid(aUCXT, (U8*)&SMEM->gen_node) == 1) { |
204 |
0 |
204 |
|
| 43 |
204 |
| SMEM->gen_has_real_node = 1; |
| 44 |
204 |
| SMEM->gen_real_node[0] = SMEM->gen_node[0]; |
| 45 |
204 |
| SMEM->gen_real_node[1] = SMEM->gen_node[1]; |
| 46 |
204 |
| SMEM->gen_real_node[2] = SMEM->gen_node[2]; |
| 47 |
204 |
| SMEM->gen_real_node[3] = SMEM->gen_node[3]; |
| 48 |
204 |
| SMEM->gen_real_node[4] = SMEM->gen_node[4]; |
| 49 |
204 |
| SMEM->gen_real_node[5] = SMEM->gen_node[5]; |
| 50 |
|
| } |
| 51 |
|
| else { |
| 52 |
0 |
| SMEM->gen_has_real_node = 0; |
| 53 |
0 |
| uu_gen_randomize(aUCXT); |
| 54 |
|
| } |
| 55 |
204 |
| } |
| 56 |
|
| |
| 57 |
8 |
| void uu_gen_setrand(pUCXT) { |
| 58 |
8 |
| SMEM->gen_use_unique = 0; |
| 59 |
8 |
| uu_gen_randomize(aUCXT); |
| 60 |
8 |
| } |
| 61 |
|
| |
| 62 |
2 |
| void uu_gen_setuniq(pUCXT) { |
| 63 |
2 |
| SMEM->gen_use_unique = 1; |
| 64 |
2 |
| } |
| 65 |
|
| |
| 66 |
|
| /* returns 1 if has real node, or 0 */ |
| 67 |
45 |
| int uu_gen_realnode(pUCXT, struct_uu_t *out) { |
| 68 |
45 |
| uu_gen_v0(aUCXT, out, NULL); |
| 69 |
45 |
| out->v1.node[0] = SMEM->gen_real_node[0]; |
| 70 |
45 |
| out->v1.node[1] = SMEM->gen_real_node[1]; |
| 71 |
45 |
| out->v1.node[2] = SMEM->gen_real_node[2]; |
| 72 |
45 |
| out->v1.node[3] = SMEM->gen_real_node[3]; |
| 73 |
45 |
| out->v1.node[4] = SMEM->gen_real_node[4]; |
| 74 |
45 |
| out->v1.node[5] = SMEM->gen_real_node[5]; |
| 75 |
45 |
| return SMEM->gen_has_real_node; |
| 76 |
|
| } |
| 77 |
|
| |
| 78 |
|
| |
| 79 |
85 |
| void uu_gen_v0(pUCXT, struct_uu_t *out, char *dptr) { |
| 80 |
85 |
| out->v0.low = 0; |
| 81 |
85 |
| out->v0.high = 0; |
| 82 |
85 |
| } |
| 83 |
|
| |
| 84 |
18082 |
| void uu_gen_v1(pUCXT, struct_uu_t *out, char *dptr) { |
| 85 |
|
| U64 clock_reg; |
| 86 |
|
| U16 clock_seq; |
| 87 |
|
| |
| 88 |
18082 |
| uu_clock(aUCXT, &clock_reg, &clock_seq); |
| 89 |
18082 |
| clock_reg += (((U64)0x01b21dd2) << 32) + 0x13814000; |
| 90 |
|
| |
| 91 |
18082 |
| out->v1.time_low = (U32)clock_reg; |
| 92 |
18082 |
| out->v1.time_mid = (U16)(clock_reg >> 32 & 0xffff); |
| 93 |
18082 |
| out->v1.time_high_and_version = (U16)((clock_reg >> 48 & 0x0fff) | 0x1000); |
| 94 |
18082 |
| out->v1.clock_seq_and_variant = (clock_seq & 0x3fff) | 0x8000; |
| 95 |
|
| |
| 96 |
18082 |
▶ | if (SMEM->gen_use_unique) uu_gen_randomize(aUCXT); |
Branch: 1 branch
| Branch | True | False | Total |
| if (SMEM->gen_use_unique) uu_gen_randomize(aUCXT); |
10 |
18072 |
18082 |
|
| 97 |
18082 |
| out->v1.node[0] = SMEM->gen_node[0]; |
| 98 |
18082 |
| out->v1.node[1] = SMEM->gen_node[1]; |
| 99 |
18082 |
| out->v1.node[2] = SMEM->gen_node[2]; |
| 100 |
18082 |
| out->v1.node[3] = SMEM->gen_node[3]; |
| 101 |
18082 |
| out->v1.node[4] = SMEM->gen_node[4]; |
| 102 |
18082 |
| out->v1.node[5] = SMEM->gen_node[5]; |
| 103 |
18082 |
| } |
| 104 |
|
| |
| 105 |
18054 |
| void uu_gen_v3(pUCXT, struct_uu_t *out, char *dptr) { |
| 106 |
|
| /* out points to a v1 uuid to use as namespace. */ |
| 107 |
|
| /* out also points to output buffer for v3 uuid. */ |
| 108 |
|
| /* dptr points to string to use as name. */ |
| 109 |
18054 |
| uu_hash_md5(aUCXT, out, dptr); |
| 110 |
18054 |
| } |
| 111 |
|
| |
| 112 |
18056 |
| void uu_gen_v4(pUCXT, struct_uu_t *out, char *dptr) { |
| 113 |
18056 |
| U64 *cp = (U64*)out; |
| 114 |
|
| |
| 115 |
18056 |
| uu_chacha_rand64(aUCXT, cp++); |
| 116 |
18056 |
| uu_chacha_rand64(aUCXT, cp); |
| 117 |
18056 |
| out->v4.rand_b_and_version = (out->v4.rand_b_and_version & 0xffff0fff) | 0x00004000; |
| 118 |
18056 |
| out->v4.rand_c_and_variant = (out->v4.rand_c_and_variant & 0x3fffffff) | 0x80000000; |
| 119 |
18056 |
| } |
| 120 |
|
| |
| 121 |
18048 |
| void uu_gen_v5(pUCXT, struct_uu_t *out, char *dptr) { |
| 122 |
|
| /* out points to a v1 uuid to use as namespace. */ |
| 123 |
|
| /* out also points to output buffer for v5 uuid. */ |
| 124 |
|
| /* dptr points to string to use as name. */ |
| 125 |
18048 |
| uu_hash_sha1(aUCXT, out, dptr); |
| 126 |
18048 |
| } |
| 127 |
|
| |
| 128 |
18054 |
| void uu_gen_v6(pUCXT, struct_uu_t *out, char *dptr) { |
| 129 |
|
| U64 clock_reg; |
| 130 |
|
| U16 clock_seq; |
| 131 |
|
| |
| 132 |
18054 |
| uu_clock(aUCXT, &clock_reg, &clock_seq); |
| 133 |
18054 |
| clock_reg += (((U64)0x01b21dd2) << 32) + 0x13814000; |
| 134 |
|
| |
| 135 |
18054 |
| out->v6.time_high = (U32)(clock_reg >> 28); |
| 136 |
18054 |
| out->v6.time_mid = (U16)(clock_reg >> 12); |
| 137 |
18054 |
| out->v6.time_low_and_version = (U16)(clock_reg & 0x0fff) | 0x6000; |
| 138 |
18054 |
| out->v6.clock_seq_and_variant = (clock_seq & 0x3fff) | 0x8000; |
| 139 |
|
| |
| 140 |
|
| /* use the same node as v1 */ |
| 141 |
18054 |
▶ | if (SMEM->gen_use_unique) uu_gen_randomize(aUCXT); |
Branch: 1 branch
| Branch | True | False | Total |
| if (SMEM->gen_use_unique) uu_gen_randomize(aUCXT); |
10 |
18044 |
18054 |
|
| 142 |
18054 |
| out->v6.node[0] = SMEM->gen_node[0]; |
| 143 |
18054 |
| out->v6.node[1] = SMEM->gen_node[1]; |
| 144 |
18054 |
| out->v6.node[2] = SMEM->gen_node[2]; |
| 145 |
18054 |
| out->v6.node[3] = SMEM->gen_node[3]; |
| 146 |
18054 |
| out->v6.node[4] = SMEM->gen_node[4]; |
| 147 |
18054 |
| out->v6.node[5] = SMEM->gen_node[5]; |
| 148 |
18054 |
| } |
| 149 |
|
| |
| 150 |
18035 |
| void uu_gen_v7(pUCXT, struct_uu_t *out, char *dptr) { |
| 151 |
|
| U64 clock_reg; |
| 152 |
|
| U16 clock_seq; |
| 153 |
|
| |
| 154 |
18035 |
| uu_clock(aUCXT, &clock_reg, &clock_seq); |
| 155 |
18035 |
| clock_reg /= 10000; |
| 156 |
|
| |
| 157 |
18035 |
| uu_chacha_rand16(aUCXT, &out->v7.rand_a_and_version); |
| 158 |
18035 |
| uu_chacha_rand64(aUCXT, &out->v7.rand_b_and_variant); |
| 159 |
18035 |
| out->v7.time_high = (U32)(clock_reg >> 16); |
| 160 |
18035 |
| out->v7.time_low = (U16)(clock_reg & 0xffff); |
| 161 |
18035 |
| out->v7.rand_a_and_version = (out->v7.rand_a_and_version & 0x0fff) | 0x7000; |
| 162 |
18035 |
| out->v7.rand_b_and_variant = (out->v7.rand_b_and_variant & 0x3fffffffffffffffULL) | 0x8000000000000000ULL; |
| 163 |
18035 |
| } |
| 164 |
|
| |
| 165 |
|
| /* ex:set ts=2 sw=2 itab=spaces: */ |