2 * Copyright (c) 2010 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Alex Hornung <ahornung@gmail.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
34 #include <sys/types.h>
35 #include <sys/device.h>
37 #include <sys/socket.h>
38 #include <sys/ioctl.h>
40 #include <sys/queue.h>
42 #include <cpu/inttypes.h>
60 #include <libprop/proplib.h>
64 #define MONITOR_LOCK() pthread_mutex_lock(&monitor_lock)
65 #define MONITOR_UNLOCK() pthread_mutex_unlock(&monitor_lock)
67 static int _parse_filter_prop(struct udev_monitor *udm, prop_array_t pa);
68 static int match_filter(struct event_filter *evf, prop_dictionary_t dict);
70 static int WildCaseCmp(const char *w, const char *s);
71 static int wildCaseCmp(const char **mary, int d, const char *w, const char *s);
73 TAILQ_HEAD(udev_monitor_list_head, udev_monitor) udev_monitor_list;
74 pthread_mutex_t monitor_lock;
78 monitor_queue_event(prop_dictionary_t ev_dict)
80 struct udev_monitor *udm;
81 struct udev_monitor_event *udm_ev;
85 TAILQ_FOREACH(udm, &udev_monitor_list, link) {
86 udm_ev = malloc(sizeof(struct udev_monitor_event));
90 prop_object_retain(ev_dict);
91 udm_ev->ev_dict = ev_dict;
93 if (match_event_filter(udm,
94 prop_dictionary_get(udm_ev->ev_dict, "evdict")) == 0) {
95 prop_object_release(ev_dict);
100 pthread_mutex_lock(&udm->q_lock);
101 TAILQ_INSERT_TAIL(&udm->ev_queue, udm_ev, link);
102 pthread_cond_signal(&udm->cond);
103 pthread_mutex_unlock(&udm->q_lock);
109 struct udev_monitor *
110 udev_monitor_init(struct client_info *cli, prop_array_t filters)
112 struct udev_monitor *udm;
115 udm = malloc(sizeof(struct udev_monitor));
119 TAILQ_INIT(&udm->ev_queue);
120 TAILQ_INIT(&udm->ev_filt);
122 pthread_mutex_init(&udm->q_lock, NULL);
123 pthread_cond_init(&udm->cond, NULL);
126 if (filters != NULL) {
127 error = _parse_filter_prop(udm, filters);
128 /* XXX: ignore error for now */
135 udev_monitor_free(struct udev_monitor *udm)
137 struct event_filter *evf;
138 struct udev_monitor_event *udm_ev;
140 pthread_mutex_lock(&udm->q_lock);
142 while ((udm_ev = TAILQ_FIRST(&udm->ev_queue)) != NULL) {
143 prop_object_release(udm_ev->ev_dict);
144 udm_ev->ev_dict = NULL;
145 TAILQ_REMOVE(&udm->ev_queue, udm_ev, link);
149 while ((evf = TAILQ_FIRST(&udm->ev_filt)) != NULL) {
150 TAILQ_REMOVE(&udm->ev_filt, evf, link);
154 pthread_mutex_unlock(&udm->q_lock);
159 client_cmd_monitor(struct client_info *cli, prop_dictionary_t dict)
163 struct udev_monitor *udm;
164 struct udev_monitor_event *udm_ev;
170 po = prop_dictionary_get(dict, "filters");
171 if ((po != NULL) && prop_object_type(po) == PROP_TYPE_ARRAY) {
175 udm = udev_monitor_init(cli, pa);
180 TAILQ_INSERT_TAIL(&udev_monitor_list, udm, link);
183 pthread_mutex_lock(&udm->q_lock);
185 pthread_cond_wait(&udm->cond, &udm->q_lock);
187 udm_ev = TAILQ_FIRST(&udm->ev_queue);
191 assert(udm_ev->ev_dict != NULL);
192 xml = prop_dictionary_externalize(udm_ev->ev_dict);
196 prop_object_release(udm_ev->ev_dict);
197 udm_ev->ev_dict = NULL;
198 TAILQ_REMOVE(&udm->ev_queue, udm_ev, link);
201 r = send_xml(cli->fd, xml);
208 pthread_mutex_unlock(&udm->q_lock);
215 TAILQ_REMOVE(&udev_monitor_list, udm, link);
218 udev_monitor_free(udm);
224 _parse_filter_prop(struct udev_monitor *udm, prop_array_t pa)
228 prop_object_iterator_t iter;
229 prop_dictionary_t dict;
230 struct event_filter *evf;
233 iter = prop_array_iterator(pa);
237 while ((dict = prop_object_iterator_next(iter)) != NULL) {
238 evf = malloc(sizeof(struct event_filter));
242 ps = prop_dictionary_get(dict, "key");
245 evf->key = prop_string_cstring(ps);
246 if (evf->key == NULL)
249 pn = prop_dictionary_get(dict, "type");
253 ps = prop_dictionary_get(dict, "expr");
257 if (prop_dictionary_get(dict, "negative"))
262 evf->type = prop_number_integer_value(pn);
264 case EVENT_FILTER_TYPE_WILDCARD:
265 evf->wildcard_match = prop_string_cstring(ps);
266 if (evf->wildcard_match == NULL)
270 case EVENT_FILTER_TYPE_REGEX:
271 error = regcomp(&evf->regex_match, prop_string_cstring_nocopy(ps), REG_ICASE | REG_NOSUB);
280 pthread_mutex_lock(&udm->q_lock);
281 TAILQ_INSERT_TAIL(&udm->ev_filt, evf, link);
282 pthread_mutex_unlock(&udm->q_lock);
286 prop_object_iterator_release(iter);
294 prop_object_iterator_release(iter);
303 <value>(e.g. kptr, devnum, ...)</value>
305 <value>(e.g. wildcard or regex)</value>
307 <value>(regex)</value>
314 match_filter(struct event_filter *evf, prop_dictionary_t ev_dict)
326 prop_object_retain(ev_dict);
328 assert(prop_dictionary_externalize(ev_dict) != NULL);
329 if ((po = prop_dictionary_get(ev_dict, evf->key)) == NULL)
332 if (prop_object_type(po) == PROP_TYPE_STRING) {
334 str = __DECONST(char *, prop_string_cstring_nocopy(ps));
335 } else if (prop_object_type(po) == PROP_TYPE_NUMBER) {
337 if (prop_number_unsigned(pn)) {
338 snprintf(buf, sizeof(buf), "%" PRIu64, prop_number_unsigned_integer_value(pn));
340 snprintf(buf, sizeof(buf), "%" PRIi64, prop_number_integer_value(pn));
344 syslog(LOG_DEBUG, "Unexpected type in match_filter: %d\n", prop_object_type(po));
345 /* Unexpected type */
350 case EVENT_FILTER_TYPE_WILDCARD:
351 ret = WildCaseCmp(evf->wildcard_match, str);
357 case EVENT_FILTER_TYPE_REGEX:
358 ret = regexec(&evf->regex_match, str, 0, NULL, 0);
367 prop_object_release(ev_dict);
371 prop_object_release(ev_dict);
376 match_event_filter(struct udev_monitor *udm, prop_dictionary_t ev_dict)
378 struct event_filter *evf;
379 int all_negative = 1;
381 pthread_mutex_lock(&udm->q_lock);
383 if (TAILQ_EMPTY(&udm->ev_filt))
386 TAILQ_FOREACH(evf, &udm->ev_filt, link) {
387 //printf("match_event_filter 3\n");
391 if (match_filter(evf, ev_dict)) {
392 pthread_mutex_unlock(&udm->q_lock);
393 return (1 ^ evf->neg); /* return 1; or 0 for 'nomatch' hit */
395 //printf("match_event_filter 5\n");
398 pthread_mutex_unlock(&udm->q_lock);
399 return (all_negative == 1)?1:0;
403 WildCaseCmp(const char *w, const char *s)
407 int slen = strlen(s);
410 for (i = c = 0; w[i]; ++i) {
414 mary = malloc(sizeof(char *) * (c + 1));
418 for (i = 0; i < c; ++i)
420 i = wildCaseCmp(mary, 0, w, s);
426 * WildCaseCmp() - compare wild string to sane string, case insensitive
428 * Returns 0 on success, -1 on failure.
431 wildCaseCmp(const char **mary, int d, const char *w, const char *s)
442 * optimize terminator
446 if (w[1] != '?' && w[1] != '*') {
448 * optimize * followed by non-wild
450 for (i = 0; s + i < mary[d]; ++i) {
451 if (s[i] == w[1] && wildCaseCmp(mary, d + 1, w + 1, s + i) == 0)
458 for (i = 0; s + i < mary[d]; ++i) {
459 if (wildCaseCmp(mary, d + 1, w + 1, s + i) == 0)
473 if (tolower(*w) != tolower(*s))
476 if (*w == 0) /* terminator */