1/* -*- mode: C; c-file-style: "gnu" -*- */ 2/* signals.c Bus signal connection implementation 3 * 4 * Copyright (C) 2003, 2005 Red Hat, Inc. 5 * 6 * Licensed under the Academic Free License version 2.1 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23#include "signals.h" 24#include "services.h" 25#include "utils.h" 26#include <dbus/dbus-marshal-validate.h> 27 28struct BusMatchRule 29{ 30 int refcount; /**< reference count */ 31 32 DBusConnection *matches_go_to; /**< Owner of the rule */ 33 34 unsigned int flags; /**< BusMatchFlags */ 35 36 int message_type; 37 char *interface; 38 char *member; 39 char *sender; 40 char *destination; 41 char *path; 42 43 char **args; 44 int args_len; 45}; 46 47BusMatchRule* 48bus_match_rule_new (DBusConnection *matches_go_to) 49{ 50 BusMatchRule *rule; 51 52 rule = dbus_new0 (BusMatchRule, 1); 53 if (rule == NULL) 54 return NULL; 55 56 rule->refcount = 1; 57 rule->matches_go_to = matches_go_to; 58 59#ifndef DBUS_BUILD_TESTS 60 _dbus_assert (rule->matches_go_to != NULL); 61#endif 62 63 return rule; 64} 65 66BusMatchRule * 67bus_match_rule_ref (BusMatchRule *rule) 68{ 69 _dbus_assert (rule->refcount > 0); 70 71 rule->refcount += 1; 72 73 return rule; 74} 75 76void 77bus_match_rule_unref (BusMatchRule *rule) 78{ 79 _dbus_assert (rule->refcount > 0); 80 81 rule->refcount -= 1; 82 if (rule->refcount == 0) 83 { 84 dbus_free (rule->interface); 85 dbus_free (rule->member); 86 dbus_free (rule->sender); 87 dbus_free (rule->destination); 88 dbus_free (rule->path); 89 90 /* can't use dbus_free_string_array() since there 91 * are embedded NULL 92 */ 93 if (rule->args) 94 { 95 int i; 96 97 i = 0; 98 while (i < rule->args_len) 99 { 100 if (rule->args[i]) 101 dbus_free (rule->args[i]); 102 ++i; 103 } 104 105 dbus_free (rule->args); 106 } 107 108 dbus_free (rule); 109 } 110} 111 112#ifdef DBUS_ENABLE_VERBOSE_MODE 113/* Note this function does not do escaping, so it's only 114 * good for debug spew at the moment 115 */ 116static char* 117match_rule_to_string (BusMatchRule *rule) 118{ 119 DBusString str; 120 char *ret; 121 122 if (!_dbus_string_init (&str)) 123 { 124 char *s; 125 while ((s = _dbus_strdup ("nomem")) == NULL) 126 ; /* only OK for debug spew... */ 127 return s; 128 } 129 130 if (rule->flags & BUS_MATCH_MESSAGE_TYPE) 131 { 132 /* FIXME make type readable */ 133 if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type)) 134 goto nomem; 135 } 136 137 if (rule->flags & BUS_MATCH_INTERFACE) 138 { 139 if (_dbus_string_get_length (&str) > 0) 140 { 141 if (!_dbus_string_append (&str, ",")) 142 goto nomem; 143 } 144 145 if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface)) 146 goto nomem; 147 } 148 149 if (rule->flags & BUS_MATCH_MEMBER) 150 { 151 if (_dbus_string_get_length (&str) > 0) 152 { 153 if (!_dbus_string_append (&str, ",")) 154 goto nomem; 155 } 156 157 if (!_dbus_string_append_printf (&str, "member='%s'", rule->member)) 158 goto nomem; 159 } 160 161 if (rule->flags & BUS_MATCH_PATH) 162 { 163 if (_dbus_string_get_length (&str) > 0) 164 { 165 if (!_dbus_string_append (&str, ",")) 166 goto nomem; 167 } 168 169 if (!_dbus_string_append_printf (&str, "path='%s'", rule->path)) 170 goto nomem; 171 } 172 173 if (rule->flags & BUS_MATCH_SENDER) 174 { 175 if (_dbus_string_get_length (&str) > 0) 176 { 177 if (!_dbus_string_append (&str, ",")) 178 goto nomem; 179 } 180 181 if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender)) 182 goto nomem; 183 } 184 185 if (rule->flags & BUS_MATCH_DESTINATION) 186 { 187 if (_dbus_string_get_length (&str) > 0) 188 { 189 if (!_dbus_string_append (&str, ",")) 190 goto nomem; 191 } 192 193 if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination)) 194 goto nomem; 195 } 196 197 if (rule->flags & BUS_MATCH_ARGS) 198 { 199 int i; 200 201 _dbus_assert (rule->args != NULL); 202 203 i = 0; 204 while (i < rule->args_len) 205 { 206 if (rule->args[i] != NULL) 207 { 208 if (_dbus_string_get_length (&str) > 0) 209 { 210 if (!_dbus_string_append (&str, ",")) 211 goto nomem; 212 } 213 214 if (!_dbus_string_append_printf (&str, 215 "arg%d='%s'", 216 i, 217 rule->args[i])) 218 goto nomem; 219 } 220 221 ++i; 222 } 223 } 224 225 if (!_dbus_string_steal_data (&str, &ret)) 226 goto nomem; 227 228 _dbus_string_free (&str); 229 return ret; 230 231 nomem: 232 _dbus_string_free (&str); 233 { 234 char *s; 235 while ((s = _dbus_strdup ("nomem")) == NULL) 236 ; /* only OK for debug spew... */ 237 return s; 238 } 239} 240#endif /* DBUS_ENABLE_VERBOSE_MODE */ 241 242dbus_bool_t 243bus_match_rule_set_message_type (BusMatchRule *rule, 244 int type) 245{ 246 rule->flags |= BUS_MATCH_MESSAGE_TYPE; 247 248 rule->message_type = type; 249 250 return TRUE; 251} 252 253dbus_bool_t 254bus_match_rule_set_interface (BusMatchRule *rule, 255 const char *interface) 256{ 257 char *new; 258 259 _dbus_assert (interface != NULL); 260 261 new = _dbus_strdup (interface); 262 if (new == NULL) 263 return FALSE; 264 265 rule->flags |= BUS_MATCH_INTERFACE; 266 dbus_free (rule->interface); 267 rule->interface = new; 268 269 return TRUE; 270} 271 272dbus_bool_t 273bus_match_rule_set_member (BusMatchRule *rule, 274 const char *member) 275{ 276 char *new; 277 278 _dbus_assert (member != NULL); 279 280 new = _dbus_strdup (member); 281 if (new == NULL) 282 return FALSE; 283 284 rule->flags |= BUS_MATCH_MEMBER; 285 dbus_free (rule->member); 286 rule->member = new; 287 288 return TRUE; 289} 290 291dbus_bool_t 292bus_match_rule_set_sender (BusMatchRule *rule, 293 const char *sender) 294{ 295 char *new; 296 297 _dbus_assert (sender != NULL); 298 299 new = _dbus_strdup (sender); 300 if (new == NULL) 301 return FALSE; 302 303 rule->flags |= BUS_MATCH_SENDER; 304 dbus_free (rule->sender); 305 rule->sender = new; 306 307 return TRUE; 308} 309 310dbus_bool_t 311bus_match_rule_set_destination (BusMatchRule *rule, 312 const char *destination) 313{ 314 char *new; 315 316 _dbus_assert (destination != NULL); 317 318 new = _dbus_strdup (destination); 319 if (new == NULL) 320 return FALSE; 321 322 rule->flags |= BUS_MATCH_DESTINATION; 323 dbus_free (rule->destination); 324 rule->destination = new; 325 326 return TRUE; 327} 328 329dbus_bool_t 330bus_match_rule_set_path (BusMatchRule *rule, 331 const char *path) 332{ 333 char *new; 334 335 _dbus_assert (path != NULL); 336 337 new = _dbus_strdup (path); 338 if (new == NULL) 339 return FALSE; 340 341 rule->flags |= BUS_MATCH_PATH; 342 dbus_free (rule->path); 343 rule->path = new; 344 345 return TRUE; 346} 347 348dbus_bool_t 349bus_match_rule_set_arg (BusMatchRule *rule, 350 int arg, 351 const char *value) 352{ 353 char *new; 354 355 _dbus_assert (value != NULL); 356 357 new = _dbus_strdup (value); 358 if (new == NULL) 359 return FALSE; 360 361 /* args_len is the number of args not including null termination 362 * in the char** 363 */ 364 if (arg >= rule->args_len) 365 { 366 char **new_args; 367 int new_args_len; 368 int i; 369 370 new_args_len = arg + 1; 371 372 /* add another + 1 here for null termination */ 373 new_args = dbus_realloc (rule->args, 374 sizeof(rule->args[0]) * (new_args_len + 1)); 375 if (new_args == NULL) 376 { 377 dbus_free (new); 378 return FALSE; 379 } 380 381 /* NULL the new slots */ 382 i = rule->args_len; 383 while (i <= new_args_len) /* <= for null termination */ 384 { 385 new_args[i] = NULL; 386 ++i; 387 } 388 389 rule->args = new_args; 390 rule->args_len = new_args_len; 391 } 392 393 rule->flags |= BUS_MATCH_ARGS; 394 395 dbus_free (rule->args[arg]); 396 rule->args[arg] = new; 397 398 /* NULL termination didn't get busted */ 399 _dbus_assert (rule->args[rule->args_len] == NULL); 400 401 return TRUE; 402} 403 404#define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r')) 405 406static dbus_bool_t 407find_key (const DBusString *str, 408 int start, 409 DBusString *key, 410 int *value_pos, 411 DBusError *error) 412{ 413 const char *p; 414 const char *s; 415 const char *key_start; 416 const char *key_end; 417 418 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 419 420 s = _dbus_string_get_const_data (str); 421 422 p = s + start; 423 424 while (*p && ISWHITE (*p)) 425 ++p; 426 427 key_start = p; 428 429 while (*p && *p != '=' && !ISWHITE (*p)) 430 ++p; 431 432 key_end = p; 433 434 while (*p && ISWHITE (*p)) 435 ++p; 436 437 if (key_start == key_end) 438 { 439 /* Empty match rules or trailing whitespace are OK */ 440 *value_pos = p - s; 441 return TRUE; 442 } 443 444 if (*p != '=') 445 { 446 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 447 "Match rule has a key with no subsequent '=' character"); 448 return FALSE; 449 } 450 ++p; 451 452 if (!_dbus_string_append_len (key, key_start, key_end - key_start)) 453 { 454 BUS_SET_OOM (error); 455 return FALSE; 456 } 457 458 *value_pos = p - s; 459 460 return TRUE; 461} 462 463static dbus_bool_t 464find_value (const DBusString *str, 465 int start, 466 const char *key, 467 DBusString *value, 468 int *value_end, 469 DBusError *error) 470{ 471 const char *p; 472 const char *s; 473 char quote_char; 474 int orig_len; 475 476 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 477 478 orig_len = _dbus_string_get_length (value); 479 480 s = _dbus_string_get_const_data (str); 481 482 p = s + start; 483 484 quote_char = '\0'; 485 486 while (*p) 487 { 488 if (quote_char == '\0') 489 { 490 switch (*p) 491 { 492 case '\0': 493 goto done; 494 495 case '\'': 496 quote_char = '\''; 497 goto next; 498 499 case ',': 500 ++p; 501 goto done; 502 503 case '\\': 504 quote_char = '\\'; 505 goto next; 506 507 default: 508 if (!_dbus_string_append_byte (value, *p)) 509 { 510 BUS_SET_OOM (error); 511 goto failed; 512 } 513 } 514 } 515 else if (quote_char == '\\') 516 { 517 /* \ only counts as an escape if escaping a quote mark */ 518 if (*p != '\'') 519 { 520 if (!_dbus_string_append_byte (value, '\\')) 521 { 522 BUS_SET_OOM (error); 523 goto failed; 524 } 525 } 526 527 if (!_dbus_string_append_byte (value, *p)) 528 { 529 BUS_SET_OOM (error); 530 goto failed; 531 } 532 533 quote_char = '\0'; 534 } 535 else 536 { 537 _dbus_assert (quote_char == '\''); 538 539 if (*p == '\'') 540 { 541 quote_char = '\0'; 542 } 543 else 544 { 545 if (!_dbus_string_append_byte (value, *p)) 546 { 547 BUS_SET_OOM (error); 548 goto failed; 549 } 550 } 551 } 552 553 next: 554 ++p; 555 } 556 557 done: 558 559 if (quote_char == '\\') 560 { 561 if (!_dbus_string_append_byte (value, '\\')) 562 { 563 BUS_SET_OOM (error); 564 goto failed; 565 } 566 } 567 else if (quote_char == '\'') 568 { 569 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 570 "Unbalanced quotation marks in match rule"); 571 goto failed; 572 } 573 else 574 _dbus_assert (quote_char == '\0'); 575 576 /* Zero-length values are allowed */ 577 578 *value_end = p - s; 579 580 return TRUE; 581 582 failed: 583 _DBUS_ASSERT_ERROR_IS_SET (error); 584 _dbus_string_set_length (value, orig_len); 585 return FALSE; 586} 587 588/* duplicates aren't allowed so the real legitimate max is only 6 or 589 * so. Leaving extra so we don't have to bother to update it. 590 * FIXME this is sort of busted now with arg matching, but we let 591 * you match on up to 10 args for now 592 */ 593#define MAX_RULE_TOKENS 16 594 595/* this is slightly too high level to be termed a "token" 596 * but let's not be pedantic. 597 */ 598typedef struct 599{ 600 char *key; 601 char *value; 602} RuleToken; 603 604static dbus_bool_t 605tokenize_rule (const DBusString *rule_text, 606 RuleToken tokens[MAX_RULE_TOKENS], 607 DBusError *error) 608{ 609 int i; 610 int pos; 611 DBusString key; 612 DBusString value; 613 dbus_bool_t retval; 614 615 retval = FALSE; 616 617 if (!_dbus_string_init (&key)) 618 { 619 BUS_SET_OOM (error); 620 return FALSE; 621 } 622 623 if (!_dbus_string_init (&value)) 624 { 625 _dbus_string_free (&key); 626 BUS_SET_OOM (error); 627 return FALSE; 628 } 629 630 i = 0; 631 pos = 0; 632 while (i < MAX_RULE_TOKENS && 633 pos < _dbus_string_get_length (rule_text)) 634 { 635 _dbus_assert (tokens[i].key == NULL); 636 _dbus_assert (tokens[i].value == NULL); 637 638 if (!find_key (rule_text, pos, &key, &pos, error)) 639 goto out; 640 641 if (_dbus_string_get_length (&key) == 0) 642 goto next; 643 644 if (!_dbus_string_steal_data (&key, &tokens[i].key)) 645 { 646 BUS_SET_OOM (error); 647 goto out; 648 } 649 650 if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error)) 651 goto out; 652 653 if (!_dbus_string_steal_data (&value, &tokens[i].value)) 654 { 655 BUS_SET_OOM (error); 656 goto out; 657 } 658 659 next: 660 ++i; 661 } 662 663 retval = TRUE; 664 665 out: 666 if (!retval) 667 { 668 i = 0; 669 while (tokens[i].key || tokens[i].value) 670 { 671 dbus_free (tokens[i].key); 672 dbus_free (tokens[i].value); 673 tokens[i].key = NULL; 674 tokens[i].value = NULL; 675 ++i; 676 } 677 } 678 679 _dbus_string_free (&key); 680 _dbus_string_free (&value); 681 682 return retval; 683} 684 685static dbus_bool_t 686bus_match_rule_parse_arg_match (BusMatchRule *rule, 687 const char *key, 688 const DBusString *value, 689 DBusError *error) 690{ 691 DBusString key_str; 692 unsigned long arg; 693 int end; 694 695 /* For now, arg0='foo' always implies that 'foo' is a 696 * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing 697 * if we wanted, which would specify another type, in which case 698 * arg0='5' would have the 5 parsed as an int rather than string. 699 */ 700 701 /* First we need to parse arg0 = 0, arg27 = 27 */ 702 703 _dbus_string_init_const (&key_str, key); 704 705 if (_dbus_string_get_length (&key_str) < 4) 706 { 707 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 708 "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key); 709 goto failed; 710 } 711 712 if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end) || 713 end != _dbus_string_get_length (&key_str)) 714 { 715 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 716 "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key); 717 goto failed; 718 } 719 720 /* If we didn't check this we could allocate a huge amount of RAM */ 721 if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER) 722 { 723 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 724 "Key '%s' in match rule has arg number %lu but the maximum is %d.\n", key, (unsigned long) arg, DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER); 725 goto failed; 726 } 727 728 if ((rule->flags & BUS_MATCH_ARGS) && 729 rule->args_len > (int) arg && 730 rule->args[arg] != NULL) 731 { 732 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 733 "Key '%s' specified twice in match rule\n", key); 734 goto failed; 735 } 736 737 if (!bus_match_rule_set_arg (rule, arg, 738 _dbus_string_get_const_data (value))) 739 { 740 BUS_SET_OOM (error); 741 goto failed; 742 } 743 744 return TRUE; 745 746 failed: 747 _DBUS_ASSERT_ERROR_IS_SET (error); 748 return FALSE; 749} 750 751/* 752 * The format is comma-separated with strings quoted with single quotes 753 * as for the shell (to escape a literal single quote, use '\''). 754 * 755 * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo', 756 * path='/bar/foo',destination=':452345.34' 757 * 758 */ 759BusMatchRule* 760bus_match_rule_parse (DBusConnection *matches_go_to, 761 const DBusString *rule_text, 762 DBusError *error) 763{ 764 BusMatchRule *rule; 765 RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */ 766 int i; 767 768 _DBUS_ASSERT_ERROR_IS_CLEAR (error); 769 770 if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH) 771 { 772 dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED, 773 "Match rule text is %d bytes, maximum is %d", 774 _dbus_string_get_length (rule_text), 775 DBUS_MAXIMUM_MATCH_RULE_LENGTH); 776 return NULL; 777 } 778 779 memset (tokens, '\0', sizeof (tokens)); 780 781 rule = bus_match_rule_new (matches_go_to); 782 if (rule == NULL) 783 { 784 BUS_SET_OOM (error); 785 goto failed; 786 } 787 788 if (!tokenize_rule (rule_text, tokens, error)) 789 goto failed; 790 791 i = 0; 792 while (tokens[i].key != NULL) 793 { 794 DBusString tmp_str; 795 int len; 796 const char *key = tokens[i].key; 797 const char *value = tokens[i].value; 798 799 _dbus_string_init_const (&tmp_str, value); 800 len = _dbus_string_get_length (&tmp_str); 801 802 if (strcmp (key, "type") == 0) 803 { 804 int t; 805 806 if (rule->flags & BUS_MATCH_MESSAGE_TYPE) 807 { 808 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 809 "Key %s specified twice in match rule\n", key); 810 goto failed; 811 } 812 813 t = dbus_message_type_from_string (value); 814 815 if (t == DBUS_MESSAGE_TYPE_INVALID) 816 { 817 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 818 "Invalid message type (%s) in match rule\n", value); 819 goto failed; 820 } 821 822 if (!bus_match_rule_set_message_type (rule, t)) 823 { 824 BUS_SET_OOM (error); 825 goto failed; 826 } 827 } 828 else if (strcmp (key, "sender") == 0) 829 { 830 if (rule->flags & BUS_MATCH_SENDER) 831 { 832 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 833 "Key %s specified twice in match rule\n", key); 834 goto failed; 835 } 836 837 if (!_dbus_validate_bus_name (&tmp_str, 0, len)) 838 { 839 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 840 "Sender name '%s' is invalid\n", value); 841 goto failed; 842 } 843 844 if (!bus_match_rule_set_sender (rule, value)) 845 { 846 BUS_SET_OOM (error); 847 goto failed; 848 } 849 } 850 else if (strcmp (key, "interface") == 0) 851 { 852 if (rule->flags & BUS_MATCH_INTERFACE) 853 { 854 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 855 "Key %s specified twice in match rule\n", key); 856 goto failed; 857 } 858 859 if (!_dbus_validate_interface (&tmp_str, 0, len)) 860 { 861 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 862 "Interface name '%s' is invalid\n", value); 863 goto failed; 864 } 865 866 if (!bus_match_rule_set_interface (rule, value)) 867 { 868 BUS_SET_OOM (error); 869 goto failed; 870 } 871 } 872 else if (strcmp (key, "member") == 0) 873 { 874 if (rule->flags & BUS_MATCH_MEMBER) 875 { 876 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 877 "Key %s specified twice in match rule\n", key); 878 goto failed; 879 } 880 881 if (!_dbus_validate_member (&tmp_str, 0, len)) 882 { 883 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 884 "Member name '%s' is invalid\n", value); 885 goto failed; 886 } 887 888 if (!bus_match_rule_set_member (rule, value)) 889 { 890 BUS_SET_OOM (error); 891 goto failed; 892 } 893 } 894 else if (strcmp (key, "path") == 0) 895 { 896 if (rule->flags & BUS_MATCH_PATH) 897 { 898 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 899 "Key %s specified twice in match rule\n", key); 900 goto failed; 901 } 902 903 if (!_dbus_validate_path (&tmp_str, 0, len)) 904 { 905 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 906 "Path '%s' is invalid\n", value); 907 goto failed; 908 } 909 910 if (!bus_match_rule_set_path (rule, value)) 911 { 912 BUS_SET_OOM (error); 913 goto failed; 914 } 915 } 916 else if (strcmp (key, "destination") == 0) 917 { 918 if (rule->flags & BUS_MATCH_DESTINATION) 919 { 920 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 921 "Key %s specified twice in match rule\n", key); 922 goto failed; 923 } 924 925 if (!_dbus_validate_bus_name (&tmp_str, 0, len)) 926 { 927 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 928 "Destination name '%s' is invalid\n", value); 929 goto failed; 930 } 931 932 if (!bus_match_rule_set_destination (rule, value)) 933 { 934 BUS_SET_OOM (error); 935 goto failed; 936 } 937 } 938 else if (strncmp (key, "arg", 3) == 0) 939 { 940 if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error)) 941 goto failed; 942 } 943 else 944 { 945 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID, 946 "Unknown key \"%s\" in match rule", 947 key); 948 goto failed; 949 } 950 951 ++i; 952 } 953 954 955 goto out; 956 957 failed: 958 _DBUS_ASSERT_ERROR_IS_SET (error); 959 if (rule) 960 { 961 bus_match_rule_unref (rule); 962 rule = NULL; 963 } 964 965 out: 966 967 i = 0; 968 while (tokens[i].key || tokens[i].value) 969 { 970 _dbus_assert (i < MAX_RULE_TOKENS); 971 dbus_free (tokens[i].key); 972 dbus_free (tokens[i].value); 973 ++i; 974 } 975 976 return rule; 977} 978 979struct BusMatchmaker 980{ 981 int refcount; 982 983 DBusList *all_rules; 984}; 985 986BusMatchmaker* 987bus_matchmaker_new (void) 988{ 989 BusMatchmaker *matchmaker; 990 991 matchmaker = dbus_new0 (BusMatchmaker, 1); 992 if (matchmaker == NULL) 993 return NULL; 994 995 matchmaker->refcount = 1; 996 997 return matchmaker; 998} 999 1000BusMatchmaker * 1001bus_matchmaker_ref (BusMatchmaker *matchmaker) 1002{ 1003 _dbus_assert (matchmaker->refcount > 0); 1004 1005 matchmaker->refcount += 1; 1006 1007 return matchmaker; 1008} 1009 1010void 1011bus_matchmaker_unref (BusMatchmaker *matchmaker) 1012{ 1013 _dbus_assert (matchmaker->refcount > 0); 1014 1015 matchmaker->refcount -= 1; 1016 if (matchmaker->refcount == 0) 1017 { 1018 while (matchmaker->all_rules != NULL) 1019 { 1020 BusMatchRule *rule; 1021 1022 rule = matchmaker->all_rules->data; 1023 bus_match_rule_unref (rule); 1024 _dbus_list_remove_link (&matchmaker->all_rules, 1025 matchmaker->all_rules); 1026 } 1027 1028 dbus_free (matchmaker); 1029 } 1030} 1031 1032/* The rule can't be modified after it's added. */ 1033dbus_bool_t 1034bus_matchmaker_add_rule (BusMatchmaker *matchmaker, 1035 BusMatchRule *rule) 1036{ 1037 _dbus_assert (bus_connection_is_active (rule->matches_go_to)); 1038 1039 if (!_dbus_list_append (&matchmaker->all_rules, rule)) 1040 return FALSE; 1041 1042 if (!bus_connection_add_match_rule (rule->matches_go_to, rule)) 1043 { 1044 _dbus_list_remove_last (&matchmaker->all_rules, rule); 1045 return FALSE; 1046 } 1047 1048 bus_match_rule_ref (rule); 1049 1050#ifdef DBUS_ENABLE_VERBOSE_MODE 1051 { 1052 char *s = match_rule_to_string (rule); 1053 1054 _dbus_verbose ("Added match rule %s to connection %p\n", 1055 s, rule->matches_go_to); 1056 dbus_free (s); 1057 } 1058#endif 1059 1060 return TRUE; 1061} 1062 1063static dbus_bool_t 1064match_rule_equal (BusMatchRule *a, 1065 BusMatchRule *b) 1066{ 1067 if (a->flags != b->flags) 1068 return FALSE; 1069 1070 if (a->matches_go_to != b->matches_go_to) 1071 return FALSE; 1072 1073 if ((a->flags & BUS_MATCH_MESSAGE_TYPE) && 1074 a->message_type != b->message_type) 1075 return FALSE; 1076 1077 if ((a->flags & BUS_MATCH_MEMBER) && 1078 strcmp (a->member, b->member) != 0) 1079 return FALSE; 1080 1081 if ((a->flags & BUS_MATCH_PATH) && 1082 strcmp (a->path, b->path) != 0) 1083 return FALSE; 1084 1085 if ((a->flags & BUS_MATCH_INTERFACE) && 1086 strcmp (a->interface, b->interface) != 0) 1087 return FALSE; 1088 1089 if ((a->flags & BUS_MATCH_SENDER) && 1090 strcmp (a->sender, b->sender) != 0) 1091 return FALSE; 1092 1093 if ((a->flags & BUS_MATCH_DESTINATION) && 1094 strcmp (a->destination, b->destination) != 0) 1095 return FALSE; 1096 1097 if (a->flags & BUS_MATCH_ARGS) 1098 { 1099 int i; 1100 1101 if (a->args_len != b->args_len) 1102 return FALSE; 1103 1104 i = 0; 1105 while (i < a->args_len) 1106 { 1107 if ((a->args[i] != NULL) != (b->args[i] != NULL)) 1108 return FALSE; 1109 1110 if (a->args[i] != NULL) 1111 { 1112 _dbus_assert (b->args[i] != NULL); 1113 if (strcmp (a->args[i], b->args[i]) != 0) 1114 return FALSE; 1115 } 1116 1117 ++i; 1118 } 1119 } 1120 1121 return TRUE; 1122} 1123 1124static void 1125bus_matchmaker_remove_rule_link (BusMatchmaker *matchmaker, 1126 DBusList *link) 1127{ 1128 BusMatchRule *rule = link->data; 1129 1130 bus_connection_remove_match_rule (rule->matches_go_to, rule); 1131 _dbus_list_remove_link (&matchmaker->all_rules, link); 1132 1133#ifdef DBUS_ENABLE_VERBOSE_MODE 1134 { 1135 char *s = match_rule_to_string (rule); 1136 1137 _dbus_verbose ("Removed match rule %s for connection %p\n", 1138 s, rule->matches_go_to); 1139 dbus_free (s); 1140 } 1141#endif 1142 1143 bus_match_rule_unref (rule); 1144} 1145 1146void 1147bus_matchmaker_remove_rule (BusMatchmaker *matchmaker, 1148 BusMatchRule *rule) 1149{ 1150 bus_connection_remove_match_rule (rule->matches_go_to, rule); 1151 _dbus_list_remove (&matchmaker->all_rules, rule); 1152 1153#ifdef DBUS_ENABLE_VERBOSE_MODE 1154 { 1155 char *s = match_rule_to_string (rule); 1156 1157 _dbus_verbose ("Removed match rule %s for connection %p\n", 1158 s, rule->matches_go_to); 1159 dbus_free (s); 1160 } 1161#endif 1162 1163 bus_match_rule_unref (rule); 1164} 1165 1166/* Remove a single rule which is equal to the given rule by value */ 1167dbus_bool_t 1168bus_matchmaker_remove_rule_by_value (BusMatchmaker *matchmaker, 1169 BusMatchRule *value, 1170 DBusError *error) 1171{ 1172 /* FIXME this is an unoptimized linear scan */ 1173 1174 DBusList *link; 1175 1176 /* we traverse backward because bus_connection_remove_match_rule() 1177 * removes the most-recently-added rule 1178 */ 1179 link = _dbus_list_get_last_link (&matchmaker->all_rules); 1180 while (link != NULL) 1181 { 1182 BusMatchRule *rule; 1183 DBusList *prev; 1184 1185 rule = link->data; 1186 prev = _dbus_list_get_prev_link (&matchmaker->all_rules, link); 1187 1188 if (match_rule_equal (rule, value)) 1189 { 1190 bus_matchmaker_remove_rule_link (matchmaker, link); 1191 break; 1192 } 1193 1194 link = prev; 1195 } 1196 1197 if (link == NULL) 1198 { 1199 dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND, 1200 "The given match rule wasn't found and can't be removed"); 1201 return FALSE; 1202 } 1203 1204 return TRUE; 1205} 1206 1207void 1208bus_matchmaker_disconnected (BusMatchmaker *matchmaker, 1209 DBusConnection *disconnected) 1210{ 1211 DBusList *link; 1212 1213 /* FIXME 1214 * 1215 * This scans all match rules on the bus. We could avoid that 1216 * for the rules belonging to the connection, since we keep 1217 * a list of those; but for the rules that just refer to 1218 * the connection we'd need to do something more elaborate. 1219 * 1220 */ 1221 1222 _dbus_assert (bus_connection_is_active (disconnected)); 1223 1224 link = _dbus_list_get_first_link (&matchmaker->all_rules); 1225 while (link != NULL) 1226 { 1227 BusMatchRule *rule; 1228 DBusList *next; 1229 1230 rule = link->data; 1231 next = _dbus_list_get_next_link (&matchmaker->all_rules, link); 1232 1233 if (rule->matches_go_to == disconnected) 1234 { 1235 bus_matchmaker_remove_rule_link (matchmaker, link); 1236 } 1237 else if (((rule->flags & BUS_MATCH_SENDER) && *rule->sender == ':') || 1238 ((rule->flags & BUS_MATCH_DESTINATION) && *rule->destination == ':')) 1239 { 1240 /* The rule matches to/from a base service, see if it's the 1241 * one being disconnected, since we know this service name 1242 * will never be recycled. 1243 */ 1244 const char *name; 1245 1246 name = bus_connection_get_name (disconnected); 1247 _dbus_assert (name != NULL); /* because we're an active connection */ 1248 1249 if (((rule->flags & BUS_MATCH_SENDER) && 1250 strcmp (rule->sender, name) == 0) || 1251 ((rule->flags & BUS_MATCH_DESTINATION) && 1252 strcmp (rule->destination, name) == 0)) 1253 { 1254 bus_matchmaker_remove_rule_link (matchmaker, link); 1255 } 1256 } 1257 1258 link = next; 1259 } 1260} 1261 1262static dbus_bool_t 1263connection_is_primary_owner (DBusConnection *connection, 1264 const char *service_name) 1265{ 1266 BusService *service; 1267 DBusString str; 1268 BusRegistry *registry; 1269 1270 _dbus_assert (connection != NULL); 1271 1272 registry = bus_connection_get_registry (connection); 1273 1274 _dbus_string_init_const (&str, service_name); 1275 service = bus_registry_lookup (registry, &str); 1276 1277 if (service == NULL) 1278 return FALSE; /* Service doesn't exist so connection can't own it. */ 1279 1280 return bus_service_get_primary_owners_connection (service) == connection; 1281} 1282 1283static dbus_bool_t 1284match_rule_matches (BusMatchRule *rule, 1285 DBusConnection *sender, 1286 DBusConnection *addressed_recipient, 1287 DBusMessage *message) 1288{ 1289 /* All features of the match rule are AND'd together, 1290 * so FALSE if any of them don't match. 1291 */ 1292 1293 /* sender/addressed_recipient of #NULL may mean bus driver, 1294 * or for addressed_recipient may mean a message with no 1295 * specific recipient (i.e. a signal) 1296 */ 1297 1298 if (rule->flags & BUS_MATCH_MESSAGE_TYPE) 1299 { 1300 _dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID); 1301 1302 if (rule->message_type != dbus_message_get_type (message)) 1303 return FALSE; 1304 } 1305 1306 if (rule->flags & BUS_MATCH_INTERFACE) 1307 { 1308 const char *iface; 1309 1310 _dbus_assert (rule->interface != NULL); 1311 1312 iface = dbus_message_get_interface (message); 1313 if (iface == NULL) 1314 return FALSE; 1315 1316 if (strcmp (iface, rule->interface) != 0) 1317 return FALSE; 1318 } 1319 1320 if (rule->flags & BUS_MATCH_MEMBER) 1321 { 1322 const char *member; 1323 1324 _dbus_assert (rule->member != NULL); 1325 1326 member = dbus_message_get_member (message); 1327 if (member == NULL) 1328 return FALSE; 1329 1330 if (strcmp (member, rule->member) != 0) 1331 return FALSE; 1332 } 1333 1334 if (rule->flags & BUS_MATCH_SENDER) 1335 { 1336 _dbus_assert (rule->sender != NULL); 1337 1338 if (sender == NULL) 1339 { 1340 if (strcmp (rule->sender, 1341 DBUS_SERVICE_DBUS) != 0) 1342 return FALSE; 1343 } 1344 else 1345 { 1346 if (!connection_is_primary_owner (sender, rule->sender)) 1347 return FALSE; 1348 } 1349 } 1350 1351 if (rule->flags & BUS_MATCH_DESTINATION) 1352 { 1353 const char *destination; 1354 1355 _dbus_assert (rule->destination != NULL); 1356 1357 destination = dbus_message_get_destination (message); 1358 if (destination == NULL) 1359 return FALSE; 1360 1361 if (addressed_recipient == NULL) 1362 { 1363 if (strcmp (rule->destination, 1364 DBUS_SERVICE_DBUS) != 0) 1365 return FALSE; 1366 } 1367 else 1368 { 1369 if (!connection_is_primary_owner (addressed_recipient, rule->destination)) 1370 return FALSE; 1371 } 1372 } 1373 1374 if (rule->flags & BUS_MATCH_PATH) 1375 { 1376 const char *path; 1377 1378 _dbus_assert (rule->path != NULL); 1379 1380 path = dbus_message_get_path (message); 1381 if (path == NULL) 1382 return FALSE; 1383 1384 if (strcmp (path, rule->path) != 0) 1385 return FALSE; 1386 } 1387 1388 if (rule->flags & BUS_MATCH_ARGS) 1389 { 1390 int i; 1391 DBusMessageIter iter; 1392 1393 _dbus_assert (rule->args != NULL); 1394 1395 dbus_message_iter_init (message, &iter); 1396 1397 i = 0; 1398 while (i < rule->args_len) 1399 { 1400 int current_type; 1401 const char *expected_arg; 1402 1403 expected_arg = rule->args[i]; 1404 1405 current_type = dbus_message_iter_get_arg_type (&iter); 1406 1407 if (expected_arg != NULL) 1408 { 1409 const char *actual_arg; 1410 1411 if (current_type != DBUS_TYPE_STRING) 1412 return FALSE; 1413 1414 actual_arg = NULL; 1415 dbus_message_iter_get_basic (&iter, &actual_arg); 1416 _dbus_assert (actual_arg != NULL); 1417 1418 if (strcmp (expected_arg, actual_arg) != 0) 1419 return FALSE; 1420 } 1421 1422 if (current_type != DBUS_TYPE_INVALID) 1423 dbus_message_iter_next (&iter); 1424 1425 ++i; 1426 } 1427 } 1428 1429 return TRUE; 1430} 1431 1432dbus_bool_t 1433bus_matchmaker_get_recipients (BusMatchmaker *matchmaker, 1434 BusConnections *connections, 1435 DBusConnection *sender, 1436 DBusConnection *addressed_recipient, 1437 DBusMessage *message, 1438 DBusList **recipients_p) 1439{ 1440 /* FIXME for now this is a wholly unoptimized linear search */ 1441 /* Guessing the important optimization is to skip the signal-related 1442 * match lists when processing method call and exception messages. 1443 * So separate match rule lists for signals? 1444 */ 1445 1446 DBusList *link; 1447 1448 _dbus_assert (*recipients_p == NULL); 1449 1450 /* This avoids sending same message to the same connection twice. 1451 * Purpose of the stamp instead of a bool is to avoid iterating over 1452 * all connections resetting the bool each time. 1453 */ 1454 bus_connections_increment_stamp (connections); 1455 1456 /* addressed_recipient is already receiving the message, don't add to list. 1457 * NULL addressed_recipient means either bus driver, or this is a signal 1458 * and thus lacks a specific addressed_recipient. 1459 */ 1460 if (addressed_recipient != NULL) 1461 bus_connection_mark_stamp (addressed_recipient); 1462 1463 link = _dbus_list_get_first_link (&matchmaker->all_rules); 1464 while (link != NULL) 1465 { 1466 BusMatchRule *rule; 1467 1468 rule = link->data; 1469 1470#ifdef DBUS_ENABLE_VERBOSE_MODE 1471 { 1472 char *s = match_rule_to_string (rule); 1473 1474 _dbus_verbose ("Checking whether message matches rule %s for connection %p\n", 1475 s, rule->matches_go_to); 1476 dbus_free (s); 1477 } 1478#endif 1479 1480 if (match_rule_matches (rule, 1481 sender, addressed_recipient, message)) 1482 { 1483 _dbus_verbose ("Rule matched\n"); 1484 1485 /* Append to the list if we haven't already */ 1486 if (bus_connection_mark_stamp (rule->matches_go_to)) 1487 { 1488 if (!_dbus_list_append (recipients_p, rule->matches_go_to)) 1489 goto nomem; 1490 } 1491#ifdef DBUS_ENABLE_VERBOSE_MODE 1492 else 1493 { 1494 _dbus_verbose ("Connection already receiving this message, so not adding again\n"); 1495 } 1496#endif /* DBUS_ENABLE_VERBOSE_MODE */ 1497 } 1498 1499 link = _dbus_list_get_next_link (&matchmaker->all_rules, link); 1500 } 1501 1502 return TRUE; 1503 1504 nomem: 1505 _dbus_list_clear (recipients_p); 1506 return FALSE; 1507} 1508 1509#ifdef DBUS_BUILD_TESTS 1510#include "test.h" 1511#include <stdlib.h> 1512 1513static BusMatchRule* 1514check_parse (dbus_bool_t should_succeed, 1515 const char *text) 1516{ 1517 BusMatchRule *rule; 1518 DBusString str; 1519 DBusError error; 1520 1521 dbus_error_init (&error); 1522 1523 _dbus_string_init_const (&str, text); 1524 1525 rule = bus_match_rule_parse (NULL, &str, &error); 1526 if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) 1527 { 1528 dbus_error_free (&error); 1529 return NULL; 1530 } 1531 1532 if (should_succeed && rule == NULL) 1533 { 1534 _dbus_warn ("Failed to parse: %s: %s: \"%s\"\n", 1535 error.name, error.message, 1536 _dbus_string_get_const_data (&str)); 1537 exit (1); 1538 } 1539 1540 if (!should_succeed && rule != NULL) 1541 { 1542 _dbus_warn ("Failed to fail to parse: \"%s\"\n", 1543 _dbus_string_get_const_data (&str)); 1544 exit (1); 1545 } 1546 1547 dbus_error_free (&error); 1548 1549 return rule; 1550} 1551 1552static void 1553assert_large_rule (BusMatchRule *rule) 1554{ 1555 _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE); 1556 _dbus_assert (rule->flags & BUS_MATCH_SENDER); 1557 _dbus_assert (rule->flags & BUS_MATCH_INTERFACE); 1558 _dbus_assert (rule->flags & BUS_MATCH_MEMBER); 1559 _dbus_assert (rule->flags & BUS_MATCH_DESTINATION); 1560 _dbus_assert (rule->flags & BUS_MATCH_PATH); 1561 1562 _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL); 1563 _dbus_assert (rule->interface != NULL); 1564 _dbus_assert (rule->member != NULL); 1565 _dbus_assert (rule->sender != NULL); 1566 _dbus_assert (rule->destination != NULL); 1567 _dbus_assert (rule->path != NULL); 1568 1569 _dbus_assert (strcmp (rule->interface, "org.freedesktop.DBusInterface") == 0); 1570 _dbus_assert (strcmp (rule->sender, "org.freedesktop.DBusSender") == 0); 1571 _dbus_assert (strcmp (rule->member, "Foo") == 0); 1572 _dbus_assert (strcmp (rule->path, "/bar/foo") == 0); 1573 _dbus_assert (strcmp (rule->destination, ":452345.34") == 0); 1574} 1575 1576static dbus_bool_t 1577test_parsing (void *data) 1578{ 1579 BusMatchRule *rule; 1580 1581 rule = check_parse (TRUE, "type='signal',sender='org.freedesktop.DBusSender',interface='org.freedesktop.DBusInterface',member='Foo',path='/bar/foo',destination=':452345.34'"); 1582 if (rule != NULL) 1583 { 1584 assert_large_rule (rule); 1585 bus_match_rule_unref (rule); 1586 } 1587 1588 /* With extra whitespace and useless quotes */ 1589 rule = check_parse (TRUE, " type='signal', \tsender='org.freedes''ktop.DBusSender', interface='org.freedesktop.DBusInterface''''', \tmember='Foo',path='/bar/foo',destination=':452345.34'''''"); 1590 if (rule != NULL) 1591 { 1592 assert_large_rule (rule); 1593 bus_match_rule_unref (rule); 1594 } 1595 1596 1597 /* A simple signal connection */ 1598 rule = check_parse (TRUE, "type='signal',path='/foo',interface='org.Bar'"); 1599 if (rule != NULL) 1600 { 1601 _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE); 1602 _dbus_assert (rule->flags & BUS_MATCH_INTERFACE); 1603 _dbus_assert (rule->flags & BUS_MATCH_PATH); 1604 1605 _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL); 1606 _dbus_assert (rule->interface != NULL); 1607 _dbus_assert (rule->path != NULL); 1608 1609 _dbus_assert (strcmp (rule->interface, "org.Bar") == 0); 1610 _dbus_assert (strcmp (rule->path, "/foo") == 0); 1611 1612 bus_match_rule_unref (rule); 1613 } 1614 1615 /* argN */ 1616 rule = check_parse (TRUE, "arg0='foo'"); 1617 if (rule != NULL) 1618 { 1619 _dbus_assert (rule->flags == BUS_MATCH_ARGS); 1620 _dbus_assert (rule->args != NULL); 1621 _dbus_assert (rule->args_len == 1); 1622 _dbus_assert (rule->args[0] != NULL); 1623 _dbus_assert (rule->args[1] == NULL); 1624 _dbus_assert (strcmp (rule->args[0], "foo") == 0); 1625 1626 bus_match_rule_unref (rule); 1627 } 1628 1629 rule = check_parse (TRUE, "arg1='foo'"); 1630 if (rule != NULL) 1631 { 1632 _dbus_assert (rule->flags == BUS_MATCH_ARGS); 1633 _dbus_assert (rule->args != NULL); 1634 _dbus_assert (rule->args_len == 2); 1635 _dbus_assert (rule->args[0] == NULL); 1636 _dbus_assert (rule->args[1] != NULL); 1637 _dbus_assert (rule->args[2] == NULL); 1638 _dbus_assert (strcmp (rule->args[1], "foo") == 0); 1639 1640 bus_match_rule_unref (rule); 1641 } 1642 1643 rule = check_parse (TRUE, "arg2='foo'"); 1644 if (rule != NULL) 1645 { 1646 _dbus_assert (rule->flags == BUS_MATCH_ARGS); 1647 _dbus_assert (rule->args != NULL); 1648 _dbus_assert (rule->args_len == 3); 1649 _dbus_assert (rule->args[0] == NULL); 1650 _dbus_assert (rule->args[1] == NULL); 1651 _dbus_assert (rule->args[2] != NULL); 1652 _dbus_assert (rule->args[3] == NULL); 1653 _dbus_assert (strcmp (rule->args[2], "foo") == 0); 1654 1655 bus_match_rule_unref (rule); 1656 } 1657 1658 rule = check_parse (TRUE, "arg40='foo'"); 1659 if (rule != NULL) 1660 { 1661 _dbus_assert (rule->flags == BUS_MATCH_ARGS); 1662 _dbus_assert (rule->args != NULL); 1663 _dbus_assert (rule->args_len == 41); 1664 _dbus_assert (rule->args[0] == NULL); 1665 _dbus_assert (rule->args[1] == NULL); 1666 _dbus_assert (rule->args[40] != NULL); 1667 _dbus_assert (rule->args[41] == NULL); 1668 _dbus_assert (strcmp (rule->args[40], "foo") == 0); 1669 1670 bus_match_rule_unref (rule); 1671 } 1672 1673 rule = check_parse (TRUE, "arg63='foo'"); 1674 if (rule != NULL) 1675 { 1676 _dbus_assert (rule->flags == BUS_MATCH_ARGS); 1677 _dbus_assert (rule->args != NULL); 1678 _dbus_assert (rule->args_len == 64); 1679 _dbus_assert (rule->args[0] == NULL); 1680 _dbus_assert (rule->args[1] == NULL); 1681 _dbus_assert (rule->args[63] != NULL); 1682 _dbus_assert (rule->args[64] == NULL); 1683 _dbus_assert (strcmp (rule->args[63], "foo") == 0); 1684 1685 bus_match_rule_unref (rule); 1686 } 1687 1688 /* Too-large argN */ 1689 rule = check_parse (FALSE, "arg300='foo'"); 1690 _dbus_assert (rule == NULL); 1691 rule = check_parse (FALSE, "arg64='foo'"); 1692 _dbus_assert (rule == NULL); 1693 1694 /* No N in argN */ 1695 rule = check_parse (FALSE, "arg='foo'"); 1696 _dbus_assert (rule == NULL); 1697 rule = check_parse (FALSE, "argv='foo'"); 1698 _dbus_assert (rule == NULL); 1699 rule = check_parse (FALSE, "arg3junk='foo'"); 1700 _dbus_assert (rule == NULL); 1701 rule = check_parse (FALSE, "argument='foo'"); 1702 _dbus_assert (rule == NULL); 1703 1704 /* Reject duplicates */ 1705 rule = check_parse (FALSE, "type='signal',type='method_call'"); 1706 _dbus_assert (rule == NULL); 1707 1708 /* Duplicates with the argN code */ 1709 rule = check_parse (FALSE, "arg0='foo',arg0='bar'"); 1710 _dbus_assert (rule == NULL); 1711 rule = check_parse (FALSE, "arg3='foo',arg3='bar'"); 1712 _dbus_assert (rule == NULL); 1713 rule = check_parse (FALSE, "arg30='foo',arg30='bar'"); 1714 _dbus_assert (rule == NULL); 1715 1716 /* Reject broken keys */ 1717 rule = check_parse (FALSE, "blah='signal'"); 1718 _dbus_assert (rule == NULL); 1719 1720 /* Reject broken values */ 1721 rule = check_parse (FALSE, "type='chouin'"); 1722 _dbus_assert (rule == NULL); 1723 rule = check_parse (FALSE, "interface='abc@def++'"); 1724 _dbus_assert (rule == NULL); 1725 rule = check_parse (FALSE, "service='youpi'"); 1726 _dbus_assert (rule == NULL); 1727 1728 /* Allow empty rule */ 1729 rule = check_parse (TRUE, ""); 1730 if (rule != NULL) 1731 { 1732 _dbus_assert (rule->flags == 0); 1733 1734 bus_match_rule_unref (rule); 1735 } 1736 1737 /* All-whitespace rule is the same as empty */ 1738 rule = check_parse (TRUE, " \t"); 1739 if (rule != NULL) 1740 { 1741 _dbus_assert (rule->flags == 0); 1742 1743 bus_match_rule_unref (rule); 1744 } 1745 1746 /* But with non-whitespace chars and no =value, it's not OK */ 1747 rule = check_parse (FALSE, "type"); 1748 _dbus_assert (rule == NULL); 1749 1750 return TRUE; 1751} 1752 1753static struct { 1754 const char *first; 1755 const char *second; 1756} equality_tests[] = { 1757 { "type='signal'", "type='signal'" }, 1758 { "type='signal',interface='foo.bar'", "interface='foo.bar',type='signal'" }, 1759 { "type='signal',member='bar'", "member='bar',type='signal'" }, 1760 { "type='method_call',sender=':1.0'", "sender=':1.0',type='method_call'" }, 1761 { "type='method_call',destination=':1.0'", "destination=':1.0',type='method_call'" }, 1762 { "type='method_call',path='/foo/bar'", "path='/foo/bar',type='method_call'" }, 1763 { "type='method_call',arg0='blah'", "arg0='blah',type='method_call'" }, 1764 { "type='method_call',arg0='boo'", "arg0='boo',type='method_call'" }, 1765 { "type='method_call',arg0='blah',arg1='baz'", "arg0='blah',arg1='baz',type='method_call'" }, 1766 { "type='method_call',arg3='foosh'", "arg3='foosh',type='method_call'" }, 1767 { "arg3='fool'", "arg3='fool'" }, 1768 { "member='food'", "member='food'" } 1769}; 1770 1771static void 1772test_equality (void) 1773{ 1774 int i; 1775 1776 i = 0; 1777 while (i < _DBUS_N_ELEMENTS (equality_tests)) 1778 { 1779 BusMatchRule *first; 1780 BusMatchRule *second; 1781 int j; 1782 1783 first = check_parse (TRUE, equality_tests[i].first); 1784 _dbus_assert (first != NULL); 1785 second = check_parse (TRUE, equality_tests[i].second); 1786 _dbus_assert (second != NULL); 1787 1788 if (!match_rule_equal (first, second)) 1789 { 1790 _dbus_warn ("rule %s and %s should have been equal\n", 1791 equality_tests[i].first, 1792 equality_tests[i].second); 1793 exit (1); 1794 } 1795 1796 bus_match_rule_unref (second); 1797 1798 /* Check that the rule is not equal to any of the 1799 * others besides its pair match 1800 */ 1801 j = 0; 1802 while (j < _DBUS_N_ELEMENTS (equality_tests)) 1803 { 1804 if (i != j) 1805 { 1806 second = check_parse (TRUE, equality_tests[j].second); 1807 1808 if (match_rule_equal (first, second)) 1809 { 1810 _dbus_warn ("rule %s and %s should not have been equal\n", 1811 equality_tests[i].first, 1812 equality_tests[j].second); 1813 exit (1); 1814 } 1815 1816 bus_match_rule_unref (second); 1817 } 1818 1819 ++j; 1820 } 1821 1822 bus_match_rule_unref (first); 1823 1824 ++i; 1825 } 1826} 1827 1828static const char* 1829should_match_message_1[] = { 1830 "type='signal'", 1831 "member='Frobated'", 1832 "arg0='foobar'", 1833 "type='signal',member='Frobated'", 1834 "type='signal',member='Frobated',arg0='foobar'", 1835 "member='Frobated',arg0='foobar'", 1836 "type='signal',arg0='foobar'", 1837 NULL 1838}; 1839 1840static const char* 1841should_not_match_message_1[] = { 1842 "type='method_call'", 1843 "type='error'", 1844 "type='method_return'", 1845 "type='signal',member='Oopsed'", 1846 "arg0='blah'", 1847 "arg1='foobar'", 1848 "arg2='foobar'", 1849 "arg3='foobar'", 1850 "arg0='3'", 1851 "arg1='3'", 1852 "arg0='foobar',arg1='abcdef'", 1853 "arg0='foobar',arg1='abcdef',arg2='abcdefghi',arg3='abcdefghi',arg4='abcdefghi'", 1854 "arg0='foobar',arg1='abcdef',arg4='abcdefghi',arg3='abcdefghi',arg2='abcdefghi'", 1855 NULL 1856}; 1857 1858static void 1859check_matches (dbus_bool_t expected_to_match, 1860 int number, 1861 DBusMessage *message, 1862 const char *rule_text) 1863{ 1864 BusMatchRule *rule; 1865 dbus_bool_t matched; 1866 1867 rule = check_parse (TRUE, rule_text); 1868 _dbus_assert (rule != NULL); 1869 1870 /* We can't test sender/destination rules since we pass NULL here */ 1871 matched = match_rule_matches (rule, NULL, NULL, message); 1872 1873 if (matched != expected_to_match) 1874 { 1875 _dbus_warn ("Expected rule %s to %s message %d, failed\n", 1876 rule_text, expected_to_match ? 1877 "match" : "not match", number); 1878 exit (1); 1879 } 1880 1881 bus_match_rule_unref (rule); 1882} 1883 1884static void 1885check_matching (DBusMessage *message, 1886 int number, 1887 const char **should_match, 1888 const char **should_not_match) 1889{ 1890 int i; 1891 1892 i = 0; 1893 while (should_match[i] != NULL) 1894 { 1895 check_matches (TRUE, number, message, should_match[i]); 1896 ++i; 1897 } 1898 1899 i = 0; 1900 while (should_not_match[i] != NULL) 1901 { 1902 check_matches (FALSE, number, message, should_not_match[i]); 1903 ++i; 1904 } 1905} 1906 1907static void 1908test_matching (void) 1909{ 1910 DBusMessage *message1; 1911 const char *v_STRING; 1912 dbus_int32_t v_INT32; 1913 1914 message1 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL); 1915 _dbus_assert (message1 != NULL); 1916 if (!dbus_message_set_member (message1, "Frobated")) 1917 _dbus_assert_not_reached ("oom"); 1918 1919 v_STRING = "foobar"; 1920 v_INT32 = 3; 1921 if (!dbus_message_append_args (message1, 1922 DBUS_TYPE_STRING, &v_STRING, 1923 DBUS_TYPE_INT32, &v_INT32, 1924 NULL)) 1925 _dbus_assert_not_reached ("oom"); 1926 1927 check_matching (message1, 1, 1928 should_match_message_1, 1929 should_not_match_message_1); 1930 1931 dbus_message_unref (message1); 1932} 1933 1934dbus_bool_t 1935bus_signals_test (const DBusString *test_data_dir) 1936{ 1937 BusMatchmaker *matchmaker; 1938 1939 matchmaker = bus_matchmaker_new (); 1940 bus_matchmaker_ref (matchmaker); 1941 bus_matchmaker_unref (matchmaker); 1942 bus_matchmaker_unref (matchmaker); 1943 1944 if (!_dbus_test_oom_handling ("parsing match rules", test_parsing, NULL)) 1945 _dbus_assert_not_reached ("Parsing match rules test failed"); 1946 1947 test_equality (); 1948 1949 test_matching (); 1950 1951 return TRUE; 1952} 1953 1954#endif /* DBUS_BUILD_TESTS */ 1955 1956