\section{ Augmented BNF for the SIP Protocol}
\label{sec:abnf}

All of the mechanisms specified in this document are described in both
prose and an augmented Backus-Naur Form (BNF) defined in
RFC~2234 \citenorm{rfc2234}.  Section 6.1 of RFC~2234 defines a set of core 
rules that are used by this specification, and not repeated here. Implementers need to be familiar with the 
notation and content of RFC~2234 in order to understand this
specification.  Certain basic rules are in uppercase, such as SP,
LWS, HTAB, CRLF, DIGIT, ALPHA, etc.  Angle brackets are used within 
definitions to clarify the use of rule names.

\begin{changebar}
In some cases, the BNF for a choice will indicate that some elements
are optional through square brackets. For example:

\begin{syntax}
foo & = & bar $/$ baz $/$ [boo] \\
\end{syntax}

The use of square brackets is redundant syntactically. It is used
as a semantic hint that the specific parameter is optional to 
use.
\end{changebar}

\subsection{Basic Rules}

The following rules are used throughout this specification to describe
basic parsing constructs.  The US-ASCII coded character set is defined
by ANSI X3.4-1986.

\begin{syntax}
alphanum    & = & ALPHA $/$ DIGIT\\
\end{syntax}


Several rules are incorporated from RFC~2396~\citenorm{rfc2396} but are updated
to make them compliant with RFC~2234~\citenorm{rfc2234}. These include:

\begin{syntax}
reserved    & = & ";" $/$ "/" $/$ "?" $/$ ":" $/$ "@" $/$ "\&" $/$ "=" $/$ "+"\\
            &   & $/$ "\$" $/$ ","\\
unreserved  & = & alphanum $/$ mark\\
mark        & = & "-" $/$ "\_" $/$ "." $/$ "!" $/$ "\~{}" $/$ "*" $/$ "'"\\
            &   & $/$ "(" $/$ ")"\\
escaped     & = & "\%" HEXDIG HEXDIG\\
\end{syntax}

SIP header field values can be folded onto multiple lines if the
continuation line begins with a space or horizontal tab.  All linear
white space, including folding, has the same semantics as SP.  A
recipient {\MAY} replace any linear white space with a single SP before
interpreting the field value or forwarding the message downstream.
This is intended to behave exactly as HTTP/1.1 as described in
RFC~2616~\citenorm{rfc2616}.  The SWS construct is used when linear white space
is optional, generally between tokens and separators.

\begin{syntax}
LWS   & = & [*WSP CRLF] 1*WSP ; \textrm{linear whitespace} \\
SWS   & = & [LWS] ; \textrm{sep whitespace}\\
\end{syntax}

To separate the header name from the rest of value, a colon is used,
which, by the above rule, allows whitespace before, but no line break,
and whitespace after, including a linebreak.  The HCOLON defines this
construct.

\begin{syntax}
HCOLON         & = & *( SP $/$ HTAB ) ":" SWS\\
\end {syntax}

The \header{TEXT-UTF8} rule is only used for descriptive field contents
and values that are not intended to be interpreted by the message
parser.  Words of \header{*TEXT-UTF8} contain characters from the UTF-8
character set (RFC~2279~\citenorm{rfc2279}).  The \header{TEXT-UTF8-TRIM}
rule is used for descriptive field contents that are {\em not} quoted
strings, where leading and trailing LWS is not meaningful.  In this
regard, SIP differs from HTTP, which uses the ISO 8859-1 character set.

\begin{syntax}
TEXT-UTF8-TRIM & =   & 1*TEXT-UTF8char *(*LWS TEXT-UTF8char)\\
TEXT-UTF8char  & =   & \%x21-7E $/$ UTF8-NONASCII\\
UTF8-NONASCII  & =   & \%xC0-DF 1UTF8-CONT\\
               & $/$ & \%xE0-EF 2UTF8-CONT\\
               & $/$ & \%xF0-F7 3UTF8-CONT\\
               & $/$ & \%xF8-Fb 4UTF8-CONT\\
               & $/$ & \%xFC-FD 5UTF8-CONT\\
UTF8-CONT      & =   & \%x80-BF\\
\end{syntax}

A CRLF is allowed in the definition of \header{TEXT-UTF8-TRIM} only as part
of a header field continuation.  It is expected that the folding
\header{LWS} will be replaced with a single \header{SP} before
interpretation of the \header{TEXT-UTF8-TRIM} value.

Hexadecimal numeric characters are used in several protocol elements.
Some elements (authentication) force hex alphas to be lower case.
\begin{syntax}
LHEX & = & DIGIT $/$ \%x61-66 ;\textrm{lowercase a-f}\\
\end{syntax}

Many SIP header field values consist of words separated by LWS or
special characters.  Unless otherwise stated, tokens are
case-insensitive.  These special characters {\MUST} be in a quoted
string to be used within a parameter value.  The word construct is
used in Call-ID to allow most separators to be used.

\begin{syntax}
token       & = & 1*(alphanum $/$ "-" $/$ "." $/$ "!" $/$ "\%" $/$ "*" \\
            &   & $/$ "\_" $/$ "+" $/$ "`" $/$ "'" $/$ "\~{}" )\\
separators  & = & "(" $/$ ")" $/$ "$<$" $/$ "$>$" $/$ "@" $/$ \\
            &   & "," $/$ ";" $/$ ":" $/$ "$\backslash$" $/$ DQUOTE $/$ \\
            &   & "/" $/$ "[" $/$ "]" $/$ "?" $/$ "=" $/$ \\
            &   & "\{" $/$ "\}" $/$ SP $/$ HTAB \\
word        & = & 1*(alphanum $/$ "-" $/$ "." $/$ "!" $/$ "\%" $/$ "*" $/$\\
            &   & "\_" $/$ "+" $/$ "`" $/$ "'" $/$ "\~{}" $/$\\
            &   & "(" $/$ ")" $/$ "$<$" $/$ "$>$" $/$\\
            &   & ":" $/$ "$\backslash$" $/$ DQUOTE $/$ \\
            &   & "/" $/$ "[" $/$ "]" $/$ "?" $/$ \\
            &   & "\{" $/$ "\}" )\\
\end{syntax}

When tokens are used or separators are used between elements, whitespace is often allowed before or after these characters:

\begin{syntax}
STAR    & = & SWS "*" SWS ; \textrm{asterisk}\\
SLASH   & = & SWS "/" SWS ; \textrm{slash}\\
EQUAL   & = & SWS "=" SWS ; \textrm{equal}\\
LPAREN  & = & SWS "(" SWS ; \textrm{left parenthesis}\\
RPAREN  & = & SWS ")" SWS ; \textrm{right parenthesis}\\
RAQUOT  & = & "$>$" SWS ; \textrm{right angle quote}\\
LAQUOT  & = & SWS "$<$"; \textrm{left angle quote}\\
COMMA   & = & SWS "," SWS ; \textrm{comma}\\
SEMI    & = & SWS ";" SWS ; \textrm{semicolon}\\
COLON   & = & SWS ":" SWS ; \textrm{colon}\\
LDQUOT  & = & SWS DQUOTE; \textrm{open double quotation mark}\\
RDQUOT  & = & DQUOTE SWS ; \textrm{close double quotation mark}\\
\end{syntax}

Comments can be included in some SIP header fields by surrounding the
comment text with parentheses.  Comments are only allowed in fields
containing ``comment'' as part of their field value definition.  In all
other fields, parentheses are considered part of the field value.

\begin{syntax}
comment          & = & LPAREN *(ctext $/$ quoted-pair $/$ comment) RPAREN \\
ctext            & = & \%x21-27 $/$ \%x2A-5B $/$ \%x5D-7E $/$ UTF8-NONASCII \\
                 &   & $/$ LWS\\
\end{syntax}

ctext includes all chars except left and right parens and backslash.
A string of text is parsed as a single word if it is quoted using
double-quote marks.  In quoted strings, quotation marks (") and
backslashes ($\backslash$) need to be escaped.

\begin{syntax}
quoted-string    & = & SWS DQUOTE *(qdtext $/$ quoted-pair ) DQUOTE\\
qdtext           & = & LWS $/$ \%x21 $/$ \%x23-5B $/$ \%x5D-7E\\
                 &   & $/$ UTF8-NONASCII\\
\end{syntax}

The backslash character ("$\backslash$") {\MAY} be used as a
single-character quoting mechanism only within quoted-string and comment
constructs.  Unlike HTTP/1.1, the characters CR and LF cannot be escaped
by this mechanism to avoid conflict with line folding and header
separation.

\begin{syntax}
quoted-pair      & = & "$\backslash$" (\%x00-09 $/$ \%x0B-0C\\ 
                 &   & $/$  \%x0E-7F)\\
\end{syntax}

\begin{syntax}
SIP-URI          & = & "sip:" [ userinfo "@" ] hostport\\
                 &   & uri-parameters [ headers ]\\
SIPS-URI          & = & "sips:" [ userinfo "@" ] hostport\\
                 &   & uri-parameters [ headers ]\\
userinfo         & = & [ user $/$ telephone-subscriber [ ":" password ]]\\
user             & = & *( unreserved $/$ escaped $/$ user-unreserved )\\
user-unreserved  & = & "\&" $/$ "=" $/$ "+" $/$ "\$" $/$ "," $/$ ";" $/$ "?" $/$ "/"\\
password         & = & *( unreserved $/$ escaped $/$ \\
                 &   & "\&" $/$ "=" $/$ "+" $/$ "\$" $/$ "," )\\
hostport         & = & host [ ":" port ]\\
host             & = & hostname $/$ IPv4address $/$ IPv6reference\\
hostname         & = & *( domainlabel "." ) toplabel [ "." ]\\
domainlabel      & = & alphanum\\
                 &   & $/$ alphanum *( alphanum $/$ "-" ) alphanum\\
toplabel         & = & ALPHA $/$ ALPHA *( alphanum $/$ "-" ) alphanum\\
\end{syntax}

\begin{syntax}
IPv4address      & = & 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT "." 1*3DIGIT\\
IPv6reference    & = & "[" IPv6address "]"\\
IPv6address      & = & hexpart [ ":" IPv4address ]\\
hexpart          & = & hexseq $/$ hexseq "::" [ hexseq ] $/$ "::" [ hexseq ]\\
hexseq           & = & hex4 *( ":" hex4)\\
hex4             & = & 1*4HEXDIG\\
port             & = & 1*DIGIT\\
\end{syntax}


The BNF for telephone-subscriber can be found in RFC~2806~\citenorm{rfc2806}. 
Note, however, that any characters allowed there that are not allowed
in the user part of the SIP URI {\MUST} be escaped.


\begin{syntax}
uri-parameters   & = & *( ";" uri-parameter)\\
uri-parameter    & = & transport-param $/$ user-param $/$ method-param\\
                 &   & $/$ ttl-param $/$ maddr-param $/$ lr-param $/$ other-param\\
transport-param  & = & "transport=" \\
                 &   & ( "udp" $/$ "tcp" $/$ "sctp" $/$ "tls" \\
                 &   & $/$ other-transport) \\
other-transport  & = & token\\
user-param       & = & "user=" ( "phone" $/$ "ip" $/$ other-user)\\
other-user       & = & token\\
method-param     & = & "method=" Method\\
ttl-param        & = & "ttl=" ttl\\
maddr-param      & = & "maddr=" host\\
lr-param         & = & "lr"\\
other-param      & = & pname [ "=" pvalue ]\\
pname            & = & 1*paramchar\\
pvalue           & = & 1*paramchar\\
paramchar        & = & param-unreserved $/$ unreserved $/$ escaped\\
param-unreserved & = & "[" $/$ "]" $/$ "/" $/$ ":" $/$ "\&" $/$ "+" $/$ "\$"\\
\end{syntax}

\begin{syntax}
headers          & = & "?" header *( "\&" header )\\ 
header           & = & hname "=" hvalue\\
hname            & = & 1*( hnv-unreserved $/$ unreserved $/$ escaped )\\
hvalue           & = & *( hnv-unreserved $/$ unreserved $/$ escaped )\\ 
hnv-unreserved   & = & "[" $/$ "]" $/$ "/" $/$ "?" $/$ ":" $/$ "+" $/$ "\$"\\
\end{syntax}

\begin{syntax}
SIP-message      & = & Request $/$ Response \\
Request          & = & Request-Line \\
                 &   & *( message-header ) \\
                 &   & CRLF \\
                 &   & [ message-body ]\\
Request-Line     & = & Method SP Request-URI SP SIP-Version CRLF \\
Request-URI      & = & SIP-URI $/$ SIPS-URI $/$ absoluteURI\\
absoluteURI      & = & scheme ":" ( hier-part $/$ opaque-part )\\
hier-part        & = & ( net-path $/$ abs-path ) [ "?" query ]\\
net-path         & = & "//" authority [ abs-path ]\\
abs-path         & = & "/"  path-segments\\
opaque-part      & = & uric-no-slash *uric\\
uric             & = & reserved $/$ unreserved $/$ escaped\\
uric-no-slash    & = & unreserved $/$ escaped $/$ ";" $/$ "?" $/$ ":" $/$ "@"\\
                 &   & $/$ "\&" $/$ "=" $/$ "+" $/$ "\$" $/$ ","\\
path-segments    & = & segment *( "/" segment )\\
segment          & = & *pchar *( ";" param )\\
param            & = & *pchar\\
pchar            & = & unreserved $/$ escaped $/$\\
                 &   & ":" $/$ "@" $/$ "\&" $/$ "=" $/$ "+" $/$ "\$" $/$ ","\\
scheme           & = & ALPHA *( ALPHA $/$ DIGIT $/$ "+" $/$ "-" $/$ "." )\\
authority        & = & srvr $/$ reg-name\\
srvr             & = & [ [ userinfo "@" ] hostport ]\\
reg-name         & = & 1*( unreserved $/$ escaped $/$ "\$" $/$ ","\\
                 &   & $/$ ";" $/$ ":" $/$ "@" $/$ "\&" $/$ "=" $/$ "+" )\\
query            & = & *uric\\
SIP-Version      & = & "SIP" "/" 1*DIGIT "." 1*DIGIT\\
\end{syntax}

\begin{syntax}
\header{message-header} 
&  =  & (\header{Accept}                \\
& $/$ & \header{Accept-Encoding}       \\
& $/$ & \header{Accept-Language}       \\
& $/$ & \header{Alert-Info}            \\
& $/$ & \header{Allow}                 \\
& $/$ & \header{Authentication-Info}   \\
& $/$ & \header{Authorization}         \\
& $/$ & \header{Call-ID}               \\
& $/$ & \header{Call-Info}             \\
& $/$ & \header{Contact}               \\
& $/$ & \header{Content-Disposition}   \\
& $/$ & \header{Content-Encoding}      \\
& $/$ & \header{Content-Language}      \\
& $/$ & \header{Content-Length}        \\
& $/$ & \header{Content-Type}          \\
& $/$ & \header{CSeq}                  \\
& $/$ & \header{Date}                  \\
& $/$ & \header{Error-Info}            \\
& $/$ & \header{Expires}               \\
& $/$ & \header{From}                  \\
& $/$ & \header{In-Reply-To}           \\
& $/$ & \header{Max-Forwards}          \\
& $/$ & \header{MIME-Version}          \\
& $/$ & \header{Min-Expires}           \\

& $/$ & \header{Organization}          \\
& $/$ & \header{Priority}              \\
& $/$ & \header{Proxy-Authenticate}    \\
& $/$ & \header{Proxy-Authorization}   \\
& $/$ & \header{Proxy-Require}         \\
& $/$ & \header{Record-Route}          \\
& $/$ & \header{Reply-To}              \\

& $/$ & \header{Require}               \\
& $/$ & \header{Retry-After}           \\
& $/$ & \header{Route}                 \\
& $/$ & \header{Server}                \\
& $/$ & \header{Subject}               \\
& $/$ & \header{Supported}             \\
& $/$ & \header{Timestamp}             \\
& $/$ & \header{To}                    \\
& $/$ & \header{Unsupported}           \\
& $/$ & \header{User-Agent}            \\
& $/$ & \header{Via}                   \\
& $/$ & \header{Warning}               \\
& $/$ & \header{WWW-Authenticate}      \\
& $/$ & \header{extension-header}) CRLF \\
\end{syntax}

\begin{syntax}
INVITEm          & = & \%x49.4E.56.49.54.45 ; \textrm{{\INVITE} in caps} \\
ACKm             & = & \%x41.43.4B ; \textrm{ACK in caps} \\
OPTIONSm         & = & \%x4F.50.54.49.4F.4E.53 ; \textrm{{\OPTIONS} in caps} \\
BYEm             & = & \%x42.59.45 ; \textrm{BYE in caps} \\
CANCELm          & = & \%x43.41.4E.43.45.4C ; \textrm{{\CANCEL} in caps} \\
REGISTERm        & = & \%x52.45.47.49.53.54.45.52 ; \textrm{{\REGISTER} in caps} \\
Method           & = & INVITEm $/$ ACKm  $/$ OPTIONSm $/$ BYEm \\
                 &   & $/$ CANCELm $/$ REGISTERm \\
                 &   & $/$ extension-method\\
extension-method & = & token\\
Response         & = & Status-Line \\
                 &   & *( message-header )  & \\
                 &   & CRLF                 & \\
                 &   & [ message-body ]     & \\
\end{syntax}

\begin{syntax}
Status-Line      & = & SIP-Version SP Status-Code SP Reason-Phrase CRLF \\
Status-Code & = & Informational  & \\
&$/$& Redirection    & \\
&$/$& Success        & \\
&$/$& Client-Error   & \\
&$/$& Server-Error   & \\
&$/$& Global-Failure & \\
&$/$& extension-code \\
extension-code   & = & 3DIGIT\\
Reason-Phrase & = & *(reserved $/$ unreserved $/$ escaped \\
              &   & $/$ UTF8-NONASCII $/$ UTF8-CONT $/$ SP $/$ HTAB)\\
\end{syntax}


\begin{syntax}
Informational & = & "100" & ; {\rm Trying}\\
&$/$& "180" & ; {\rm Ringing}\\
&$/$& "181" & ; {\rm Call Is Being Forwarded}\\
&$/$& "182" & ; {\rm Queued}\\
&$/$& "183" & ; {\rm Session Progress}\\
\end{syntax}

\begin{syntax}
Success
& = & "200" & ; {\rm OK}\\
\end{syntax}

\begin{syntax}
Redirection
& = & "300" & ; {\rm Multiple Choices}\\
&$/$& "301" & ; {\rm Moved Permanently}\\
&$/$& "302" & ; {\rm Moved Temporarily}\\
&$/$& "305" & ; {\rm Use Proxy}\\
&$/$& "380" & ; {\rm Alternative Service}\\
\end{syntax}

\begin{changebar}
\begin{syntax}
Client-Error
& = & "400" & ; {\rm Bad Request}\\
&$/$& "401" & ; {\rm Unauthorized}\\
&$/$& "402" & ; {\rm Payment Required}\\
&$/$& "403" & ; {\rm Forbidden}\\
&$/$& "404" & ; {\rm Not Found}\\
&$/$& "405" & ; {\rm Method Not Allowed}\\
&$/$& "406" & ; {\rm Not Acceptable}\\
&$/$& "407" & ; {\rm Proxy Authentication Required}\\
&$/$& "408" & ; {\rm Request Timeout}\\
&$/$& "410" & ; {\rm Gone}\\
&$/$& "413" & ; {\rm Request Entity Too Large}\\
&$/$& "414" & ; {\rm Request-URI Too Large}\\
&$/$& "415" & ; {\rm Unsupported Media Type}\\
&$/$& "416" & ; {\rm Unsupported URI Scheme}\\
&$/$& "420" & ; {\rm Bad Extension}\\
&$/$& "421" & ; {\rm Extension Required}\\
&$/$& "423" & ; {\rm Interval Too Brief}\\ 
&$/$& "480" & ; {\rm Temporarily not available}\\
&$/$& "481" & ; {\rm Call Leg/Transaction Does Not Exist}\\
&$/$& "482" & ; {\rm Loop Detected}\\
&$/$& "483" & ; {\rm Too Many Hops}\\
&$/$& "484" & ; {\rm Address Incomplete}\\
&$/$& "485" & ; {\rm Ambiguous}\\
&$/$& "486" & ; {\rm Busy Here}\\
&$/$& "487" & ; {\rm Request Terminated}\\
&$/$& "488" & ; {\rm Not Acceptable Here}\\
&$/$& "491" & ; {\rm Request Pending}\\
&$/$& "493" & ; {\rm Undecipherable}\\
\end{syntax}

\begin{syntax}
Server-Error
& = & "500" & ; {\rm Internal Server Error}\\
&$/$& "501" & ; {\rm Not Implemented}\\
&$/$& "502" & ; {\rm Bad Gateway}\\
&$/$& "503" & ; {\rm Service Unavailable}\\
&$/$& "504" & ; {\rm Server Time-out}\\
&$/$& "505" & ; {\rm SIP Version not supported}\\
&$/$& "513" & ; {\rm Message Too Large}\\
\end{syntax}
\end{changebar}

\begin{syntax}
Global-Failure
& = & "600" & ; {\rm Busy Everywhere}\\
&$/$& "603" & ; {\rm Decline}\\
&$/$& "604" & ; {\rm Does not exist anywhere}\\
&$/$& "606" & ; {\rm Not Acceptable}\\
\end{syntax}

\begin{syntax}
Accept           & = & "Accept" HCOLON \\
                 &   & ( accept-range *(COMMA accept-range) )\\
accept-range     & = & media-range *(SEMI accept-param)\\
media-range      & = & ( "*/*"\\
                 &   & $/$ ( m-type SLASH "*" )\\
                 &   & $/$ ( m-type SLASH m-subtype )\\
                 &   & ) *( SEMI m-parameter )\\
accept-param     & = & ("q" EQUAL qvalue) $/$ generic-param\\
qvalue           & = & ( "0" [ "." 0*3DIGIT ] )\\
                 &   & $/$ ( "1" [ "." 0*3("0") ] )\\
generic-param    & = & token [ EQUAL gen-value ]\\
gen-value        & = & token $/$ host $/$ quoted-string\\
\end{syntax}

\begin{syntax}
Accept-Encoding  & = & "Accept-Encoding" HCOLON \\
                 &   & ( encoding *(COMMA encoding) )\\
encoding         & = & codings *(SEMI accept-param)\\
codings          & = & content-coding $/$ "*"\\
content-coding   & = & token \\
\end{syntax}

\begin{syntax}
Accept-Language  & = & "Accept-Language" HCOLON \\
                 &   & ( language *(COMMA language) )\\
language         & = & language-range *(SEMI accept-param)\\
language-range   & = & ( ( 1*8ALPHA *( "-" 1*8ALPHA ) ) $/$ "*" )\\
\end{syntax}

\begin{syntax}
Alert-Info       & = & "Alert-Info" HCOLON alert-param *(COMMA alert-param)\\
alert-param      & = & LAQUOT absoluteURI RAQUOT *( SEMI generic-param )\\
\end{syntax}

\begin{syntax}
Allow            & = & "Allow" HCOLON Method *(COMMA Method)\\
\end{syntax}

\begin{syntax}
Authorization    & = & "Authorization" HCOLON credentials\\
credentials      & = & ("Digest" LWS digest-response) \\
                 &   & $/$ other-response \\
digest-response  & = & dig-resp *(COMMA dig-resp)\\
dig-resp         & = & username $/$ realm $/$ nonce $/$ digest-uri \\
                 &   & $/$ dresponse $/$ [ algorithm ] $/$ [cnonce] \\
                 &   & $/$ [opaque] $/$ [message-qop] \\
                 &   & $/$ [nonce-count]  $/$ [auth-param]\\
username         & = & "username" EQUAL username-value \\
username-value   & = & quoted-string \\
digest-uri       & = & "uri" EQUAL LDQUOT digest-uri-value RDQUOT\\
digest-uri-value & = & rquest-uri   ; Equal to request-uri as specified by HTTP/1.1 \\
message-qop      & = & "qop" EQUAL qop-value \\
cnonce           & = & "cnonce" EQUAL cnonce-value \\
cnonce-value     & = & nonce-value \\
nonce-count      & = & "nc" EQUAL nc-value \\
nc-value         & = & 8LHEX\\
dresponse        & = & "response" EQUAL request-digest \\
request-digest   & = & LDQUOT 32LHEX RDQUOT \\
auth-param       & = & auth-param-name EQUAL \\
                 &   & ( token $/$ quoted-string )\\
auth-param-name  & = & token\\
other-response   & = & auth-scheme LWS auth-param \\
                 &   & *(COMMA auth-param)\\
auth-scheme      & = & token \\
\end{syntax}


\begin{syntax}
Authentication-Info & = & "Authentication-Info" HCOLON ainfo \\
                 &   & *(COMMA ainfo) \\
ainfo            & = & [nextnonce] $/$ [ message-qop ]\\
                 &   & $/$ [ response-auth ] $/$ [ cnonce ]\\
                 &   & $/$ [nonce-count] \\
nextnonce        & = & "nextnonce" EQUAL nonce-value\\
response-auth    & = & "rspauth" EQUAL response-digest\\
response-digest  & = & LDQUOT *LHEX RDQUOT\\
\end{syntax}


\begin{syntax}
Call-ID          & = & ( "Call-ID" $/$ "i" ) HCOLON callid\\
callid           & = & word [ "@" word ]\\
\end{syntax}

\begin{syntax}
Call-Info        & = & "Call-Info" HCOLON info *(COMMA info)\\
info             & = & LAQUOT absoluteURI RAQUOT *( SEMI info-param)\\
info-param       & = & ( "purpose" EQUAL ( "icon" $/$ "info"\\
                 &   & $/$ "card" $/$ token ) ) $/$ generic-param \\
\end{syntax}

\begin{syntax}
Contact          & = & ("Contact" $/$ "m" ) HCOLON \\
                 &   & ( STAR $/$ (contact-param *(COMMA contact-param)))\\
contact-param    & = & (name-addr $/$ addr-spec) *(SEMI contact-params)\\
name-addr        & = & [ display-name ] LAQUOT addr-spec RAQUOT\\
addr-spec        & = & SIP-URI $/$ SIPS-URI $/$ absoluteURI \\
display-name     & = & *(token LWS)$/$ quoted-string\\  
\end{syntax}

\begin{syntax}
contact-params   & = & c-p-q $/$ c-p-expires \\ 
                 &   & $/$ contact-extension\\
c-p-q            & = & "q" EQUAL qvalue\\
c-p-expires      & = & "expires" EQUAL delta-seconds\\
contact-extension 
                 & = & generic-param\\
delta-seconds    & = & 1*DIGIT \\
\end{syntax}

\begin{syntax}
Content-Disposition & = & "Content-Disposition" HCOLON \\
                 &   & disp-type *( SEMI disp-param )\\
disp-type        & = & "render" $/$ "session" $/$ "icon" $/$ "alert" \\
                 &   & $/$ disp-extension-token\\
disp-param       & = & handling-param $/$ generic-param \\
handling-param   & = & "handling" EQUAL \\
                 &   & ( "optional" $/$ "required" \\
                 &   & $/$ other-handling )\\
other-handling   & = & token\\
disp-extension-token & = & token\\
\end{syntax}

\begin{syntax}
Content-Encoding & = & ( "Content-Encoding" $/$ "e" ) HCOLON \\
                 &   & content-coding *(COMMA content-coding) \\
\end{syntax}

\begin{syntax}
Content-Language & = & "Content-Language" HCOLON\\ 
                 &   & language-tag *(COMMA language-tag)\\
language-tag     & = & primary-tag *( "-" subtag )\\
primary-tag      & = & 1*8ALPHA \\
subtag           & = & 1*8ALPHA \\
\end{syntax}

\begin{syntax}
Content-Length   & = & ( "Content-Length" $/$ "l" ) HCOLON 1*DIGIT\\
\end{syntax}

\begin{syntax}
Content-Type     & = & ( "Content-Type" $/$ "c" ) HCOLON media-type\\
media-type       & = & m-type SLASH m-subtype *(SEMI m-parameter)\\
m-type           & = & discrete-type $/$ composite-type\\
discrete-type    & = & "text" $/$ "image" $/$ "audio" $/$ "video" \\
                 &   & $/$ "application" $/$ extension-token\\
composite-type   & = & "message" $/$ "multipart" $/$ extension-token\\
extension-token  & = & ietf-token $/$ x-token\\
ietf-token       & = & token\\ 
x-token          & = &  "x-" token\\
m-subtype        & = & extension-token $/$ iana-token\\
iana-token       & = & token\\
m-parameter        & = & m-attribute EQUAL m-value\\
m-attribute      & = & token\\
m-value          & = & token $/$ quoted-string\\
\end{syntax}

\begin{syntax}
CSeq             & = & "CSeq" HCOLON 1*DIGIT LWS Method\\
\end{syntax}

\begin{syntax}
Date             & = & "Date" HCOLON SIP-date\\
SIP-date         & = & rfc1123-date \\
rfc1123-date     & = & wkday "," date1 SP time SP "GMT"\\
date1            & = & 2DIGIT SP month SP 4DIGIT\\
                 &   & ; day month year (e.g., 02 Jun 1982)\\
time             & = & 2DIGIT ":" 2DIGIT ":" 2DIGIT\\
                 &   & ; 00:00:00 - 23:59:59\\
wkday            & = & "Mon" $/$ "Tue" $/$ "Wed"\\
                 &   & $/$ "Thu" $/$ "Fri" $/$ "Sat" $/$ "Sun"\\
month            & = & "Jan" $/$ "Feb" $/$ "Mar" $/$ "Apr"\\
                 &   & $/$ "May" $/$ "Jun" $/$ "Jul" $/$ "Aug"\\
                 &   & $/$ "Sep" $/$ "Oct" $/$ "Nov" $/$ "Dec"\\

\end{syntax}

\begin{syntax}
Error-Info       & = & "Error-Info" HCOLON error-uri *(COMMA error-uri) \\
error-uri        & = & LAQUOT absoluteURI RAQUOT *( SEMI generic-param )\\
\end{syntax}

\begin{syntax}
Expires          & = & "Expires" HCOLON delta-seconds \\
From             & = & ( "From" $/$ "f" ) HCOLON from-spec\\
from-spec        & = & ( name-addr $/$ addr-spec ) \\
                 &   & *( SEMI from-param )\\
from-param       & = & tag-param $/$ generic-param\\
tag-param        & = & "tag" EQUAL token\\
\end{syntax}

\begin{syntax}
In-Reply-To      & = & "In-Reply-To" HCOLON callid *(COMMA callid)\\
\end{syntax}

\begin{syntax}
Max-Forwards     & = & "Max-Forwards" HCOLON 1*DIGIT\\
\end{syntax}

\begin{syntax}
MIME-Version     & = & "MIME-Version" HCOLON 1*DIGIT "." 1*DIGIT\\
\end{syntax}

\begin{syntax}
Min-Expires      & = & "Min-Expires" HCOLON delta-seconds \\
\end{syntax}

\begin{syntax}
Organization     & = & "Organization" HCOLON [TEXT-UTF8-TRIM]\\
\end{syntax}

\begin{syntax}
Priority         & = & "Priority" HCOLON priority-value\\
priority-value   & = & "emergency" $/$ "urgent" $/$ "normal"\\
                 &   & $/$ "non-urgent" $/$ other-priority\\
other-priority   & = & token\\
\end{syntax}

\begin{syntax}
Proxy-Authenticate & = & "Proxy-Authenticate" HCOLON challenge\\
challenge        & = & ("Digest" LWS digest-cln *(COMMA digest-cln)) \\
                 &   & $/$ other-challenge \\
other-challenge  & = & auth-scheme LWS auth-param \\
                 &   & *(COMMA auth-param)\\
digest-cln       & = & realm $/$ [ domain ] $/$ nonce \\
                 &   & $/$ [ opaque ] $/$ [ stale ] $/$ [ algorithm ] \\
                 &   & $/$ [ qop-options ] $/$ [auth-param]\\
realm            & = & "realm" EQUAL realm-value \\
realm-value      & = & quoted-string \\
domain           & = & "domain" EQUAL LDQUOT URI \\
                 &   & *( 1*SP URI ) RDQUOT \\
URI              & = & absoluteURI $/$ abs-path \\
nonce            & = & "nonce" EQUAL nonce-value \\
nonce-value      & = & quoted-string \\
opaque           & = & "opaque" EQUAL quoted-string \\
stale            & = & "stale" EQUAL ( "true" $/$ "false" )\\
algorithm        & = & "algorithm" EQUAL ( "MD5" $/$ "MD5-sess" \\
                 &   & $/$ token )\\
qop-options      & = & "qop" EQUAL LDQUOT qop-value \\
                 &   & *("," qop-value) RDQUOT \\
qop-value        & = & "auth" $/$ "auth-int" $/$ token \\
\end{syntax}

\begin{syntax}
Proxy-Authorization & = & "Proxy-Authorization" HCOLON credentials\\
\end{syntax}

\begin{syntax}
Proxy-Require    & = & "Proxy-Require" HCOLON option-tag \\
                 &   & *(COMMA option-tag)\\
option-tag       & = & token \\
\end{syntax}

\begin{syntax}
Record-Route     & = & "Record-Route" HCOLON rec-route *(COMMA rec-route) \\
rec-route        & = & name-addr *( SEMI rr-param )\\
rr-param         & = & generic-param\\
\end{syntax}


\begin{syntax}
Reply-To         & = & "Reply-To" HCOLON rplyto-spec\\
rplyto-spec      & = & ( name-addr $/$ addr-spec ) \\
                 &   & *( SEMI rplyto-param )\\
rplyto-param     & = & generic-param\\
Require          & = & "Require" HCOLON option-tag *(COMMA option-tag)\\
\end{syntax}


\begin{syntax}
Retry-After      & = & "Retry-After" HCOLON delta-seconds\\
                 &   & [ comment ] *( SEMI retry-param )\\
retry-param      & = & ("duration" EQUAL delta-seconds)\\
                 &   & $/$ generic-param\\
\end{syntax}

\begin{syntax}
Route            & = & "Route" HCOLON route-param *(COMMA route-param)\\
route-param      & = & name-addr *( SEMI rr-param )\\
\end{syntax}

\begin{syntax}
Server           & = & "Server" HCOLON server-val *(LWS server-val)\\
server-val       & = & product $/$ comment\\
product          & = & token [SLASH product-version]\\
product-version  & = & token \\
\end{syntax}

\begin{syntax}
Subject          & = & ( "Subject" $/$ "s" ) HCOLON [TEXT-UTF8-TRIM]\\
\end{syntax}

\begin{syntax}
Supported        & = & ( "Supported" $/$ "k" ) HCOLON\\ 
                 &   & [option-tag *(COMMA option-tag)]\\
\end{syntax}

\begin{syntax}
Timestamp        & = & "Timestamp" HCOLON 1*(DIGIT) \\
                 &   & [ "." *(DIGIT) ] [ delay ]\\
delay            & = & *(DIGIT) [ "." *(DIGIT) ]\\
\end{syntax}

\begin{syntax}
To               & = & ( "To" $/$ "t" ) HCOLON ( name-addr \\
                 &   & $/$ addr-spec ) *( SEMI to-param )\\
to-param         & = & tag-param $/$ generic-param\\  
\end{syntax}

\begin{syntax}
Unsupported      & = & "Unsupported" HCOLON option-tag *(COMMA option-tag)\\
\end{syntax}

\begin{syntax}
User-Agent       & = & "User-Agent" HCOLON server-val *(LWS server-val)\\
\end{syntax}

\begin{syntax}
Via              & = & ( "Via" $/$ "v" ) HCOLON via-parm *(COMMA via-parm)\\
via-parm         & = & sent-protocol LWS sent-by *( SEMI via-params )\\
via-params       & = & via-ttl $/$ via-maddr\\
                 &   & $/$ via-received $/$ via-branch \\
                 &   & $/$ via-extension\\
via-ttl          & = & "ttl" EQUAL ttl \\
via-maddr        & = & "maddr" EQUAL host \\
via-received     & = & "received" EQUAL (IPv4address $/$ IPv6address)\\
via-branch       & = & "branch" EQUAL token \\
via-extension    & = & generic-param\\
sent-protocol    & = & protocol-name SLASH protocol-version \\
                 &   & SLASH transport \\
protocol-name    & = & "SIP" $/$ token \\
protocol-version & = & token \\
transport        & = & "UDP" $/$ "TCP" $/$ "TLS" $/$ "SCTP" \\
                 &   & $/$ other-transport\\
sent-by          & = & host [ COLON port ]\\
ttl              & = & 1*3DIGIT        ; 0 to 255\\
\end{syntax}


\begin{syntax}
Warning          & = & "Warning" HCOLON warning-value *(COMMA warning-value)\\
warning-value    & = & warn-code SP warn-agent SP warn-text\\
warn-code        & = & 3DIGIT\\
warn-agent       & = & hostport $/$ pseudonym\\
                 &   & ; {\rm the name or pseudonym of the server adding}\\
                 &   & ; {\rm the Warning header, for use in debugging}\\
warn-text        & = & quoted-string\\
pseudonym        & = & token \\
\end{syntax}


\begin{syntax}
WWW-Authenticate & = & "WWW-Authenticate" HCOLON challenge\\
\end{syntax}

\begin{syntax}
extension-header & = & header-name HCOLON header-value \\
header-name      & = & token \\
header-value     & = & *(TEXT-UTF8char $/$ UTF8-CONT $/$ LWS)\\
\end{syntax}

\begin{syntax}
message-body     & = & *OCTET\\
\end{syntax}

