security/apparmor/match.c

   1 /*
   2  * AppArmor security module
   3  *
   4  * This file contains AppArmor dfa based regular expression matching engine
   5  *
   6  * Copyright (C) 1998-2008 Novell/SUSE
   7  * Copyright 2009-2012 Canonical Ltd.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation, version 2 of the
  12  * License.
  13  */
  14
  15 #include <linux/errno.h>
  16 #include <linux/kernel.h>
  17 #include <linux/mm.h>
  18 #include <linux/slab.h>
  19 #include <linux/vmalloc.h>
  20 #include <linux/err.h>
  21 #include <linux/kref.h>
  22
  23 #include "include/lib.h"
  24 #include "include/match.h"
  25
  26 #define base_idx(X) ((X) & 0xffffff)
  27
  28 static char nulldfa_src[] = {
  29         #include "nulldfa.in"
  30 };
  31 struct aa_dfa *nulldfa;
  32
  33 static char stacksplitdfa_src[] = {
  34         #include "stacksplitdfa.in"
  35 };
  36 struct aa_dfa *stacksplitdfa;
  37
  38 int aa_setup_dfa_engine(void)
  39 {
  40         int error;
  41
  42         nulldfa = aa_dfa_unpack(nulldfa_src, sizeof(nulldfa_src),
  43                                 TO_ACCEPT1_FLAG(YYTD_DATA32) |
  44                                 TO_ACCEPT2_FLAG(YYTD_DATA32));
  45         if (IS_ERR(nulldfa)) {
  46                 error = PTR_ERR(nulldfa);
  47                 nulldfa = NULL;
  48                 return error;
  49         }
  50
  51         stacksplitdfa = aa_dfa_unpack(stacksplitdfa_src,
  52                                       sizeof(stacksplitdfa_src),
  53                                       TO_ACCEPT1_FLAG(YYTD_DATA32) |
  54                                       TO_ACCEPT2_FLAG(YYTD_DATA32));
  55         if (IS_ERR(stacksplitdfa)) {
  56                 aa_put_dfa(nulldfa);
  57                 nulldfa = NULL;
  58                 error = PTR_ERR(stacksplitdfa);
  59                 stacksplitdfa = NULL;
  60                 return error;
  61         }
  62
  63         return 0;
  64 }
  65
  66 void aa_teardown_dfa_engine(void)
  67 {
  68         aa_put_dfa(stacksplitdfa);
  69         aa_put_dfa(nulldfa);
  70 }
  71
  72 /**
  73  * unpack_table - unpack a dfa table (one of accept, default, base, next check)
  74  * @blob: data to unpack (NOT NULL)
  75  * @bsize: size of blob
  76  *
  77  * Returns: pointer to table else NULL on failure
  78  *
  79  * NOTE: must be freed by kvfree (not kfree)
  80  */
  81 static struct table_header *unpack_table(char *blob, size_t bsize)
  82 {
  83         struct table_header *table = NULL;
  84         struct table_header th;
  85         size_t tsize;
  86
  87         if (bsize < sizeof(struct table_header))
  88                 goto out;
  89
  90         /* loaded td_id's start at 1, subtract 1 now to avoid doing
  91          * it every time we use td_id as an index
  92          */
  93         th.td_id = be16_to_cpu(*(__be16 *) (blob)) - 1;
  94         if (th.td_id > YYTD_ID_MAX)
  95                 goto out;
  96         th.td_flags = be16_to_cpu(*(__be16 *) (blob + 2));
  97         th.td_lolen = be32_to_cpu(*(__be32 *) (blob + 8));
  98         blob += sizeof(struct table_header);
  99
 100         if (!(th.td_flags == YYTD_DATA16 || th.td_flags == YYTD_DATA32 ||
 101               th.td_flags == YYTD_DATA8))
 102                 goto out;
 103
 104         /* if we have a table it must have some entries */
 105         if (th.td_lolen == 0)
 106                 goto out;
 107         tsize = table_size(th.td_lolen, th.td_flags);
 108         if (bsize < tsize)
 109                 goto out;
 110
 111         table = kvzalloc(tsize, GFP_KERNEL);
 112         if (table) {
 113                 table->td_id = th.td_id;
 114                 table->td_flags = th.td_flags;
 115                 table->td_lolen = th.td_lolen;
 116                 if (th.td_flags == YYTD_DATA8)
 117                         UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
 118                                      u8, u8, byte_to_byte);
 119                 else if (th.td_flags == YYTD_DATA16)
 120                         UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
 121                                      u16, __be16, be16_to_cpu);
 122                 else if (th.td_flags == YYTD_DATA32)
 123                         UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
 124                                      u32, __be32, be32_to_cpu);
 125                 else
 126                         goto fail;
 127                 /* if table was vmalloced make sure the page tables are synced
 128                  * before it is used, as it goes live to all cpus.
 129                  */
 130                 if (is_vmalloc_addr(table))
 131                         vm_unmap_aliases();
 132         }
 133
 134 out:
 135         return table;
 136 fail:
 137         kvfree(table);
 138         return NULL;
 139 }
 140
 141 /**
 142  * verify_table_headers - verify that the tables headers are as expected
 143  * @tables - array of dfa tables to check (NOT NULL)
 144  * @flags: flags controlling what type of accept table are acceptable
 145  *
 146  * Assumes dfa has gone through the first pass verification done by unpacking
 147  * NOTE: this does not valid accept table values
 148  *
 149  * Returns: %0 else error code on failure to verify
 150  */
 151 static int verify_table_headers(struct table_header **tables, int flags)
 152 {
 153         size_t state_count, trans_count;
 154         int error = -EPROTO;
 155
 156         /* check that required tables exist */
 157         if (!(tables[YYTD_ID_DEF] && tables[YYTD_ID_BASE] &&
 158               tables[YYTD_ID_NXT] && tables[YYTD_ID_CHK]))
 159                 goto out;
 160
 161         /* accept.size == default.size == base.size */
 162         state_count = tables[YYTD_ID_BASE]->td_lolen;
 163         if (ACCEPT1_FLAGS(flags)) {
 164                 if (!tables[YYTD_ID_ACCEPT])
 165                         goto out;
 166                 if (state_count != tables[YYTD_ID_ACCEPT]->td_lolen)
 167                         goto out;
 168         }
 169         if (ACCEPT2_FLAGS(flags)) {
 170                 if (!tables[YYTD_ID_ACCEPT2])
 171                         goto out;
 172                 if (state_count != tables[YYTD_ID_ACCEPT2]->td_lolen)
 173                         goto out;
 174         }
 175         if (state_count != tables[YYTD_ID_DEF]->td_lolen)
 176                 goto out;
 177
 178         /* next.size == chk.size */
 179         trans_count = tables[YYTD_ID_NXT]->td_lolen;
 180         if (trans_count != tables[YYTD_ID_CHK]->td_lolen)
 181                 goto out;
 182
 183         /* if equivalence classes then its table size must be 256 */
 184         if (tables[YYTD_ID_EC] && tables[YYTD_ID_EC]->td_lolen != 256)
 185                 goto out;
 186
 187         error = 0;
 188 out:
 189         return error;
 190 }
 191
 192 /**
 193  * verify_dfa - verify that transitions and states in the tables are in bounds.
 194  * @dfa: dfa to test  (NOT NULL)
 195  *
 196  * Assumes dfa has gone through the first pass verification done by unpacking
 197  * NOTE: this does not valid accept table values
 198  *
 199  * Returns: %0 else error code on failure to verify
 200  */
 201 static int verify_dfa(struct aa_dfa *dfa)
 202 {
 203         size_t i, state_count, trans_count;
 204         int error = -EPROTO;
 205
 206         state_count = dfa->tables[YYTD_ID_BASE]->td_lolen;
 207         trans_count = dfa->tables[YYTD_ID_NXT]->td_lolen;
 208         if (state_count == 0)
 209                 goto out;
 210         for (i = 0; i < state_count; i++) {
 211                 if (!(BASE_TABLE(dfa)[i] & MATCH_FLAG_DIFF_ENCODE) &&
 212                     (DEFAULT_TABLE(dfa)[i] >= state_count))
 213                         goto out;
 214                 if (base_idx(BASE_TABLE(dfa)[i]) + 255 >= trans_count) {
 215                         pr_err("AppArmor DFA next/check upper bounds error\n");
 216                         goto out;
 217                 }
 218         }
 219
 220         for (i = 0; i < trans_count; i++) {
 221                 if (NEXT_TABLE(dfa)[i] >= state_count)
 222                         goto out;
 223                 if (CHECK_TABLE(dfa)[i] >= state_count)
 224                         goto out;
 225         }
 226
 227         /* Now that all the other tables are verified, verify diffencoding */
 228         for (i = 0; i < state_count; i++) {
 229                 size_t j, k;
 230
 231                 for (j = i;
 232                      (BASE_TABLE(dfa)[j] & MATCH_FLAG_DIFF_ENCODE) &&
 233                      !(BASE_TABLE(dfa)[j] & MARK_DIFF_ENCODE);
 234                      j = k) {
 235                         k = DEFAULT_TABLE(dfa)[j];
 236                         if (j == k)
 237                                 goto out;
 238                         if (k < j)
 239                                 break;          /* already verified */
 240                         BASE_TABLE(dfa)[j] |= MARK_DIFF_ENCODE;
 241                 }
 242         }
 243         error = 0;
 244
 245 out:
 246         return error;
 247 }
 248
 249 /**
 250  * dfa_free - free a dfa allocated by aa_dfa_unpack
 251  * @dfa: the dfa to free  (MAYBE NULL)
 252  *
 253  * Requires: reference count to dfa == 0
 254  */
 255 static void dfa_free(struct aa_dfa *dfa)
 256 {
 257         if (dfa) {
 258                 int i;
 259
 260                 for (i = 0; i < ARRAY_SIZE(dfa->tables); i++) {
 261                         kvfree(dfa->tables[i]);
 262                         dfa->tables[i] = NULL;
 263                 }
 264                 kfree(dfa);
 265         }
 266 }
 267
 268 /**
 269  * aa_dfa_free_kref - free aa_dfa by kref (called by aa_put_dfa)
 270  * @kr: kref callback for freeing of a dfa  (NOT NULL)
 271  */
 272 void aa_dfa_free_kref(struct kref *kref)
 273 {
 274         struct aa_dfa *dfa = container_of(kref, struct aa_dfa, count);
 275         dfa_free(dfa);
 276 }
 277
 278 /**
 279  * aa_dfa_unpack - unpack the binary tables of a serialized dfa
 280  * @blob: aligned serialized stream of data to unpack  (NOT NULL)
 281  * @size: size of data to unpack
 282  * @flags: flags controlling what type of accept tables are acceptable
 283  *
 284  * Unpack a dfa that has been serialized.  To find information on the dfa
 285  * format look in Documentation/admin-guide/LSM/apparmor.rst
 286  * Assumes the dfa @blob stream has been aligned on a 8 byte boundary
 287  *
 288  * Returns: an unpacked dfa ready for matching or ERR_PTR on failure
 289  */
 290 struct aa_dfa *aa_dfa_unpack(void *blob, size_t size, int flags)
 291 {
 292         int hsize;
 293         int error = -ENOMEM;
 294         char *data = blob;
 295         struct table_header *table = NULL;
 296         struct aa_dfa *dfa = kzalloc(sizeof(struct aa_dfa), GFP_KERNEL);
 297         if (!dfa)
 298                 goto fail;
 299
 300         kref_init(&dfa->count);
 301
 302         error = -EPROTO;
 303
 304         /* get dfa table set header */
 305         if (size < sizeof(struct table_set_header))
 306                 goto fail;
 307
 308         if (ntohl(*(__be32 *) data) != YYTH_MAGIC)
 309                 goto fail;
 310
 311         hsize = ntohl(*(__be32 *) (data + 4));
 312         if (size < hsize)
 313                 goto fail;
 314
 315         dfa->flags = ntohs(*(__be16 *) (data + 12));
 316         if (dfa->flags != 0 && dfa->flags != YYTH_FLAG_DIFF_ENCODE)
 317                 goto fail;
 318
 319         data += hsize;
 320         size -= hsize;
 321
 322         while (size > 0) {
 323                 table = unpack_table(data, size);
 324                 if (!table)
 325                         goto fail;
 326
 327                 switch (table->td_id) {
 328                 case YYTD_ID_ACCEPT:
 329                         if (!(table->td_flags & ACCEPT1_FLAGS(flags)))
 330                                 goto fail;
 331                         break;
 332                 case YYTD_ID_ACCEPT2:
 333                         if (!(table->td_flags & ACCEPT2_FLAGS(flags)))
 334                                 goto fail;
 335                         break;
 336                 case YYTD_ID_BASE:
 337                         if (table->td_flags != YYTD_DATA32)
 338                                 goto fail;
 339                         break;
 340                 case YYTD_ID_DEF:
 341                 case YYTD_ID_NXT:
 342                 case YYTD_ID_CHK:
 343                         if (table->td_flags != YYTD_DATA16)
 344                                 goto fail;
 345                         break;
 346                 case YYTD_ID_EC:
 347                         if (table->td_flags != YYTD_DATA8)
 348                                 goto fail;
 349                         break;
 350                 default:
 351                         goto fail;
 352                 }
 353                 /* check for duplicate table entry */
 354                 if (dfa->tables[table->td_id])
 355                         goto fail;
 356                 dfa->tables[table->td_id] = table;
 357                 data += table_size(table->td_lolen, table->td_flags);
 358                 size -= table_size(table->td_lolen, table->td_flags);
 359                 table = NULL;
 360         }
 361         error = verify_table_headers(dfa->tables, flags);
 362         if (error)
 363                 goto fail;
 364
 365         if (flags & DFA_FLAG_VERIFY_STATES) {
 366                 error = verify_dfa(dfa);
 367                 if (error)
 368                         goto fail;
 369         }
 370
 371         return dfa;
 372
 373 fail:
 374         kvfree(table);
 375         dfa_free(dfa);
 376         return ERR_PTR(error);
 377 }
 378
 379 #define match_char(state, def, base, next, check, C)    \
 380 do {                                                    \
 381         u32 b = (base)[(state)];                        \
 382         unsigned int pos = base_idx(b) + (C);           \
 383         if ((check)[pos] != (state)) {                  \
 384                 (state) = (def)[(state)];               \
 385                 if (b & MATCH_FLAG_DIFF_ENCODE)         \
 386                         continue;                       \
 387                 break;                                  \
 388         }                                               \
 389         (state) = (next)[pos];                          \
 390         break;                                          \
 391 } while (1)
 392
 393 /**
 394  * aa_dfa_match_len - traverse @dfa to find state @str stops at
 395  * @dfa: the dfa to match @str against  (NOT NULL)
 396  * @start: the state of the dfa to start matching in
 397  * @str: the string of bytes to match against the dfa  (NOT NULL)
 398  * @len: length of the string of bytes to match
 399  *
 400  * aa_dfa_match_len will match @str against the dfa and return the state it
 401  * finished matching in. The final state can be used to look up the accepting
 402  * label, or as the start state of a continuing match.
 403  *
 404  * This function will happily match again the 0 byte and only finishes
 405  * when @len input is consumed.
 406  *
 407  * Returns: final state reached after input is consumed
 408  */
 409 unsigned int aa_dfa_match_len(struct aa_dfa *dfa, unsigned int start,
 410                               const char *str, int len)
 411 {
 412         u16 *def = DEFAULT_TABLE(dfa);
 413         u32 *base = BASE_TABLE(dfa);
 414         u16 *next = NEXT_TABLE(dfa);
 415         u16 *check = CHECK_TABLE(dfa);
 416         unsigned int state = start;
 417
 418         if (state == 0)
 419                 return 0;
 420
 421         /* current state is <state>, matching character *str */
 422         if (dfa->tables[YYTD_ID_EC]) {
 423                 /* Equivalence class table defined */
 424                 u8 *equiv = EQUIV_TABLE(dfa);
 425                 for (; len; len--)
 426                         match_char(state, def, base, next, check,
 427                                    equiv[(u8) *str++]);
 428         } else {
 429                 /* default is direct to next state */
 430                 for (; len; len--)
 431                         match_char(state, def, base, next, check, (u8) *str++);
 432         }
 433
 434         return state;
 435 }
 436
 437 /**
 438  * aa_dfa_match - traverse @dfa to find state @str stops at
 439  * @dfa: the dfa to match @str against  (NOT NULL)
 440  * @start: the state of the dfa to start matching in
 441  * @str: the null terminated string of bytes to match against the dfa (NOT NULL)
 442  *
 443  * aa_dfa_match will match @str against the dfa and return the state it
 444  * finished matching in. The final state can be used to look up the accepting
 445  * label, or as the start state of a continuing match.
 446  *
 447  * Returns: final state reached after input is consumed
 448  */
 449 unsigned int aa_dfa_match(struct aa_dfa *dfa, unsigned int start,
 450                           const char *str)
 451 {
 452         u16 *def = DEFAULT_TABLE(dfa);
 453         u32 *base = BASE_TABLE(dfa);
 454         u16 *next = NEXT_TABLE(dfa);
 455         u16 *check = CHECK_TABLE(dfa);
 456         unsigned int state = start;
 457
 458         if (state == 0)
 459                 return 0;
 460
 461         /* current state is <state>, matching character *str */
 462         if (dfa->tables[YYTD_ID_EC]) {
 463                 /* Equivalence class table defined */
 464                 u8 *equiv = EQUIV_TABLE(dfa);
 465                 /* default is direct to next state */
 466                 while (*str)
 467                         match_char(state, def, base, next, check,
 468                                    equiv[(u8) *str++]);
 469         } else {
 470                 /* default is direct to next state */
 471                 while (*str)
 472                         match_char(state, def, base, next, check, (u8) *str++);
 473         }
 474
 475         return state;
 476 }
 477
 478 /**
 479  * aa_dfa_next - step one character to the next state in the dfa
 480  * @dfa: the dfa to traverse (NOT NULL)
 481  * @state: the state to start in
 482  * @c: the input character to transition on
 483  *
 484  * aa_dfa_match will step through the dfa by one input character @c
 485  *
 486  * Returns: state reach after input @c
 487  */
 488 unsigned int aa_dfa_next(struct aa_dfa *dfa, unsigned int state,
 489                           const char c)
 490 {
 491         u16 *def = DEFAULT_TABLE(dfa);
 492         u32 *base = BASE_TABLE(dfa);
 493         u16 *next = NEXT_TABLE(dfa);
 494         u16 *check = CHECK_TABLE(dfa);
 495
 496         /* current state is <state>, matching character *str */
 497         if (dfa->tables[YYTD_ID_EC]) {
 498                 /* Equivalence class table defined */
 499                 u8 *equiv = EQUIV_TABLE(dfa);
 500                 match_char(state, def, base, next, check, equiv[(u8) c]);
 501         } else
 502                 match_char(state, def, base, next, check, (u8) c);
 503
 504         return state;
 505 }
 506
 507 /**
 508  * aa_dfa_match_until - traverse @dfa until accept state or end of input
 509  * @dfa: the dfa to match @str against  (NOT NULL)
 510  * @start: the state of the dfa to start matching in
 511  * @str: the null terminated string of bytes to match against the dfa (NOT NULL)
 512  * @retpos: first character in str after match OR end of string
 513  *
 514  * aa_dfa_match will match @str against the dfa and return the state it
 515  * finished matching in. The final state can be used to look up the accepting
 516  * label, or as the start state of a continuing match.
 517  *
 518  * Returns: final state reached after input is consumed
 519  */
 520 unsigned int aa_dfa_match_until(struct aa_dfa *dfa, unsigned int start,
 521                                 const char *str, const char **retpos)
 522 {
 523         u16 *def = DEFAULT_TABLE(dfa);
 524         u32 *base = BASE_TABLE(dfa);
 525         u16 *next = NEXT_TABLE(dfa);
 526         u16 *check = CHECK_TABLE(dfa);
 527         u32 *accept = ACCEPT_TABLE(dfa);
 528         unsigned int state = start, pos;
 529
 530         if (state == 0)
 531                 return 0;
 532
 533         /* current state is <state>, matching character *str */
 534         if (dfa->tables[YYTD_ID_EC]) {
 535                 /* Equivalence class table defined */
 536                 u8 *equiv = EQUIV_TABLE(dfa);
 537                 /* default is direct to next state */
 538                 while (*str) {
 539                         pos = base_idx(base[state]) + equiv[(u8) *str++];
 540                         if (check[pos] == state)
 541                                 state = next[pos];
 542                         else
 543                                 state = def[state];
 544                         if (accept[state])
 545                                 break;
 546                 }
 547         } else {
 548                 /* default is direct to next state */
 549                 while (*str) {
 550                         pos = base_idx(base[state]) + (u8) *str++;
 551                         if (check[pos] == state)
 552                                 state = next[pos];
 553                         else
 554                                 state = def[state];
 555                         if (accept[state])
 556                                 break;
 557                 }
 558         }
 559
 560         *retpos = str;
 561         return state;
 562 }
 563
 564 /**
 565  * aa_dfa_matchn_until - traverse @dfa until accept or @n bytes consumed
 566  * @dfa: the dfa to match @str against  (NOT NULL)
 567  * @start: the state of the dfa to start matching in
 568  * @str: the string of bytes to match against the dfa  (NOT NULL)
 569  * @n: length of the string of bytes to match
 570  * @retpos: first character in str after match OR str + n
 571  *
 572  * aa_dfa_match_len will match @str against the dfa and return the state it
 573  * finished matching in. The final state can be used to look up the accepting
 574  * label, or as the start state of a continuing match.
 575  *
 576  * This function will happily match again the 0 byte and only finishes
 577  * when @n input is consumed.
 578  *
 579  * Returns: final state reached after input is consumed
 580  */
 581 unsigned int aa_dfa_matchn_until(struct aa_dfa *dfa, unsigned int start,
 582                                  const char *str, int n, const char **retpos)
 583 {
 584         u16 *def = DEFAULT_TABLE(dfa);
 585         u32 *base = BASE_TABLE(dfa);
 586         u16 *next = NEXT_TABLE(dfa);
 587         u16 *check = CHECK_TABLE(dfa);
 588         u32 *accept = ACCEPT_TABLE(dfa);
 589         unsigned int state = start, pos;
 590
 591         *retpos = NULL;
 592         if (state == 0)
 593                 return 0;
 594
 595         /* current state is <state>, matching character *str */
 596         if (dfa->tables[YYTD_ID_EC]) {
 597                 /* Equivalence class table defined */
 598                 u8 *equiv = EQUIV_TABLE(dfa);
 599                 /* default is direct to next state */
 600                 for (; n; n--) {
 601                         pos = base_idx(base[state]) + equiv[(u8) *str++];
 602                         if (check[pos] == state)
 603                                 state = next[pos];
 604                         else
 605                                 state = def[state];
 606                         if (accept[state])
 607                                 break;
 608                 }
 609         } else {
 610                 /* default is direct to next state */
 611                 for (; n; n--) {
 612                         pos = base_idx(base[state]) + (u8) *str++;
 613                         if (check[pos] == state)
 614                                 state = next[pos];
 615                         else
 616                                 state = def[state];
 617                         if (accept[state])
 618                                 break;
 619                 }
 620         }
 621
 622         *retpos = str;
 623         return state;
 624 }
 625
 626 #define inc_wb_pos(wb)                                          \
 627 do {                                                            \
 628         wb->pos = (wb->pos + 1) & (wb->size - 1);               \
 629         wb->len = (wb->len + 1) & (wb->size - 1);               \
 630 } while (0)
 631
 632 /* For DFAs that don't support extended tagging of states */
 633 static bool is_loop(struct match_workbuf *wb, unsigned int state,
 634                     unsigned int *adjust)
 635 {
 636         unsigned int pos = wb->pos;
 637         unsigned int i;
 638
 639         if (wb->history[pos] < state)
 640                 return false;
 641
 642         for (i = 0; i <= wb->len; i++) {
 643                 if (wb->history[pos] == state) {
 644                         *adjust = i;
 645                         return true;
 646                 }
 647                 if (pos == 0)
 648                         pos = wb->size;
 649                 pos--;
 650         }
 651
 652         *adjust = i;
 653         return true;
 654 }
 655
 656 static unsigned int leftmatch_fb(struct aa_dfa *dfa, unsigned int start,
 657                                  const char *str, struct match_workbuf *wb,
 658                                  unsigned int *count)
 659 {
 660         u16 *def = DEFAULT_TABLE(dfa);
 661         u32 *base = BASE_TABLE(dfa);
 662         u16 *next = NEXT_TABLE(dfa);
 663         u16 *check = CHECK_TABLE(dfa);
 664         unsigned int state = start, pos;
 665
 666         AA_BUG(!dfa);
 667         AA_BUG(!str);
 668         AA_BUG(!wb);
 669         AA_BUG(!count);
 670
 671         *count = 0;
 672         if (state == 0)
 673                 return 0;
 674
 675         /* current state is <state>, matching character *str */
 676         if (dfa->tables[YYTD_ID_EC]) {
 677                 /* Equivalence class table defined */
 678                 u8 *equiv = EQUIV_TABLE(dfa);
 679                 /* default is direct to next state */
 680                 while (*str) {
 681                         unsigned int adjust;
 682
 683                         wb->history[wb->pos] = state;
 684                         pos = base_idx(base[state]) + equiv[(u8) *str++];
 685                         if (check[pos] == state)
 686                                 state = next[pos];
 687                         else
 688                                 state = def[state];
 689                         if (is_loop(wb, state, &adjust)) {
 690                                 state = aa_dfa_match(dfa, state, str);
 691                                 *count -= adjust;
 692                                 goto out;
 693                         }
 694                         inc_wb_pos(wb);
 695                         (*count)++;
 696                 }
 697         } else {
 698                 /* default is direct to next state */
 699                 while (*str) {
 700                         unsigned int adjust;
 701
 702                         wb->history[wb->pos] = state;
 703                         pos = base_idx(base[state]) + (u8) *str++;
 704                         if (check[pos] == state)
 705                                 state = next[pos];
 706                         else
 707                                 state = def[state];
 708                         if (is_loop(wb, state, &adjust)) {
 709                                 state = aa_dfa_match(dfa, state, str);
 710                                 *count -= adjust;
 711                                 goto out;
 712                         }
 713                         inc_wb_pos(wb);
 714                         (*count)++;
 715                 }
 716         }
 717
 718 out:
 719         if (!state)
 720                 *count = 0;
 721         return state;
 722 }
 723
 724 /**
 725  * aa_dfa_leftmatch - traverse @dfa to find state @str stops at
 726  * @dfa: the dfa to match @str against  (NOT NULL)
 727  * @start: the state of the dfa to start matching in
 728  * @str: the null terminated string of bytes to match against the dfa (NOT NULL)
 729  * @count: current count of longest left.
 730  *
 731  * aa_dfa_match will match @str against the dfa and return the state it
 732  * finished matching in. The final state can be used to look up the accepting
 733  * label, or as the start state of a continuing match.
 734  *
 735  * Returns: final state reached after input is consumed
 736  */
 737 unsigned int aa_dfa_leftmatch(struct aa_dfa *dfa, unsigned int start,
 738                               const char *str, unsigned int *count)
 739 {
 740         DEFINE_MATCH_WB(wb);
 741
 742         /* TODO: match for extended state dfas */
 743
 744         return leftmatch_fb(dfa, start, str, &wb, count);
 745 }