]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
8dfc8dbe | 2 | |
b4bbcaa9 TA |
3 | #include "libudev.h" |
4 | ||
f4ac4d1a | 5 | #include "device-private.h" |
07630cea LP |
6 | #include "libudev-device-internal.h" |
7 | #include "libudev-private.h" | |
f4ac4d1a TG |
8 | |
9 | int udev_device_tag_index(struct udev_device *udev_device, struct udev_device *udev_device_old, bool add) { | |
10 | sd_device *device_old = NULL; | |
11 | int r; | |
12 | ||
13 | assert(udev_device); | |
14 | ||
15 | if (udev_device_old) | |
16 | device_old = udev_device_old->device; | |
17 | ||
18 | r = device_tag_index(udev_device->device, device_old, add); | |
19 | if (r < 0) | |
20 | return r; | |
21 | ||
22 | return 0; | |
23 | } | |
24 | ||
25 | int udev_device_update_db(struct udev_device *udev_device) { | |
26 | int r; | |
27 | ||
28 | assert(udev_device); | |
29 | ||
30 | r = device_update_db(udev_device->device); | |
31 | if (r < 0) | |
32 | return r; | |
33 | ||
34 | return 0; | |
35 | } | |
36 | ||
37 | int udev_device_delete_db(struct udev_device *udev_device) { | |
38 | int r; | |
39 | ||
40 | assert(udev_device); | |
41 | ||
42 | r = device_delete_db(udev_device->device); | |
43 | if (r < 0) | |
44 | return r; | |
45 | ||
46 | return 0; | |
47 | } | |
48 | ||
49 | int udev_device_get_ifindex(struct udev_device *udev_device) { | |
50 | int r, ifindex; | |
51 | ||
52 | assert(udev_device); | |
53 | ||
54 | r = sd_device_get_ifindex(udev_device->device, &ifindex); | |
8ecbc4b8 YW |
55 | if (r == -ENOENT) |
56 | return 0; | |
f4ac4d1a TG |
57 | if (r < 0) |
58 | return r; | |
59 | ||
60 | return ifindex; | |
61 | } | |
62 | ||
63 | const char *udev_device_get_devpath_old(struct udev_device *udev_device) { | |
64 | const char *devpath_old = NULL; | |
65 | int r; | |
2b41e68a | 66 | |
f4ac4d1a TG |
67 | assert(udev_device); |
68 | ||
69 | r = sd_device_get_property_value(udev_device->device, "DEVPATH_OLD", &devpath_old); | |
70 | if (r < 0 && r != -ENOENT) { | |
71 | errno = -r; | |
72 | return NULL; | |
912541b0 | 73 | } |
f4ac4d1a TG |
74 | |
75 | return devpath_old; | |
c1dbe11d | 76 | } |
28460195 | 77 | |
f4ac4d1a TG |
78 | mode_t udev_device_get_devnode_mode(struct udev_device *udev_device) { |
79 | mode_t mode; | |
80 | int r; | |
81 | ||
82 | assert(udev_device); | |
83 | ||
84 | r = device_get_devnode_mode(udev_device->device, &mode); | |
85 | if (r < 0) { | |
86 | errno = -r; | |
87 | return 0; | |
912541b0 KS |
88 | } |
89 | ||
f4ac4d1a TG |
90 | return mode; |
91 | } | |
912541b0 | 92 | |
f4ac4d1a TG |
93 | uid_t udev_device_get_devnode_uid(struct udev_device *udev_device) { |
94 | uid_t uid; | |
95 | int r; | |
96 | ||
97 | assert(udev_device); | |
98 | ||
99 | r = device_get_devnode_uid(udev_device->device, &uid); | |
100 | if (r < 0) { | |
101 | errno = -r; | |
102 | return 0; | |
103 | } | |
104 | ||
105 | return uid; | |
28460195 KS |
106 | } |
107 | ||
f4ac4d1a TG |
108 | gid_t udev_device_get_devnode_gid(struct udev_device *udev_device) { |
109 | gid_t gid; | |
110 | int r; | |
111 | ||
112 | assert(udev_device); | |
113 | ||
114 | r = device_get_devnode_gid(udev_device->device, &gid); | |
115 | if (r < 0) { | |
116 | errno = -r; | |
912541b0 KS |
117 | return 0; |
118 | } | |
119 | ||
f4ac4d1a TG |
120 | return gid; |
121 | } | |
122 | ||
123 | void udev_device_ensure_usec_initialized(struct udev_device *udev_device, struct udev_device *udev_device_old) { | |
f4ac4d1a TG |
124 | assert(udev_device); |
125 | ||
90b33a27 ZJS |
126 | device_ensure_usec_initialized(udev_device->device, |
127 | udev_device_old ? udev_device_old->device : NULL); | |
f4ac4d1a TG |
128 | } |
129 | ||
130 | char **udev_device_get_properties_envp(struct udev_device *udev_device) { | |
131 | char **envp; | |
132 | int r; | |
133 | ||
134 | assert(udev_device); | |
135 | ||
136 | r = device_get_properties_strv(udev_device->device, &envp); | |
137 | if (r < 0) { | |
138 | errno = -r; | |
139 | return NULL; | |
912541b0 KS |
140 | } |
141 | ||
f4ac4d1a TG |
142 | return envp; |
143 | } | |
144 | ||
145 | ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf) { | |
146 | const char *nulstr; | |
147 | size_t len; | |
148 | int r; | |
149 | ||
150 | assert(udev_device); | |
151 | assert(buf); | |
152 | ||
153 | r = device_get_properties_nulstr(udev_device->device, (const uint8_t **)&nulstr, &len); | |
029f4f21 | 154 | if (r < 0) |
f4ac4d1a TG |
155 | return r; |
156 | ||
157 | *buf = nulstr; | |
158 | ||
159 | return len; | |
160 | } | |
161 | ||
162 | int udev_device_get_devlink_priority(struct udev_device *udev_device) { | |
163 | int priority, r; | |
164 | ||
165 | assert(udev_device); | |
166 | ||
167 | r = device_get_devlink_priority(udev_device->device, &priority); | |
168 | if (r < 0) | |
169 | return r; | |
170 | ||
171 | return priority; | |
172 | } | |
173 | ||
174 | int udev_device_get_watch_handle(struct udev_device *udev_device) { | |
175 | int handle, r; | |
176 | ||
177 | assert(udev_device); | |
178 | ||
179 | r = device_get_watch_handle(udev_device->device, &handle); | |
180 | if (r < 0) | |
181 | return r; | |
182 | ||
183 | return handle; | |
184 | } | |
185 | ||
186 | void udev_device_set_is_initialized(struct udev_device *udev_device) { | |
187 | assert(udev_device); | |
188 | ||
189 | device_set_is_initialized(udev_device->device); | |
190 | } | |
191 | ||
192 | int udev_device_rename(struct udev_device *udev_device, const char *name) { | |
193 | int r; | |
194 | ||
195 | assert(udev_device); | |
196 | ||
197 | r = device_rename(udev_device->device, name); | |
198 | if (r < 0) | |
199 | return r; | |
200 | ||
912541b0 | 201 | return 0; |
ca999860 GKH |
202 | } |
203 | ||
f4ac4d1a | 204 | struct udev_device *udev_device_shallow_clone(struct udev_device *old_device) { |
02e7ae2f | 205 | _cleanup_(sd_device_unrefp) sd_device *device = NULL; |
f4ac4d1a TG |
206 | int r; |
207 | ||
208 | assert(old_device); | |
209 | ||
02e7ae2f | 210 | r = device_shallow_clone(old_device->device, &device); |
f4ac4d1a | 211 | if (r < 0) { |
f4ac4d1a TG |
212 | errno = -r; |
213 | return NULL; | |
214 | } | |
215 | ||
02e7ae2f | 216 | return udev_device_new(old_device->udev, device); |
f4ac4d1a TG |
217 | } |
218 | ||
219 | struct udev_device *udev_device_clone_with_db(struct udev_device *udev_device_old) { | |
02e7ae2f | 220 | _cleanup_(sd_device_unrefp) sd_device *device = NULL; |
f4ac4d1a TG |
221 | int r; |
222 | ||
223 | assert(udev_device_old); | |
224 | ||
02e7ae2f | 225 | r = device_clone_with_db(udev_device_old->device, &device); |
f4ac4d1a | 226 | if (r < 0) { |
f4ac4d1a TG |
227 | errno = -r; |
228 | return NULL; | |
229 | } | |
230 | ||
02e7ae2f | 231 | return udev_device_new(udev_device_old->udev, device); |
f4ac4d1a TG |
232 | } |
233 | ||
234 | struct udev_device *udev_device_new_from_nulstr(struct udev *udev, char *nulstr, ssize_t buflen) { | |
02e7ae2f | 235 | _cleanup_(sd_device_unrefp) sd_device *device = NULL; |
f4ac4d1a TG |
236 | int r; |
237 | ||
02e7ae2f | 238 | r = device_new_from_nulstr(&device, (uint8_t*)nulstr, buflen); |
f4ac4d1a | 239 | if (r < 0) { |
f4ac4d1a TG |
240 | errno = -r; |
241 | return NULL; | |
242 | } | |
243 | ||
02e7ae2f | 244 | return udev_device_new(udev, device); |
f4ac4d1a TG |
245 | } |
246 | ||
247 | struct udev_device *udev_device_new_from_synthetic_event(struct udev *udev, const char *syspath, const char *action) { | |
02e7ae2f | 248 | _cleanup_(sd_device_unrefp) sd_device *device = NULL; |
f4ac4d1a TG |
249 | int r; |
250 | ||
02e7ae2f | 251 | r = device_new_from_synthetic_event(&device, syspath, action); |
f4ac4d1a | 252 | if (r < 0) { |
f4ac4d1a TG |
253 | errno = -r; |
254 | return NULL; | |
255 | } | |
256 | ||
02e7ae2f | 257 | return udev_device_new(udev, device); |
f4ac4d1a TG |
258 | } |
259 | ||
260 | int udev_device_copy_properties(struct udev_device *udev_device_dst, struct udev_device *udev_device_src) { | |
261 | int r; | |
262 | ||
263 | assert(udev_device_dst); | |
264 | assert(udev_device_src); | |
265 | ||
266 | r = device_copy_properties(udev_device_dst->device, udev_device_src->device); | |
267 | if (r < 0) | |
268 | return r; | |
269 | ||
270 | return 0; | |
271 | } | |
272 | ||
273 | const char *udev_device_get_id_filename(struct udev_device *udev_device) { | |
274 | const char *filename; | |
275 | int r; | |
276 | ||
277 | assert(udev_device); | |
278 | ||
279 | r = device_get_id_filename(udev_device->device, &filename); | |
280 | if (r < 0) { | |
281 | errno = -r; | |
282 | return NULL; | |
283 | } | |
284 | ||
285 | return filename; | |
286 | } | |
287 | ||
288 | int udev_device_set_watch_handle(struct udev_device *udev_device, int handle) { | |
912541b0 | 289 | |
f4ac4d1a TG |
290 | assert(udev_device); |
291 | ||
292 | device_set_watch_handle(udev_device->device, handle); | |
293 | ||
294 | return 0; | |
295 | } | |
296 | ||
297 | void udev_device_set_db_persist(struct udev_device *udev_device) { | |
298 | assert(udev_device); | |
299 | ||
300 | device_set_db_persist(udev_device->device); | |
301 | } | |
302 | ||
303 | int udev_device_set_devlink_priority(struct udev_device *udev_device, int priority) { | |
304 | assert(udev_device); | |
305 | ||
306 | device_set_devlink_priority(udev_device->device, priority); | |
3c0bab4a | 307 | |
912541b0 | 308 | return 0; |
8e41d35d | 309 | } |
f4ac4d1a TG |
310 | |
311 | int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink) { | |
312 | int r; | |
313 | ||
314 | assert(udev_device); | |
315 | ||
316 | r = device_add_devlink(udev_device->device, devlink); | |
317 | if (r < 0) | |
318 | return r; | |
319 | ||
320 | return 0; | |
321 | } | |
322 | ||
323 | int udev_device_add_property(struct udev_device *udev_device, const char *property, const char *value) { | |
324 | int r; | |
325 | ||
326 | assert(udev_device); | |
327 | ||
328 | r = device_add_property(udev_device->device, property, value); | |
329 | if (r < 0) | |
330 | return r; | |
331 | ||
332 | return 0; | |
333 | } | |
334 | ||
335 | int udev_device_add_tag(struct udev_device *udev_device, const char *tag) { | |
336 | int r; | |
337 | ||
338 | assert(udev_device); | |
339 | ||
340 | r = device_add_tag(udev_device->device, tag); | |
341 | if (r < 0) | |
342 | return r; | |
343 | ||
344 | return 0; | |
345 | } | |
346 | ||
347 | void udev_device_remove_tag(struct udev_device *udev_device, const char *tag) { | |
348 | assert(udev_device); | |
349 | ||
350 | device_remove_tag(udev_device->device, tag); | |
351 | } | |
352 | ||
353 | void udev_device_cleanup_tags_list(struct udev_device *udev_device) { | |
354 | assert(udev_device); | |
355 | ||
356 | device_cleanup_tags(udev_device->device); | |
357 | } | |
358 | ||
359 | void udev_device_cleanup_devlinks_list(struct udev_device *udev_device) { | |
360 | assert(udev_device); | |
361 | ||
362 | device_cleanup_devlinks(udev_device->device); | |
363 | } | |
364 | ||
365 | void udev_device_set_info_loaded(struct udev_device *udev_device) { | |
366 | assert(udev_device); | |
367 | ||
368 | device_seal(udev_device->device); | |
369 | } | |
107f2e25 TG |
370 | |
371 | void udev_device_read_db(struct udev_device *udev_device) { | |
372 | assert(udev_device); | |
373 | ||
374 | device_read_db_force(udev_device->device); | |
375 | } |