tools/lib/traceevent/parse-filter.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  * Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   4  *
   5  */
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <stdarg.h>
  10 #include <errno.h>
  11 #include <sys/types.h>
  12
  13 #include "event-parse.h"
  14 #include "event-parse-local.h"
  15 #include "event-utils.h"
  16
  17 #define COMM "COMM"
  18 #define CPU "CPU"
  19
  20 static struct tep_format_field comm = {
  21         .name = "COMM",
  22 };
  23
  24 static struct tep_format_field cpu = {
  25         .name = "CPU",
  26 };
  27
  28 struct event_list {
  29         struct event_list       *next;
  30         struct tep_event        *event;
  31 };
  32
  33 static void show_error(char *error_buf, const char *fmt, ...)
  34 {
  35         unsigned long long index;
  36         const char *input;
  37         va_list ap;
  38         int len;
  39         int i;
  40
  41         input = tep_get_input_buf();
  42         index = tep_get_input_buf_ptr();
  43         len = input ? strlen(input) : 0;
  44
  45         if (len) {
  46                 strcpy(error_buf, input);
  47                 error_buf[len] = '\n';
  48                 for (i = 1; i < len && i < index; i++)
  49                         error_buf[len+i] = ' ';
  50                 error_buf[len + i] = '^';
  51                 error_buf[len + i + 1] = '\n';
  52                 len += i+2;
  53         }
  54
  55         va_start(ap, fmt);
  56         vsnprintf(error_buf + len, TEP_FILTER_ERROR_BUFSZ - len, fmt, ap);
  57         va_end(ap);
  58 }
  59
  60 static void free_token(char *token)
  61 {
  62         tep_free_token(token);
  63 }
  64
  65 static enum tep_event_type read_token(char **tok)
  66 {
  67         enum tep_event_type type;
  68         char *token = NULL;
  69
  70         do {
  71                 free_token(token);
  72                 type = tep_read_token(&token);
  73         } while (type == TEP_EVENT_NEWLINE || type == TEP_EVENT_SPACE);
  74
  75         /* If token is = or ! check to see if the next char is ~ */
  76         if (token &&
  77             (strcmp(token, "=") == 0 || strcmp(token, "!") == 0) &&
  78             tep_peek_char() == '~') {
  79                 /* append it */
  80                 *tok = malloc(3);
  81                 if (*tok == NULL) {
  82                         free_token(token);
  83                         return TEP_EVENT_ERROR;
  84                 }
  85                 sprintf(*tok, "%c%c", *token, '~');
  86                 free_token(token);
  87                 /* Now remove the '~' from the buffer */
  88                 tep_read_token(&token);
  89                 free_token(token);
  90         } else
  91                 *tok = token;
  92
  93         return type;
  94 }
  95
  96 static int filter_cmp(const void *a, const void *b)
  97 {
  98         const struct tep_filter_type *ea = a;
  99         const struct tep_filter_type *eb = b;
 100
 101         if (ea->event_id < eb->event_id)
 102                 return -1;
 103
 104         if (ea->event_id > eb->event_id)
 105                 return 1;
 106
 107         return 0;
 108 }
 109
 110 static struct tep_filter_type *
 111 find_filter_type(struct tep_event_filter *filter, int id)
 112 {
 113         struct tep_filter_type *filter_type;
 114         struct tep_filter_type key;
 115
 116         key.event_id = id;
 117
 118         filter_type = bsearch(&key, filter->event_filters,
 119                               filter->filters,
 120                               sizeof(*filter->event_filters),
 121                               filter_cmp);
 122
 123         return filter_type;
 124 }
 125
 126 static struct tep_filter_type *
 127 add_filter_type(struct tep_event_filter *filter, int id)
 128 {
 129         struct tep_filter_type *filter_type;
 130         int i;
 131
 132         filter_type = find_filter_type(filter, id);
 133         if (filter_type)
 134                 return filter_type;
 135
 136         filter_type = realloc(filter->event_filters,
 137                               sizeof(*filter->event_filters) *
 138                               (filter->filters + 1));
 139         if (!filter_type)
 140                 return NULL;
 141
 142         filter->event_filters = filter_type;
 143
 144         for (i = 0; i < filter->filters; i++) {
 145                 if (filter->event_filters[i].event_id > id)
 146                         break;
 147         }
 148
 149         if (i < filter->filters)
 150                 memmove(&filter->event_filters[i+1],
 151                         &filter->event_filters[i],
 152                         sizeof(*filter->event_filters) *
 153                         (filter->filters - i));
 154
 155         filter_type = &filter->event_filters[i];
 156         filter_type->event_id = id;
 157         filter_type->event = tep_find_event(filter->tep, id);
 158         filter_type->filter = NULL;
 159
 160         filter->filters++;
 161
 162         return filter_type;
 163 }
 164
 165 /**
 166  * tep_filter_alloc - create a new event filter
 167  * @tep: The tep that this filter is associated with
 168  */
 169 struct tep_event_filter *tep_filter_alloc(struct tep_handle *tep)
 170 {
 171         struct tep_event_filter *filter;
 172
 173         filter = malloc(sizeof(*filter));
 174         if (filter == NULL)
 175                 return NULL;
 176
 177         memset(filter, 0, sizeof(*filter));
 178         filter->tep = tep;
 179         tep_ref(tep);
 180
 181         return filter;
 182 }
 183
 184 static struct tep_filter_arg *allocate_arg(void)
 185 {
 186         return calloc(1, sizeof(struct tep_filter_arg));
 187 }
 188
 189 static void free_arg(struct tep_filter_arg *arg)
 190 {
 191         if (!arg)
 192                 return;
 193
 194         switch (arg->type) {
 195         case TEP_FILTER_ARG_NONE:
 196         case TEP_FILTER_ARG_BOOLEAN:
 197                 break;
 198
 199         case TEP_FILTER_ARG_NUM:
 200                 free_arg(arg->num.left);
 201                 free_arg(arg->num.right);
 202                 break;
 203
 204         case TEP_FILTER_ARG_EXP:
 205                 free_arg(arg->exp.left);
 206                 free_arg(arg->exp.right);
 207                 break;
 208
 209         case TEP_FILTER_ARG_STR:
 210                 free(arg->str.val);
 211                 regfree(&arg->str.reg);
 212                 free(arg->str.buffer);
 213                 break;
 214
 215         case TEP_FILTER_ARG_VALUE:
 216                 if (arg->value.type == TEP_FILTER_STRING ||
 217                     arg->value.type == TEP_FILTER_CHAR)
 218                         free(arg->value.str);
 219                 break;
 220
 221         case TEP_FILTER_ARG_OP:
 222                 free_arg(arg->op.left);
 223                 free_arg(arg->op.right);
 224         default:
 225                 break;
 226         }
 227
 228         free(arg);
 229 }
 230
 231 static int add_event(struct event_list **events,
 232                      struct tep_event *event)
 233 {
 234         struct event_list *list;
 235
 236         list = malloc(sizeof(*list));
 237         if (list == NULL)
 238                 return -1;
 239
 240         list->next = *events;
 241         *events = list;
 242         list->event = event;
 243         return 0;
 244 }
 245
 246 static int event_match(struct tep_event *event,
 247                        regex_t *sreg, regex_t *ereg)
 248 {
 249         if (sreg) {
 250                 return !regexec(sreg, event->system, 0, NULL, 0) &&
 251                         !regexec(ereg, event->name, 0, NULL, 0);
 252         }
 253
 254         return !regexec(ereg, event->system, 0, NULL, 0) ||
 255                 !regexec(ereg, event->name, 0, NULL, 0);
 256 }
 257
 258 static enum tep_errno
 259 find_event(struct tep_handle *tep, struct event_list **events,
 260            char *sys_name, char *event_name)
 261 {
 262         struct tep_event *event;
 263         regex_t ereg;
 264         regex_t sreg;
 265         int match = 0;
 266         int fail = 0;
 267         char *reg;
 268         int ret;
 269         int i;
 270
 271         if (!event_name) {
 272                 /* if no name is given, then swap sys and name */
 273                 event_name = sys_name;
 274                 sys_name = NULL;
 275         }
 276
 277         ret = asprintf(&reg, "^%s$", event_name);
 278         if (ret < 0)
 279                 return TEP_ERRNO__MEM_ALLOC_FAILED;
 280
 281         ret = regcomp(&ereg, reg, REG_ICASE|REG_NOSUB);
 282         free(reg);
 283
 284         if (ret)
 285                 return TEP_ERRNO__INVALID_EVENT_NAME;
 286
 287         if (sys_name) {
 288                 ret = asprintf(&reg, "^%s$", sys_name);
 289                 if (ret < 0) {
 290                         regfree(&ereg);
 291                         return TEP_ERRNO__MEM_ALLOC_FAILED;
 292                 }
 293
 294                 ret = regcomp(&sreg, reg, REG_ICASE|REG_NOSUB);
 295                 free(reg);
 296                 if (ret) {
 297                         regfree(&ereg);
 298                         return TEP_ERRNO__INVALID_EVENT_NAME;
 299                 }
 300         }
 301
 302         for (i = 0; i < tep->nr_events; i++) {
 303                 event = tep->events[i];
 304                 if (event_match(event, sys_name ? &sreg : NULL, &ereg)) {
 305                         match = 1;
 306                         if (add_event(events, event) < 0) {
 307                                 fail = 1;
 308                                 break;
 309                         }
 310                 }
 311         }
 312
 313         regfree(&ereg);
 314         if (sys_name)
 315                 regfree(&sreg);
 316
 317         if (!match)
 318                 return TEP_ERRNO__EVENT_NOT_FOUND;
 319         if (fail)
 320                 return TEP_ERRNO__MEM_ALLOC_FAILED;
 321
 322         return 0;
 323 }
 324
 325 static void free_events(struct event_list *events)
 326 {
 327         struct event_list *event;
 328
 329         while (events) {
 330                 event = events;
 331                 events = events->next;
 332                 free(event);
 333         }
 334 }
 335
 336 static enum tep_errno
 337 create_arg_item(struct tep_event *event, const char *token,
 338                 enum tep_event_type type, struct tep_filter_arg **parg, char *error_str)
 339 {
 340         struct tep_format_field *field;
 341         struct tep_filter_arg *arg;
 342
 343         arg = allocate_arg();
 344         if (arg == NULL) {
 345                 show_error(error_str, "failed to allocate filter arg");
 346                 return TEP_ERRNO__MEM_ALLOC_FAILED;
 347         }
 348
 349         switch (type) {
 350
 351         case TEP_EVENT_SQUOTE:
 352         case TEP_EVENT_DQUOTE:
 353                 arg->type = TEP_FILTER_ARG_VALUE;
 354                 arg->value.type =
 355                         type == TEP_EVENT_DQUOTE ? TEP_FILTER_STRING : TEP_FILTER_CHAR;
 356                 arg->value.str = strdup(token);
 357                 if (!arg->value.str) {
 358                         free_arg(arg);
 359                         show_error(error_str, "failed to allocate string filter arg");
 360                         return TEP_ERRNO__MEM_ALLOC_FAILED;
 361                 }
 362                 break;
 363         case TEP_EVENT_ITEM:
 364                 /* if it is a number, then convert it */
 365                 if (isdigit(token[0])) {
 366                         arg->type = TEP_FILTER_ARG_VALUE;
 367                         arg->value.type = TEP_FILTER_NUMBER;
 368                         arg->value.val = strtoull(token, NULL, 0);
 369                         break;
 370                 }
 371                 /* Consider this a field */
 372                 field = tep_find_any_field(event, token);
 373                 if (!field) {
 374                         /* If token is 'COMM' or 'CPU' then it is special */
 375                         if (strcmp(token, COMM) == 0) {
 376                                 field = &comm;
 377                         } else if (strcmp(token, CPU) == 0) {
 378                                 field = &cpu;
 379                         } else {
 380                                 /* not a field, Make it false */
 381                                 arg->type = TEP_FILTER_ARG_BOOLEAN;
 382                                 arg->boolean.value = TEP_FILTER_FALSE;
 383                                 break;
 384                         }
 385                 }
 386                 arg->type = TEP_FILTER_ARG_FIELD;
 387                 arg->field.field = field;
 388                 break;
 389         default:
 390                 free_arg(arg);
 391                 show_error(error_str, "expected a value but found %s", token);
 392                 return TEP_ERRNO__UNEXPECTED_TYPE;
 393         }
 394         *parg = arg;
 395         return 0;
 396 }
 397
 398 static struct tep_filter_arg *
 399 create_arg_op(enum tep_filter_op_type btype)
 400 {
 401         struct tep_filter_arg *arg;
 402
 403         arg = allocate_arg();
 404         if (!arg)
 405                 return NULL;
 406
 407         arg->type = TEP_FILTER_ARG_OP;
 408         arg->op.type = btype;
 409
 410         return arg;
 411 }
 412
 413 static struct tep_filter_arg *
 414 create_arg_exp(enum tep_filter_exp_type etype)
 415 {
 416         struct tep_filter_arg *arg;
 417
 418         arg = allocate_arg();
 419         if (!arg)
 420                 return NULL;
 421
 422         arg->type = TEP_FILTER_ARG_EXP;
 423         arg->exp.type = etype;
 424
 425         return arg;
 426 }
 427
 428 static struct tep_filter_arg *
 429 create_arg_cmp(enum tep_filter_cmp_type ctype)
 430 {
 431         struct tep_filter_arg *arg;
 432
 433         arg = allocate_arg();
 434         if (!arg)
 435                 return NULL;
 436
 437         /* Use NUM and change if necessary */
 438         arg->type = TEP_FILTER_ARG_NUM;
 439         arg->num.type = ctype;
 440
 441         return arg;
 442 }
 443
 444 static enum tep_errno
 445 add_right(struct tep_filter_arg *op, struct tep_filter_arg *arg, char *error_str)
 446 {
 447         struct tep_filter_arg *left;
 448         char *str;
 449         int op_type;
 450         int ret;
 451
 452         switch (op->type) {
 453         case TEP_FILTER_ARG_EXP:
 454                 if (op->exp.right)
 455                         goto out_fail;
 456                 op->exp.right = arg;
 457                 break;
 458
 459         case TEP_FILTER_ARG_OP:
 460                 if (op->op.right)
 461                         goto out_fail;
 462                 op->op.right = arg;
 463                 break;
 464
 465         case TEP_FILTER_ARG_NUM:
 466                 if (op->op.right)
 467                         goto out_fail;
 468                 /*
 469                  * The arg must be num, str, or field
 470                  */
 471                 switch (arg->type) {
 472                 case TEP_FILTER_ARG_VALUE:
 473                 case TEP_FILTER_ARG_FIELD:
 474                         break;
 475                 default:
 476                         show_error(error_str, "Illegal rvalue");
 477                         return TEP_ERRNO__ILLEGAL_RVALUE;
 478                 }
 479
 480                 /*
 481                  * Depending on the type, we may need to
 482                  * convert this to a string or regex.
 483                  */
 484                 switch (arg->value.type) {
 485                 case TEP_FILTER_CHAR:
 486                         /*
 487                          * A char should be converted to number if
 488                          * the string is 1 byte, and the compare
 489                          * is not a REGEX.
 490                          */
 491                         if (strlen(arg->value.str) == 1 &&
 492                             op->num.type != TEP_FILTER_CMP_REGEX &&
 493                             op->num.type != TEP_FILTER_CMP_NOT_REGEX) {
 494                                 arg->value.type = TEP_FILTER_NUMBER;
 495                                 goto do_int;
 496                         }
 497                         /* fall through */
 498                 case TEP_FILTER_STRING:
 499
 500                         /* convert op to a string arg */
 501                         op_type = op->num.type;
 502                         left = op->num.left;
 503                         str = arg->value.str;
 504
 505                         /* reset the op for the new field */
 506                         memset(op, 0, sizeof(*op));
 507
 508                         /*
 509                          * If left arg was a field not found then
 510                          * NULL the entire op.
 511                          */
 512                         if (left->type == TEP_FILTER_ARG_BOOLEAN) {
 513                                 free_arg(left);
 514                                 free_arg(arg);
 515                                 op->type = TEP_FILTER_ARG_BOOLEAN;
 516                                 op->boolean.value = TEP_FILTER_FALSE;
 517                                 break;
 518                         }
 519
 520                         /* Left arg must be a field */
 521                         if (left->type != TEP_FILTER_ARG_FIELD) {
 522                                 show_error(error_str,
 523                                            "Illegal lvalue for string comparison");
 524                                 return TEP_ERRNO__ILLEGAL_LVALUE;
 525                         }
 526
 527                         /* Make sure this is a valid string compare */
 528                         switch (op_type) {
 529                         case TEP_FILTER_CMP_EQ:
 530                                 op_type = TEP_FILTER_CMP_MATCH;
 531                                 break;
 532                         case TEP_FILTER_CMP_NE:
 533                                 op_type = TEP_FILTER_CMP_NOT_MATCH;
 534                                 break;
 535
 536                         case TEP_FILTER_CMP_REGEX:
 537                         case TEP_FILTER_CMP_NOT_REGEX:
 538                                 ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);
 539                                 if (ret) {
 540                                         show_error(error_str,
 541                                                    "RegEx '%s' did not compute",
 542                                                    str);
 543                                         return TEP_ERRNO__INVALID_REGEX;
 544                                 }
 545                                 break;
 546                         default:
 547                                 show_error(error_str,
 548                                            "Illegal comparison for string");
 549                                 return TEP_ERRNO__ILLEGAL_STRING_CMP;
 550                         }
 551
 552                         op->type = TEP_FILTER_ARG_STR;
 553                         op->str.type = op_type;
 554                         op->str.field = left->field.field;
 555                         op->str.val = strdup(str);
 556                         if (!op->str.val) {
 557                                 show_error(error_str, "Failed to allocate string filter");
 558                                 return TEP_ERRNO__MEM_ALLOC_FAILED;
 559                         }
 560                         /*
 561                          * Need a buffer to copy data for tests
 562                          */
 563                         op->str.buffer = malloc(op->str.field->size + 1);
 564                         if (!op->str.buffer) {
 565                                 show_error(error_str, "Failed to allocate string filter");
 566                                 return TEP_ERRNO__MEM_ALLOC_FAILED;
 567                         }
 568                         /* Null terminate this buffer */
 569                         op->str.buffer[op->str.field->size] = 0;
 570
 571                         /* We no longer have left or right args */
 572                         free_arg(arg);
 573                         free_arg(left);
 574
 575                         break;
 576
 577                 case TEP_FILTER_NUMBER:
 578
 579  do_int:
 580                         switch (op->num.type) {
 581                         case TEP_FILTER_CMP_REGEX:
 582                         case TEP_FILTER_CMP_NOT_REGEX:
 583                                 show_error(error_str,
 584                                            "Op not allowed with integers");
 585                                 return TEP_ERRNO__ILLEGAL_INTEGER_CMP;
 586
 587                         default:
 588                                 break;
 589                         }
 590
 591                         /* numeric compare */
 592                         op->num.right = arg;
 593                         break;
 594                 default:
 595                         goto out_fail;
 596                 }
 597                 break;
 598         default:
 599                 goto out_fail;
 600         }
 601
 602         return 0;
 603
 604  out_fail:
 605         show_error(error_str, "Syntax error");
 606         return TEP_ERRNO__SYNTAX_ERROR;
 607 }
 608
 609 static struct tep_filter_arg *
 610 rotate_op_right(struct tep_filter_arg *a, struct tep_filter_arg *b)
 611 {
 612         struct tep_filter_arg *arg;
 613
 614         arg = a->op.right;
 615         a->op.right = b;
 616         return arg;
 617 }
 618
 619 static enum tep_errno add_left(struct tep_filter_arg *op, struct tep_filter_arg *arg)
 620 {
 621         switch (op->type) {
 622         case TEP_FILTER_ARG_EXP:
 623                 if (arg->type == TEP_FILTER_ARG_OP)
 624                         arg = rotate_op_right(arg, op);
 625                 op->exp.left = arg;
 626                 break;
 627
 628         case TEP_FILTER_ARG_OP:
 629                 op->op.left = arg;
 630                 break;
 631         case TEP_FILTER_ARG_NUM:
 632                 if (arg->type == TEP_FILTER_ARG_OP)
 633                         arg = rotate_op_right(arg, op);
 634
 635                 /* left arg of compares must be a field */
 636                 if (arg->type != TEP_FILTER_ARG_FIELD &&
 637                     arg->type != TEP_FILTER_ARG_BOOLEAN)
 638                         return TEP_ERRNO__INVALID_ARG_TYPE;
 639                 op->num.left = arg;
 640                 break;
 641         default:
 642                 return TEP_ERRNO__INVALID_ARG_TYPE;
 643         }
 644         return 0;
 645 }
 646
 647 enum op_type {
 648         OP_NONE,
 649         OP_BOOL,
 650         OP_NOT,
 651         OP_EXP,
 652         OP_CMP,
 653 };
 654
 655 static enum op_type process_op(const char *token,
 656                                enum tep_filter_op_type *btype,
 657                                enum tep_filter_cmp_type *ctype,
 658                                enum tep_filter_exp_type *etype)
 659 {
 660         *btype = TEP_FILTER_OP_NOT;
 661         *etype = TEP_FILTER_EXP_NONE;
 662         *ctype = TEP_FILTER_CMP_NONE;
 663
 664         if (strcmp(token, "&&") == 0)
 665                 *btype = TEP_FILTER_OP_AND;
 666         else if (strcmp(token, "||") == 0)
 667                 *btype = TEP_FILTER_OP_OR;
 668         else if (strcmp(token, "!") == 0)
 669                 return OP_NOT;
 670
 671         if (*btype != TEP_FILTER_OP_NOT)
 672                 return OP_BOOL;
 673
 674         /* Check for value expressions */
 675         if (strcmp(token, "+") == 0) {
 676                 *etype = TEP_FILTER_EXP_ADD;
 677         } else if (strcmp(token, "-") == 0) {
 678                 *etype = TEP_FILTER_EXP_SUB;
 679         } else if (strcmp(token, "*") == 0) {
 680                 *etype = TEP_FILTER_EXP_MUL;
 681         } else if (strcmp(token, "/") == 0) {
 682                 *etype = TEP_FILTER_EXP_DIV;
 683         } else if (strcmp(token, "%") == 0) {
 684                 *etype = TEP_FILTER_EXP_MOD;
 685         } else if (strcmp(token, ">>") == 0) {
 686                 *etype = TEP_FILTER_EXP_RSHIFT;
 687         } else if (strcmp(token, "<<") == 0) {
 688                 *etype = TEP_FILTER_EXP_LSHIFT;
 689         } else if (strcmp(token, "&") == 0) {
 690                 *etype = TEP_FILTER_EXP_AND;
 691         } else if (strcmp(token, "|") == 0) {
 692                 *etype = TEP_FILTER_EXP_OR;
 693         } else if (strcmp(token, "^") == 0) {
 694                 *etype = TEP_FILTER_EXP_XOR;
 695         } else if (strcmp(token, "~") == 0)
 696                 *etype = TEP_FILTER_EXP_NOT;
 697
 698         if (*etype != TEP_FILTER_EXP_NONE)
 699                 return OP_EXP;
 700
 701         /* Check for compares */
 702         if (strcmp(token, "==") == 0)
 703                 *ctype = TEP_FILTER_CMP_EQ;
 704         else if (strcmp(token, "!=") == 0)
 705                 *ctype = TEP_FILTER_CMP_NE;
 706         else if (strcmp(token, "<") == 0)
 707                 *ctype = TEP_FILTER_CMP_LT;
 708         else if (strcmp(token, ">") == 0)
 709                 *ctype = TEP_FILTER_CMP_GT;
 710         else if (strcmp(token, "<=") == 0)
 711                 *ctype = TEP_FILTER_CMP_LE;
 712         else if (strcmp(token, ">=") == 0)
 713                 *ctype = TEP_FILTER_CMP_GE;
 714         else if (strcmp(token, "=~") == 0)
 715                 *ctype = TEP_FILTER_CMP_REGEX;
 716         else if (strcmp(token, "!~") == 0)
 717                 *ctype = TEP_FILTER_CMP_NOT_REGEX;
 718         else
 719                 return OP_NONE;
 720
 721         return OP_CMP;
 722 }
 723
 724 static int check_op_done(struct tep_filter_arg *arg)
 725 {
 726         switch (arg->type) {
 727         case TEP_FILTER_ARG_EXP:
 728                 return arg->exp.right != NULL;
 729
 730         case TEP_FILTER_ARG_OP:
 731                 return arg->op.right != NULL;
 732
 733         case TEP_FILTER_ARG_NUM:
 734                 return arg->num.right != NULL;
 735
 736         case TEP_FILTER_ARG_STR:
 737                 /* A string conversion is always done */
 738                 return 1;
 739
 740         case TEP_FILTER_ARG_BOOLEAN:
 741                 /* field not found, is ok */
 742                 return 1;
 743
 744         default:
 745                 return 0;
 746         }
 747 }
 748
 749 enum filter_vals {
 750         FILTER_VAL_NORM,
 751         FILTER_VAL_FALSE,
 752         FILTER_VAL_TRUE,
 753 };
 754
 755 static enum tep_errno
 756 reparent_op_arg(struct tep_filter_arg *parent, struct tep_filter_arg *old_child,
 757                 struct tep_filter_arg *arg, char *error_str)
 758 {
 759         struct tep_filter_arg *other_child;
 760         struct tep_filter_arg **ptr;
 761
 762         if (parent->type != TEP_FILTER_ARG_OP &&
 763             arg->type != TEP_FILTER_ARG_OP) {
 764                 show_error(error_str, "can not reparent other than OP");
 765                 return TEP_ERRNO__REPARENT_NOT_OP;
 766         }
 767
 768         /* Get the sibling */
 769         if (old_child->op.right == arg) {
 770                 ptr = &old_child->op.right;
 771                 other_child = old_child->op.left;
 772         } else if (old_child->op.left == arg) {
 773                 ptr = &old_child->op.left;
 774                 other_child = old_child->op.right;
 775         } else {
 776                 show_error(error_str, "Error in reparent op, find other child");
 777                 return TEP_ERRNO__REPARENT_FAILED;
 778         }
 779
 780         /* Detach arg from old_child */
 781         *ptr = NULL;
 782
 783         /* Check for root */
 784         if (parent == old_child) {
 785                 free_arg(other_child);
 786                 *parent = *arg;
 787                 /* Free arg without recussion */
 788                 free(arg);
 789                 return 0;
 790         }
 791
 792         if (parent->op.right == old_child)
 793                 ptr = &parent->op.right;
 794         else if (parent->op.left == old_child)
 795                 ptr = &parent->op.left;
 796         else {
 797                 show_error(error_str, "Error in reparent op");
 798                 return TEP_ERRNO__REPARENT_FAILED;
 799         }
 800
 801         *ptr = arg;
 802
 803         free_arg(old_child);
 804         return 0;
 805 }
 806
 807 /* Returns either filter_vals (success) or tep_errno (failfure) */
 808 static int test_arg(struct tep_filter_arg *parent, struct tep_filter_arg *arg,
 809                     char *error_str)
 810 {
 811         int lval, rval;
 812
 813         switch (arg->type) {
 814
 815                 /* bad case */
 816         case TEP_FILTER_ARG_BOOLEAN:
 817                 return FILTER_VAL_FALSE + arg->boolean.value;
 818
 819                 /* good cases: */
 820         case TEP_FILTER_ARG_STR:
 821         case TEP_FILTER_ARG_VALUE:
 822         case TEP_FILTER_ARG_FIELD:
 823                 return FILTER_VAL_NORM;
 824
 825         case TEP_FILTER_ARG_EXP:
 826                 lval = test_arg(arg, arg->exp.left, error_str);
 827                 if (lval != FILTER_VAL_NORM)
 828                         return lval;
 829                 rval = test_arg(arg, arg->exp.right, error_str);
 830                 if (rval != FILTER_VAL_NORM)
 831                         return rval;
 832                 return FILTER_VAL_NORM;
 833
 834         case TEP_FILTER_ARG_NUM:
 835                 lval = test_arg(arg, arg->num.left, error_str);
 836                 if (lval != FILTER_VAL_NORM)
 837                         return lval;
 838                 rval = test_arg(arg, arg->num.right, error_str);
 839                 if (rval != FILTER_VAL_NORM)
 840                         return rval;
 841                 return FILTER_VAL_NORM;
 842
 843         case TEP_FILTER_ARG_OP:
 844                 if (arg->op.type != TEP_FILTER_OP_NOT) {
 845                         lval = test_arg(arg, arg->op.left, error_str);
 846                         switch (lval) {
 847                         case FILTER_VAL_NORM:
 848                                 break;
 849                         case FILTER_VAL_TRUE:
 850                                 if (arg->op.type == TEP_FILTER_OP_OR)
 851                                         return FILTER_VAL_TRUE;
 852                                 rval = test_arg(arg, arg->op.right, error_str);
 853                                 if (rval != FILTER_VAL_NORM)
 854                                         return rval;
 855
 856                                 return reparent_op_arg(parent, arg, arg->op.right,
 857                                                        error_str);
 858
 859                         case FILTER_VAL_FALSE:
 860                                 if (arg->op.type == TEP_FILTER_OP_AND)
 861                                         return FILTER_VAL_FALSE;
 862                                 rval = test_arg(arg, arg->op.right, error_str);
 863                                 if (rval != FILTER_VAL_NORM)
 864                                         return rval;
 865
 866                                 return reparent_op_arg(parent, arg, arg->op.right,
 867                                                        error_str);
 868
 869                         default:
 870                                 return lval;
 871                         }
 872                 }
 873
 874                 rval = test_arg(arg, arg->op.right, error_str);
 875                 switch (rval) {
 876                 case FILTER_VAL_NORM:
 877                 default:
 878                         break;
 879
 880                 case FILTER_VAL_TRUE:
 881                         if (arg->op.type == TEP_FILTER_OP_OR)
 882                                 return FILTER_VAL_TRUE;
 883                         if (arg->op.type == TEP_FILTER_OP_NOT)
 884                                 return FILTER_VAL_FALSE;
 885
 886                         return reparent_op_arg(parent, arg, arg->op.left,
 887                                                error_str);
 888
 889                 case FILTER_VAL_FALSE:
 890                         if (arg->op.type == TEP_FILTER_OP_AND)
 891                                 return FILTER_VAL_FALSE;
 892                         if (arg->op.type == TEP_FILTER_OP_NOT)
 893                                 return FILTER_VAL_TRUE;
 894
 895                         return reparent_op_arg(parent, arg, arg->op.left,
 896                                                error_str);
 897                 }
 898
 899                 return rval;
 900         default:
 901                 show_error(error_str, "bad arg in filter tree");
 902                 return TEP_ERRNO__BAD_FILTER_ARG;
 903         }
 904         return FILTER_VAL_NORM;
 905 }
 906
 907 /* Remove any unknown event fields */
 908 static int collapse_tree(struct tep_filter_arg *arg,
 909                          struct tep_filter_arg **arg_collapsed, char *error_str)
 910 {
 911         int ret;
 912
 913         ret = test_arg(arg, arg, error_str);
 914         switch (ret) {
 915         case FILTER_VAL_NORM:
 916                 break;
 917
 918         case FILTER_VAL_TRUE:
 919         case FILTER_VAL_FALSE:
 920                 free_arg(arg);
 921                 arg = allocate_arg();
 922                 if (arg) {
 923                         arg->type = TEP_FILTER_ARG_BOOLEAN;
 924                         arg->boolean.value = ret == FILTER_VAL_TRUE;
 925                 } else {
 926                         show_error(error_str, "Failed to allocate filter arg");
 927                         ret = TEP_ERRNO__MEM_ALLOC_FAILED;
 928                 }
 929                 break;
 930
 931         default:
 932                 /* test_arg() already set the error_str */
 933                 free_arg(arg);
 934                 arg = NULL;
 935                 break;
 936         }
 937
 938         *arg_collapsed = arg;
 939         return ret;
 940 }
 941
 942 static enum tep_errno
 943 process_filter(struct tep_event *event, struct tep_filter_arg **parg,
 944                char *error_str, int not)
 945 {
 946         enum tep_event_type type;
 947         char *token = NULL;
 948         struct tep_filter_arg *current_op = NULL;
 949         struct tep_filter_arg *current_exp = NULL;
 950         struct tep_filter_arg *left_item = NULL;
 951         struct tep_filter_arg *arg = NULL;
 952         enum op_type op_type;
 953         enum tep_filter_op_type btype;
 954         enum tep_filter_exp_type etype;
 955         enum tep_filter_cmp_type ctype;
 956         enum tep_errno ret;
 957
 958         *parg = NULL;
 959
 960         do {
 961                 free(token);
 962                 type = read_token(&token);
 963                 switch (type) {
 964                 case TEP_EVENT_SQUOTE:
 965                 case TEP_EVENT_DQUOTE:
 966                 case TEP_EVENT_ITEM:
 967                         ret = create_arg_item(event, token, type, &arg, error_str);
 968                         if (ret < 0)
 969                                 goto fail;
 970                         if (!left_item)
 971                                 left_item = arg;
 972                         else if (current_exp) {
 973                                 ret = add_right(current_exp, arg, error_str);
 974                                 if (ret < 0)
 975                                         goto fail;
 976                                 left_item = NULL;
 977                                 /* Not's only one one expression */
 978                                 if (not) {
 979                                         arg = NULL;
 980                                         if (current_op)
 981                                                 goto fail_syntax;
 982                                         free(token);
 983                                         *parg = current_exp;
 984                                         return 0;
 985                                 }
 986                         } else
 987                                 goto fail_syntax;
 988                         arg = NULL;
 989                         break;
 990
 991                 case TEP_EVENT_DELIM:
 992                         if (*token == ',') {
 993                                 show_error(error_str, "Illegal token ','");
 994                                 ret = TEP_ERRNO__ILLEGAL_TOKEN;
 995                                 goto fail;
 996                         }
 997
 998                         if (*token == '(') {
 999                                 if (left_item) {
1000                                         show_error(error_str,
1001                                                    "Open paren can not come after item");
1002                                         ret = TEP_ERRNO__INVALID_PAREN;
1003                                         goto fail;
1004                                 }
1005                                 if (current_exp) {
1006                                         show_error(error_str,
1007                                                    "Open paren can not come after expression");
1008                                         ret = TEP_ERRNO__INVALID_PAREN;
1009                                         goto fail;
1010                                 }
1011
1012                                 ret = process_filter(event, &arg, error_str, 0);
1013                                 if (ret != TEP_ERRNO__UNBALANCED_PAREN) {
1014                                         if (ret == 0) {
1015                                                 show_error(error_str,
1016                                                            "Unbalanced number of '('");
1017                                                 ret = TEP_ERRNO__UNBALANCED_PAREN;
1018                                         }
1019                                         goto fail;
1020                                 }
1021                                 ret = 0;
1022
1023                                 /* A not wants just one expression */
1024                                 if (not) {
1025                                         if (current_op)
1026                                                 goto fail_syntax;
1027                                         *parg = arg;
1028                                         return 0;
1029                                 }
1030
1031                                 if (current_op)
1032                                         ret = add_right(current_op, arg, error_str);
1033                                 else
1034                                         current_exp = arg;
1035
1036                                 if (ret < 0)
1037                                         goto fail;
1038
1039                         } else { /* ')' */
1040                                 if (!current_op && !current_exp)
1041                                         goto fail_syntax;
1042
1043                                 /* Make sure everything is finished at this level */
1044                                 if (current_exp && !check_op_done(current_exp))
1045                                         goto fail_syntax;
1046                                 if (current_op && !check_op_done(current_op))
1047                                         goto fail_syntax;
1048
1049                                 if (current_op)
1050                                         *parg = current_op;
1051                                 else
1052                                         *parg = current_exp;
1053                                 free(token);
1054                                 return TEP_ERRNO__UNBALANCED_PAREN;
1055                         }
1056                         break;
1057
1058                 case TEP_EVENT_OP:
1059                         op_type = process_op(token, &btype, &ctype, &etype);
1060
1061                         /* All expect a left arg except for NOT */
1062                         switch (op_type) {
1063                         case OP_BOOL:
1064                                 /* Logic ops need a left expression */
1065                                 if (!current_exp && !current_op)
1066                                         goto fail_syntax;
1067                                 /* fall through */
1068                         case OP_NOT:
1069                                 /* logic only processes ops and exp */
1070                                 if (left_item)
1071                                         goto fail_syntax;
1072                                 break;
1073                         case OP_EXP:
1074                         case OP_CMP:
1075                                 if (!left_item)
1076                                         goto fail_syntax;
1077                                 break;
1078                         case OP_NONE:
1079                                 show_error(error_str,
1080                                            "Unknown op token %s", token);
1081                                 ret = TEP_ERRNO__UNKNOWN_TOKEN;
1082                                 goto fail;
1083                         }
1084
1085                         ret = 0;
1086                         switch (op_type) {
1087                         case OP_BOOL:
1088                                 arg = create_arg_op(btype);
1089                                 if (arg == NULL)
1090                                         goto fail_alloc;
1091                                 if (current_op)
1092                                         ret = add_left(arg, current_op);
1093                                 else
1094                                         ret = add_left(arg, current_exp);
1095                                 current_op = arg;
1096                                 current_exp = NULL;
1097                                 break;
1098
1099                         case OP_NOT:
1100                                 arg = create_arg_op(btype);
1101                                 if (arg == NULL)
1102                                         goto fail_alloc;
1103                                 if (current_op)
1104                                         ret = add_right(current_op, arg, error_str);
1105                                 if (ret < 0)
1106                                         goto fail;
1107                                 current_exp = arg;
1108                                 ret = process_filter(event, &arg, error_str, 1);
1109                                 if (ret < 0)
1110                                         goto fail;
1111                                 ret = add_right(current_exp, arg, error_str);
1112                                 if (ret < 0)
1113                                         goto fail;
1114                                 break;
1115
1116                         case OP_EXP:
1117                         case OP_CMP:
1118                                 if (op_type == OP_EXP)
1119                                         arg = create_arg_exp(etype);
1120                                 else
1121                                         arg = create_arg_cmp(ctype);
1122                                 if (arg == NULL)
1123                                         goto fail_alloc;
1124
1125                                 if (current_op)
1126                                         ret = add_right(current_op, arg, error_str);
1127                                 if (ret < 0)
1128                                         goto fail;
1129                                 ret = add_left(arg, left_item);
1130                                 if (ret < 0) {
1131                                         arg = NULL;
1132                                         goto fail_syntax;
1133                                 }
1134                                 current_exp = arg;
1135                                 break;
1136                         default:
1137                                 break;
1138                         }
1139                         arg = NULL;
1140                         if (ret < 0)
1141                                 goto fail_syntax;
1142                         break;
1143                 case TEP_EVENT_NONE:
1144                         break;
1145                 case TEP_EVENT_ERROR:
1146                         goto fail_alloc;
1147                 default:
1148                         goto fail_syntax;
1149                 }
1150         } while (type != TEP_EVENT_NONE);
1151
1152         if (!current_op && !current_exp)
1153                 goto fail_syntax;
1154
1155         if (!current_op)
1156                 current_op = current_exp;
1157
1158         ret = collapse_tree(current_op, parg, error_str);
1159         /* collapse_tree() may free current_op, and updates parg accordingly */
1160         current_op = NULL;
1161         if (ret < 0)
1162                 goto fail;
1163
1164         free(token);
1165         return 0;
1166
1167  fail_alloc:
1168         show_error(error_str, "failed to allocate filter arg");
1169         ret = TEP_ERRNO__MEM_ALLOC_FAILED;
1170         goto fail;
1171  fail_syntax:
1172         show_error(error_str, "Syntax error");
1173         ret = TEP_ERRNO__SYNTAX_ERROR;
1174  fail:
1175         free_arg(current_op);
1176         free_arg(current_exp);
1177         free_arg(arg);
1178         free(token);
1179         return ret;
1180 }
1181
1182 static enum tep_errno
1183 process_event(struct tep_event *event, const char *filter_str,
1184               struct tep_filter_arg **parg, char *error_str)
1185 {
1186         int ret;
1187
1188         tep_buffer_init(filter_str, strlen(filter_str));
1189
1190         ret = process_filter(event, parg, error_str, 0);
1191         if (ret < 0)
1192                 return ret;
1193
1194         /* If parg is NULL, then make it into FALSE */
1195         if (!*parg) {
1196                 *parg = allocate_arg();
1197                 if (*parg == NULL)
1198                         return TEP_ERRNO__MEM_ALLOC_FAILED;
1199
1200                 (*parg)->type = TEP_FILTER_ARG_BOOLEAN;
1201                 (*parg)->boolean.value = TEP_FILTER_FALSE;
1202         }
1203
1204         return 0;
1205 }
1206
1207 static enum tep_errno
1208 filter_event(struct tep_event_filter *filter, struct tep_event *event,
1209              const char *filter_str, char *error_str)
1210 {
1211         struct tep_filter_type *filter_type;
1212         struct tep_filter_arg *arg;
1213         enum tep_errno ret;
1214
1215         if (filter_str) {
1216                 ret = process_event(event, filter_str, &arg, error_str);
1217                 if (ret < 0)
1218                         return ret;
1219
1220         } else {
1221                 /* just add a TRUE arg */
1222                 arg = allocate_arg();
1223                 if (arg == NULL)
1224                         return TEP_ERRNO__MEM_ALLOC_FAILED;
1225
1226                 arg->type = TEP_FILTER_ARG_BOOLEAN;
1227                 arg->boolean.value = TEP_FILTER_TRUE;
1228         }
1229
1230         filter_type = add_filter_type(filter, event->id);
1231         if (filter_type == NULL)
1232                 return TEP_ERRNO__MEM_ALLOC_FAILED;
1233
1234         if (filter_type->filter)
1235                 free_arg(filter_type->filter);
1236         filter_type->filter = arg;
1237
1238         return 0;
1239 }
1240
1241 static void filter_init_error_buf(struct tep_event_filter *filter)
1242 {
1243         /* clear buffer to reset show error */
1244         tep_buffer_init("", 0);
1245         filter->error_buffer[0] = '\0';
1246 }
1247
1248 /**
1249  * tep_filter_add_filter_str - add a new filter
1250  * @filter: the event filter to add to
1251  * @filter_str: the filter string that contains the filter
1252  *
1253  * Returns 0 if the filter was successfully added or a
1254  * negative error code.  Use tep_filter_strerror() to see
1255  * actual error message in case of error.
1256  */
1257 enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter,
1258                                          const char *filter_str)
1259 {
1260         struct tep_handle *tep = filter->tep;
1261         struct event_list *event;
1262         struct event_list *events = NULL;
1263         const char *filter_start;
1264         const char *next_event;
1265         char *this_event;
1266         char *event_name = NULL;
1267         char *sys_name = NULL;
1268         char *sp;
1269         enum tep_errno rtn = 0; /* TEP_ERRNO__SUCCESS */
1270         int len;
1271         int ret;
1272
1273         filter_init_error_buf(filter);
1274
1275         filter_start = strchr(filter_str, ':');
1276         if (filter_start)
1277                 len = filter_start - filter_str;
1278         else
1279                 len = strlen(filter_str);
1280
1281         do {
1282                 next_event = strchr(filter_str, ',');
1283                 if (next_event &&
1284                     (!filter_start || next_event < filter_start))
1285                         len = next_event - filter_str;
1286                 else if (filter_start)
1287                         len = filter_start - filter_str;
1288                 else
1289                         len = strlen(filter_str);
1290
1291                 this_event = malloc(len + 1);
1292                 if (this_event == NULL) {
1293                         /* This can only happen when events is NULL, but still */
1294                         free_events(events);
1295                         return TEP_ERRNO__MEM_ALLOC_FAILED;
1296                 }
1297                 memcpy(this_event, filter_str, len);
1298                 this_event[len] = 0;
1299
1300                 if (next_event)
1301                         next_event++;
1302
1303                 filter_str = next_event;
1304
1305                 sys_name = strtok_r(this_event, "/", &sp);
1306                 event_name = strtok_r(NULL, "/", &sp);
1307
1308                 if (!sys_name) {
1309                         /* This can only happen when events is NULL, but still */
1310                         free_events(events);
1311                         free(this_event);
1312                         return TEP_ERRNO__FILTER_NOT_FOUND;
1313                 }
1314
1315                 /* Find this event */
1316                 ret = find_event(tep, &events, strim(sys_name), strim(event_name));
1317                 if (ret < 0) {
1318                         free_events(events);
1319                         free(this_event);
1320                         return ret;
1321                 }
1322                 free(this_event);
1323         } while (filter_str);
1324
1325         /* Skip the ':' */
1326         if (filter_start)
1327                 filter_start++;
1328
1329         /* filter starts here */
1330         for (event = events; event; event = event->next) {
1331                 ret = filter_event(filter, event->event, filter_start,
1332                                    filter->error_buffer);
1333                 /* Failures are returned if a parse error happened */
1334                 if (ret < 0)
1335                         rtn = ret;
1336
1337                 if (ret >= 0 && tep->test_filters) {
1338                         char *test;
1339                         test = tep_filter_make_string(filter, event->event->id);
1340                         if (test) {
1341                                 printf(" '%s: %s'\n", event->event->name, test);
1342                                 free(test);
1343                         }
1344                 }
1345         }
1346
1347         free_events(events);
1348
1349         return rtn;
1350 }
1351
1352 static void free_filter_type(struct tep_filter_type *filter_type)
1353 {
1354         free_arg(filter_type->filter);
1355 }
1356
1357 /**
1358  * tep_filter_strerror - fill error message in a buffer
1359  * @filter: the event filter contains error
1360  * @err: the error code
1361  * @buf: the buffer to be filled in
1362  * @buflen: the size of the buffer
1363  *
1364  * Returns 0 if message was filled successfully, -1 if error
1365  */
1366 int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err,
1367                         char *buf, size_t buflen)
1368 {
1369         if (err <= __TEP_ERRNO__START || err >= __TEP_ERRNO__END)
1370                 return -1;
1371
1372         if (strlen(filter->error_buffer) > 0) {
1373                 size_t len = snprintf(buf, buflen, "%s", filter->error_buffer);
1374
1375                 if (len > buflen)
1376                         return -1;
1377                 return 0;
1378         }
1379
1380         return tep_strerror(filter->tep, err, buf, buflen);
1381 }
1382
1383 /**
1384  * tep_filter_remove_event - remove a filter for an event
1385  * @filter: the event filter to remove from
1386  * @event_id: the event to remove a filter for
1387  *
1388  * Removes the filter saved for an event defined by @event_id
1389  * from the @filter.
1390  *
1391  * Returns 1: if an event was removed
1392  *   0: if the event was not found
1393  */
1394 int tep_filter_remove_event(struct tep_event_filter *filter,
1395                             int event_id)
1396 {
1397         struct tep_filter_type *filter_type;
1398         unsigned long len;
1399
1400         if (!filter->filters)
1401                 return 0;
1402
1403         filter_type = find_filter_type(filter, event_id);
1404
1405         if (!filter_type)
1406                 return 0;
1407
1408         free_filter_type(filter_type);
1409
1410         /* The filter_type points into the event_filters array */
1411         len = (unsigned long)(filter->event_filters + filter->filters) -
1412                 (unsigned long)(filter_type + 1);
1413
1414         memmove(filter_type, filter_type + 1, len);
1415         filter->filters--;
1416
1417         memset(&filter->event_filters[filter->filters], 0,
1418                sizeof(*filter_type));
1419
1420         return 1;
1421 }
1422
1423 /**
1424  * tep_filter_reset - clear all filters in a filter
1425  * @filter: the event filter to reset
1426  *
1427  * Removes all filters from a filter and resets it.
1428  */
1429 void tep_filter_reset(struct tep_event_filter *filter)
1430 {
1431         int i;
1432
1433         for (i = 0; i < filter->filters; i++)
1434                 free_filter_type(&filter->event_filters[i]);
1435
1436         free(filter->event_filters);
1437         filter->filters = 0;
1438         filter->event_filters = NULL;
1439 }
1440
1441 void tep_filter_free(struct tep_event_filter *filter)
1442 {
1443         tep_unref(filter->tep);
1444
1445         tep_filter_reset(filter);
1446
1447         free(filter);
1448 }
1449
1450 static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg);
1451
1452 static int copy_filter_type(struct tep_event_filter *filter,
1453                             struct tep_event_filter *source,
1454                             struct tep_filter_type *filter_type)
1455 {
1456         struct tep_filter_arg *arg;
1457         struct tep_event *event;
1458         const char *sys;
1459         const char *name;
1460         char *str;
1461
1462         /* Can't assume that the tep's are the same */
1463         sys = filter_type->event->system;
1464         name = filter_type->event->name;
1465         event = tep_find_event_by_name(filter->tep, sys, name);
1466         if (!event)
1467                 return -1;
1468
1469         str = arg_to_str(source, filter_type->filter);
1470         if (!str)
1471                 return -1;
1472
1473         if (strcmp(str, "TRUE") == 0 || strcmp(str, "FALSE") == 0) {
1474                 /* Add trivial event */
1475                 arg = allocate_arg();
1476                 if (arg == NULL)
1477                         return -1;
1478
1479                 arg->type = TEP_FILTER_ARG_BOOLEAN;
1480                 if (strcmp(str, "TRUE") == 0)
1481                         arg->boolean.value = 1;
1482                 else
1483                         arg->boolean.value = 0;
1484
1485                 filter_type = add_filter_type(filter, event->id);
1486                 if (filter_type == NULL)
1487                         return -1;
1488
1489                 filter_type->filter = arg;
1490
1491                 free(str);
1492                 return 0;
1493         }
1494
1495         filter_event(filter, event, str, NULL);
1496         free(str);
1497
1498         return 0;
1499 }
1500
1501 /**
1502  * tep_filter_copy - copy a filter using another filter
1503  * @dest - the filter to copy to
1504  * @source - the filter to copy from
1505  *
1506  * Returns 0 on success and -1 if not all filters were copied
1507  */
1508 int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source)
1509 {
1510         int ret = 0;
1511         int i;
1512
1513         tep_filter_reset(dest);
1514
1515         for (i = 0; i < source->filters; i++) {
1516                 if (copy_filter_type(dest, source, &source->event_filters[i]))
1517                         ret = -1;
1518         }
1519         return ret;
1520 }
1521
1522 static int test_filter(struct tep_event *event, struct tep_filter_arg *arg,
1523                        struct tep_record *record, enum tep_errno *err);
1524
1525 static const char *
1526 get_comm(struct tep_event *event, struct tep_record *record)
1527 {
1528         const char *comm;
1529         int pid;
1530
1531         pid = tep_data_pid(event->tep, record);
1532         comm = tep_data_comm_from_pid(event->tep, pid);
1533         return comm;
1534 }
1535
1536 static unsigned long long
1537 get_value(struct tep_event *event,
1538           struct tep_format_field *field, struct tep_record *record)
1539 {
1540         unsigned long long val;
1541
1542         /* Handle our dummy "comm" field */
1543         if (field == &comm) {
1544                 const char *name;
1545
1546                 name = get_comm(event, record);
1547                 return (unsigned long)name;
1548         }
1549
1550         /* Handle our dummy "cpu" field */
1551         if (field == &cpu)
1552                 return record->cpu;
1553
1554         tep_read_number_field(field, record->data, &val);
1555
1556         if (!(field->flags & TEP_FIELD_IS_SIGNED))
1557                 return val;
1558
1559         switch (field->size) {
1560         case 1:
1561                 return (char)val;
1562         case 2:
1563                 return (short)val;
1564         case 4:
1565                 return (int)val;
1566         case 8:
1567                 return (long long)val;
1568         }
1569         return val;
1570 }
1571
1572 static unsigned long long
1573 get_arg_value(struct tep_event *event, struct tep_filter_arg *arg,
1574               struct tep_record *record, enum tep_errno *err);
1575
1576 static unsigned long long
1577 get_exp_value(struct tep_event *event, struct tep_filter_arg *arg,
1578               struct tep_record *record, enum tep_errno *err)
1579 {
1580         unsigned long long lval, rval;
1581
1582         lval = get_arg_value(event, arg->exp.left, record, err);
1583         rval = get_arg_value(event, arg->exp.right, record, err);
1584
1585         if (*err) {
1586                 /*
1587                  * There was an error, no need to process anymore.
1588                  */
1589                 return 0;
1590         }
1591
1592         switch (arg->exp.type) {
1593         case TEP_FILTER_EXP_ADD:
1594                 return lval + rval;
1595
1596         case TEP_FILTER_EXP_SUB:
1597                 return lval - rval;
1598
1599         case TEP_FILTER_EXP_MUL:
1600                 return lval * rval;
1601
1602         case TEP_FILTER_EXP_DIV:
1603                 return lval / rval;
1604
1605         case TEP_FILTER_EXP_MOD:
1606                 return lval % rval;
1607
1608         case TEP_FILTER_EXP_RSHIFT:
1609                 return lval >> rval;
1610
1611         case TEP_FILTER_EXP_LSHIFT:
1612                 return lval << rval;
1613
1614         case TEP_FILTER_EXP_AND:
1615                 return lval & rval;
1616
1617         case TEP_FILTER_EXP_OR:
1618                 return lval | rval;
1619
1620         case TEP_FILTER_EXP_XOR:
1621                 return lval ^ rval;
1622
1623         case TEP_FILTER_EXP_NOT:
1624         default:
1625                 if (!*err)
1626                         *err = TEP_ERRNO__INVALID_EXP_TYPE;
1627         }
1628         return 0;
1629 }
1630
1631 static unsigned long long
1632 get_arg_value(struct tep_event *event, struct tep_filter_arg *arg,
1633               struct tep_record *record, enum tep_errno *err)
1634 {
1635         switch (arg->type) {
1636         case TEP_FILTER_ARG_FIELD:
1637                 return get_value(event, arg->field.field, record);
1638
1639         case TEP_FILTER_ARG_VALUE:
1640                 if (arg->value.type != TEP_FILTER_NUMBER) {
1641                         if (!*err)
1642                                 *err = TEP_ERRNO__NOT_A_NUMBER;
1643                 }
1644                 return arg->value.val;
1645
1646         case TEP_FILTER_ARG_EXP:
1647                 return get_exp_value(event, arg, record, err);
1648
1649         default:
1650                 if (!*err)
1651                         *err = TEP_ERRNO__INVALID_ARG_TYPE;
1652         }
1653         return 0;
1654 }
1655
1656 static int test_num(struct tep_event *event, struct tep_filter_arg *arg,
1657                     struct tep_record *record, enum tep_errno *err)
1658 {
1659         unsigned long long lval, rval;
1660
1661         lval = get_arg_value(event, arg->num.left, record, err);
1662         rval = get_arg_value(event, arg->num.right, record, err);
1663
1664         if (*err) {
1665                 /*
1666                  * There was an error, no need to process anymore.
1667                  */
1668                 return 0;
1669         }
1670
1671         switch (arg->num.type) {
1672         case TEP_FILTER_CMP_EQ:
1673                 return lval == rval;
1674
1675         case TEP_FILTER_CMP_NE:
1676                 return lval != rval;
1677
1678         case TEP_FILTER_CMP_GT:
1679                 return lval > rval;
1680
1681         case TEP_FILTER_CMP_LT:
1682                 return lval < rval;
1683
1684         case TEP_FILTER_CMP_GE:
1685                 return lval >= rval;
1686
1687         case TEP_FILTER_CMP_LE:
1688                 return lval <= rval;
1689
1690         default:
1691                 if (!*err)
1692                         *err = TEP_ERRNO__ILLEGAL_INTEGER_CMP;
1693                 return 0;
1694         }
1695 }
1696
1697 static const char *get_field_str(struct tep_filter_arg *arg, struct tep_record *record)
1698 {
1699         struct tep_event *event;
1700         struct tep_handle *tep;
1701         unsigned long long addr;
1702         const char *val = NULL;
1703         unsigned int size;
1704         char hex[64];
1705
1706         /* If the field is not a string convert it */
1707         if (arg->str.field->flags & TEP_FIELD_IS_STRING) {
1708                 val = record->data + arg->str.field->offset;
1709                 size = arg->str.field->size;
1710
1711                 if (arg->str.field->flags & TEP_FIELD_IS_DYNAMIC) {
1712                         addr = *(unsigned int *)val;
1713                         val = record->data + (addr & 0xffff);
1714                         size = addr >> 16;
1715                 }
1716
1717                 /*
1718                  * We need to copy the data since we can't be sure the field
1719                  * is null terminated.
1720                  */
1721                 if (*(val + size - 1)) {
1722                         /* copy it */
1723                         memcpy(arg->str.buffer, val, arg->str.field->size);
1724                         /* the buffer is already NULL terminated */
1725                         val = arg->str.buffer;
1726                 }
1727
1728         } else {
1729                 event = arg->str.field->event;
1730                 tep = event->tep;
1731                 addr = get_value(event, arg->str.field, record);
1732
1733                 if (arg->str.field->flags & (TEP_FIELD_IS_POINTER | TEP_FIELD_IS_LONG))
1734                         /* convert to a kernel symbol */
1735                         val = tep_find_function(tep, addr);
1736
1737                 if (val == NULL) {
1738                         /* just use the hex of the string name */
1739                         snprintf(hex, 64, "0x%llx", addr);
1740                         val = hex;
1741                 }
1742         }
1743
1744         return val;
1745 }
1746
1747 static int test_str(struct tep_event *event, struct tep_filter_arg *arg,
1748                     struct tep_record *record, enum tep_errno *err)
1749 {
1750         const char *val;
1751
1752         if (arg->str.field == &comm)
1753                 val = get_comm(event, record);
1754         else
1755                 val = get_field_str(arg, record);
1756
1757         switch (arg->str.type) {
1758         case TEP_FILTER_CMP_MATCH:
1759                 return strcmp(val, arg->str.val) == 0;
1760
1761         case TEP_FILTER_CMP_NOT_MATCH:
1762                 return strcmp(val, arg->str.val) != 0;
1763
1764         case TEP_FILTER_CMP_REGEX:
1765                 /* Returns zero on match */
1766                 return !regexec(&arg->str.reg, val, 0, NULL, 0);
1767
1768         case TEP_FILTER_CMP_NOT_REGEX:
1769                 return regexec(&arg->str.reg, val, 0, NULL, 0);
1770
1771         default:
1772                 if (!*err)
1773                         *err = TEP_ERRNO__ILLEGAL_STRING_CMP;
1774                 return 0;
1775         }
1776 }
1777
1778 static int test_op(struct tep_event *event, struct tep_filter_arg *arg,
1779                    struct tep_record *record, enum tep_errno *err)
1780 {
1781         switch (arg->op.type) {
1782         case TEP_FILTER_OP_AND:
1783                 return test_filter(event, arg->op.left, record, err) &&
1784                         test_filter(event, arg->op.right, record, err);
1785
1786         case TEP_FILTER_OP_OR:
1787                 return test_filter(event, arg->op.left, record, err) ||
1788                         test_filter(event, arg->op.right, record, err);
1789
1790         case TEP_FILTER_OP_NOT:
1791                 return !test_filter(event, arg->op.right, record, err);
1792
1793         default:
1794                 if (!*err)
1795                         *err = TEP_ERRNO__INVALID_OP_TYPE;
1796                 return 0;
1797         }
1798 }
1799
1800 static int test_filter(struct tep_event *event, struct tep_filter_arg *arg,
1801                        struct tep_record *record, enum tep_errno *err)
1802 {
1803         if (*err) {
1804                 /*
1805                  * There was an error, no need to process anymore.
1806                  */
1807                 return 0;
1808         }
1809
1810         switch (arg->type) {
1811         case TEP_FILTER_ARG_BOOLEAN:
1812                 /* easy case */
1813                 return arg->boolean.value;
1814
1815         case TEP_FILTER_ARG_OP:
1816                 return test_op(event, arg, record, err);
1817
1818         case TEP_FILTER_ARG_NUM:
1819                 return test_num(event, arg, record, err);
1820
1821         case TEP_FILTER_ARG_STR:
1822                 return test_str(event, arg, record, err);
1823
1824         case TEP_FILTER_ARG_EXP:
1825         case TEP_FILTER_ARG_VALUE:
1826         case TEP_FILTER_ARG_FIELD:
1827                 /*
1828                  * Expressions, fields and values evaluate
1829                  * to true if they return non zero
1830                  */
1831                 return !!get_arg_value(event, arg, record, err);
1832
1833         default:
1834                 if (!*err)
1835                         *err = TEP_ERRNO__INVALID_ARG_TYPE;
1836                 return 0;
1837         }
1838 }
1839
1840 /**
1841  * tep_event_filtered - return true if event has filter
1842  * @filter: filter struct with filter information
1843  * @event_id: event id to test if filter exists
1844  *
1845  * Returns 1 if filter found for @event_id
1846  *   otherwise 0;
1847  */
1848 int tep_event_filtered(struct tep_event_filter *filter, int event_id)
1849 {
1850         struct tep_filter_type *filter_type;
1851
1852         if (!filter->filters)
1853                 return 0;
1854
1855         filter_type = find_filter_type(filter, event_id);
1856
1857         return filter_type ? 1 : 0;
1858 }
1859
1860 /**
1861  * tep_filter_match - test if a record matches a filter
1862  * @filter: filter struct with filter information
1863  * @record: the record to test against the filter
1864  *
1865  * Returns: match result or error code (prefixed with TEP_ERRNO__)
1866  * FILTER_MATCH - filter found for event and @record matches
1867  * FILTER_MISS  - filter found for event and @record does not match
1868  * FILTER_NOT_FOUND - no filter found for @record's event
1869  * NO_FILTER - if no filters exist
1870  * otherwise - error occurred during test
1871  */
1872 enum tep_errno tep_filter_match(struct tep_event_filter *filter,
1873                                 struct tep_record *record)
1874 {
1875         struct tep_handle *tep = filter->tep;
1876         struct tep_filter_type *filter_type;
1877         int event_id;
1878         int ret;
1879         enum tep_errno err = 0;
1880
1881         filter_init_error_buf(filter);
1882
1883         if (!filter->filters)
1884                 return TEP_ERRNO__NO_FILTER;
1885
1886         event_id = tep_data_type(tep, record);
1887
1888         filter_type = find_filter_type(filter, event_id);
1889         if (!filter_type)
1890                 return TEP_ERRNO__FILTER_NOT_FOUND;
1891
1892         ret = test_filter(filter_type->event, filter_type->filter, record, &err);
1893         if (err)
1894                 return err;
1895
1896         return ret ? TEP_ERRNO__FILTER_MATCH : TEP_ERRNO__FILTER_MISS;
1897 }
1898
1899 static char *op_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
1900 {
1901         char *str = NULL;
1902         char *left = NULL;
1903         char *right = NULL;
1904         char *op = NULL;
1905         int left_val = -1;
1906         int right_val = -1;
1907         int val;
1908
1909         switch (arg->op.type) {
1910         case TEP_FILTER_OP_AND:
1911                 op = "&&";
1912                 /* fall through */
1913         case TEP_FILTER_OP_OR:
1914                 if (!op)
1915                         op = "||";
1916
1917                 left = arg_to_str(filter, arg->op.left);
1918                 right = arg_to_str(filter, arg->op.right);
1919                 if (!left || !right)
1920                         break;
1921
1922                 /* Try to consolidate boolean values */
1923                 if (strcmp(left, "TRUE") == 0)
1924                         left_val = 1;
1925                 else if (strcmp(left, "FALSE") == 0)
1926                         left_val = 0;
1927
1928                 if (strcmp(right, "TRUE") == 0)
1929                         right_val = 1;
1930                 else if (strcmp(right, "FALSE") == 0)
1931                         right_val = 0;
1932
1933                 if (left_val >= 0) {
1934                         if ((arg->op.type == TEP_FILTER_OP_AND && !left_val) ||
1935                             (arg->op.type == TEP_FILTER_OP_OR && left_val)) {
1936                                 /* Just return left value */
1937                                 str = left;
1938                                 left = NULL;
1939                                 break;
1940                         }
1941                         if (right_val >= 0) {
1942                                 /* just evaluate this. */
1943                                 val = 0;
1944                                 switch (arg->op.type) {
1945                                 case TEP_FILTER_OP_AND:
1946                                         val = left_val && right_val;
1947                                         break;
1948                                 case TEP_FILTER_OP_OR:
1949                                         val = left_val || right_val;
1950                                         break;
1951                                 default:
1952                                         break;
1953                                 }
1954                                 asprintf(&str, val ? "TRUE" : "FALSE");
1955                                 break;
1956                         }
1957                 }
1958                 if (right_val >= 0) {
1959                         if ((arg->op.type == TEP_FILTER_OP_AND && !right_val) ||
1960                             (arg->op.type == TEP_FILTER_OP_OR && right_val)) {
1961                                 /* Just return right value */
1962                                 str = right;
1963                                 right = NULL;
1964                                 break;
1965                         }
1966                         /* The right value is meaningless */
1967                         str = left;
1968                         left = NULL;
1969                         break;
1970                 }
1971
1972                 asprintf(&str, "(%s) %s (%s)", left, op, right);
1973                 break;
1974
1975         case TEP_FILTER_OP_NOT:
1976                 op = "!";
1977                 right = arg_to_str(filter, arg->op.right);
1978                 if (!right)
1979                         break;
1980
1981                 /* See if we can consolidate */
1982                 if (strcmp(right, "TRUE") == 0)
1983                         right_val = 1;
1984                 else if (strcmp(right, "FALSE") == 0)
1985                         right_val = 0;
1986                 if (right_val >= 0) {
1987                         /* just return the opposite */
1988                         asprintf(&str, right_val ? "FALSE" : "TRUE");
1989                         break;
1990                 }
1991                 asprintf(&str, "%s(%s)", op, right);
1992                 break;
1993
1994         default:
1995                 /* ?? */
1996                 break;
1997         }
1998         free(left);
1999         free(right);
2000         return str;
2001 }
2002
2003 static char *val_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2004 {
2005         char *str = NULL;
2006
2007         asprintf(&str, "%lld", arg->value.val);
2008
2009         return str;
2010 }
2011
2012 static char *field_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2013 {
2014         return strdup(arg->field.field->name);
2015 }
2016
2017 static char *exp_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2018 {
2019         char *lstr;
2020         char *rstr;
2021         char *op;
2022         char *str = NULL;
2023
2024         lstr = arg_to_str(filter, arg->exp.left);
2025         rstr = arg_to_str(filter, arg->exp.right);
2026         if (!lstr || !rstr)
2027                 goto out;
2028
2029         switch (arg->exp.type) {
2030         case TEP_FILTER_EXP_ADD:
2031                 op = "+";
2032                 break;
2033         case TEP_FILTER_EXP_SUB:
2034                 op = "-";
2035                 break;
2036         case TEP_FILTER_EXP_MUL:
2037                 op = "*";
2038                 break;
2039         case TEP_FILTER_EXP_DIV:
2040                 op = "/";
2041                 break;
2042         case TEP_FILTER_EXP_MOD:
2043                 op = "%";
2044                 break;
2045         case TEP_FILTER_EXP_RSHIFT:
2046                 op = ">>";
2047                 break;
2048         case TEP_FILTER_EXP_LSHIFT:
2049                 op = "<<";
2050                 break;
2051         case TEP_FILTER_EXP_AND:
2052                 op = "&";
2053                 break;
2054         case TEP_FILTER_EXP_OR:
2055                 op = "|";
2056                 break;
2057         case TEP_FILTER_EXP_XOR:
2058                 op = "^";
2059                 break;
2060         default:
2061                 op = "[ERROR IN EXPRESSION TYPE]";
2062                 break;
2063         }
2064
2065         asprintf(&str, "%s %s %s", lstr, op, rstr);
2066 out:
2067         free(lstr);
2068         free(rstr);
2069
2070         return str;
2071 }
2072
2073 static char *num_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2074 {
2075         char *lstr;
2076         char *rstr;
2077         char *str = NULL;
2078         char *op = NULL;
2079
2080         lstr = arg_to_str(filter, arg->num.left);
2081         rstr = arg_to_str(filter, arg->num.right);
2082         if (!lstr || !rstr)
2083                 goto out;
2084
2085         switch (arg->num.type) {
2086         case TEP_FILTER_CMP_EQ:
2087                 op = "==";
2088                 /* fall through */
2089         case TEP_FILTER_CMP_NE:
2090                 if (!op)
2091                         op = "!=";
2092                 /* fall through */
2093         case TEP_FILTER_CMP_GT:
2094                 if (!op)
2095                         op = ">";
2096                 /* fall through */
2097         case TEP_FILTER_CMP_LT:
2098                 if (!op)
2099                         op = "<";
2100                 /* fall through */
2101         case TEP_FILTER_CMP_GE:
2102                 if (!op)
2103                         op = ">=";
2104                 /* fall through */
2105         case TEP_FILTER_CMP_LE:
2106                 if (!op)
2107                         op = "<=";
2108
2109                 asprintf(&str, "%s %s %s", lstr, op, rstr);
2110                 break;
2111
2112         default:
2113                 /* ?? */
2114                 break;
2115         }
2116
2117 out:
2118         free(lstr);
2119         free(rstr);
2120         return str;
2121 }
2122
2123 static char *str_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2124 {
2125         char *str = NULL;
2126         char *op = NULL;
2127
2128         switch (arg->str.type) {
2129         case TEP_FILTER_CMP_MATCH:
2130                 op = "==";
2131                 /* fall through */
2132         case TEP_FILTER_CMP_NOT_MATCH:
2133                 if (!op)
2134                         op = "!=";
2135                 /* fall through */
2136         case TEP_FILTER_CMP_REGEX:
2137                 if (!op)
2138                         op = "=~";
2139                 /* fall through */
2140         case TEP_FILTER_CMP_NOT_REGEX:
2141                 if (!op)
2142                         op = "!~";
2143
2144                 asprintf(&str, "%s %s \"%s\"",
2145                          arg->str.field->name, op, arg->str.val);
2146                 break;
2147
2148         default:
2149                 /* ?? */
2150                 break;
2151         }
2152         return str;
2153 }
2154
2155 static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
2156 {
2157         char *str = NULL;
2158
2159         switch (arg->type) {
2160         case TEP_FILTER_ARG_BOOLEAN:
2161                 asprintf(&str, arg->boolean.value ? "TRUE" : "FALSE");
2162                 return str;
2163
2164         case TEP_FILTER_ARG_OP:
2165                 return op_to_str(filter, arg);
2166
2167         case TEP_FILTER_ARG_NUM:
2168                 return num_to_str(filter, arg);
2169
2170         case TEP_FILTER_ARG_STR:
2171                 return str_to_str(filter, arg);
2172
2173         case TEP_FILTER_ARG_VALUE:
2174                 return val_to_str(filter, arg);
2175
2176         case TEP_FILTER_ARG_FIELD:
2177                 return field_to_str(filter, arg);
2178
2179         case TEP_FILTER_ARG_EXP:
2180                 return exp_to_str(filter, arg);
2181
2182         default:
2183                 /* ?? */
2184                 return NULL;
2185         }
2186
2187 }
2188
2189 /**
2190  * tep_filter_make_string - return a string showing the filter
2191  * @filter: filter struct with filter information
2192  * @event_id: the event id to return the filter string with
2193  *
2194  * Returns a string that displays the filter contents.
2195  *  This string must be freed with free(str).
2196  *  NULL is returned if no filter is found or allocation failed.
2197  */
2198 char *
2199 tep_filter_make_string(struct tep_event_filter *filter, int event_id)
2200 {
2201         struct tep_filter_type *filter_type;
2202
2203         if (!filter->filters)
2204                 return NULL;
2205
2206         filter_type = find_filter_type(filter, event_id);
2207
2208         if (!filter_type)
2209                 return NULL;
2210
2211         return arg_to_str(filter, filter_type->filter);
2212 }
2213
2214 /**
2215  * tep_filter_compare - compare two filters and return if they are the same
2216  * @filter1: Filter to compare with @filter2
2217  * @filter2: Filter to compare with @filter1
2218  *
2219  * Returns:
2220  *  1 if the two filters hold the same content.
2221  *  0 if they do not.
2222  */
2223 int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2)
2224 {
2225         struct tep_filter_type *filter_type1;
2226         struct tep_filter_type *filter_type2;
2227         char *str1, *str2;
2228         int result;
2229         int i;
2230
2231         /* Do the easy checks first */
2232         if (filter1->filters != filter2->filters)
2233                 return 0;
2234         if (!filter1->filters && !filter2->filters)
2235                 return 1;
2236
2237         /*
2238          * Now take a look at each of the events to see if they have the same
2239          * filters to them.
2240          */
2241         for (i = 0; i < filter1->filters; i++) {
2242                 filter_type1 = &filter1->event_filters[i];
2243                 filter_type2 = find_filter_type(filter2, filter_type1->event_id);
2244                 if (!filter_type2)
2245                         break;
2246                 if (filter_type1->filter->type != filter_type2->filter->type)
2247                         break;
2248                 /* The best way to compare complex filters is with strings */
2249                 str1 = arg_to_str(filter1, filter_type1->filter);
2250                 str2 = arg_to_str(filter2, filter_type2->filter);
2251                 if (str1 && str2)
2252                         result = strcmp(str1, str2) != 0;
2253                 else
2254                         /* bail out if allocation fails */
2255                         result = 1;
2256
2257                 free(str1);
2258                 free(str2);
2259                 if (result)
2260                         break;
2261         }
2262
2263         if (i < filter1->filters)
2264                 return 0;
2265         return 1;
2266 }
2267