Debian Codegraph @

src/libsystemd-network/sd-dhcp-client-id.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "alloc-util.h"
4 #include "dhcp-client-id-internal.h"
5 #include "iovec-util.h"
6 #include "json-util.h"
7 #include "siphash24.h"
8 #include "string-util.h"
9 #include "unaligned.h"
10 #include "utf8.h"
11
12 int sd_dhcp_client_id_clear(sd_dhcp_client_id *client_id) {
13 assert_return(client_id, -EINVAL);
14
15 *client_id = (sd_dhcp_client_id) {};
16 return 0;
17 }
18
19 int sd_dhcp_client_id_is_set(const sd_dhcp_client_id *client_id) {
20 if (!client_id)
21 return false;
22
23 return client_id_size_is_valid(client_id->size);
24 }
25
26 int sd_dhcp_client_id_get(const sd_dhcp_client_id *client_id, uint8_t *ret_type, const void **ret_data, size_t *ret_size) {
27 assert_return(sd_dhcp_client_id_is_set(client_id), -EINVAL);
28 assert_return(ret_type, -EINVAL);
29 assert_return(ret_data, -EINVAL);
30 assert_return(ret_size, -EINVAL);
31
32 *ret_type = client_id->id.type;
33 *ret_data = client_id->id.data;
34 *ret_size = client_id->size - offsetof(typeof(client_id->id), data);
35 return 0;
36 }
37
38 int sd_dhcp_client_id_get_raw(const sd_dhcp_client_id *client_id, const void **ret_data, size_t *ret_size) {
39 assert_return(sd_dhcp_client_id_is_set(client_id), -EINVAL);
40 assert_return(ret_data, -EINVAL);
41 assert_return(ret_size, -EINVAL);
42
43 /* Unlike sd_dhcp_client_id_get(), this returns whole client ID including its type. */
44
45 *ret_data = client_id->raw;
46 *ret_size = client_id->size;
47 return 0;
48 }
49
50 int sd_dhcp_client_id_set(
51 sd_dhcp_client_id *client_id,
52 uint8_t type,
53 const void *data,
54 size_t data_size) {
55
56 assert_return(client_id, -EINVAL);
57 assert_return(data, -EINVAL);
58
59 if (!client_id_data_size_is_valid(data_size))
60 return -EINVAL;
61
62 client_id->id.type = type;
63 memcpy(client_id->id.data, data, data_size);
64
65 client_id->size = offsetof(typeof(client_id->id), data) + data_size;
66 return 0;
67 }
68
69 int sd_dhcp_client_id_set_raw(
70 sd_dhcp_client_id *client_id,
71 const void *data,
72 size_t data_size) {
73
74 assert_return(client_id, -EINVAL);
75 assert_return(data, -EINVAL);
76
77 /* Unlike sd_dhcp_client_id_set(), this takes whole client ID including its type. */
78
79 if (!client_id_size_is_valid(data_size))
80 return -EINVAL;
81
82 memcpy(client_id->raw, data, data_size);
83
84 client_id->size = data_size;
85 return 0;
86 }
87
88 int sd_dhcp_client_id_set_iaid_duid(
89 sd_dhcp_client_id *client_id,
90 uint32_t iaid,
91 sd_dhcp_duid *duid) {
92
93 assert_return(client_id, -EINVAL);
94 assert_return(duid, -EINVAL);
95 assert_return(sd_dhcp_duid_is_set(duid), -ESTALE);
96
97 client_id->id.type = 255;
98 unaligned_write_be32(&client_id->id.ns.iaid, iaid);
99 memcpy(&client_id->id.ns.duid, &duid->duid, duid->size);
100
101 client_id->size = offsetof(typeof(client_id->id), ns.duid) + duid->size;
102 return 0;
103 }
104
105 int sd_dhcp_client_id_to_string(const sd_dhcp_client_id *client_id, char **ret) {
106 _cleanup_free_ char *t = NULL;
107 size_t len;
108 int r;
109
110 assert_return(sd_dhcp_client_id_is_set(client_id), -EINVAL);
111 assert_return(ret, -EINVAL);
112
113 len = client_id->size - offsetof(typeof(client_id->id), data);
114
115 switch (client_id->id.type) {
116 case 0:
117 if (utf8_is_printable((char *) client_id->id.gen.data, len))
118 r = asprintf(&t, "%.*s", (int) len, client_id->id.gen.data);
119 else
120 r = asprintf(&t, "DATA");
121 break;
122 case 1:
123 if (len == sizeof_field(sd_dhcp_client_id, id.eth))
124 r = asprintf(&t, "%02x:%02x:%02x:%02x:%02x:%02x",
125 client_id->id.eth.haddr[0],
126 client_id->id.eth.haddr[1],
127 client_id->id.eth.haddr[2],
128 client_id->id.eth.haddr[3],
129 client_id->id.eth.haddr[4],
130 client_id->id.eth.haddr[5]);
131 else
132 r = asprintf(&t, "ETHER");
133 break;
134 case 2 ... 254:
135 r = asprintf(&t, "ARP/LL");
136 break;
137 case 255:
138 if (len < sizeof(uint32_t))
139 r = asprintf(&t, "IAID/DUID");
140 else {
141 uint32_t iaid = be32toh(client_id->id.ns.iaid);
142 /* TODO: check and stringify DUID */
143 r = asprintf(&t, "IAID:0x%x/DUID", iaid);
144 }
145 break;
146 default:
147 assert_not_reached();
148 }
149 if (r < 0)
150 return -ENOMEM;
151
152 *ret = TAKE_PTR(t);
153 return 0;
154 }
155
156 int sd_dhcp_client_id_to_string_from_raw(const void *data, size_t data_size, char **ret) {
157 sd_dhcp_client_id client_id;
158 int r;
159
160 assert_return(data, -EINVAL);
161 assert_return(ret, -EINVAL);
162
163 r = sd_dhcp_client_id_set_raw(&client_id, data, data_size);
164 if (r < 0)
165 return r;
166
167 return sd_dhcp_client_id_to_string(&client_id, ret);
168 }
169
170 void client_id_hash_func(const sd_dhcp_client_id *client_id, struct siphash *state) {
171 assert(sd_dhcp_client_id_is_set(client_id));
172 assert(state);
173
174 siphash24_compress_typesafe(client_id->size, state);
175 siphash24_compress(client_id->raw, client_id->size, state);
176 }
177
178 int client_id_compare_func(const sd_dhcp_client_id *a, const sd_dhcp_client_id *b) {
179 assert(sd_dhcp_client_id_is_set(a));
180 assert(sd_dhcp_client_id_is_set(b));
181
182 return memcmp_nn(a->raw, a->size, b->raw, b->size);
183 }
184
185 int json_dispatch_client_id(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
186 sd_dhcp_client_id *client_id = ASSERT_PTR(userdata);
187 _cleanup_(iovec_done) struct iovec iov = {};
188 int r;
189
190 r = json_dispatch_byte_array_iovec(name, variant, flags, &iov);
191 if (r < 0)
192 return r;
193
194 r = sd_dhcp_client_id_set_raw(client_id, iov.iov_base, iov.iov_len);
195 if (r < 0)
196 return json_log(variant, flags, r, "Failed to set DHCP client ID from JSON field '%s': %m", strna(name));
197
198 return 0;
199 }