| aes-cfb-128-encrypted-string |
string |
The aes-cfb-128-encrypted-string works exactly like
des3-cbc-encrypted-string but AES/128bits in CFB mode is used to
encrypt the string. The prefix for encrypted values is '$8$'. |
| aes-cfb-128-encrypted-string |
string |
The aes-cfb-128-encrypted-string works exactly like
des3-cbc-encrypted-string but AES/128bits in CFB mode is used to
encrypt the string. The prefix for encrypted values is '$8$'. |
| aes-cfb-128-encrypted-string |
string |
The aes-cfb-128-encrypted-string works exactly like
des3-cbc-encrypted-string but AES/128bits in CFB mode is used to
encrypt the string. The prefix for encrypted values is '$8$'. |
| aes-cfb-128-encrypted-string |
string |
The aes-cfb-128-encrypted-string works exactly like
des3-cbc-encrypted-string but AES/128bits in CFB mode is used to
encrypt the string. The prefix for encrypted values is '$8$'. |
| cli-template-string |
string |
A template is a text string which is expanded by the CLI engine,
and then displayed to the user.
The template may contain a mix of text and expandable entries.
Expandable entries all start with $( and end with a matching ).
Parentheses and dollar signs need to be quoted in plain text.
The template is expanded as follows:
A parameter is either a relative or absolute path to a leaf
element (eg /foo/bar, foo/bar), or one of the builtin variables:
.selected, .entered, .legend_shown, .user, .groups, .ip,
.display_groups, .path, .ipath or .licounter. In addition the
variables .spath and .ispath are available when a command
is executed from a show path.
.selected
The .selected variable contains the list of selected paths
to be shown. The show template can inspect this element to
determine if a given element should be displayed or
not. For example:
$(.selected~=hwaddr?HW Address)
.entered
The .entered variable is true if the "entered" text has
been displayed (either the auto generated text or a
showTemplateEnter). This is useful when having a non-table
template where each instance should have a text.
$(.entered?:host $(name))
.legend_shown
The .legend_shown variable is true if the "legend" text has
been displayed (either the auto generated table header or
a showTemplateLegend). This is useful to inspect when
displaying a table row. If the user enteres the path to a
specific instance the builtin table header will not be
displayed and the showTemplateLegend will not be invoked
and it may be useful to render the legend specifically
for this instance.
$(.legend_shown!=true?Address Interface)
.user
The .user variable contains the name of the current
user. This can be used for differentiating the content
displayed for a specific user, or in paths. For exapmle:
$(user{$(.user)}/settings)
.groups
The .groups variable contains the a list of groups that the
user belongs to.
.display_groups
The .display_groups variable contains a list of selected
display groups. This can be used to display different
content depending on the selected display group. For
example:
$(.display_groups~=details?details...)
.ip
The .ip variable contains the ip address that the user
connected from.
.path
The .path variable contains the path to the entry,
formated in CLI style.
.ipath
The .ipath variable contains the path to the entry,
formated in template style.
.spath
The .spath variable contains the show path,
formated in CLI style.
.ispath
The .ispath variable contains the show path,
formated in template style.
.licounter
The .licounter variable contains a counter that is
incremented for each instance in a list. This means that
it will be 0 in the legend, contain the total number of
list instances in the footer and something in between in
the basic show template.
$(parameter)
The value of 'parameter' is substituted.
$(cond?word1:word2)
The expansion of 'word1' is substituted if 'cond'
evaluates to true, otherwise the expansion of 'word2' is
substituted.
'cond' may be one of
parameter
Evaluates to true if the node exists.
parameter == <value>
Evaluates to true if the value of the parameter equals
<value>.
parameter != <value>
Evalutes to true if the value of the parameter does not
equal <value>
parameter ~= <value>
Provided that the value of the parameter is a list
(i.e., the node that the parameter refers to is a
leaf-list), this expression evaluates to true if <value>
is a member of the list.
$(parameter|filter)
The value of 'parameter' processed by 'filter' is
substituted. Filters may be either one of the
built-ins or a customized filter defined in a
callback. See /confdConfig/cli/templateFilter.
A built-in 'filter' may be one of:
capfirst
Capitalizes the first character of the value.
lower
Converts the value into lowercase.
upper
Converts the value into uppercase.
filesizeformat
Formats the value in a human-readable format (e.g.,
'13 KB', '4.10 MB', '102 bytes' etc), where K
means 1024, M means 1024*1024 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, filesizeformat will display the
given number of decimal places.
humanreadable
Similar to filesizeformat except no bytes suffix
is added (e.g., '13.00 k', '4.10 M' '102' etc),
where k means 1000, M means 1000*1000 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, humanreadable will display the
given number of decimal places.
commasep
Separate the numerical values into groups of three
digits using a comma (e.g., 1234567 -> 1,234,567)
hex
Display integer as hex number. An argument can be
used to indicate how many digits should be used in
the output. If the hex number is too long it will
be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hex }} 3039
12345 {{ value|hex:2 }} 39
12345 {{ value|hex:8 }} 00003039
12345 {{ value|hex:-8 }} 3039
14911 {{ value|hex:-8:upper }} 3A3F
14911 {{ value|hex:-8:lower }} 3a3f
hexlist
Display integer as hex number with : between pairs. An
argument can be used to indicate how many digits should
be used in the output. If the hex number is too long it
will be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hexlist }} 30:39
12345 {{ value|hexlist:2 }} 39
12345 {{ value|hexlist:8 }} 00:00:30:39
12345 {{ value|hexlist:-8 }} 30:39
14911 {{ value|hexlist:-8:upper }} 3A:3F
14911 {{ value|hexlist:-8:lower }} 3a:3f
floatformat
Used for type 'float' in tailf-xsd-types. We recommend
that the YANG built-in type 'decimal64' is used instead of
'float'.
When used without an argument, rounds a floating-point
number to one decimal place -- but only if there is a
decimal part to be displayed.
For example:
value Template Output
34.23234 {{ value|floatformat }} 34.2
34.00000 {{ value|floatformat }} 34
34.26000 {{ value|floatformat }} 34.3
If used with a numeric integer argument, floatformat
rounds a number to that many decimal places. For example:
value Template Output
34.23234 {{ value|floatformat:3 }} 34.232
34.00000 {{ value|floatformat:3 }} 34.000
34.26000 {{ value|floatformat:3 }} 34.260
If the argument passed to floatformat is negative, it will
round a number to that many decimal places -- but only if
there's a decimal part to be displayed. For example:
value Template Output
34.23234 {{ value|floatformat:-3 }} 34.232
34.00000 {{ value|floatformat:-3 }} 34
34.26000 {{ value|floatformat:-3 }} 34.260
Using floatformat with no argument is equivalent to using
floatformat with an argument of -1.
ljust:width
Left-align the value given a width.
rjust:width
Right-align the value given a width.
trunc:width
Truncate value to a given width.
lower
Convert the value into lowercase.
upper
Convert the value into uppercase.
show:<dictionary>
Substitutes the result of invoking the default display
function for the parameter. The dictionary can be used
for introducing own variables that can be accessed in
the same manner as builtin variables. The user defined
variables overrides builtin variables. The dictionary
is specified as a string on the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|show:myvar1=true:myvar2=Interface)
the user defined variables can be accessed like this:
$(.myvar1!=true?Address) $(.myvar2)
A special case is the dict variable 'indent'. It
controls the indentation level of the displayed path.
The current indent level can be incremented and
decremented using =+ and =-.
For example:
$(foobar|show:indent=+2)
$(foobar|show:indent=-1)
$(foobar|show:indent=10)
Another special case is he dict variable 'noalign'.
It may be used to suppress the default aligning that
may occur when displaying an element.
For example:
$(foobar|show:noalign)
dict:<dictionary>
Translates the value using the dictionary. Can for
example be used for displaying on/off instead of
true/false. The dictionary is specified as a string on
the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|dict:true=on:false=off)
if the leaf 'foo' has value 'true', it is displayed as 'on', and
if its value is 'false' it is displayed as 'off'.
Nested invocations are allowed, ie it is possible to have expressions
like $((state|dict:yes=Yes:no=No)|rjust:14), or $(/foo{$(../bar)})
For example:
list interface {
key name;
leaf name { ... }
leaf status { ... }
container line {
leaf status { ... }
}
leaf mtu { ... }
leaf bw { ... }
leaf encapsulation { ... }
leaf loopback { ... }
tailf:cli-show-template
'$(name) is administratively $(status),'
+ ' line protocol is $(line/status)\\n'
+ 'MTU $(mtu) bytes, BW $(bw|humanreadable)bit, \\n'
+ 'Encap $(encapsulation|upper), $(loopback?:loopback not set)\\n';
} |
| cli-template-string |
string |
A template is a text string which is expanded by the CLI engine,
and then displayed to the user.
The template may contain a mix of text and expandable entries.
Expandable entries all start with $( and end with a matching ).
Parentheses and dollar signs need to be quoted in plain text.
(Disclaimer: tailf:cli-template-string will not respect
all CLI YANG extensions existing from expandable entries.
For instance, tailf:cli-no-name-on-delete will have no
effect when the value of a node with this extension is
fetched as a result of expanding CLI templates.)
The template is expanded as follows:
A parameter is either a relative or absolute path to a leaf
element (eg /foo/bar, foo/bar), or one of the builtin variables:
.selected, .entered, .legend_shown, .user, .groups, .ip,
.display_groups, .path, .ipath or .licounter. In addition the
variables .spath and .ispath are available when a command
is executed from a show path.
.selected
The .selected variable contains the list of selected paths
to be shown. The show template can inspect this element to
determine if a given element should be displayed or
not. For example:
$(.selected~=hwaddr?HW Address)
.entered
The .entered variable is true if the "entered" text has
been displayed (either the auto generated text or a
showTemplateEnter). This is useful when having a non-table
template where each instance should have a text.
$(.entered?:host $(name))
.legend_shown
The .legend_shown variable is true if the "legend" text has
been displayed (either the auto generated table header or
a showTemplateLegend). This is useful to inspect when
displaying a table row. If the user enteres the path to a
specific instance the builtin table header will not be
displayed and the showTemplateLegend will not be invoked
and it may be useful to render the legend specifically
for this instance.
$(.legend_shown!=true?Address Interface)
.user
The .user variable contains the name of the current
user. This can be used for differentiating the content
displayed for a specific user, or in paths. For exapmle:
$(user{$(.user)}/settings)
.groups
The .groups variable contains the a list of groups that the
user belongs to.
.display_groups
The .display_groups variable contains a list of selected
display groups. This can be used to display different
content depending on the selected display group. For
example:
$(.display_groups~=details?details...)
.ip
The .ip variable contains the ip address that the user
connected from.
.path
The .path variable contains the path to the entry,
formated in CLI style.
.ipath
The .ipath variable contains the path to the entry,
formated in template style.
.spath
The .spath variable contains the show path,
formated in CLI style.
.ispath
The .ispath variable contains the show path,
formated in template style.
.licounter
The .licounter variable contains a counter that is
incremented for each instance in a list. This means that
it will be 0 in the legend, contain the total number of
list instances in the footer and something in between in
the basic show template.
$(parameter)
The value of 'parameter' is substituted.
$(cond?word1:word2)
The expansion of 'word1' is substituted if 'cond'
evaluates to true, otherwise the expansion of 'word2' is
substituted.
'cond' may be one of
parameter
Evaluates to true if the node exists.
parameter == <value>
Evaluates to true if the value of the parameter equals
<value>.
parameter != <value>
Evalutes to true if the value of the parameter does not
equal <value>
parameter ~= <value>
Provided that the value of the parameter is a list
(i.e., the node that the parameter refers to is a
leaf-list), this expression evaluates to true if <value>
is a member of the list.
Note that it is also possible to omit ':word2' in
order to print the entire statement, or nothing.
As an example $(conf?word1) will print 'word1' if conf
exists, otherwise it will print nothing.
$(cond??word1)
Double question marks can be used to achieve the same effect
as above, but with the distinction that the 'cond' variable
needs to be explicitly configured, in order to be evaluated
as existing. This is needed in the case of evaluating leafs
with default values, where the single question mark operator
would evaluate to existing even if not explicitly configured.
$(parameter|filter)
The value of 'parameter' processed by 'filter' is
substituted. Filters may be either one of the
built-ins or a customized filter defined in a
callback. See /confdConfig/cli/templateFilter.
A built-in 'filter' may be one of:
capfirst
Capitalizes the first character of the value.
lower
Converts the value into lowercase.
upper
Converts the value into uppercase.
filesizeformat
Formats the value in a human-readable format (e.g.,
'13 KB', '4.10 MB', '102 bytes' etc), where K
means 1024, M means 1024*1024 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, filesizeformat will display the
given number of decimal places.
humanreadable
Similar to filesizeformat except no bytes suffix
is added (e.g., '13.00 k', '4.10 M' '102' etc),
where k means 1000, M means 1000*1000 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, humanreadable will display the
given number of decimal places.
commasep
Separate the numerical values into groups of three
digits using a comma (e.g., 1234567 -> 1,234,567)
hex
Display integer as hex number. An argument can be
used to indicate how many digits should be used in
the output. If the hex number is too long it will
be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hex }} 3039
12345 {{ value|hex:2 }} 39
12345 {{ value|hex:8 }} 00003039
12345 {{ value|hex:-8 }} 3039
14911 {{ value|hex:-8:upper }} 3A3F
14911 {{ value|hex:-8:lower }} 3a3f
hexlist
Display integer as hex number with : between pairs. An
argument can be used to indicate how many digits should
be used in the output. If the hex number is too long it
will be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hexlist }} 30:39
12345 {{ value|hexlist:2 }} 39
12345 {{ value|hexlist:8 }} 00:00:30:39
12345 {{ value|hexlist:-8 }} 30:39
14911 {{ value|hexlist:-8:upper }} 3A:3F
14911 {{ value|hexlist:-8:lower }} 3a:3f
floatformat
Used for type 'float' in tailf-xsd-types. We recommend
that the YANG built-in type 'decimal64' is used instead of
'float'.
When used without an argument, rounds a floating-point
number to one decimal place -- but only if there is a
decimal part to be displayed.
For example:
value Template Output
34.23234 {{ value|floatformat }} 34.2
34.00000 {{ value|floatformat }} 34
34.26000 {{ value|floatformat }} 34.3
If used with a numeric integer argument, floatformat
rounds a number to that many decimal places. For example:
value Template Output
34.23234 {{ value|floatformat:3 }} 34.232
34.00000 {{ value|floatformat:3 }} 34.000
34.26000 {{ value|floatformat:3 }} 34.260
If the argument passed to floatformat is negative, it will
round a number to that many decimal places -- but only if
there's a decimal part to be displayed. For example:
value Template Output
34.23234 {{ value|floatformat:-3 }} 34.232
34.00000 {{ value|floatformat:-3 }} 34
34.26000 {{ value|floatformat:-3 }} 34.260
Using floatformat with no argument is equivalent to using
floatformat with an argument of -1.
ljust:width
Left-align the value given a width.
rjust:width
Right-align the value given a width.
trunc:width
Truncate value to a given width.
lower
Convert the value into lowercase.
upper
Convert the value into uppercase.
show:<dictionary>
Substitutes the result of invoking the default display
function for the parameter. The dictionary can be used
for introducing own variables that can be accessed in
the same manner as builtin variables. The user defined
variables overrides builtin variables. The dictionary
is specified as a string on the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|show:myvar1=true:myvar2=Interface)
the user defined variables can be accessed like this:
$(.myvar1!=true?Address) $(.myvar2)
A special case is the dict variable 'indent'. It
controls the indentation level of the displayed path.
The current indent level can be incremented and
decremented using =+ and =-.
For example:
$(foobar|show:indent=+2)
$(foobar|show:indent=-1)
$(foobar|show:indent=10)
Another special case is he dict variable 'noalign'.
It may be used to suppress the default aligning that
may occur when displaying an element.
For example:
$(foobar|show:noalign)
dict:<dictionary>
Translates the value using the dictionary. Can for
example be used for displaying on/off instead of
true/false. The dictionary is specified as a string on
the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|dict:true=on:false=off)
if the leaf 'foo' has value 'true', it is displayed as 'on', and
if its value is 'false' it is displayed as 'off'.
Nested invocations are allowed, ie it is possible to have expressions
like $((state|dict:yes=Yes:no=No)|rjust:14), or $(/foo{$(../bar)})
For example:
list interface {
key name;
leaf name { ... }
leaf status { ... }
container line {
leaf status { ... }
}
leaf mtu { ... }
leaf bw { ... }
leaf encapsulation { ... }
leaf loopback { ... }
tailf:cli-show-template
'$(name) is administratively $(status),'
+ ' line protocol is $(line/status)\\n'
+ 'MTU $(mtu) bytes, BW $(bw|humanreadable)bit, \\n'
+ 'Encap $(encapsulation|upper), $(loopback?:loopback not set)\\n';
} |
| cli-template-string |
string |
A template is a text string which is expanded by the CLI engine,
and then displayed to the user.
The template may contain a mix of text and expandable entries.
Expandable entries all start with $( and end with a matching ).
Parentheses and dollar signs need to be quoted in plain text.
(Disclaimer: tailf:cli-template-string will not respect
all CLI YANG extensions existing from expandable entries.
For instance, tailf:cli-no-name-on-delete will have no
effect when the value of a node with this extension is
fetched as a result of expanding CLI templates.)
The template is expanded as follows:
A parameter is either a relative or absolute path to a leaf
element (eg /foo/bar, foo/bar), or one of the builtin variables:
.selected, .entered, .legend_shown, .user, .groups, .ip,
.display_groups, .path, .ipath or .licounter. In addition the
variables .spath and .ispath are available when a command
is executed from a show path.
.selected
The .selected variable contains the list of selected paths
to be shown. The show template can inspect this element to
determine if a given element should be displayed or
not. For example:
$(.selected~=hwaddr?HW Address)
.entered
The .entered variable is true if the "entered" text has
been displayed (either the auto generated text or a
showTemplateEnter). This is useful when having a non-table
template where each instance should have a text.
$(.entered?:host $(name))
.legend_shown
The .legend_shown variable is true if the "legend" text has
been displayed (either the auto generated table header or
a showTemplateLegend). This is useful to inspect when
displaying a table row. If the user enters the path to a
specific instance the builtin table header will not be
displayed and the showTemplateLegend will not be invoked
and it may be useful to render the legend specifically
for this instance.
$(.legend_shown!=true?Address Interface)
.user
The .user variable contains the name of the current
user. This can be used for differentiating the content
displayed for a specific user, or in paths. For example:
$(user{$(.user)}/settings)
.groups
The .groups variable contains the a list of groups that the
user belongs to.
.display_groups
The .display_groups variable contains a list of selected
display groups. This can be used to display different
content depending on the selected display group. For
example:
$(.display_groups~=details?details...)
.ip
The .ip variable contains the ip address that the user
connected from.
.path
The .path variable contains the path to the entry,
formatted in CLI style.
.ipath
The .ipath variable contains the path to the entry,
formatted in template style.
.spath
The .spath variable contains the show path,
formatted in CLI style.
.ispath
The .ispath variable contains the show path,
formatted in template style.
.licounter
The .licounter variable contains a counter that is
incremented for each instance in a list. This means that
it will be 0 in the legend, contain the total number of
list instances in the footer and something in between in
the basic show template.
$(parameter)
The value of 'parameter' is substituted.
$(cond?word1:word2)
The expansion of 'word1' is substituted if 'cond'
evaluates to true, otherwise the expansion of 'word2' is
substituted.
'cond' may be one of
parameter
Evaluates to true if the node exists.
parameter == <value>
Evaluates to true if the value of the parameter equals
<value>.
parameter != <value>
Evaluates to true if the value of the parameter does not
equal <value>
parameter ~= <value>
Provided that the value of the parameter is a list
(i.e., the node that the parameter refers to is a
leaf-list), this expression evaluates to true if <value>
is a member of the list.
Note that it is also possible to omit ':word2' in
order to print the entire statement, or nothing.
As an example $(conf?word1) will print 'word1' if conf
exists, otherwise it will print nothing.
$(cond??word1)
Double question marks can be used to achieve the same effect
as above, but with the distinction that the 'cond' variable
needs to be explicitly configured, in order to be evaluated
as existing. This is needed in the case of evaluating leafs
with default values, where the single question mark operator
would evaluate to existing even if not explicitly configured.
$(parameter|filter)
The value of 'parameter' processed by 'filter' is
substituted. Filters may be either one of the
built-ins or a customized filter defined in a
callback. See /confdConfig/cli/templateFilter.
A built-in 'filter' may be one of:
capfirst
Capitalizes the first character of the value.
lower
Converts the value into lowercase.
upper
Converts the value into uppercase.
filesizeformat
Formats the value in a human-readable format (e.g.,
'13 KB', '4.10 MB', '102 bytes' etc), where K
means 1024, M means 1024*1024 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, filesizeformat will display the
given number of decimal places.
humanreadable
Similar to filesizeformat except no bytes suffix
is added (e.g., '13.00 k', '4.10 M' '102' etc),
where k means 1000, M means 1000*1000 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, humanreadable will display the
given number of decimal places.
commasep
Separate the numerical values into groups of three
digits using a comma (e.g., 1234567 -> 1,234,567)
hex
Display integer as hex number. An argument can be
used to indicate how many digits should be used in
the output. If the hex number is too long it will
be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hex }} 3039
12345 {{ value|hex:2 }} 39
12345 {{ value|hex:8 }} 00003039
12345 {{ value|hex:-8 }} 3039
14911 {{ value|hex:-8:upper }} 3A3F
14911 {{ value|hex:-8:lower }} 3a3f
hexlist
Display integer as hex number with : between pairs. An
argument can be used to indicate how many digits should
be used in the output. If the hex number is too long it
will be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hexlist }} 30:39
12345 {{ value|hexlist:2 }} 39
12345 {{ value|hexlist:8 }} 00:00:30:39
12345 {{ value|hexlist:-8 }} 30:39
14911 {{ value|hexlist:-8:upper }} 3A:3F
14911 {{ value|hexlist:-8:lower }} 3a:3f
floatformat
Used for type 'float' in tailf-xsd-types. We recommend
that the YANG built-in type 'decimal64' is used instead of
'float'.
When used without an argument, rounds a floating-point
number to one decimal place -- but only if there is a
decimal part to be displayed.
For example:
value Template Output
34.23234 {{ value|floatformat }} 34.2
34.00000 {{ value|floatformat }} 34
34.26000 {{ value|floatformat }} 34.3
If used with a numeric integer argument, floatformat
rounds a number to that many decimal places. For example:
value Template Output
34.23234 {{ value|floatformat:3 }} 34.232
34.00000 {{ value|floatformat:3 }} 34.000
34.26000 {{ value|floatformat:3 }} 34.260
If the argument passed to floatformat is negative, it will
round a number to that many decimal places -- but only if
there's a decimal part to be displayed. For example:
value Template Output
34.23234 {{ value|floatformat:-3 }} 34.232
34.00000 {{ value|floatformat:-3 }} 34
34.26000 {{ value|floatformat:-3 }} 34.260
Using floatformat with no argument is equivalent to using
floatformat with an argument of -1.
ljust:width
Left-align the value given a width.
rjust:width
Right-align the value given a width.
trunc:width
Truncate value to a given width.
lower
Convert the value into lowercase.
upper
Convert the value into uppercase.
show:<dictionary>
Substitutes the result of invoking the default display
function for the parameter. The dictionary can be used
for introducing own variables that can be accessed in
the same manner as builtin variables. The user defined
variables overrides builtin variables. The dictionary
is specified as a string on the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|show:myvar1=true:myvar2=Interface)
the user defined variables can be accessed like this:
$(.myvar1!=true?Address) $(.myvar2)
A special case is the dict variable 'indent'. It
controls the indentation level of the displayed path.
The current indent level can be incremented and
decremented using =+ and =-.
For example:
$(foobar|show:indent=+2)
$(foobar|show:indent=-1)
$(foobar|show:indent=10)
Another special case is he dict variable 'noalign'.
It may be used to suppress the default aligning that
may occur when displaying an element.
For example:
$(foobar|show:noalign)
dict:<dictionary>
Translates the value using the dictionary. Can for
example be used for displaying on/off instead of
true/false. The dictionary is specified as a string on
the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|dict:true=on:false=off)
if the leaf 'foo' has value 'true', it is displayed as 'on', and
if its value is 'false' it is displayed as 'off'.
Nested invocations are allowed, ie it is possible to have expressions
like $((state|dict:yes=Yes:no=No)|rjust:14), or $(/foo{$(../bar)})
For example:
list interface {
key name;
leaf name { ... }
leaf status { ... }
container line {
leaf status { ... }
}
leaf mtu { ... }
leaf bw { ... }
leaf encapsulation { ... }
leaf loopback { ... }
tailf:cli-show-template
'$(name) is administratively $(status),'
+ ' line protocol is $(line/status)\\n'
+ 'MTU $(mtu) bytes, BW $(bw|humanreadable)bit, \\n'
+ 'Encap $(encapsulation|upper), $(loopback?:loopback not set)\\n';
} |
| cli-template-string |
string |
A template is a text string which is expanded by the CLI engine,
and then displayed to the user.
The template may contain a mix of text and expandable entries.
Expandable entries all start with $( and end with a matching ).
Parentheses and dollar signs need to be quoted in plain text.
(Disclaimer: tailf:cli-template-string will not respect
all CLI YANG extensions existing from expandable entries.
For instance, tailf:cli-no-name-on-delete will have no
effect when the value of a node with this extension is
fetched as a result of expanding CLI templates.)
The template is expanded as follows:
A parameter is either a relative or absolute path to a leaf
element (eg /foo/bar, foo/bar), or one of the builtin variables:
.selected, .entered, .legend_shown, .user, .groups, .ip,
.display_groups, .path, .ipath or .licounter. In addition the
variables .spath and .ispath are available when a command
is executed from a show path.
.selected
The .selected variable contains the list of selected paths
to be shown. The show template can inspect this element to
determine if a given element should be displayed or
not. For example:
$(.selected~=hwaddr?HW Address)
.entered
The .entered variable is true if the "entered" text has
been displayed (either the auto generated text or a
showTemplateEnter). This is useful when having a non-table
template where each instance should have a text.
$(.entered?:host $(name))
.legend_shown
The .legend_shown variable is true if the "legend" text has
been displayed (either the auto generated table header or
a showTemplateLegend). This is useful to inspect when
displaying a table row. If the user enters the path to a
specific instance the builtin table header will not be
displayed and the showTemplateLegend will not be invoked
and it may be useful to render the legend specifically
for this instance.
$(.legend_shown!=true?Address Interface)
.user
The .user variable contains the name of the current
user. This can be used for differentiating the content
displayed for a specific user, or in paths. For example:
$(user{$(.user)}/settings)
.groups
The .groups variable contains the a list of groups that the
user belongs to.
.display_groups
The .display_groups variable contains a list of selected
display groups. This can be used to display different
content depending on the selected display group. For
example:
$(.display_groups~=details?details...)
.ip
The .ip variable contains the ip address that the user
connected from.
.path
The .path variable contains the path to the entry,
formatted in CLI style.
.ipath
The .ipath variable contains the path to the entry,
formatted in template style.
.spath
The .spath variable contains the show path,
formatted in CLI style.
.ispath
The .ispath variable contains the show path,
formatted in template style.
.licounter
The .licounter variable contains a counter that is
incremented for each instance in a list. This means that
it will be 0 in the legend, contain the total number of
list instances in the footer and something in between in
the basic show template.
$(parameter)
The value of 'parameter' is substituted.
$(cond?word1:word2)
The expansion of 'word1' is substituted if 'cond'
evaluates to true, otherwise the expansion of 'word2' is
substituted.
'cond' may be one of
parameter
Evaluates to true if the node exists.
parameter == <value>
Evaluates to true if the value of the parameter equals
<value>.
parameter != <value>
Evaluates to true if the value of the parameter does not
equal <value>
parameter ~= <value>
Provided that the value of the parameter is a list
(i.e., the node that the parameter refers to is a
leaf-list), this expression evaluates to true if <value>
is a member of the list.
Note that it is also possible to omit ':word2' in
order to print the entire statement, or nothing.
As an example $(conf?word1) will print 'word1' if conf
exists, otherwise it will print nothing.
$(cond??word1)
Double question marks can be used to achieve the same effect
as above, but with the distinction that the 'cond' variable
needs to be explicitly configured, in order to be evaluated
as existing. This is needed in the case of evaluating leafs
with default values, where the single question mark operator
would evaluate to existing even if not explicitly configured.
$(parameter|filter)
The value of 'parameter' processed by 'filter' is
substituted. Filters may be either one of the
built-ins or a customized filter defined in a
callback. See /confdConfig/cli/templateFilter.
A built-in 'filter' may be one of:
capfirst
Capitalizes the first character of the value.
lower
Converts the value into lowercase.
upper
Converts the value into uppercase.
filesizeformat
Formats the value in a human-readable format (e.g.,
'13 KB', '4.10 MB', '102 bytes' etc), where K
means 1024, M means 1024*1024 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, filesizeformat will display the
given number of decimal places.
humanreadable
Similar to filesizeformat except no bytes suffix
is added (e.g., '13.00 k', '4.10 M' '102' etc),
where k means 1000, M means 1000*1000 etc.
When used without argument the default number of
decimals displayed is 2. When used with a numeric
integer argument, humanreadable will display the
given number of decimal places.
commasep
Separate the numerical values into groups of three
digits using a comma (e.g., 1234567 -> 1,234,567)
hex
Display integer as hex number. An argument can be
used to indicate how many digits should be used in
the output. If the hex number is too long it will
be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hex }} 3039
12345 {{ value|hex:2 }} 39
12345 {{ value|hex:8 }} 00003039
12345 {{ value|hex:-8 }} 3039
14911 {{ value|hex:-8:upper }} 3A3F
14911 {{ value|hex:-8:lower }} 3a3f
hexlist
Display integer as hex number with : between pairs. An
argument can be used to indicate how many digits should
be used in the output. If the hex number is too long it
will be truncated at the front, if it is too short it will
be padded with zeros at the front. If the width is
a negative number then at most that number of digits
will be used, but short numbers will not be padded
with zeroes. Another argument can be given to indicate
if the hex numbers should be written with lower
or upper case.
For example:
value Template Output
12345 {{ value|hexlist }} 30:39
12345 {{ value|hexlist:2 }} 39
12345 {{ value|hexlist:8 }} 00:00:30:39
12345 {{ value|hexlist:-8 }} 30:39
14911 {{ value|hexlist:-8:upper }} 3A:3F
14911 {{ value|hexlist:-8:lower }} 3a:3f
floatformat
Used for type 'float' in tailf-xsd-types. We recommend
that the YANG built-in type 'decimal64' is used instead of
'float'.
When used without an argument, rounds a floating-point
number to one decimal place -- but only if there is a
decimal part to be displayed.
For example:
value Template Output
34.23234 {{ value|floatformat }} 34.2
34.00000 {{ value|floatformat }} 34
34.26000 {{ value|floatformat }} 34.3
If used with a numeric integer argument, floatformat
rounds a number to that many decimal places. For example:
value Template Output
34.23234 {{ value|floatformat:3 }} 34.232
34.00000 {{ value|floatformat:3 }} 34.000
34.26000 {{ value|floatformat:3 }} 34.260
If the argument passed to floatformat is negative, it will
round a number to that many decimal places -- but only if
there's a decimal part to be displayed. For example:
value Template Output
34.23234 {{ value|floatformat:-3 }} 34.232
34.00000 {{ value|floatformat:-3 }} 34
34.26000 {{ value|floatformat:-3 }} 34.260
Using floatformat with no argument is equivalent to using
floatformat with an argument of -1.
ljust:width
Left-align the value given a width.
rjust:width
Right-align the value given a width.
trunc:width
Truncate value to a given width.
lower
Convert the value into lowercase.
upper
Convert the value into uppercase.
show:<dictionary>
Substitutes the result of invoking the default display
function for the parameter. The dictionary can be used
for introducing own variables that can be accessed in
the same manner as builtin variables. The user defined
variables overrides builtin variables. The dictionary
is specified as a string on the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|show:myvar1=true:myvar2=Interface)
the user defined variables can be accessed like this:
$(.myvar1!=true?Address) $(.myvar2)
A special case is the dict variable 'indent'. It
controls the indentation level of the displayed path.
The current indent level can be incremented and
decremented using =+ and =-.
For example:
$(foobar|show:indent=+2)
$(foobar|show:indent=-1)
$(foobar|show:indent=10)
Another special case is he dict variable 'noalign'.
It may be used to suppress the default aligning that
may occur when displaying an element.
For example:
$(foobar|show:noalign)
dict:<dictionary>
Translates the value using the dictionary. Can for
example be used for displaying on/off instead of
true/false. The dictionary is specified as a string on
the following form:
(key=value)(:key=value)*
For example, with the following expression:
$(foo|dict:true=on:false=off)
if the leaf 'foo' has value 'true', it is displayed as 'on', and
if its value is 'false' it is displayed as 'off'.
Nested invocations are allowed, ie it is possible to have expressions
like $((state|dict:yes=Yes:no=No)|rjust:14), or $(/foo{$(../bar)})
For example:
list interface {
key name;
leaf name { ... }
leaf status { ... }
container line {
leaf status { ... }
}
leaf mtu { ... }
leaf bw { ... }
leaf encapsulation { ... }
leaf loopback { ... }
tailf:cli-show-template
'$(name) is administratively $(status),'
+ ' line protocol is $(line/status)\\n'
+ 'MTU $(mtu) bytes, BW $(bw|humanreadable)bit, \\n'
+ 'Encap $(encapsulation|upper), $(loopback?:loopback not set)\\n';
} |
| des3-cbc-encrypted-string |
string |
The des3-cbc-encrypted-string type automatically encrypts a value
adhering to this type using DES in CBC mode followed by a base64
conversion. If the value isn't encrypted already, that is.
This is best explained using an example. Suppose we have a leaf:
leaf enc {
type tailf:des3-cbc-encrypted-string;
}
A valid configuration is:
<enc>$0$In god we trust.</enc>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, the value is DES3/Base64
encrypted, and the string '$7$' is prepended. The resulting
string is stored in the configuration data store.
When a value of this type is read, the encrypted value is always
returned. In the example above, the following value could be
returned:
<enc>$7$Qxxsn8BVzxphCdflqRwZm6noKKmt0QoSWnRnhcXqocg=</enc>
If a value starting with '$7$' is received, the server knows
that the value is already encrypted, and stores it as is in the
data store.
A value adhering to this type must have a '$0$' or a '$7$' prefix.
ConfD uses a configurable set of encryption keys to encrypt the
string. For details, see 'encryptedStrings' in the
confd.conf(5) manual page. |
| des3-cbc-encrypted-string |
string |
The des3-cbc-encrypted-string type automatically encrypts a value
adhering to this type using DES in CBC mode followed by a base64
conversion. If the value isn't encrypted already, that is.
This is best explained using an example. Suppose we have a leaf:
leaf enc {
type tailf:des3-cbc-encrypted-string;
}
A valid configuration is:
<enc>$0$In god we trust.</enc>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, the value is DES3/Base64
encrypted, and the string '$7$' is prepended. The resulting
string is stored in the configuration data store.
When a value of this type is read, the encrypted value is always
returned. In the example above, the following value could be
returned:
<enc>$7$Qxxsn8BVzxphCdflqRwZm6noKKmt0QoSWnRnhcXqocg=</enc>
If a value starting with '$7$' is received, the server knows
that the value is already encrypted, and stores it as is in the
data store.
A value adhering to this type must have a '$0$' or a '$7$' prefix.
ConfD uses a configurable set of encryption keys to encrypt the
string. For details, see 'encryptedStrings' in the
confd.conf(5) manual page. |
| des3-cbc-encrypted-string |
string |
The des3-cbc-encrypted-string type automatically encrypts a value
adhering to this type using DES in CBC mode followed by a base64
conversion. If the value isn't encrypted already, that is.
This is best explained using an example. Suppose we have a leaf:
leaf enc {
type tailf:des3-cbc-encrypted-string;
}
A valid configuration is:
<enc>$0$My plain text.</enc>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, the value is DES3/Base64
encrypted, and the string '$7$' is prepended. The resulting
string is stored in the configuration data store.
When a value of this type is read, the encrypted value is always
returned. In the example above, the following value could be
returned:
<enc>$7$Qxxsn8BVzxphCdflqRwZm6noKKmt0QoSWnRnhcXqocg=</enc>
If a value starting with '$7$' is received, the server knows
that the value is already encrypted, and stores it as is in the
data store.
A value adhering to this type must have a '$0$' or a '$7$' prefix.
ConfD uses a configurable set of encryption keys to encrypt the
string. For details, see 'encryptedStrings' in the
confd.conf(5) manual page. |
| des3-cbc-encrypted-string |
string |
The des3-cbc-encrypted-string type automatically encrypts a value
adhering to this type using DES in CBC mode followed by a base64
conversion. If the value isn't encrypted already, that is.
This is best explained using an example. Suppose we have a leaf:
leaf enc {
type tailf:des3-cbc-encrypted-string;
}
A valid configuration is:
<enc>$0$In god we trust.</enc>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, the value is DES3/Base64
encrypted, and the string '$7$' is prepended. The resulting
string is stored in the configuration data store.
When a value of this type is read, the encrypted value is always
returned. In the example above, the following value could be
returned:
<enc>$7$Qxxsn8BVzxphCdflqRwZm6noKKmt0QoSWnRnhcXqocg=</enc>
If a value starting with '$7$' is received, the server knows
that the value is already encrypted, and stores it as is in the
data store.
A value adhering to this type must have a '$0$' or a '$7$' prefix.
ConfD uses a configurable set of encryption keys to encrypt the
string. For details, see 'encryptedStrings' in the
confd.conf(5) manual page. |
| hex-list |
string |
DEPRECATED: Use yang:hex-string instead. There are no plans to remove
tailf:hex-list.
A list of colon-separated hexa-decimal octets e.g. '4F:4C:41:71'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| hex-list |
string |
DEPRECATED: Use yang:hex-string instead. There are no plans to remove
tailf:hex-list.
A list of colon-separated hexa-decimal octets e.g. '4F:4C:41:71'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| hex-list |
string |
DEPRECATED: Use yang:hex-string instead. There are no plans to remove
tailf:hex-list.
A list of colon-separated hexa-decimal octets e.g. '4F:4C:41:71'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| hex-list |
string |
DEPRECATED: Use yang:hex-string instead. There are no plans to remove
tailf:hex-list.
A list of colon-separated hexa-decimal octets e.g. '4F:4C:41:71'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| identifier |
string |
|
| identifier |
string |
|
| identifier |
string |
|
| identifier-ref |
string |
|
| identifier-ref |
string |
|
| ip-address-and-prefix-length |
union |
The ip-address-and-prefix-length type represents a combination of
an IP address and a prefix length and is IP version neutral. The
format of the textual representations implies the IP version. |
| ip-address-and-prefix-length |
union |
The ip-address-and-prefix-length type represents a combination of
an IP address and a prefix length and is IP version neutral. The
format of the textual representations implies the IP version. |
| ip-address-and-prefix-length |
union |
The ip-address-and-prefix-length type represents a combination of
an IP address and a prefix length and is IP version neutral. The
format of the textual representations implies the IP version. |
| ip-address-and-prefix-length |
union |
The ip-address-and-prefix-length type represents a combination of
an IP address and a prefix length and is IP version neutral. The
format of the textual representations implies the IP version. |
| ipv4-address-and-prefix-length |
string |
The ipv4-address-and-prefix-length type represents a combination
of an IPv4 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 32. |
| ipv4-address-and-prefix-length |
string |
The ipv4-address-and-prefix-length type represents a combination
of an IPv4 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 32. |
| ipv4-address-and-prefix-length |
string |
The ipv4-address-and-prefix-length type represents a combination
of an IPv4 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 32. |
| ipv4-address-and-prefix-length |
string |
The ipv4-address-and-prefix-length type represents a combination
of an IPv4 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 32. |
| ipv6-address-and-prefix-length |
string |
The ipv6-address-and-prefix-length type represents a combination
of an IPv6 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 128. |
| ipv6-address-and-prefix-length |
string |
The ipv6-address-and-prefix-length type represents a combination
of an IPv6 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 128. |
| ipv6-address-and-prefix-length |
string |
The ipv6-address-and-prefix-length type represents a combination
of an IPv6 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 128. |
| ipv6-address-and-prefix-length |
string |
The ipv6-address-and-prefix-length type represents a combination
of an IPv6 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 128. |
| md5-digest-string |
string |
The md5-digest-string type automatically computes a MD5 digest for
a value adhering to this type.
This is best explained using an example. Suppose we have a
leaf:
leaf key {
type tailf:md5-digest-string;
}
A valid configuration is:
<key>$0$In god we trust.</key>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, an MD5 digest is
calculated, and the string '$1$<salt>$' is prepended to the
result, where <salt> is a random eight character salt used to
generate the digest. This value is stored in the configuration
data store.
When a value of this type is read, the computed MD5 value is
always returned. In the example above, the following value
could be returned:
<key>$1$fB$ndk2z/PIS0S1SvzWLqTJb.</key>
If a value starting with '$1$' is received, the server
knows that the value already represents an MD5 digest, and
stores it as is in the data store.
A value adhering to this type must have a '$0$' or a
'$1$<salt>$' prefix.
If a default value is specified, it must have a '$1$<salt>$' prefix.
The digest algorithm used is the same as the md5 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.freebsd.org/cgi/cvsweb.cgi/~checkout/~/src/lib/libcrypt/crypt.c
|
| md5-digest-string |
string |
The md5-digest-string type automatically computes a MD5 digest for
a value adhering to this type.
This is best explained using an example. Suppose we have a
leaf:
leaf key {
type tailf:md5-digest-string;
}
A valid configuration is:
<key>$0$In god we trust.</key>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, an MD5 digest is
calculated, and the string '$1$<salt>$' is prepended to the
result, where <salt> is a random eight character salt used to
generate the digest. This value is stored in the configuration
data store.
When a value of this type is read, the computed MD5 value is
always returned. In the example above, the following value
could be returned:
<key>$1$fB$ndk2z/PIS0S1SvzWLqTJb.</key>
If a value starting with '$1$' is received, the server
knows that the value already represents an MD5 digest, and
stores it as is in the data store.
A value adhering to this type must have a '$0$' or a
'$1$<salt>$' prefix.
If a default value is specified, it must have a '$1$<salt>$' prefix.
The digest algorithm used is the same as the md5 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.freebsd.org/cgi/cvsweb.cgi/~checkout/~/src/lib/libcrypt/crypt.c
|
| md5-digest-string |
string |
The md5-digest-string type automatically computes a MD5 digest for
a value adhering to this type.
This is best explained using an example. Suppose we have a
leaf:
leaf key {
type tailf:md5-digest-string;
}
A valid configuration is:
<key>$0$My plain text.</key>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, an MD5 digest is
calculated, and the string '$1$<salt>$' is prepended to the
result, where <salt> is a random eight character salt used to
generate the digest. This value is stored in the configuration
data store.
When a value of this type is read, the computed MD5 value is
always returned. In the example above, the following value
could be returned:
<key>$1$fB$ndk2z/PIS0S1SvzWLqTJb.</key>
If a value starting with '$1$' is received, the server
knows that the value already represents an MD5 digest, and
stores it as is in the data store.
A value adhering to this type must have a '$0$' or a
'$1$<salt>$' prefix.
If a default value is specified, it must have a '$1$<salt>$' prefix.
The digest algorithm used is the same as the md5 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.freebsd.org/cgi/cvsweb.cgi/~checkout/~/src/lib/libcrypt/crypt.c
|
| md5-digest-string |
string |
The md5-digest-string type automatically computes a MD5 digest for
a value adhering to this type.
This is best explained using an example. Suppose we have a
leaf:
leaf key {
type tailf:md5-digest-string;
}
A valid configuration is:
<key>$0$In god we trust.</key>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, an MD5 digest is
calculated, and the string '$1$<salt>$' is prepended to the
result, where <salt> is a random eight character salt used to
generate the digest. This value is stored in the configuration
data store.
When a value of this type is read, the computed MD5 value is
always returned. In the example above, the following value
could be returned:
<key>$1$fB$ndk2z/PIS0S1SvzWLqTJb.</key>
If a value starting with '$1$' is received, the server
knows that the value already represents an MD5 digest, and
stores it as is in the data store.
A value adhering to this type must have a '$0$' or a
'$1$<salt>$' prefix.
If a default value is specified, it must have a '$1$<salt>$' prefix.
The digest algorithm used is the same as the md5 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.freebsd.org/cgi/cvsweb.cgi/~checkout/~/src/lib/libcrypt/crypt.c
|
| node-instance-identifier |
string |
This is the same type as the node-instance-identifier defined in the
ietf-netconf-acm module, replicated here to make it possible for
Tail-f YANG modules to avoid a dependency on ietf-netconf-acm.
The description from ietf-netconf-acm revision 2017-12-11 follows.
Path expression used to represent a special
data node, action, or notification instance identifier
string.
A node-instance-identifier value is an
unrestricted YANG instance-identifier expression.
All the same rules as an instance-identifier apply
except predicates for keys are optional. If a key
predicate is missing, then the node-instance-identifier
represents all possible server instances for that key.
This XPath expression is evaluated in the following context:
o The set of namespace declarations are those in scope on
the leaf element where this type is used.
o The set of variable bindings contains one variable,
'USER', which contains the name of the user of the current
session.
o The function library is the core function library, but
note that due to the syntax restrictions of an
instance-identifier, no functions are allowed.
o The context node is the root node in the data tree.
The accessible tree includes actions and notifications tied
to data nodes. |
| octet-list |
string |
A list of dot-separated octets e.g. '192.168.255.1.0'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| octet-list |
string |
A list of dot-separated octets e.g. '192.168.255.1.0'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| octet-list |
string |
A list of dot-separated octets e.g. '192.168.255.1.0'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| octet-list |
string |
A list of dot-separated octets e.g. '192.168.255.1.0'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation. |
| sha-256-digest-string |
string |
The sha-256-digest-string type automatically computes a SHA-256
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$5$<salt>$<password hash>
$5$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-256 digest is
calculated, and the string '$5$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$5$rounds=<number>$<salt>$' to
be prepended instead of only '$5$<salt>$'.
If a value starting with '$5$' is received, the server
knows that the value already represents a SHA-256 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$5$' prefix.
The digest algorithm used is the same as the SHA-256 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-256-digest-string |
string |
The sha-256-digest-string type automatically computes a SHA-256
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$5$<salt>$<password hash>
$5$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-256 digest is
calculated, and the string '$5$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$5$rounds=<number>$<salt>$' to
be prepended instead of only '$5$<salt>$'.
If a value starting with '$5$' is received, the server
knows that the value already represents a SHA-256 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$5$' prefix.
The digest algorithm used is the same as the SHA-256 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-256-digest-string |
string |
The sha-256-digest-string type automatically computes a SHA-256
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$5$<salt>$<password hash>
$5$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-256 digest is
calculated, and the string '$5$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$5$rounds=<number>$<salt>$' to
be prepended instead of only '$5$<salt>$'.
If a value starting with '$5$' is received, the server
knows that the value already represents a SHA-256 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$5$' prefix.
The digest algorithm used is the same as the SHA-256 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-256-digest-string |
string |
The sha-256-digest-string type automatically computes a SHA-256
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$5$<salt>$<password hash>
$5$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-256 digest is
calculated, and the string '$5$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$5$rounds=<number>$<salt>$' to
be prepended instead of only '$5$<salt>$'.
If a value starting with '$5$' is received, the server
knows that the value already represents a SHA-256 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$5$' prefix.
The digest algorithm used is the same as the SHA-256 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-512-digest-string |
string |
The sha-512-digest-string type automatically computes a SHA-512
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$6$<salt>$<password hash>
$6$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-512 digest is
calculated, and the string '$6$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$6$rounds=<number>$<salt>$' to
be prepended instead of only '$6$<salt>$'.
If a value starting with '$6$' is received, the server
knows that the value already represents a SHA-512 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$6$' prefix.
The digest algorithm used is the same as the SHA-512 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-512-digest-string |
string |
The sha-512-digest-string type automatically computes a SHA-512
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$6$<salt>$<password hash>
$6$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-512 digest is
calculated, and the string '$6$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$6$rounds=<number>$<salt>$' to
be prepended instead of only '$6$<salt>$'.
If a value starting with '$6$' is received, the server
knows that the value already represents a SHA-512 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$6$' prefix.
The digest algorithm used is the same as the SHA-512 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-512-digest-string |
string |
The sha-512-digest-string type automatically computes a SHA-512
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$6$<salt>$<password hash>
$6$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-512 digest is
calculated, and the string '$6$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$6$rounds=<number>$<salt>$' to
be prepended instead of only '$6$<salt>$'.
If a value starting with '$6$' is received, the server
knows that the value already represents a SHA-512 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$6$' prefix.
The digest algorithm used is the same as the SHA-512 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| sha-512-digest-string |
string |
The sha-512-digest-string type automatically computes a SHA-512
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$<clear text password>
$6$<salt>$<password hash>
$6$rounds=<number>$<salt>$<password hash>
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-512 digest is
calculated, and the string '$6$<salt>$' is prepended to the
result, where <salt> is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$6$rounds=<number>$<salt>$' to
be prepended instead of only '$6$<salt>$'.
If a value starting with '$6$' is received, the server
knows that the value already represents a SHA-512 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$6$' prefix.
The digest algorithm used is the same as the SHA-512 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt |
| size |
string |
A value that represents a number of bytes. An example could be
S1G8M7K956B; meaning 1GB + 8MB + 7KB + 956B = 1082138556 bytes.
The value must start with an S. Any byte magnifier can be left
out, e.g. S1K1B equals 1025 bytes. The order is significant
though, i.e. S1B56G is not a valid byte size.
In ConfD, a 'size' value is represented as an uint64. |
| size |
string |
A value that represents a number of bytes. An example could be
S1G8M7K956B; meaning 1GB + 8MB + 7KB + 956B = 1082138556 bytes.
The value must start with an S. Any byte magnifier can be left
out, e.g. S1K1B equals 1025 bytes. The order is significant
though, i.e. S1B56G is not a valid byte size.
In ConfD, a 'size' value is represented as an uint64. |
| size |
string |
A value that represents a number of bytes. An example could be
S1G8M7K956B; meaning 1GB + 8MB + 7KB + 956B = 1082138556 bytes.
The value must start with an S. Any byte magnifier can be left
out, e.g. S1K1B equals 1025 bytes. The order is significant
though, i.e. S1B56G is not a valid byte size.
In ConfD, a 'size' value is represented as an uint64. |
| size |
string |
A value that represents a number of bytes. An example could be
S1G8M7K956B; meaning 1GB + 8MB + 7KB + 956B = 1082138556 bytes.
The value must start with an S. Any byte magnifier can be left
out, e.g. S1K1B equals 1025 bytes. The order is significant
though, i.e. S1B56G is not a valid byte size.
In ConfD, a 'size' value is represented as an uint64. |
| snmp-identifier |
string |
|
| snmp-identifier |
string |
|
| snmp-identifier |
string |
|
| tailf-oid |
string |
|
| tailf-oid |
string |
|
| tailf-oid |
string |
|