sbin/udevd/udevd_monitor.c

   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 }