1 /*
2 * Copyright (c) 2010 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Alex Hornung <ahornung@gmail.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34 #include <sys/types.h>
35 #include <sys/device.h>
36 #include <sys/wait.h>
37 #include <sys/socket.h>
38 #include <sys/ioctl.h>
39 #include <sys/poll.h>
40 #include <sys/queue.h>
41 #include <sys/un.h>
42
43 #include <err.h>
44 #include <errno.h>
45 #include <fcntl.h>
46 #include <libgen.h>
47 #include <regex.h>
48 #include <signal.h>
49 #include <stdarg.h>
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <syslog.h>
54 #include <unistd.h>
55
56 #include <libprop/proplib.h>
57 #include <sys/udev.h>
58 #define LIBDEVATTR_INTERNAL
59 #include "devattr.h"
60
61 struct udev_enumerate {
62 struct udev *udev_ctx;
63 prop_array_t ev_filt;
64 prop_array_t pa;
65 int refs;
66 TAILQ_HEAD(, udev_list_entry) list_entries;
67 };
68
69 struct udev_list_entry {
70 struct udev *udev_ctx;
71 prop_dictionary_t dict;
72 TAILQ_ENTRY(udev_list_entry) link;
73 };
74
75 struct udev_enumerate *
udev_enumerate_new(struct udev * udev_ctx)76 udev_enumerate_new(struct udev *udev_ctx)
77 {
78 struct udev_enumerate *udev_enum;
79
80 udev_enum = malloc(sizeof(struct udev_enumerate));
81
82 udev_enum->refs = 1;
83 udev_enum->ev_filt = NULL;
84 udev_enum->pa = NULL;
85 TAILQ_INIT(&udev_enum->list_entries);
86 udev_enum->udev_ctx = udev_ref(udev_ctx);
87
88 return udev_enum;
89 }
90
91 struct udev_enumerate *
udev_enumerate_ref(struct udev_enumerate * udev_enum)92 udev_enumerate_ref(struct udev_enumerate *udev_enum)
93 {
94 atomic_add_int(&udev_enum->refs, 1);
95
96 return udev_enum;
97 }
98
99 void
udev_enumerate_unref(struct udev_enumerate * udev_enum)100 udev_enumerate_unref(struct udev_enumerate *udev_enum)
101 {
102 struct udev_list_entry *le;
103 int refcount;
104
105 refcount = atomic_fetchadd_int(&udev_enum->refs, -1);
106
107 if (refcount == 1) {
108 atomic_subtract_int(&udev_enum->refs, 0x400); /* in destruction */
109 if (udev_enum->pa != NULL)
110 prop_object_release(udev_enum->pa);
111 if (udev_enum->ev_filt != NULL)
112 prop_object_release(udev_enum->ev_filt);
113
114 while (!TAILQ_EMPTY(&udev_enum->list_entries)) {
115 le = TAILQ_FIRST(&udev_enum->list_entries);
116 TAILQ_REMOVE(&udev_enum->list_entries, le, link);
117 prop_object_release(le->dict);
118 free(le);
119 }
120 udev_unref(udev_enum->udev_ctx);
121 free(udev_enum);
122 }
123 }
124
125 struct udev *
udev_enumerate_get_udev(struct udev_enumerate * udev_enum)126 udev_enumerate_get_udev(struct udev_enumerate *udev_enum)
127 {
128 return udev_enum->udev_ctx;
129 }
130
131 int
udev_enumerate_scan_devices(struct udev_enumerate * udev_enum)132 udev_enumerate_scan_devices(struct udev_enumerate *udev_enum)
133 {
134 prop_array_t pa;
135
136 if (udev_get_fd(udev_enum->udev_ctx) == -1)
137 return -1;
138
139 pa = udevd_request_devs(udev_get_fd(udev_enum->udev_ctx), udev_enum->ev_filt);
140 if (pa == NULL)
141 return -1;
142
143 prop_object_retain(pa);
144
145 if (udev_enum->pa != NULL)
146 prop_object_release(udev_enum->pa);
147
148 udev_enum->pa = pa;
149
150 return 0;
151 }
152
153 struct udev_list_entry *
udev_enumerate_get_list_entry(struct udev_enumerate * udev_enum)154 udev_enumerate_get_list_entry(struct udev_enumerate *udev_enum)
155 {
156 struct udev_list_entry *le;
157 prop_object_iterator_t iter;
158 prop_dictionary_t dict;
159
160 /* If the list is not empty, assume it was populated in an earlier call */
161 if (!TAILQ_EMPTY(&udev_enum->list_entries))
162 return TAILQ_FIRST(&udev_enum->list_entries);
163
164 iter = prop_array_iterator(udev_enum->pa);
165 if (iter == NULL)
166 return NULL;
167
168 while ((dict = prop_object_iterator_next(iter)) != NULL) {
169 le = malloc(sizeof(struct udev_list_entry));
170 if (le == NULL)
171 goto out;
172
173 prop_object_retain(dict);
174 le->dict = dict;
175 le->udev_ctx = udev_enum->udev_ctx;
176 TAILQ_INSERT_TAIL(&udev_enum->list_entries, le, link);
177 }
178
179 le = TAILQ_FIRST(&udev_enum->list_entries);
180
181 out:
182 prop_object_iterator_release(iter);
183 return le;
184 }
185
186 prop_array_t
udev_enumerate_get_array(struct udev_enumerate * udev_enum)187 udev_enumerate_get_array(struct udev_enumerate *udev_enum)
188 {
189 return udev_enum->pa;
190 }
191
192 struct udev_list_entry *
udev_list_entry_get_next(struct udev_list_entry * list_entry)193 udev_list_entry_get_next(struct udev_list_entry *list_entry)
194 {
195 return TAILQ_NEXT(list_entry, link);
196 }
197
198 prop_dictionary_t
udev_list_entry_get_dictionary(struct udev_list_entry * list_entry)199 udev_list_entry_get_dictionary(struct udev_list_entry *list_entry)
200 {
201 return list_entry->dict;
202 }
203
204 struct udev_device *
udev_list_entry_get_device(struct udev_list_entry * list_entry)205 udev_list_entry_get_device(struct udev_list_entry *list_entry)
206 {
207 struct udev_device *udev_dev;
208
209 udev_dev = udev_device_new_from_dictionary(list_entry->udev_ctx,
210 list_entry->dict);
211
212 return udev_dev;
213 }
214
215 int
udev_enumerate_add_match_subsystem(struct udev_enumerate * udev_enum,const char * subsystem)216 udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enum,
217 const char *subsystem)
218 {
219 int ret;
220
221 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
222 EVENT_FILTER_TYPE_WILDCARD,
223 0,
224 "subsystem",
225 __DECONST(char *, subsystem));
226
227 return ret;
228 }
229
230 int
udev_enumerate_add_nomatch_subsystem(struct udev_enumerate * udev_enum,const char * subsystem)231 udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enum,
232 const char *subsystem)
233 {
234 int ret;
235
236 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
237 EVENT_FILTER_TYPE_WILDCARD,
238 1,
239 "subsystem",
240 __DECONST(char *, subsystem));
241
242 return ret;
243 }
244
245 int
udev_enumerate_add_match_expr(struct udev_enumerate * udev_enum,const char * key,char * expr)246 udev_enumerate_add_match_expr(struct udev_enumerate *udev_enum,
247 const char *key,
248 char *expr)
249 {
250 int ret;
251
252 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
253 EVENT_FILTER_TYPE_WILDCARD,
254 0,
255 key,
256 expr);
257
258 return ret;
259 }
260
261 int
udev_enumerate_add_nomatch_expr(struct udev_enumerate * udev_enum,const char * key,char * expr)262 udev_enumerate_add_nomatch_expr(struct udev_enumerate *udev_enum,
263 const char *key,
264 char *expr)
265 {
266 int ret;
267
268 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
269 EVENT_FILTER_TYPE_WILDCARD,
270 1,
271 key,
272 expr);
273
274 return ret;
275 }
276
277 int
udev_enumerate_add_match_regex(struct udev_enumerate * udev_enum,const char * key,char * expr)278 udev_enumerate_add_match_regex(struct udev_enumerate *udev_enum,
279 const char *key,
280 char *expr)
281 {
282 int ret;
283
284 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
285 EVENT_FILTER_TYPE_REGEX,
286 0,
287 key,
288 expr);
289
290 return ret;
291 }
292
293 int
udev_enumerate_add_nomatch_regex(struct udev_enumerate * udev_enum,const char * key,char * expr)294 udev_enumerate_add_nomatch_regex(struct udev_enumerate *udev_enum,
295 const char *key,
296 char *expr)
297 {
298 int ret;
299
300 ret = _udev_enumerate_filter_add_match_gen(udev_enum,
301 EVENT_FILTER_TYPE_REGEX,
302 1,
303 key,
304 expr);
305
306 return ret;
307 }
308
309 int
_udev_enumerate_filter_add_match_gen(struct udev_enumerate * udev_enum,int type,int neg,const char * key,char * expr)310 _udev_enumerate_filter_add_match_gen(struct udev_enumerate *udev_enum,
311 int type,
312 int neg,
313 const char *key,
314 char *expr)
315 {
316 prop_array_t pa;
317 int error;
318
319 if (udev_enum->ev_filt == NULL) {
320 pa = prop_array_create_with_capacity(5);
321 if (pa == NULL)
322 return -1;
323
324 udev_enum->ev_filt = pa;
325 }
326
327 error = _udev_filter_add_match_gen(udev_enum->ev_filt, type, neg, key, expr);
328
329 return error;
330 }
331