Line data Source code
1 : /***
2 : This file is part of systemd.
3 :
4 : Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
5 : Copyright 2015 Tom Gundersen <teg@jklm.no>
6 :
7 : systemd is free software; you can redistribute it and/or modify it
8 : under the terms of the GNU Lesser General Public License as published by
9 : the Free Software Foundation; either version 2.1 of the License, or
10 : (at your option) any later version.
11 :
12 : systemd is distributed in the hope that it will be useful, but
13 : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : Lesser General Public License for more details.
16 :
17 : You should have received a copy of the GNU Lesser General Public License
18 : along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 : ***/
20 :
21 : #include "libudev.h"
22 : #include "libudev-private.h"
23 : #include "libudev-device-internal.h"
24 :
25 : #include "device-private.h"
26 :
27 0 : int udev_device_tag_index(struct udev_device *udev_device, struct udev_device *udev_device_old, bool add) {
28 0 : sd_device *device_old = NULL;
29 : int r;
30 :
31 0 : assert(udev_device);
32 :
33 0 : if (udev_device_old)
34 0 : device_old = udev_device_old->device;
35 :
36 0 : r = device_tag_index(udev_device->device, device_old, add);
37 0 : if (r < 0)
38 0 : return r;
39 :
40 0 : return 0;
41 : }
42 :
43 0 : int udev_device_update_db(struct udev_device *udev_device) {
44 : int r;
45 :
46 0 : assert(udev_device);
47 :
48 0 : r = device_update_db(udev_device->device);
49 0 : if (r < 0)
50 0 : return r;
51 :
52 0 : return 0;
53 : }
54 :
55 0 : int udev_device_delete_db(struct udev_device *udev_device) {
56 : int r;
57 :
58 0 : assert(udev_device);
59 :
60 0 : r = device_delete_db(udev_device->device);
61 0 : if (r < 0)
62 0 : return r;
63 :
64 0 : return 0;
65 : }
66 :
67 1 : int udev_device_get_ifindex(struct udev_device *udev_device) {
68 : int r, ifindex;
69 :
70 1 : assert(udev_device);
71 :
72 1 : r = sd_device_get_ifindex(udev_device->device, &ifindex);
73 1 : if (r < 0)
74 0 : return r;
75 :
76 1 : return ifindex;
77 : }
78 :
79 0 : const char *udev_device_get_devpath_old(struct udev_device *udev_device) {
80 0 : const char *devpath_old = NULL;
81 : int r;
82 :
83 0 : assert(udev_device);
84 :
85 0 : r = sd_device_get_property_value(udev_device->device, "DEVPATH_OLD", &devpath_old);
86 0 : if (r < 0 && r != -ENOENT) {
87 0 : errno = -r;
88 0 : return NULL;
89 : }
90 :
91 0 : return devpath_old;
92 : }
93 :
94 0 : mode_t udev_device_get_devnode_mode(struct udev_device *udev_device) {
95 : mode_t mode;
96 : int r;
97 :
98 0 : assert(udev_device);
99 :
100 0 : r = device_get_devnode_mode(udev_device->device, &mode);
101 0 : if (r < 0) {
102 0 : errno = -r;
103 0 : return 0;
104 : }
105 :
106 0 : return mode;
107 : }
108 :
109 0 : uid_t udev_device_get_devnode_uid(struct udev_device *udev_device) {
110 : uid_t uid;
111 : int r;
112 :
113 0 : assert(udev_device);
114 :
115 0 : r = device_get_devnode_uid(udev_device->device, &uid);
116 0 : if (r < 0) {
117 0 : errno = -r;
118 0 : return 0;
119 : }
120 :
121 0 : return uid;
122 : }
123 :
124 0 : gid_t udev_device_get_devnode_gid(struct udev_device *udev_device) {
125 : gid_t gid;
126 : int r;
127 :
128 0 : assert(udev_device);
129 :
130 0 : r = device_get_devnode_gid(udev_device->device, &gid);
131 0 : if (r < 0) {
132 0 : errno = -r;
133 0 : return 0;
134 : }
135 :
136 0 : return gid;
137 : }
138 :
139 0 : void udev_device_ensure_usec_initialized(struct udev_device *udev_device, struct udev_device *udev_device_old) {
140 0 : sd_device *device_old = NULL;
141 :
142 0 : assert(udev_device);
143 :
144 0 : if (udev_device_old)
145 0 : device_old = udev_device_old->device;
146 :
147 0 : device_ensure_usec_initialized(udev_device->device, device_old);
148 0 : }
149 :
150 0 : char **udev_device_get_properties_envp(struct udev_device *udev_device) {
151 : char **envp;
152 : int r;
153 :
154 0 : assert(udev_device);
155 :
156 0 : r = device_get_properties_strv(udev_device->device, &envp);
157 0 : if (r < 0) {
158 0 : errno = -r;
159 0 : return NULL;
160 : }
161 :
162 0 : return envp;
163 : }
164 :
165 0 : ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf) {
166 : const char *nulstr;
167 : size_t len;
168 : int r;
169 :
170 0 : assert(udev_device);
171 0 : assert(buf);
172 :
173 0 : r = device_get_properties_nulstr(udev_device->device, (const uint8_t **)&nulstr, &len);
174 0 : if (r < 0)
175 0 : return r;
176 :
177 0 : *buf = nulstr;
178 :
179 0 : return len;
180 : }
181 :
182 0 : int udev_device_get_devlink_priority(struct udev_device *udev_device) {
183 : int priority, r;
184 :
185 0 : assert(udev_device);
186 :
187 0 : r = device_get_devlink_priority(udev_device->device, &priority);
188 0 : if (r < 0)
189 0 : return r;
190 :
191 0 : return priority;
192 : }
193 :
194 0 : int udev_device_get_watch_handle(struct udev_device *udev_device) {
195 : int handle, r;
196 :
197 0 : assert(udev_device);
198 :
199 0 : r = device_get_watch_handle(udev_device->device, &handle);
200 0 : if (r < 0)
201 0 : return r;
202 :
203 0 : return handle;
204 : }
205 :
206 0 : void udev_device_set_is_initialized(struct udev_device *udev_device) {
207 0 : assert(udev_device);
208 :
209 0 : device_set_is_initialized(udev_device->device);
210 0 : }
211 :
212 0 : int udev_device_rename(struct udev_device *udev_device, const char *name) {
213 : int r;
214 :
215 0 : assert(udev_device);
216 :
217 0 : r = device_rename(udev_device->device, name);
218 0 : if (r < 0)
219 0 : return r;
220 :
221 0 : return 0;
222 : }
223 :
224 0 : struct udev_device *udev_device_shallow_clone(struct udev_device *old_device) {
225 : struct udev_device *device;
226 : int r;
227 :
228 0 : assert(old_device);
229 :
230 0 : device = udev_device_new(old_device->udev);
231 0 : if (!device)
232 0 : return NULL;
233 :
234 0 : r = device_shallow_clone(old_device->device, &device->device);
235 0 : if (r < 0) {
236 0 : udev_device_unref(device);
237 0 : errno = -r;
238 0 : return NULL;
239 : }
240 :
241 0 : return device;
242 : }
243 :
244 0 : struct udev_device *udev_device_clone_with_db(struct udev_device *udev_device_old) {
245 : struct udev_device *udev_device;
246 : int r;
247 :
248 0 : assert(udev_device_old);
249 :
250 0 : udev_device = udev_device_new(udev_device_old->udev);
251 0 : if (!udev_device)
252 0 : return NULL;
253 :
254 0 : r = device_clone_with_db(udev_device_old->device, &udev_device->device);
255 0 : if (r < 0) {
256 0 : udev_device_unref(udev_device);
257 0 : errno = -r;
258 0 : return NULL;
259 : }
260 :
261 0 : return udev_device;
262 : }
263 :
264 0 : struct udev_device *udev_device_new_from_nulstr(struct udev *udev, char *nulstr, ssize_t buflen) {
265 : struct udev_device *device;
266 : int r;
267 :
268 0 : device = udev_device_new(udev);
269 0 : if (!device)
270 0 : return NULL;
271 :
272 0 : r = device_new_from_nulstr(&device->device, (uint8_t*)nulstr, buflen);
273 0 : if (r < 0) {
274 0 : udev_device_unref(device);
275 0 : errno = -r;
276 0 : return NULL;
277 : }
278 :
279 0 : return device;
280 : }
281 :
282 0 : struct udev_device *udev_device_new_from_synthetic_event(struct udev *udev, const char *syspath, const char *action) {
283 : struct udev_device *device;
284 : int r;
285 :
286 0 : device = udev_device_new(udev);
287 0 : if (!device)
288 0 : return NULL;
289 :
290 0 : r = device_new_from_synthetic_event(&device->device, syspath, action);
291 0 : if (r < 0) {
292 0 : udev_device_unref(device);
293 0 : errno = -r;
294 0 : return NULL;
295 : }
296 :
297 0 : return device;
298 : }
299 :
300 0 : int udev_device_copy_properties(struct udev_device *udev_device_dst, struct udev_device *udev_device_src) {
301 : int r;
302 :
303 0 : assert(udev_device_dst);
304 0 : assert(udev_device_src);
305 :
306 0 : r = device_copy_properties(udev_device_dst->device, udev_device_src->device);
307 0 : if (r < 0)
308 0 : return r;
309 :
310 0 : return 0;
311 : }
312 :
313 0 : const char *udev_device_get_id_filename(struct udev_device *udev_device) {
314 : const char *filename;
315 : int r;
316 :
317 0 : assert(udev_device);
318 :
319 0 : r = device_get_id_filename(udev_device->device, &filename);
320 0 : if (r < 0) {
321 0 : errno = -r;
322 0 : return NULL;
323 : }
324 :
325 0 : return filename;
326 : }
327 :
328 0 : int udev_device_set_watch_handle(struct udev_device *udev_device, int handle) {
329 :
330 0 : assert(udev_device);
331 :
332 0 : device_set_watch_handle(udev_device->device, handle);
333 :
334 0 : return 0;
335 : }
336 :
337 0 : void udev_device_set_db_persist(struct udev_device *udev_device) {
338 0 : assert(udev_device);
339 :
340 0 : device_set_db_persist(udev_device->device);
341 0 : }
342 :
343 0 : int udev_device_set_devlink_priority(struct udev_device *udev_device, int priority) {
344 0 : assert(udev_device);
345 :
346 0 : device_set_devlink_priority(udev_device->device, priority);
347 :
348 0 : return 0;
349 : }
350 :
351 0 : int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink) {
352 : int r;
353 :
354 0 : assert(udev_device);
355 :
356 0 : r = device_add_devlink(udev_device->device, devlink);
357 0 : if (r < 0)
358 0 : return r;
359 :
360 0 : return 0;
361 : }
362 :
363 0 : int udev_device_add_property(struct udev_device *udev_device, const char *property, const char *value) {
364 : int r;
365 :
366 0 : assert(udev_device);
367 :
368 0 : r = device_add_property(udev_device->device, property, value);
369 0 : if (r < 0)
370 0 : return r;
371 :
372 0 : return 0;
373 : }
374 :
375 0 : int udev_device_add_tag(struct udev_device *udev_device, const char *tag) {
376 : int r;
377 :
378 0 : assert(udev_device);
379 :
380 0 : r = device_add_tag(udev_device->device, tag);
381 0 : if (r < 0)
382 0 : return r;
383 :
384 0 : return 0;
385 : }
386 :
387 0 : void udev_device_remove_tag(struct udev_device *udev_device, const char *tag) {
388 0 : assert(udev_device);
389 :
390 0 : device_remove_tag(udev_device->device, tag);
391 0 : }
392 :
393 0 : void udev_device_cleanup_tags_list(struct udev_device *udev_device) {
394 0 : assert(udev_device);
395 :
396 0 : device_cleanup_tags(udev_device->device);
397 0 : }
398 :
399 0 : void udev_device_cleanup_devlinks_list(struct udev_device *udev_device) {
400 0 : assert(udev_device);
401 :
402 0 : device_cleanup_devlinks(udev_device->device);
403 0 : }
404 :
405 0 : void udev_device_set_info_loaded(struct udev_device *udev_device) {
406 0 : assert(udev_device);
407 :
408 0 : device_seal(udev_device->device);
409 0 : }
410 :
411 0 : void udev_device_read_db(struct udev_device *udev_device) {
412 0 : assert(udev_device);
413 :
414 0 : device_read_db_force(udev_device->device);
415 0 : }
|
