Subject: RPSL and Applications documents have been revised

From: Cengiz Alaettinoglu <[email-masked]>
Date: Wed, 18 Nov 1998 14:17:43 -0800 (PST)

The following drafts should make to a repository near you:
	draft-ietf-rps-rpsl-05.ps
	draft-ietf-rps-rpsl-05.txt

	draft-ietf-rps-appl-rpsl-03.ps
	draft-ietf-rps-appl-rpsl-03.txt

        draft-ietf-rps-dbsec-pgp-authent-00.txt

The changes to the RPSL document reflects our discussions during Los
Angeles and Chicago meetings, and are summarized below. Applications
document is updated to comply with these changes as well.

**** 3561:10 and 1.1.1.1 notations for integers

An integer can be  specified using (1) the  C programming language  notation
(e.g. 1, 12345); (2) sequence of four 1-octet integers (in the range from  0
to 255) separated by the character  dot ``.''  (e.g. 1.1.1.1,  255.255.0.0),
in this case  a 4-octet  integer is  formed by  concatenating these  1-octet
integers in the most  significant to least  significant order; (3)  sequence
of two 2-octet  integers (in the  range from  0 to 65535)  separated by  the
character colon  ``:''   (e.g. 3561:70,  3582:10), in  this  case a  4-octet
integer is  formed  by concatenating  these  2-octet integers  in  the  most
significant to least significant order.

**** community::operator.= now takes "list of community_elm" as argument

typedef:      # a community value in RPSL is either
              #  - a 4 byte integer (ok to use 3561:70 notation)
              #  - internet, no_export, no_advertise (see RFC-1997)
              community_elm union
                  integer[1, 4294967200],
                  enum[internet, no_export, no_advertise],
typedef:      # list of community values { 40, no_export, 3561:70 }
              community_list list of community_elm
rp-attribute: # BGP community attribute
              community
              # set to a list of communities
              operator=(community_list)
              # append community values
              operator.=(community_list)
              append(community_elm, ...)
              # delete community values
              delete(community_elm, ...)
              # a filter: true if one of community values is contained
              contains(community_elm, ...)
              # shortcut to contains: community(no_export, 3561:70)
              operator()(community_elm, ...)
              # order independent equality comparison
              operator==(community_list)

**** address prefix range redefined

An address prefix range is an address prefix followed by an optional
range operator.

**** ^n-m^k-l semantics

    It is  an  error to  follow  a range  operator  with another  one  (e.g.
    30.0.0.0/8^24-28^+ is  an error).    However, a  range  operator can  be
    applied to an address  prefix set that has  address prefix ranges in  it
    (e.g. {30.0.0.0/8^24-28}^27-30  is not an  error).   In  this case,  the
    outer operator ^n-m distributes over the inner operator ^k-l and becomes
    the operator ^max(n,k)-m if m is  greater than or equal to max(n,k),  or
    otherwise, the prefix is deleted from  the set.  Note that the  operator
    ^n is equivalent  to ^n-n;  prefix/l^+ is  equivalent to  prefix/l^l-32;
    prefix/l^-  is  equivalent  to prefix/l^(l+1)-32;   {prefix/l^n-m}^+  is
    equivalent to  {prefix/l^n-32};  and {prefix/l^n-m}^-  is  equivalent to
    {prefix/l^(n+1)-32}.  For example,

                {128.9.0.0/16^+}^-     == {128.9.0.0/16^-}
                {128.9.0.0/16^-}^+     == {128.9.0.0/16^-}
                {128.9.0.0/16^17}^24   == {128.9.0.0/16^24}
                {128.9.0.0/16^20-24}^26-28 == {128.9.0.0/16^26-28}
                {128.9.0.0/16^20-24}^22-28 == {128.9.0.0/16^22-28}
                {128.9.0.0/16^20-24}^18-28 == {128.9.0.0/16^20-28}
                {128.9.0.0/16^20-24}^18-22 == {128.9.0.0/16^20-22}
                {128.9.0.0/16^20-24}^18-19 == {}

**** all dates are in UTC

**** union/typedef/list discussion in dictionary

Arguments are strongly typed.  A <type> in RPSL is either a predefined type,
a union type, a  list type, or  a dictionary defined type.   The  predefined
types are listed in Figure 20.

The integer and the  real predefined types  can be followed  by a lower  and
an upper bound  to specify the  set of valid  values of the  argument.   The
range specification is optional.  We use the ANSI C language conventions for
representing integer, real  and string values.   The  enum type is  followed
by a  list of  RPSL names  which are  the valid  values of  the type.    The
boolean type can  take the values  true or false.   as_number, ipv4_address,
address_prefix and  dns_name types  are as  in Section 2.   filter  type is  a
policy filter as in Section 6.

The syntax of a union type is as follows:

    union <type-1>, ... , <type-N>

where <type-i> is  an RPSL  type.   The union  type is either  of the  types
<type-1> through <type-N> (analogous to unions in C[13]).

The syntax of a list type is as follows:

    list [<min_elems>:<max_elems>] of <type>

In this case, the list elements are of <type> and the list contains at least
<min_elems> and  at most  <max_elems>  elements.   The  size specification  is
optional.  If  it is not  specified, there is no  restriction in the  number
of list elements.  A  value of a list type  is represented as a sequence  of
elements separated by  the character ``,''  and enclosed  by the  characters
``{'' and ``}''.

The typedef attribute in the dictionary defines named types as follows:

   typedef: <name> <type>

where <name> is a name  for type <type>.   typedef attribute is  paticularly
useful when the type defined is not a predefined type (e.g. list of  unions,
list of lists, etc.).

**** export-comps's new syntax:

When a  set of  routes are  aggregated, the  intent is  to  export only  the
aggregate route and  suppress exporting  of the more  specifics outside  the
aggregation boundary.    However,  to satisfy  certain policy  and  topology
constraints (e.g. a multi-homed component),  it is often required to  export
some of the components.  The export-comps attribute serves this purpose.  It
equals an RPSL export policy expression as follows (see Section6.2):

    export-comps: to <peering-1> [action <action-1>]
                  . . .
                  to <peering-N> [action <action-N>]
                  announce <filter>

where <filter> matches the  more specifics that need  to be exported to  the
peerings specified.    While exporting  to  <peering-i>, the  <action-i>  is
executed to set the  path attributes.   If this  attribute is missing,  more
specifics are not exported outside the aggregation boundary.  Note that, the
<filter> contains an  implicit "AND"  term with  the more  specifics of  the
aggregate.

**** extending rpsl

   The i-d that provides the guidelines for extending rpsl is now
   merged into the RPSL document.

**** '+' in line continuation

An attribute's  value can be  split over  multiple lines,  by
having a space, a tab  or a plus ('+') character  as the first character  of
the continuation lines.   The character ``+''  for line continuation  allows
attribute values to contain blank lines.  More spaces may optionally be used
after the continuation  character to  increase readability.    The order  of
attribute-value pairs is significant.

Cengiz

-- 
Cengiz Alaettinoglu           Information Sciences Institute
http://www.isi.edu/~cengiz    University of Southern California