Variables
@{VAR} and sets for application developers
A set variable is a name for one or several pieces of path text. It is assigned in the preamble and a reference in a rule is replaced by its values before the rule is compiled. Several values become an alternation. Slashes next to a reference are trimmed. The kernel receives only the expanded pattern.
On the map: preamble and reuse
▶ Watch this deck — 8 scenes, ~6 min
Worth seeing first
- The preamble — the preamble, where variables are assigned
- Abstractions and tunables — the tunables files that declare most variables you use
Part of journeys
- Write your first profile, step 4 of 12 · previous: Abstractions and tunables · next: Globbing (AARE)
01 One name for two directories
@{APP_DATA} = /var/lib/demo /srv/demo names two directories. A rule that uses the variable is compiled for both.
Demo keeps its data in two places: the usual one, /var/lib/demo, and a second one, /srv slash demo. You could write every rule twice. Instead, line 3 of the preamble gives the pair a name, and the rules use the name. That's the @{APP_DATA} variable. When the profile is compiled, the name is replaced by its values, so the one rule covers both directories. Ask the parser for the rule it actually built, and you see the two directories side by side in one pattern. The variable itself is gone by then: the kernel only ever gets the expanded rule.
Details and sources
Details
- The line is line 3 of this district's example file:
@{APP_DATA} = /var/lib/demo /srv/demo. The rule is its line 10:owner @{APP_DATA}/{cache,state}/** rwk,. - The dump line in full, run with the tree's parser for this deck (
-Q -K --skip-kernel-load -D rule-exprs):aare: {/srv/demo,/var/lib/demo}/{cache,state}/** -> (/srv/demo|/var/lib/demo)/(cache|state)/[^/\x00][^\x00]*. The slide shows the text left of the arrow. - Expansion is done when the profile is compiled, and only then. The compiled profile holds the expanded pattern; the kernel has no variables.
- The utilities do not expand variables when they match a path against a rule.
- Known discrepancy: The utilities' path matching ignores variables, so aa-logprof does not see that a rule with
@{...}covers a logged path. - The program
demo, its files and its profile are invented for the map.
Read more
- apparmor.d(5), Variables.
- apparmor.net: Profiles quick reference.
- Globbing: the alternation in the compiled rule.
for AppArmor developers for security researchers
In the code
- Expansion runs once per profile after parsing:
process_profile_variables(parser_variable.c:137-179). - The substitution itself:
variable::expand_by_alternation(variable.cc:252-340).
02 A name in curly braces, and a line of values
@{NAME} = value value ... up to the end of the line. Names are case sensitive; values may be quoted.
A variable is an at sign, an opening curly brace, a name and a closing brace. You give it values in the preamble: the variable, an operator, and then values separated by blanks, up to the end of the line. A value is a word, or a quoted string if it has a space in it, and two quotes with nothing between them make an empty value. Note what's missing: there's no comma. The line end finishes the assignment, unless a backslash carries it on. The name starts with a letter and goes on with letters, digits and underscores, and case matters. The other operators have their own deck.
Details and sources
Details
- A reference is
@{NAME}. The name is a letter followed by letters, digits and underscores, and it is case sensitive:@{Case}and@{case}are two variables (run with the tree's parser for this deck:-D variablesprints@case = "/lower"and@Case = "/upper"). - apparmor.d(5) gives the same form:
VARIABLE = '@{' ALPHA [ ( ALPHANUMERIC | '_' ) ... ] '}'(apparmor.d.pod:112). - An assignment is the variable, one of four operators and values up to the end of the line. Each word or quoted string is one value.
""is the empty value. - A quoted value may hold a comma:
@{LIBVIRT} = "libvirt,"(vars_simple_assignment_13.sd, expected to pass). - A comma outside quotes is refused:
Variable declarations do not accept trailing commas. - The continued line on the slide was run with the tree's parser for this deck:
@{APP_DATA} = /var/lib/demo \followed by/srv/demo # two placesgives@APP_DATA = "/srv/demo" "/var/lib/demo", exit status 0. - Assignments stand in the preamble only: see the preamble. The four operators are in variable assignment.
- The scanner also accepts
@NAMEwithout braces in an assignment, and it is the same variable as@{NAME}. - Known discrepancy:
@NAMEwithout braces is accepted in a rule and compiled as literal text. Recorded in the research notes:@NOBRACE = /nband the rule@NOBRACE/x r,printaare: @NOBRACE/x, exit status 0.
for AppArmor developers for security researchers
In the code
VARIABLE_NAME [[:alpha:]][[:alnum:]_]*andSET_VARIABLE @(\{VARIABLE_NAME\}|VARIABLE_NAME)(parser_lex.l:296-298).- After the operator the scanner is in
ASSIGN_MODEuntil the end of the line (parser_lex.l:564-590, parser_lex.l:824-832): each word or quoted string is oneTOK_VALUE,\at the end of a line continues the list, a comma is the error. varassign: TOK_SET_VAR assign_op valuelist(parser_yacc.y:524-548).
03 The home variable, step by step
@{HOME}/.ssh/** becomes {/home/*,/root}/.ssh/**: the values joined as an alternation, with slashes trimmed at the joint.
Follow one rule through. Demo denies access to .ssh under the @{HOME} variable. The table says that variable has two values: root's own directory, and a second one that's built from another variable, the @{HOMEDIRS} variable. The parser fills that in first, so the second value becomes every directory under /home. Then it tidies the joints. The rule continues with a slash after the variable, so each value drops its own trailing slash. Finally the two values go into curly braces, separated by a comma: an alternation, the same one you could have written by hand. A variable with a single value is simply replaced, without braces.
Details and sources
Details
- The rule is line 11 of the example file:
audit deny @{HOME}/.ssh/** rw,. - The two table lines are from
-D variables, which prints the table as written:@HOME = "/root/" "@{HOMEDIRS}/*/"and@HOMEDIRS = "/home/". Both variables come from the shipped filetunables/home: see abstractions and tunables. - The resolved values are from
-D expanded-variables:@HOME = "/home//*/" "/root/". - The result is the
aare:line of-D rule-exprs:{/home/*,/root}/.ssh/**. All three dumps were run with the tree's parser for this deck. - The double slash in
/home//*/is what the dump prints. The compiled rule has/home/*: file rule paths pass through a filter that turns repeated slashes into one. - Trimming: when the text before the reference ends in
/, leading slashes of each value are trimmed; when the text after it begins with/, trailing slashes are trimmed. Recorded in the research notes:/srv/@{HOME}/x r,compiles as/srv/{home/*,root}/x. - A value may refer to other variables. They are resolved when the variable is first needed, so a reference may stand before the assignment it refers to:
@{b} = @{A}/fwdbefore@{A} = /ais accepted (recorded in the research notes). - The single-value example was run with the tree's parser for this deck: with
tunables/globalincluded,@{PROC}/sys/ r,printsaare: /proc/sys/. The shipped value is@{PROC}=/proc/. - Known discrepancy: A variable after a prefix of only slashes keeps its leading
/, so the rule starts with//and never matches.
Read more
- apparmor.d(5), Variables.
- Globbing: alternations.
- File rules.
for AppArmor developers for security researchers
In the code
variable::expand_by_alternation(variable.cc:252-340); the trimming is at lines 288-295 and 310-322.expand_variableresolves nested references and keeps the result inexpanded(variable.cc:342-404).- Path rules then pass through
filter_slashes.
04 Values are a set, not a list
Values are stored as a set: no duplicates, and printed in text order. "" is the empty value.
Three small facts about values. A quoted value keeps its space, and in the expanded rule it's just one of the alternatives. The empty value, two quotes, expands to nothing, which is handy for an optional part of a path. And the values form a set, not a list. Write the same value twice and it's stored once. Print the table, and the values come out in text order, not in the order you wrote them. That doesn't change what a rule matches, since an alternation doesn't care about order, but it explains why the dump looks rearranged.
Details and sources
Details
- The first two assignments and their rules are from a profile recorded in the research notes:
@{D} = "with space" plainwith/q/@{D} r,printsaare: /q/{plain,with space};@{E} = ""with/e/@{E}/x r,printsaare: /e/x. - The third line is the example file's line 3.
-D variablesprints@APP_DATA = "/srv/demo" "/var/lib/demo"for it (run with the tree's parser for this deck). The whole dump has 85 lines, becausetunables/globaldefines the rest. - Duplicates collapse:
@{DUP} = /a /a /bprints@DUP = "/a" "/b", and@{DUP}/x r,compiles as{/a,/b}/x(run with the tree's parser for this deck). -D variablesprints the table as written (@HOME = "/root/" "@{HOMEDIRS}/*/"),-D expanded-variablesafter expansion (@HOME = "/home//*/" "/root/"). Both print names as@NAMEwithout braces, and boolean variables as$NAME = true.- A comma is not a separator:
@{A} = /a,is the errorVariable declarations do not accept trailing commas. - That the order of an alternation does not change what a rule matches is derived: the alternation is compiled as a regular expression of alternatives.
for AppArmor developers for security researchers
In the code
- The values are a
std::set<std::string>(variable.h:35): no duplicates, ordered as strings. - The dumps: variable.cc:412-420, parser_main.c:637-646, parser_main.c:1386-1400.
05 Where a reference is expanded
Variables are expanded in the paths, names and labels of most rule classes and in the profile head, once per profile after parsing.
Where can you use a variable? Almost anywhere a rule has a path, a name or a label. Even the profile's own name and attachment may use one. File rules, of course. Link rules, on both sides of the arrow. The peer of a signal or ptrace rule. The mount point of a mount rule, D-Bus paths and names, unix socket addresses. Rule classes that are made of fixed words only, like capability or network, have nothing to expand. All of this happens once per profile, after the whole file has been parsed. So order matters little: one variable's value can even mention another that's assigned further down.
Details and sources
Details
- The five rule lines are illustrations built from the list of places where the parser expands variables. They were run together through the tree's parser for this deck, with
tunables/globalincluded, and compile with exit status 0. The dump shows{/srv/demo,/var/lib/demo}/**,{/srv/demo,/var/lib/demo}/currentand{/srv/demo,/var/lib/demo}/releases/*,demo//worker,{/run,/var/run}/demo/and/org/demo/followed by the alternation of digit patterns that@{pid}stands for. - Expanded: the profile name, the attachment and the
attach_disconnected.pathandattach_disconnected.ipcvalues; file rule paths and link targets; mount point, device, transition and option and fstype values; dbus bus, name, peer label, path, interface and member; signal and ptrace peer labels; labels and unix addresses; mqueue name and label. - Nothing to expand:
network,io_uringandusernsrules (from the code). That a capability rule has no text to expand is derived: it is a list of fixed words. - Expansion runs once per profile after the whole file has been parsed. A value may mention a variable that is assigned further down:
@{b} = @{A}/fwdbefore@{A} = /ais accepted (recorded in the research notes). - Known discrepancy: A variable in an exec target is accepted and never expanded.
- Known discrepancy: Variables in
io_uring ... label=are not expanded. - Known discrepancy: A variable cannot begin an mqueue name.
- Known discrepancy: A profile name that begins with a variable is refused unless the head has the
profilekeyword.
Read more
- apparmor.d(5), Variables.
- The profile name.
- Rule conditionals: peers, labels and addresses.
- Post-processing.
for AppArmor developers for security researchers
In the code
process_profile_variables(parser_variable.c:137-179), called from parser_policy.c:133; the head and theattach_disconnectedvalues at parser_variable.c:58-85.- Per rule class: file and link rules block_rules.cc:393-407, mount mount.cc:641, dbus dbus.cc:176, signal signal.cc:249, ptrace ptrace.cc:108, labels and unix addresses af_rule.cc:161 and af_unix.cc:166, mqueue mqueue.cc:179.
expand_variablesofnetwork,io_uringandusernsreturn 0: network.cc:664, io_uring.cc:106, userns.cc:91.
06 One table, text substitution, per profile for AppArmor developers for security researchers
variable.cc:252-340 expands the first @{...} and repeats; parser_variable.c:137-179 runs it per profile.
Under the hood there's one symbol table, a map from a name to a variable object. It holds booleans as well as sets, which is why the two kinds can't share a name. Expansion is plain text substitution. A function finds the first at sign and curly brace in a string, looks the name up, makes sure its own nested references are resolved, trims slashes at the joint, and writes either the single value or a brace alternation. Then it repeats on the rest of the string. This runs per profile after parsing, and every rule class brings its own function that says which of its strings to expand.
Details and sources
for AppArmor developers for security researchers
Details
- The table is a map from name to
variable(symtab.cc:25-151):add_var(25-76),add_set_value(90-101),delete_var(103-112),get_set_var(135-151). - In variable.cc:
is_var(74-131),process_var(133-151),extract_variable(variable.cc:169-221),expand_by_alternation(variable.cc:252-340),expand_variable(variable.cc:342-404). - Only
@{starts a reference inside a string;\@does not (variable.cc:184-194). - A nested reference is resolved the first time the variable is needed and the result is kept in
expanded(variable.cc:353-355). - Recursion is detected:
Variable @{A} is referenced recursively (by @{B})(variable.cc:378-383). process_profile_variables(parser_variable.c:137-179) is called once per profile from parser_policy.c:133.- Known discrepancy: A failed expansion inside a variable's value ends in
std::bad_allocinstead of an error. Recorded in the research notes:@{A} = /a/@{UNDEF}with the rule@{A}/x r,printsFailed to find declaration for: @{UNDEF}and thenterminate called after throwing an instance of 'std::bad_alloc'. - Known discrepancy: A variable defined from
@{profile_name},@{attach_path}or@{exec_path}keeps the value of the first profile that uses it. Recorded in the research notes:@{DIR} = /var/lib/@{profile_name}used in the profilesoneandtwocompiles/var/lib/one/**in both.
for security researchers
Attack surface
- A variable widens every rule that uses it, in every profile whose preamble includes its definition.
- The definition can be extended from a
.ddirectory: see include if exists. - The expanded rule, not the written one, is what is enforced. Review with
-D rule-exprs. - Values are not checked for pattern characters. A value
*or**is a glob in every rule that uses the variable (derived from the substitution being textual; not run).
Read more
07 Mistakes and their messages
No comma after an assignment. Failed to find declaration for: @{NAME} means the name was never assigned in this file's preamble.
The mistakes. A comma at the end of an assignment, out of habit from rules: the parser says so in plain words. Nothing after the equals sign. A name that starts with a digit, which the scanner doesn't recognise as a variable at all. Then the common one: a name that was never assigned, usually a typo or a missing include of the tunables. And a boolean variable used in a path is refused, because a boolean isn't a set. Those last two messages give you the variable and the profile, but no line number, so search the file for the name.
Details and sources
Details
- Every row ends with exit status 1. All five were run with the tree's parser for this deck, with demo's names.
- Row 1 in full:
AppArmor parser error for /work/v-comma.sd in profile /work/v-comma.sd at line 1: Variable declarations do not accept trailing commas. The wordsin profileare followed by the name of the file being parsed, not by a profile name. - Row 2 in full:
... at line 2: syntax error, unexpected TOK_PROFILE, expecting TOK_VALUE. The token named is whatever follows the empty assignment; here it is theprofilekeyword of the next line. - Row 3: the scanner does not take
@{4DATA}for a variable, so it stops at the@. - Row 4: the two lines on the slide are all that is printed. The rule was
@{APPDATA}/** rw,in the profiledemo, withtunables/globalincluded. - Row 5 prints three lines:
Variable DEMO_DEBUG is not a set variable,Failed to find declaration for: @{DEMO_DEBUG},ERROR expanding variables for profile demo, failed to load. The slide shows the first two. - From the code, not run:
Variable '%s' must start with alphabet lettersandVariable '%s' contains invalid characters, for a malformed name inside a string. @{a,b}in a rule is left as it is and, with--warn=all, drawsThe usage of comma in the variable formatting to indicate alternation is deprecated. Escape the character @ to indicate it is not a variable.The warning class isdeprecated, off by default (recorded in the research notes).- Known discrepancy: An undefined variable is reported without file name or line.
- Known discrepancy: The deprecation warning for
@{a,b}advises escaping@, the escape draws a warning of its own, and a later variable in the same string is left unexpanded. - Known discrepancy:
@NAMEwithout braces is accepted in a rule and compiled as literal text.
for AppArmor developers for security researchers
In the code
- The comma: parser_lex.l:570-574. The undefined name: variable.cc:297-300. The name checks: variable.cc:108 and variable.cc:113. The deprecation warning: variable.cc:276-283.
08 Setting them, and the ones you get for free
Onward: syn-variable-assignment, syn-builtin-variables, syn-boolean-variables, syn-globbing.
That's a set variable: a name, some values, and an alternation in the compiled rule. How the four operators set, extend and replace a variable is in the deck on variable assignment, and the tunables deck shows where the shipped variables come from. The three variables the parser defines for you, like the profile's own name, have the built-in variables deck, and the boolean kind has a deck too. And if the curly braces of the alternation are new to you, the globbing deck explains them.
Details and sources
Details
@{NAME}is a set of strings, assigned in the preamble, case sensitive.- A reference is replaced by the single value, or by
{v1,v2,...}when there are several. Slashes at the joint are trimmed. - Expansion happens once per profile, after parsing. The compiled profile holds only the expanded patterns.
-D variablesand-D expanded-variablesprint the table;-D rule-exprsprints the rules after expansion.- Commit read for this deck: AppArmor 836052d21 (6.0.0~alpha2). Variables have no kernel side.
Read more
Basis of the statements on this page: "tree" means the parser built from the AppArmor commit 836052d21 (6.0.0~alpha2) was run on the fragment (-Q -K --skip-kernel-load, with the tree's abi/5.0 as kernel feature set and the dump option named), with nothing loaded into a kernel; "code" means the parser source was read and not run; "derived" means the result was reasoned from that code. Nothing here was observed on a running kernel.
Grammar
reference: @{NAME}
NAME: a letter, then letters, digits and _ (case sensitive)
assignment: @{NAME} ( = | += | ?= | := ) VALUE ... up to the end of the line
VALUE: a word | "a quoted string" | ""
- Assignments stand in the preamble, before the first profile (code).
- Values are separated by blanks. There is no comma at the end; a comma outside quotes is an error (tree).
- A quoted value keeps its spaces and may hold a comma:
@{LIBVIRT} = "libvirt,"(the parser's testvars_simple_assignment_13.sd). ""is the empty value (tree).- A
#comment may follow the values, and\at the end of a line continues the list on the next line (tree). @{Case}and@{case}are two variables (tree).@NAMEwithout braces is accepted in an assignment and is the same variable as@{NAME}(tree).- The four operators: see variable assignment.
Expansion
| Case | Written | Compiled | Basis |
|---|---|---|---|
| one value | @{PROC}/sys/ with @{PROC}=/proc/ | /proc/sys/ | tree |
| several values | @{HOME}/.ssh/** | {/home/*,/root}/.ssh/** | tree |
text before ends in / | /srv/@{HOME}/x | /srv/{home/*,root}/x | tree |
| quoted value | /q/@{D} with @{D} = "with space" plain | /q/{plain,with space} | tree |
| empty value | /e/@{E}/x with @{E} = "" | /e/x | tree |
| duplicate value | @{DUP}/x with @{DUP} = /a /a /b | {/a,/b}/x | tree |
- When the text before the reference ends in
/, leading slashes of each value are trimmed. When the text after it begins with/, trailing slashes are trimmed (code). - File rule paths then pass through a filter that turns repeated slashes into one (code).
- A value may refer to other variables. They are resolved the first time the variable is needed (code).
- A reference may stand before the assignment it refers to:
@{b} = @{A}/fwdbefore@{A} = /a(tree). - Values are a set: duplicates are stored once, and the order is that of the strings, not of writing (code; tree for the dump).
Where a reference is expanded
| Place | Fields | Source |
|---|---|---|
| profile head | the name, the attachment, the attach_disconnected.path and .ipc values | parser_variable.c:58-85 |
| file rules | the path | block_rules.cc:393-407 |
| link rules | the link and the target | block_rules.cc:393-407 |
| mount rules | mount point, device, transition, option and fstype values | mount.cc:641 |
| dbus rules | bus, name, peer label, path, interface, member | dbus.cc:176 |
| signal rules | the peer label | signal.cc:249 |
| ptrace rules | the peer label | ptrace.cc:108 |
| unix rules | labels and addresses | af_rule.cc:161, af_unix.cc:166 |
| mqueue rules | the name and the label | mqueue.cc:179 |
- Not expanded, because the class has no text to expand:
network,io_uring,userns(code). - The table is from the code. One rule each of the file, link, signal, mount and dbus rows was run (tree).
The two dumps
| Option | Prints | For the example file |
|---|---|---|
-D variables | the table as written | @HOME = "/root/" "@{HOMEDIRS}/*/", @HOMEDIRS = "/home/", @APP_DATA = "/srv/demo" "/var/lib/demo", $DEMO_DEBUG = false; 85 lines |
-D expanded-variables | the table after expansion | @HOME = "/home//*/" "/root/"; the others unchanged |
-D rule-exprs | each rule after expansion | aare: {/home/*,/root}/.ssh/**, aare: {/srv/demo,/var/lib/demo}/{cache,state}/** |
- Names are printed as
@NAMEwithout braces, boolean variables as$NAME = true(tree).
Errors and warnings
| Message | Cause | Exit | Basis |
|---|---|---|---|
Variable declarations do not accept trailing commas | a comma at the end of an assignment | 1 | tree |
syntax error, unexpected TOK_PROFILE, expecting TOK_VALUE | no value after the operator; the token named is the next one in the file | 1 | tree |
Lexer found unexpected character: '@' (0x40) in state: INITIAL | a name that starts with a digit | 1 | tree |
Failed to find declaration for: @{NAME} then ERROR expanding variables for profile P, failed to load | a name that was never assigned | 1 | tree |
Variable NAME is not a set variable then the two lines above | a boolean variable used as a set | 1 | tree |
Variable @{A} is referenced recursively (by @{B}) | two variables that refer to each other | see the known discrepancies | tree |
Variable '%s' must start with alphabet letters, Variable '%s' contains invalid characters | a malformed name inside a string | code | |
The usage of comma in the variable formatting to indicate alternation is deprecated. Escape the character @ to indicate it is not a variable. | @{a,b} in a rule; class deprecated, off by default | warning | tree, with --warn=all |
for security researchers
Attack surface
- A variable widens every rule that uses it, in every profile whose preamble includes its definition.
- A definition can be extended by any text that is included later, for example a file in a
.ddirectory: see include if exists. - What is enforced is the expanded rule.
-D rule-exprsprints it; the profile text does not. - Values are not checked for pattern characters, so a value
*or**is a glob in every rule that uses the variable (derived).
for AppArmor developers for security researchers
In the code
- Scanner:
VARIABLE_NAME,SET_VARIABLE(parser_lex.l:296-298);ASSIGN_MODE(parser_lex.l:564-590, parser_lex.l:824-832). - Grammar:
varassign: TOK_SET_VAR assign_op valuelist(parser_yacc.y:524-548). - Table: symtab.cc:25-151. Values:
std::set<std::string>(variable.h:35). - Expansion:
extract_variable(variable.cc:169-221),expand_by_alternation(variable.cc:252-340),expand_variable(variable.cc:342-404). - Per profile:
process_profile_variables(parser_variable.c:137-179), called from parser_policy.c:133.
for AppArmor developers for security researchers
Known discrepancies
- A variable defined from
@{profile_name},@{attach_path}or@{exec_path}keeps the value of the first profile that uses it. Run:@{DIR} = /var/lib/@{profile_name}used in the profilesoneandtwocompiles/var/lib/one/**in both;-D expanded-variablesprints@DIR = "/var/lib/one"; exit status 0. - A failed expansion inside a variable's value ends in
std::bad_allocinstead of an error. Runs:@{A} = /a/@{UNDEF}with the rule@{A}/x r,;@{A} = @{B}and@{B} = @{A}with the rule/x/@{A} r,. @NAMEwithout braces is accepted in a rule and compiled as literal text. Run:@NOBRACE = /nband the rule@NOBRACE/x r,printaare: @NOBRACE/x, exit status 0.- The deprecation warning for
@{a,b}advises escaping@, the escape draws a warning of its own, and a later variable in the same string is left unexpanded. Runs:/a/@{x,y}/@{H} r,prints the warning and thenRegex grouping error: Invalid number of items between {}, exit status 255;/a/\@{x,y} r,printsCharacter @ was quotedunnecessarily, dropped preceding quote ('\') character. - An undefined variable is reported without file name or line.
- A variable after a prefix of only slashes keeps its leading
/, so the rule starts with//and never matches. - A variable in an exec target is accepted and never expanded.
- Variables in
io_uring ... label=are not expanded. - A variable cannot begin an mqueue name.
- A profile name that begins with a variable is refused unless the head has the
profilekeyword. - The utilities' path matching ignores variables, so aa-logprof does not see that a rule with
@{...}covers a logged path.
Roads from here
START HERE
- The profile language at a glance — every kind of line on one page
FILE ACCESS
- Globbing (AARE) — the alternation a set expands to
- File rules — the rules most variables are used in
PREAMBLE AND REUSE
- Variable assignment — the four operators that set a variable
- Built-in variables — the three variables the parser defines itself
- Boolean variables — the other kind of variable
- Abstractions and tunables — where the shipped variables come from
PROFILE HEAD
- The profile name — variables in a profile name and attachment
RULE CLASSES
- Rule conditionals — variables in peer labels and addresses
PROFILE STRUCTURE
- Quoting and escaping — quoted values with spaces
INSIDE THE PARSER
- Post-processing (no slides yet) — when expansion runs