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 #include <cpu/inttypes.h> 43 #include <assert.h> 44 45 #include <ctype.h> 46 #include <err.h> 47 #include <errno.h> 48 #include <fcntl.h> 49 #include <libgen.h> 50 #include <regex.h> 51 #include <signal.h> 52 #include <stdarg.h> 53 #include <stdio.h> 54 #include <stdlib.h> 55 #include <string.h> 56 #include <syslog.h> 57 #include <unistd.h> 58 #include <pthread.h> 59 60 #include <libprop/proplib.h> 61 #include <sys/udev.h> 62 #include "udevd.h" 63 64 #define MONITOR_LOCK() pthread_mutex_lock(&monitor_lock) 65 #define MONITOR_UNLOCK() pthread_mutex_unlock(&monitor_lock) 66 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); 69 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); 72 73 TAILQ_HEAD(udev_monitor_list_head, udev_monitor) udev_monitor_list; 74 pthread_mutex_t monitor_lock; 75 76 77 void 78 monitor_queue_event(prop_dictionary_t ev_dict) 79 { 80 struct udev_monitor *udm; 81 struct udev_monitor_event *udm_ev; 82 83 MONITOR_LOCK(); 84 85 TAILQ_FOREACH(udm, &udev_monitor_list, link) { 86 udm_ev = malloc(sizeof(struct udev_monitor_event)); 87 if (udm_ev == NULL) 88 continue; 89 90 prop_object_retain(ev_dict); 91 udm_ev->ev_dict = ev_dict; 92 93 if (match_event_filter(udm, 94 prop_dictionary_get(udm_ev->ev_dict, "evdict")) == 0) { 95 prop_object_release(ev_dict); 96 free(udm_ev); 97 continue; 98 } 99 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); 104 } 105 106 MONITOR_UNLOCK(); 107 } 108 109 struct udev_monitor * 110 udev_monitor_init(struct client_info *cli, prop_array_t filters) 111 { 112 struct udev_monitor *udm; 113 114 udm = malloc(sizeof(struct udev_monitor)); 115 if (udm == NULL) 116 return NULL; 117 118 TAILQ_INIT(&udm->ev_queue); 119 TAILQ_INIT(&udm->ev_filt); 120 121 pthread_mutex_init(&udm->q_lock, NULL); 122 pthread_cond_init(&udm->cond, NULL); 123 udm->cli = cli; 124 125 if (filters != NULL) { 126 __unused int error = _parse_filter_prop(udm, filters); 127 /* XXX: ignore error for now */ 128 } 129 130 return udm; 131 } 132 133 void 134 udev_monitor_free(struct udev_monitor *udm) 135 { 136 struct event_filter *evf; 137 struct udev_monitor_event *udm_ev; 138 139 pthread_mutex_lock(&udm->q_lock); 140 141 while ((udm_ev = TAILQ_FIRST(&udm->ev_queue)) != NULL) { 142 prop_object_release(udm_ev->ev_dict); 143 udm_ev->ev_dict = NULL; 144 TAILQ_REMOVE(&udm->ev_queue, udm_ev, link); 145 free(udm_ev); 146 } 147 148 while ((evf = TAILQ_FIRST(&udm->ev_filt)) != NULL) { 149 TAILQ_REMOVE(&udm->ev_filt, evf, link); 150 free(evf->key); 151 if (evf->type == EVENT_FILTER_TYPE_WILDCARD) 152 free(evf->wildcard_match); 153 else if (evf->type == EVENT_FILTER_TYPE_REGEX) 154 regfree(&evf->regex_match); 155 free(evf); 156 } 157 158 pthread_mutex_unlock(&udm->q_lock); 159 free(udm); 160 } 161 162 int 163 client_cmd_monitor(struct client_info *cli, prop_dictionary_t dict) 164 { 165 prop_array_t pa; 166 prop_object_t po; 167 struct udev_monitor *udm; 168 struct udev_monitor_event *udm_ev; 169 struct timespec abstime; 170 struct pollfd fds[1]; 171 char *xml; 172 ssize_t r; 173 int ret, ok, dummy; 174 175 pa = NULL; 176 po = prop_dictionary_get(dict, "filters"); 177 if ((po != NULL) && prop_object_type(po) == PROP_TYPE_ARRAY) { 178 pa = po; 179 } 180 181 udm = udev_monitor_init(cli, pa); 182 if (udm == NULL) 183 return 1; 184 185 ok = 1; 186 fds[0].fd = cli->fd; 187 fds[0].events = POLLRDNORM; 188 189 MONITOR_LOCK(); 190 TAILQ_INSERT_TAIL(&udev_monitor_list, udm, link); 191 MONITOR_UNLOCK(); 192 193 pthread_mutex_lock(&udm->q_lock); 194 while (ok) { 195 clock_gettime(CLOCK_REALTIME,&abstime); 196 abstime.tv_sec += 2; 197 ret = pthread_cond_timedwait(&udm->cond, &udm->q_lock, &abstime); 198 199 if (ret == EINVAL) { 200 syslog(LOG_ERR, "pthread_cond_timedwait error: EINVAL"); 201 goto end_nofree; 202 } 203 204 if ((ret = poll(fds, 1, 0)) > 0) { 205 ret = recv(fds[0].fd, &dummy, sizeof(dummy), MSG_DONTWAIT); 206 if ((ret == 0) || ((ret < 0) && (errno != EAGAIN))) 207 goto end_nofree; 208 } 209 210 udm_ev = TAILQ_FIRST(&udm->ev_queue); 211 if (udm_ev == NULL) 212 continue; 213 214 assert(udm_ev->ev_dict != NULL); 215 xml = prop_dictionary_externalize(udm_ev->ev_dict); 216 if (xml == NULL) 217 continue; 218 219 prop_object_release(udm_ev->ev_dict); 220 udm_ev->ev_dict = NULL; 221 TAILQ_REMOVE(&udm->ev_queue, udm_ev, link); 222 free(udm_ev); 223 224 r = send_xml(cli->fd, xml); 225 if (r <= 0) 226 goto end; 227 228 free(xml); 229 continue; 230 end: 231 free(xml); 232 end_nofree: 233 pthread_mutex_unlock(&udm->q_lock); 234 close(cli->fd); 235 ok = 0; 236 237 } 238 239 MONITOR_LOCK(); 240 TAILQ_REMOVE(&udev_monitor_list, udm, link); 241 MONITOR_UNLOCK(); 242 243 udev_monitor_free(udm); 244 245 return 1; 246 } 247 248 static int 249 _parse_filter_prop(struct udev_monitor *udm, prop_array_t pa) 250 { 251 prop_string_t ps; 252 prop_number_t pn; 253 prop_object_iterator_t iter; 254 prop_dictionary_t dict; 255 struct event_filter *evf; 256 int error; 257 258 iter = prop_array_iterator(pa); 259 if (iter == NULL) 260 return -1; 261 262 while ((dict = prop_object_iterator_next(iter)) != NULL) { 263 evf = malloc(sizeof(struct event_filter)); 264 bzero(evf, sizeof(struct event_filter)); 265 if (evf == NULL) 266 goto error_alloc; 267 268 ps = prop_dictionary_get(dict, "key"); 269 if (ps == NULL) 270 goto error_out; 271 evf->key = prop_string_cstring(ps); 272 if (evf->key == NULL) 273 goto error_out; 274 275 pn = prop_dictionary_get(dict, "type"); 276 if (pn == NULL) 277 goto error_out_ps; 278 279 ps = prop_dictionary_get(dict, "expr"); 280 if (ps == NULL) 281 goto error_out_ps; 282 283 if (prop_dictionary_get(dict, "negative")) 284 evf->neg = 1; 285 else 286 evf->neg = 0; 287 288 evf->type = prop_number_integer_value(pn); 289 switch (evf->type) { 290 case EVENT_FILTER_TYPE_WILDCARD: 291 evf->wildcard_match = prop_string_cstring(ps); 292 if (evf->wildcard_match == NULL) 293 goto error_out_ps; 294 break; 295 296 case EVENT_FILTER_TYPE_REGEX: 297 error = regcomp(&evf->regex_match, prop_string_cstring_nocopy(ps), REG_ICASE | REG_NOSUB); 298 if (error) 299 goto error_out_ps; 300 break; 301 302 default: 303 goto error_out_ps; 304 } 305 306 pthread_mutex_lock(&udm->q_lock); 307 TAILQ_INSERT_TAIL(&udm->ev_filt, evf, link); 308 pthread_mutex_unlock(&udm->q_lock); 309 310 } 311 312 prop_object_iterator_release(iter); 313 return 0; 314 315 error_out_ps: 316 free(evf->key); 317 error_out: 318 free(evf); 319 error_alloc: 320 prop_object_iterator_release(iter); 321 return -1; 322 } 323 324 /* 325 Event filter format: 326 <array> 327 <dictionary> 328 <key>key</key> 329 <value>(e.g. kptr, devnum, ...)</value> 330 <key>type</key> 331 <value>(e.g. wildcard or regex)</value> 332 <key>expr</key> 333 <value>(regex)</value> 334 </dictionary> 335 ... repeat ... 336 </array> 337 */ 338 339 static int 340 match_filter(struct event_filter *evf, prop_dictionary_t ev_dict) 341 { 342 prop_object_t po; 343 prop_string_t ps; 344 prop_number_t pn; 345 char *str; 346 char buf[128]; 347 int ret; 348 349 if (ev_dict == NULL) 350 return 0; 351 352 prop_object_retain(ev_dict); 353 354 if ((po = prop_dictionary_get(ev_dict, evf->key)) == NULL) 355 goto no_match; 356 357 if (prop_object_type(po) == PROP_TYPE_STRING) { 358 ps = po; 359 str = __DECONST(char *, prop_string_cstring_nocopy(ps)); 360 } else if (prop_object_type(po) == PROP_TYPE_NUMBER) { 361 pn = po; 362 if (prop_number_unsigned(pn)) { 363 snprintf(buf, sizeof(buf), "%" PRIu64, prop_number_unsigned_integer_value(pn)); 364 } else { 365 snprintf(buf, sizeof(buf), "%" PRIi64, prop_number_integer_value(pn)); 366 } 367 str = buf; 368 } else { 369 syslog(LOG_DEBUG, "Unexpected type in match_filter: %d\n", prop_object_type(po)); 370 /* Unexpected type */ 371 goto no_match; 372 } 373 374 switch (evf->type) { 375 case EVENT_FILTER_TYPE_WILDCARD: 376 ret = WildCaseCmp(evf->wildcard_match, str); 377 378 if (ret != 0) 379 goto no_match; 380 381 break; 382 case EVENT_FILTER_TYPE_REGEX: 383 ret = regexec(&evf->regex_match, str, 0, NULL, 0); 384 385 if (ret != 0) 386 goto no_match; 387 break; 388 default: 389 goto no_match; 390 } 391 392 prop_object_release(ev_dict); 393 return 1; 394 395 no_match: 396 prop_object_release(ev_dict); 397 return 0; 398 } 399 400 int 401 match_event_filter(struct udev_monitor *udm, prop_dictionary_t ev_dict) 402 { 403 struct event_filter *evf; 404 405 pthread_mutex_lock(&udm->q_lock); 406 407 if (TAILQ_EMPTY(&udm->ev_filt)) 408 return 1; 409 410 TAILQ_FOREACH(evf, &udm->ev_filt, link) { 411 if ((evf->neg == 0 && !match_filter(evf, ev_dict)) || 412 (evf->neg == 1 && match_filter(evf, ev_dict))) { 413 pthread_mutex_unlock(&udm->q_lock); 414 return 0; 415 } 416 } 417 418 pthread_mutex_unlock(&udm->q_lock); 419 return 1; 420 } 421 422 static int 423 WildCaseCmp(const char *w, const char *s) 424 { 425 int i; 426 int c; 427 int slen = strlen(s); 428 const char **mary; 429 430 for (i = c = 0; w[i]; ++i) { 431 if (w[i] == '*') 432 ++c; 433 } 434 mary = malloc(sizeof(char *) * (c + 1)); 435 if (mary == NULL) 436 return -1; 437 438 for (i = 0; i < c; ++i) 439 mary[i] = s + slen; 440 i = wildCaseCmp(mary, 0, w, s); 441 free(mary); 442 return(i); 443 } 444 445 /* 446 * WildCaseCmp() - compare wild string to sane string, case insensitive 447 * 448 * Returns 0 on success, -1 on failure. 449 */ 450 static int 451 wildCaseCmp(const char **mary, int d, const char *w, const char *s) 452 { 453 int i; 454 455 /* 456 * skip fixed portion 457 */ 458 for (;;) { 459 switch(*w) { 460 case '*': 461 /* 462 * optimize terminator 463 */ 464 if (w[1] == 0) 465 return(0); 466 if (w[1] != '?' && w[1] != '*') { 467 /* 468 * optimize * followed by non-wild 469 */ 470 for (i = 0; s + i < mary[d]; ++i) { 471 if (s[i] == w[1] && wildCaseCmp(mary, d + 1, w + 1, s + i) == 0) 472 return(0); 473 } 474 } else { 475 /* 476 * less-optimal 477 */ 478 for (i = 0; s + i < mary[d]; ++i) { 479 if (wildCaseCmp(mary, d + 1, w + 1, s + i) == 0) 480 return(0); 481 } 482 } 483 mary[d] = s; 484 return(-1); 485 case '?': 486 if (*s == 0) 487 return(-1); 488 ++w; 489 ++s; 490 break; 491 default: 492 if (*w != *s) { 493 if (tolower(*w) != tolower(*s)) 494 return(-1); 495 } 496 if (*w == 0) /* terminator */ 497 return(0); 498 ++w; 499 ++s; 500 break; 501 } 502 } 503 /* not reached */ 504 return(-1); 505 } 506