SipParser (SIP Framer and Parser Library 1.0.6 API)

java.lang.Object
- io.pkts.packet.sip.impl.SipParser

Direct Known Subclasses:

SipInitialLine
```
public class SipParser
extends Object
```
Basic sip parser that contains most (all?) of the different grammar rules for SIP as defined by RFC 3261. View these various methods as building blocks for building up a complete SIP parser (perhaps I should rename this class?). All of these functions work in the following way:
- consumeXXXX - will (in general) simply try and consume whatever it is supposed to consume and the function will return true of false depending on whether is was able to consume anything from the Buffer. The consume-functions will (if successful) move the reader index of the Buffer. If unsuccessful, the reader index will be left untouched.
- expectXXX - will (in general) expect that the next thing is whatever it is supposed to expect. These functions are really the same as the consumeXXXX ones but instead of returning true or false the expect-functions will throw a SipParseException to indicate that things didn't turn out as we were hoping for. Also, remember that the SipParseException contains the error offset into the Buffer where things broke. As with the consume-functions, the expect-functions will (if successful) move the reader index of the Buffer
Author:

jonas@jonasborjesson.com

Field Summary

Fields
Modifier and Type	Field and Description
`static byte`	`AT`
`static byte`	`BACK_SLASH`
`static byte`	`BACKTICK`
`static byte`	`COLON`
`static byte`	`COMMA`
`static byte`	`CR`
`static byte`	`DASH`
`static byte`	`DOUBLE_QOUTE`
`static byte`	`DQUOT` Double quotation mark
`static byte`	`EQ`
`static byte`	`EXCLAMATIONPOINT`
`static Map<Buffer,java.util.function.Function<SipHeader,? extends SipHeader>>`	`framers`
`static byte`	`HTAB`
`static byte`	`LAQUOT` Left angle quote
`static byte`	`LF`
`static byte`	`LPAREN` Left parenthesis
`static Buffer`	`MADDR`
`static int`	`MAX_LOOK_AHEAD` There are many situations where you are looking to frame something but you cannot find the terminating condition.
`static Buffer`	`METHOD`
`static byte`	`PERCENT`
`static byte`	`PERIOD`
`static byte`	`PLUS`
`static byte`	`QUESTIONMARK`
`static byte`	`RAQUOT` Right angle quote
`static byte`	`RPAREN` Right parenthesis
`static Buffer`	`SCHEME_SIP`
`static Buffer`	`SCHEME_SIP_COLON`
`static Buffer`	`SCHEME_SIPS`
`static Buffer`	`SCHEME_SIPS_COLON`
`static Buffer`	`SCTP`
`static byte`	`SEMI`
`static Buffer`	`SIP2_0`
`static Buffer`	`SIP2_0_SLASH`
`static byte`	`SLASH`
`static byte`	`SP`
`static byte`	`STAR`
`static Buffer`	`TCP`
`static byte`	`TICK`
`static byte`	`TILDE`
`static Buffer`	`TLS`
`static Buffer`	`TRANSPORT`
`static Buffer`	`TRANSPORT_EQ`
`static Buffer`	`TTL`
`static Buffer`	`UDP`
`static byte`	`UNDERSCORE`
`static Buffer`	`USER`
`static Buffer`	`WS`

Constructor Summary

Constructors
Constructor and Description

SipParser()

Constructors
Constructor and Description
`SipParser()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Buffer`	`consumeAddressSpec(Buffer buffer)` Consumes addr-spec, which according to RFC3261 section 25.1 is:
`static Buffer`	`consumeAlphaNum(Buffer buffer)` Consumes a alphanum.
`static int`	`consumeCOLON(Buffer buffer)` Consume colon (COLON), which according to RFC3261 section 25.1 Basic Rules is: COLON = SWS ":" SWS ; colon
`static int`	`consumeCOMMA(Buffer buffer)` Consume comma (COMMA), which according to RFC3261 section 25.1 Basic Rules is: COMMA = SWS "," SWS ; comma
`static int`	`consumeCRLF(Buffer buffer)` Consume CR + LF
`static Buffer`	`consumeDisplayName(Buffer buffer)` The display name in SIP is a little tricky since it may or may not be there and the stuff following it (whether or not it was there to begin with) can easily be confused with being a display name.
`static int`	`consumeEQUAL(Buffer buffer)` Consume equal sign (EQUAL), which according to RFC3261 section 25.1 Basic Rules is: EQUAL = SWS "=" SWS ; equal
`static Buffer[]`	`consumeGenericParam(Buffer buffer)` Consumes a generic param, which according to RFC 3261 section 25.1 is:
`static List<Buffer[]>`	`consumeGenericParams(Buffer buffer)` Consumes all generic-params it can find.
`static Buffer`	`consumeHostname(Buffer buffer)`
`static int`	`consumeLAQUOT(Buffer buffer)` Consume left angle quote (LAQUOT), which according to RFC3261 section 25.1 Basic Rules is: LAQUOT = SWS "<"; left angle quote
`static int`	`consumeLDQUOT(Buffer buffer)` Consume open double quotation mark (LDQUT), which according to RFC3261 section 25.1 Basic Rules is: LDQUOT = SWS DQUOTE; open double quotation mark
`static int`	`consumeLPAREN(Buffer buffer)` Consume left parenthesis (LPAREN), which according to RFC3261 section 25.1 Basic Rules is: LPAREN = SWS "(" SWS ; left parenthesis
`static int`	`consumeLWS(Buffer buffer)` Consume linear whitespace (LWS), which according to RFC3261 section 25.1 Basic Rules is: LWS = [WSP CRLF] 1WSP ; linear whitespace
`static Buffer`	`consumeMSubtype(Buffer buffer)` Consume a m-subtype, which according to RFC3261 section 25.1 Basic Rules is:
`static Buffer`	`consumeMType(Buffer buffer)` Consume a m-type, which according to RFC3261 section 25.1 Basic Rules is:
`static Buffer`	`consumePort(Buffer buffer)` Consume a port, which according to RFC 3261 is: port = 1*DIGIT
`static Buffer`	`consumeQuotedString(Buffer buffer)` Consumes a quoted-string, which is defined as:
`static int`	`consumeRAQUOT(Buffer buffer)` Consume right angle quote (RAQUOT), which according to RFC3261 section 25.1 Basic Rules is: RAQUOT = SWS ">"; left angle quote
`static int`	`consumeRDQUOT(Buffer buffer)` Consume close double quotation mark (RDQUT), which according to RFC3261 section 25.1 Basic Rules is: RDQUOT = DQUOTE SWS ; close double quotation mark
`static int`	`consumeRPAREN(Buffer buffer)` Consume right parenthesis (RPAREN), which according to RFC3261 section 25.1 Basic Rules is: RPAREN = SWS ")" SWS ; right parenthesis
`static int`	`consumeSEMI(Buffer buffer)` Consume semicolon (SEMI), which according to RFC3261 section 25.1 Basic Rules is: SEMI = SWS ";" SWS ; semicolon
`static Buffer[]`	`consumeSentBye(Buffer buffer)` Consume a sent-by which according to 3261 is:
`static Buffer`	`consumeSentProtocol(Buffer buffer)` Consume the "sent-protocol", which according to RFC 3261 is:
`static int`	`consumeSLASH(Buffer buffer)` Consume an slash (SLASH), which according to RFC3261 section 25.1 Basic Rules is: SLASH = SWS "/" SWS ; slash
`static int`	`consumeSTAR(Buffer buffer)` Consume an asterisk/star (STAR), which according to RFC3261 section 25.1 Basic Rules is: STAR = SWS "*" SWS ; asterisk
`static int`	`consumeSWS(Buffer buffer)` Consume sep (separating?) whitespace (LWS), which according to RFC3261 section 25.1 Basic Rules is: SWS = [LWS] ; sep whitespace "The SWS construct is used when linear white space is optional, generally between tokens and separators." (RFC3261)
`static Buffer`	`consumeToken(Buffer buffer)` Consume a token, which according to RFC3261 section 25.1 Basic Rules is: token = 1(alphanum / "-" / "." / "!" / "%" / "" / "_" / "+" / "`" / "'" / "~" )
`static Buffer[]`	`consumeUserInfoHostPort(Buffer buffer)` Consume the userinfo and hostport.
`static Object[]`	`consumeVia(Buffer buffer)` Consume a Via-header, which according to RFC3261 is:
`static int`	`consumeWS(Buffer buffer)` Consume all the whitespace we find (WS)
`static boolean`	`couldBeSipMessage(Buffer data)` Helper function that checks whether or not the data could be a SIP message.
`static void`	`expect(Buffer buffer, byte expected)` Check so that the next byte in the passed in buffer is the expected one.
`static void`	`expect(Buffer buffer, char ch)` Check so that the next byte in the passed in buffer is the expected one.
`static Buffer`	`expectDigit(Buffer buffer)` Will expect at least 1 digit and will continue consuming bytes until a non-digit is encountered
`static int`	`expectHCOLON(Buffer buffer)` Convenience method for expecting (and consuming) a HCOLON, which is defined as: HCOLON = *( SP / HTAB ) ":" SWS See RFC3261 section 25.1 Basic Rules
`static Buffer`	`expectMethod(Buffer buffer)`
`static void`	`expectSIP2_0(Buffer buffer)` Expect that the next set of bytes is "SIP/2.0" and if not then we will throw a `SipParseException`
`static void`	`expectSLASH(Buffer buffer)` Convenience method for expecting (and consuming) a SLASH, which is defined as: See RFC3261 section 25.1 Basic Rules
`static Buffer`	`expectToken(Buffer buffer)` Expects a token, which according to RFC3261 section 25.1 Basic Rules is: token = 1(alphanum / "-" / "." / "!" / "%" / "" / "_" / "+" / "`" / "'" / "~" )
`static int`	`expectWS(Buffer buffer)` Expect the next byte to be a white space
`static SipMessage`	`frame(Buffer buffer)` Frame the supplied buffer into a `SipMessage`.
`static int`	`getAlphaNumCount(Buffer buffer)` Helper method that counts the number of bytes that are considered part of the next alphanum block.
`static int`	`getTokenCount(Buffer buffer)` Helper method that counts the number of bytes that are considered part of the next token in the `Buffer`.
`static boolean`	`isAlphaNum(byte b)`
`static boolean`	`isAlphaNum(char ch)` Helper method for checking whether the supplied byte is a alphanumeric character or not.
`static boolean`	`isDigit(byte b)`
`static boolean`	`isDigit(char ch)`
`static boolean`	`isNext(Buffer buffer, byte b)` Will check whether the next readable byte in the buffer is a certain byte
`static boolean`	`isNextAlphaNum(Buffer buffer)` Check whether next byte is a alpha numeric one.
`static boolean`	`isNextDigit(Buffer buffer)` Check whether the next byte is a digit or not
`static boolean`	`isSCTP(Buffer t)`
`static boolean`	`isSCTPLower(Buffer t)`
`static boolean`	`isSips(Buffer buffer)`
`static boolean`	`isTCP(Buffer t)`
`static boolean`	`isTCPLower(Buffer t)`
`static boolean`	`isTLS(Buffer t)`
`static boolean`	`isTLSLower(Buffer t)`
`static boolean`	`isUDP(Buffer t)` Check whether the buffer is exactly three bytes long and has the bytes "UDP" in it.
`static boolean`	`isUDPLower(Buffer t)` Check whether the buffer is exactly three bytes long and has the bytes "udp" in it.
`static boolean`	`isWS(Buffer t)`
`static boolean`	`isWSLower(Buffer t)`
`static SipHeader`	`nextHeader(Buffer buffer)` Get the next header, which may actually be returning multiple if there are multiple headers on the same line.
`static List<SipHeader>`	`nextHeaders(Buffer buffer)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MAX_LOOK_AHEAD
```
public static final int MAX_LOOK_AHEAD
```
    There are many situations where you are looking to frame something but you cannot find the terminating condition. Since an attacker could easily just have you read a never ending stream we need at some point give up and abort.
    
    See Also:
    
    Constant Field Values
  - USER
```
public static final Buffer USER
```
  - TTL
```
public static final Buffer TTL
```
  - MADDR
```
public static final Buffer MADDR
```
  - METHOD
```
public static final Buffer METHOD
```
  - TRANSPORT
```
public static final Buffer TRANSPORT
```
  - TRANSPORT_EQ
```
public static final Buffer TRANSPORT_EQ
```
  - SIP2_0
```
public static final Buffer SIP2_0
```
  - SIP2_0_SLASH
```
public static final Buffer SIP2_0_SLASH
```
  - SCHEME_SIP
```
public static final Buffer SCHEME_SIP
```
  - SCHEME_SIP_COLON
```
public static final Buffer SCHEME_SIP_COLON
```
  - SCHEME_SIPS
```
public static final Buffer SCHEME_SIPS
```
  - SCHEME_SIPS_COLON
```
public static final Buffer SCHEME_SIPS_COLON
```
  - AT
```
public static final byte AT
```
    See Also:
    
    Constant Field Values
  - COLON
```
public static final byte COLON
```
    See Also:
    
    Constant Field Values
  - SEMI
```
public static final byte SEMI
```
    See Also:
    
    Constant Field Values
  - DOUBLE_QOUTE
```
public static final byte DOUBLE_QOUTE
```
    See Also:
    
    Constant Field Values
  - CR
```
public static final byte CR
```
    See Also:
    
    Constant Field Values
  - LF
```
public static final byte LF
```
    See Also:
    
    Constant Field Values
  - SP
```
public static final byte SP
```
    See Also:
    
    Constant Field Values
  - HTAB
```
public static final byte HTAB
```
    See Also:
    
    Constant Field Values
  - DASH
```
public static final byte DASH
```
    See Also:
    
    Constant Field Values
  - PERIOD
```
public static final byte PERIOD
```
    See Also:
    
    Constant Field Values
  - COMMA
```
public static final byte COMMA
```
    See Also:
    
    Constant Field Values
  - EXCLAMATIONPOINT
```
public static final byte EXCLAMATIONPOINT
```
    See Also:
    
    Constant Field Values
  - PERCENT
```
public static final byte PERCENT
```
    See Also:
    
    Constant Field Values
  - STAR
```
public static final byte STAR
```
    See Also:
    
    Constant Field Values
  - UNDERSCORE
```
public static final byte UNDERSCORE
```
    See Also:
    
    Constant Field Values
  - QUESTIONMARK
```
public static final byte QUESTIONMARK
```
    See Also:
    
    Constant Field Values
  - PLUS
```
public static final byte PLUS
```
    See Also:
    
    Constant Field Values
  - BACKTICK
```
public static final byte BACKTICK
```
    See Also:
    
    Constant Field Values
  - TICK
```
public static final byte TICK
```
    See Also:
    
    Constant Field Values
  - TILDE
```
public static final byte TILDE
```
    See Also:
    
    Constant Field Values
  - EQ
```
public static final byte EQ
```
    See Also:
    
    Constant Field Values
  - SLASH
```
public static final byte SLASH
```
    See Also:
    
    Constant Field Values
  - BACK_SLASH
```
public static final byte BACK_SLASH
```
    See Also:
    
    Constant Field Values
  - LPAREN
```
public static final byte LPAREN
```
    Left parenthesis
    
    See Also:
    
    Constant Field Values
  - RPAREN
```
public static final byte RPAREN
```
    Right parenthesis
    
    See Also:
    
    Constant Field Values
  - RAQUOT
```
public static final byte RAQUOT
```
    Right angle quote
    
    See Also:
    
    Constant Field Values
  - LAQUOT
```
public static final byte LAQUOT
```
    Left angle quote
    
    See Also:
    
    Constant Field Values
  - DQUOT
```
public static final byte DQUOT
```
    Double quotation mark
    
    See Also:
    
    Constant Field Values
  - UDP
```
public static final Buffer UDP
```
  - TCP
```
public static final Buffer TCP
```
  - TLS
```
public static final Buffer TLS
```
  - SCTP
```
public static final Buffer SCTP
```
  - WS
```
public static final Buffer WS
```
  - framers
```
public static final Map<Buffer,java.util.function.Function<SipHeader,? extends SipHeader>> framers
```
- Constructor Detail
  - SipParser
```
public SipParser()
```
- Method Detail
  - expectSIP2_0
```
public static void expectSIP2_0(Buffer buffer)
                         throws SipParseException
```
    Expect that the next set of bytes is "SIP/2.0" and if not then we will throw a SipParseException
    
    Parameters:
    
    buffer -
    
    Throws:
    
    SipParseException
  - expectMethod
```
public static Buffer expectMethod(Buffer buffer)
```
    Returns:
  - isUDP
```
public static boolean isUDP(Buffer t)
```
    Check whether the buffer is exactly three bytes long and has the bytes "UDP" in it.
    
    Parameters:
    
    t -
    
    Returns:
  - isTCP
```
public static boolean isTCP(Buffer t)
```
  - isTLS
```
public static boolean isTLS(Buffer t)
```
  - isWS
```
public static boolean isWS(Buffer t)
```
  - isSCTP
```
public static boolean isSCTP(Buffer t)
```
  - isUDPLower
```
public static boolean isUDPLower(Buffer t)
```
    Check whether the buffer is exactly three bytes long and has the bytes "udp" in it. Note, in SIP there is a different between transport specified in a Via-header and a transport-param specified in a SIP URI. One is upper case, one is lower case. Another really annoying thing with SIP.
    
    Parameters:
    
    t -
    
    Returns:
  - isTCPLower
```
public static boolean isTCPLower(Buffer t)
```
  - isTLSLower
```
public static boolean isTLSLower(Buffer t)
```
  - isWSLower
```
public static boolean isWSLower(Buffer t)
```
  - isSCTPLower
```
public static boolean isSCTPLower(Buffer t)
```
  - isSips
```
public static boolean isSips(Buffer buffer)
                      throws SipParseException,
                             IndexOutOfBoundsException,
                             IOException
```
    Throws:
    
    SipParseException
    
    IndexOutOfBoundsException
    
    IOException
  - consumeGenericParams
```
public static List<Buffer[]> consumeGenericParams(Buffer buffer)
                                           throws IndexOutOfBoundsException,
                                                  IOException
```
    Consumes all generic-params it can find. If there are no generic params to be consumed it will return an empty list. The list of generic-params are found on many SIP headers such as the To, From etc. In general, the BNF looks like so:
```
  *( SEMI generic-param )
 
```
    E.g. in To:
```
 To        =  ( "To" / "t" ) HCOLON ( name-addr / addr-spec ) *( SEMI to-param )
 to-param  =  tag-param / generic-param
 
```
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeGenericParam
```
public static Buffer[] consumeGenericParam(Buffer buffer)
                                    throws IndexOutOfBoundsException,
                                           IOException
```
    Consumes a generic param, which according to RFC 3261 section 25.1 is:
```
 generic-param  =  token [ EQUAL gen-value ]
 gen-value      =  token / host / quoted-string
 
```
    The return value is two buffers returned as an array and if the second element is null (so make sure you check it!) then there was no value for this parameter. Also note that due to poor implementations out there, the following is accepted as valid input: foo= I.e., foo is a flag parameter and as such there should not be an equal sign following it but there are many servers out there that does this anyway.
    Parameters:
    
    buffer - the buffer from which we will consume a generic-param
    
    Returns:
    
    a buffer array of size two. The first element is the name of the parameter and the second element is the value of that parameter or null if the parameter was a flag parameter (didn't have a value)
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - isNext
```
public static boolean isNext(Buffer buffer,
                             byte b)
                      throws IOException
```
    Will check whether the next readable byte in the buffer is a certain byte
    
    Parameters:
    
    buffer - the buffer to peek into
    
    b - the byte we are checking is the next byte in the buffer to be read
    
    Returns:
    
    true if the next byte to read indeed is what we hope it is
    
    Throws:
    
    IOException
  - isNextDigit
```
public static boolean isNextDigit(Buffer buffer)
                           throws IndexOutOfBoundsException,
                                  IOException
```
    Check whether the next byte is a digit or not
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - expectDigit
```
public static Buffer expectDigit(Buffer buffer)
                          throws SipParseException
```
    Will expect at least 1 digit and will continue consuming bytes until a non-digit is encountered
    
    Parameters:
    
    buffer - the buffer to consume the digits from
    
    Returns:
    
    the buffer containing digits only
    
    Throws:
    
    SipParseException - in case there is not one digit at the first position in the buffer (where the current reader index is pointing to)
    
    IOException
    
    IndexOutOfBoundsException
  - expectHCOLON
```
public static int expectHCOLON(Buffer buffer)
                        throws SipParseException
```
    Convenience method for expecting (and consuming) a HCOLON, which is defined as: HCOLON = *( SP / HTAB ) ":" SWS See RFC3261 section 25.1 Basic Rules
    
    Throws:
    
    SipParseException
  - expectSLASH
```
public static void expectSLASH(Buffer buffer)
                        throws SipParseException
```
    Convenience method for expecting (and consuming) a SLASH, which is defined as: See RFC3261 section 25.1 Basic Rules
    
    Parameters:
    
    buffer -
    
    Throws:
    
    SipParseException
  - consumeSLASH
```
public static int consumeSLASH(Buffer buffer)
                        throws SipParseException,
                               IndexOutOfBoundsException,
                               IOException
```
    Consume an slash (SLASH), which according to RFC3261 section 25.1 Basic Rules is: SLASH = SWS "/" SWS ; slash
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a SLASH
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - expectWS
```
public static int expectWS(Buffer buffer)
                    throws SipParseException
```
    Expect the next byte to be a white space
    
    Parameters:
    
    buffer -
    
    Throws:
    
    SipParseException
  - consumeSWS
```
public static int consumeSWS(Buffer buffer)
```
    Consume sep (separating?) whitespace (LWS), which according to RFC3261 section 25.1 Basic Rules is: SWS = [LWS] ; sep whitespace "The SWS construct is used when linear white space is optional, generally between tokens and separators." (RFC3261)
    
    Parameters:
    
    buffer -
    
    Returns:
  - consumeSTAR
```
public static int consumeSTAR(Buffer buffer)
                       throws SipParseException,
                              IndexOutOfBoundsException,
                              IOException
```
    Consume an asterisk/star (STAR), which according to RFC3261 section 25.1 Basic Rules is: STAR = SWS "*" SWS ; asterisk
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a STAR
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - consumeEQUAL
```
public static int consumeEQUAL(Buffer buffer)
                        throws IndexOutOfBoundsException,
                               IOException
```
    Consume equal sign (EQUAL), which according to RFC3261 section 25.1 Basic Rules is: EQUAL = SWS "=" SWS ; equal
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeLPAREN
```
public static int consumeLPAREN(Buffer buffer)
                         throws IndexOutOfBoundsException,
                                IOException
```
    Consume left parenthesis (LPAREN), which according to RFC3261 section 25.1 Basic Rules is: LPAREN = SWS "(" SWS ; left parenthesis
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeRPAREN
```
public static int consumeRPAREN(Buffer buffer)
                         throws IndexOutOfBoundsException,
                                IOException
```
    Consume right parenthesis (RPAREN), which according to RFC3261 section 25.1 Basic Rules is: RPAREN = SWS ")" SWS ; right parenthesis
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeRAQUOT
```
public static int consumeRAQUOT(Buffer buffer)
                         throws IndexOutOfBoundsException,
                                IOException
```
    Consume right angle quote (RAQUOT), which according to RFC3261 section 25.1 Basic Rules is: RAQUOT = SWS ">"; left angle quote
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeLAQUOT
```
public static int consumeLAQUOT(Buffer buffer)
                         throws IndexOutOfBoundsException,
                                IOException
```
    Consume left angle quote (LAQUOT), which according to RFC3261 section 25.1 Basic Rules is: LAQUOT = SWS "<"; left angle quote
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeCOMMA
```
public static int consumeCOMMA(Buffer buffer)
                        throws SipParseException,
                               IndexOutOfBoundsException,
                               IOException
```
    Consume comma (COMMA), which according to RFC3261 section 25.1 Basic Rules is: COMMA = SWS "," SWS ; comma
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a COMMA
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - consumeSEMI
```
public static int consumeSEMI(Buffer buffer)
                       throws SipParseException,
                              IndexOutOfBoundsException,
                              IOException
```
    Consume semicolon (SEMI), which according to RFC3261 section 25.1 Basic Rules is: SEMI = SWS ";" SWS ; semicolon
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a SEMI
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - consumeCOLON
```
public static int consumeCOLON(Buffer buffer)
                        throws SipParseException,
                               IndexOutOfBoundsException,
                               IOException
```
    Consume colon (COLON), which according to RFC3261 section 25.1 Basic Rules is: COLON = SWS ":" SWS ; colon
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a COLON
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - consumeLDQUOT
```
public static int consumeLDQUOT(Buffer buffer)
                         throws SipParseException,
                                IndexOutOfBoundsException,
                                IOException
```
    Consume open double quotation mark (LDQUT), which according to RFC3261 section 25.1 Basic Rules is: LDQUOT = SWS DQUOTE; open double quotation mark
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a LDQUOT
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - consumeRDQUOT
```
public static int consumeRDQUOT(Buffer buffer)
                         throws SipParseException,
                                IndexOutOfBoundsException,
                                IOException
```
    Consume close double quotation mark (RDQUT), which according to RFC3261 section 25.1 Basic Rules is: RDQUOT = DQUOTE SWS ; close double quotation mark
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume a LDQUOT
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException
  - expectToken
```
public static Buffer expectToken(Buffer buffer)
                          throws IndexOutOfBoundsException,
                                 IOException,
                                 SipParseException
```
    Expects a token, which according to RFC3261 section 25.1 Basic Rules is: token = 1*(alphanum / "-" / "." / "!" / "%" / "*" / "_" / "+" / "`" / "'" / "~" )
    
    Parameters:
    
    buffer -
    
    Returns:
    
    the buffer containing the expected token
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException - in case there is no token
  - consumeQuotedString
```
public static Buffer consumeQuotedString(Buffer buffer)
                                  throws SipParseException,
                                         IOException
```
    Consumes a quoted-string, which is defined as:
```
 quoted-string  =  SWS DQUOTE *(qdtext / quoted-pair ) DQUOTE
 qdtext         =  LWS / %x21 / %x23-5B / %x5D-7E / UTF8-NONASCII
 quoted-pair    =  "\" (%x00-09 / %x0B-0C / %x0E-7F)
 
```
    Note, this is a somewhat simplified version and we'll
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    SipParseException
  - consumeDisplayName
```
public static Buffer consumeDisplayName(Buffer buffer)
                                 throws IOException,
                                        SipParseException
```
    The display name in SIP is a little tricky since it may or may not be there and the stuff following it (whether or not it was there to begin with) can easily be confused with being a display name. Note, a display name in SIP is only part of of the "name-addr" construct and this function assumes that (even though it actually would work like a regular consumeToken(Buffer) in some cases)
```
 name-addr      =  [ display-name ] LAQUOT addr-spec RAQUOT
 display-name   =  *(token LWS)/ quoted-string
 
```
    Parameters:
    
    buffer -
    
    Returns:
    
    the display name or null if there was none
    
    Throws:
    
    IOException
    
    SipParseException
  - consumeAddressSpec
```
public static Buffer consumeAddressSpec(Buffer buffer)
                                 throws IndexOutOfBoundsException,
                                        IOException,
                                        SipParseException
```
    Consumes addr-spec, which according to RFC3261 section 25.1 is:
```
 addr-spec      =  SIP-URI / SIPS-URI / absoluteURI
 SIP-URI          =  "sip:" [ userinfo ] hostport
                      uri-parameters [ headers ]
 SIPS-URI         =  "sips:" [ userinfo ] hostport
                      uri-parameters [ headers ]
 
 absoluteURI    =  scheme ":" ( hier-part / opaque-part )
 
```
    And as you can see, it gets complicated. Also, these consume-functions are not to validate the exact grammar but rather to find the boundaries so the strategy for consuming the addr-spec is:
    - If '>' is encountered, then we assume that this addr-spec is within a name-addr so we stop here
    - If a white space or end-of-line is encountered, we also assume we are done.
    Note, I think the above is safe since I do believe you cannot have a white space or a quoted string (which could have contained white space) within any of the elements that are part of the addr-spec... Anyone?
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
    
    SipParseException - in case we cannot successfully frame the addr-spec.
  - consumeUserInfoHostPort
```
public static Buffer[] consumeUserInfoHostPort(Buffer buffer)
                                        throws SipParseException,
                                               IOException
```
    Consume the userinfo and hostport. The reason why this method does both is because the userinfo portion is optional and as such you actually don't know whether the stuff you are currently going over is the hostport or the userinfo. Also, unfortunately the userinfo is allowed to have characters that normally are reserved (such as ';'), which complicates things as well.
```
 SIP-URI  =  "sip:" [ userinfo ] hostport
             uri-parameters [ headers ]
 SIPS-URI =  "sips:" [ userinfo ] hostport
             uri-parameters [ headers ]
 
 userinfo         =  ( user / telephone-subscriber ) [ ":" password ] "@"
 user             =  1*( unreserved / escaped / user-unreserved )
 user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/"
 password         =  *( unreserved / escaped / "&" / "=" / "+" / "$" / "," )
 hostport         =  host [ ":" port ]
 
```
    As you can see, the user-unreserved is what mess things up. it would have been way easier and more efficient if the user-unreserved wasn't there...
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    SipParseException
    
    IOException
  - consumeSentProtocol
```
public static Buffer consumeSentProtocol(Buffer buffer)
                                  throws IOException,
                                         SipParseException
```
    Consume the "sent-protocol", which according to RFC 3261 is:
```
 sent-protocol = protocol-name SLASH protocol-version SLASH transport
 transport     =  "UDP" / "TCP" / "TLS" / "SCTP" / other-transport
 other-transport   =  token
 
```
    The "sent-protocol" is only present in a Via header and typically looks like this: SIP/2.0/UDP The consume method will make sure that "SIP/2.0/" is present and if not, complain. The transport can really be anything and as such that is what you will get back as a return value. Hence, in the above example you would get back a buffer consisting of "UDP". Also note that the transport can be "other-transport" which translates to a "token" so we allow really anything and as such we will just consume and return the token after verifying that it start with the SIP/2.0 stuff.
    Parameters:
    
    buffer -
    
    Returns:
    
    the transport part of the "sent-protocol". Typically this will be one of UDP, TCP or TLS.
    
    Throws:
    
    IOException
    
    SipParseException - in case anything goes wrong while parsing including if the protocol-name isn't SIP and the version isn't 2.0
  - consumeToken
```
public static Buffer consumeToken(Buffer buffer)
                           throws IndexOutOfBoundsException,
                                  IOException
```
    Consume a token, which according to RFC3261 section 25.1 Basic Rules is: token = 1*(alphanum / "-" / "." / "!" / "%" / "*" / "_" / "+" / "`" / "'" / "~" )
    
    Parameters:
    
    buffer -
    
    Returns:
    
    the buffer containing the token we consumed or null if nothing was consumed.
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - consumeAlphaNum
```
public static Buffer consumeAlphaNum(Buffer buffer)
                              throws IOException
```
    Consumes a alphanum.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
  - consumeVia
```
public static Object[] consumeVia(Buffer buffer)
                           throws SipParseException,
                                  IOException
```
    Consume a Via-header, which according to RFC3261 is:
```
 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
 
```
    Note, this method assumes that you have already stripped off the "Via" or "v". I.e., the header name. The return value is ALWAYS an array of objects of size 4. However, the port can be null (index 2 = the third value) so make sure to check it. Also, the 4th value (index 3) contains a List
    containing all the via-parameters. Each entry in the list is a two dimensional array where the first element is the key and the second is the value. For flag parameters, the value will be null so make sure to check. For more info regarding how parameters are parsed, see consumeGenericParams(Buffer).
    
    result[0] - the protocol. Will never ever be null
    
    result[1] - the sent-by host. Will never ever be null
    
    result[2] - the sent-by port. May be null if port wasn't specified
    
    result[3] - the via-parameters as a List. Will always have elements in it since a via without a branch parameter is illegal.
    Parameters:
    
    buffer -
    
    Returns:
    
    returns an array of 4 elements. See above for details
    
    Throws:
    
    SipParseException
    
    IOException
  - consumeSentBye
```
public static Buffer[] consumeSentBye(Buffer buffer)
                               throws SipParseException,
                                      IOException
```
    Consume a sent-by which according to 3261 is:
```
 sent-by           =  host [ COLON port ]
 host             =  hostname / IPv4address / IPv6reference
 hostname         =  *( domainlabel "." ) toplabel [ "." ]
 domainlabel      =  alphanum
 toplabel         =  ALPHA / ALPHA *( alphanum / "-" ) alphanum
 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
 
```
    Now, since we want to do things as fast as possible and all the consumeXXX methods only do framing we will implement something a little simpler, faster but not 100% according to the BNF. So, consume everything until we either hit a ';' signifying parameters or a ':' which then forces us to start checking the port. Also, white space will stop parsing. However, a colon could also signify an IPv6 address, which is not handled right now.
    Parameters:
    
    buffer -
    
    Returns:
    
    Throws:
    
    IOException
    
    SipParseException
  - consumePort
```
public static Buffer consumePort(Buffer buffer)
                          throws IOException
```
    Consume a port, which according to RFC 3261 is: port = 1*DIGIT
    
    Parameters:
    
    buffer -
    
    Returns:
    
    the buffer containing only digits or null if there was none fun.
    
    Throws:
    
    IOException
  - consumeHostname
```
public static Buffer consumeHostname(Buffer buffer)
                              throws IOException
```
    Throws:
    
    IOException
  - consumeMType
```
public static Buffer consumeMType(Buffer buffer)
                           throws SipParseException
```
    Consume a m-type, which according to RFC3261 section 25.1 Basic Rules is:
```
 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
 
```
    And if you really read through all of that stuff it all boils down to "token" so that is all we end up doing in this method. Hence, this method is really only to put some context to consuming a media-type
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
    
    SipParseException
  - consumeMSubtype
```
public static Buffer consumeMSubtype(Buffer buffer)
                              throws SipParseException
```
    Consume a m-subtype, which according to RFC3261 section 25.1 Basic Rules is:
```
 m-subtype        =  extension-token / iana-token
 extension-token  =  ietf-token / x-token
 ietf-token       =  token
 x-token          =  "x-" token
 iana-token       =  token
 
```
    And if you really read through all of that stuff it all boils down to "token" so that is all we end up doing in this method. Hence, this method is really only to put some context to consuming a media-type
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
    
    SipParseException
  - getTokenCount
```
public static int getTokenCount(Buffer buffer)
                         throws IndexOutOfBoundsException,
                                IOException
```
    Helper method that counts the number of bytes that are considered part of the next token in the Buffer.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    a count of the number of bytes the next token contains or zero if no token is to be found within the buffer.
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - getAlphaNumCount
```
public static int getAlphaNumCount(Buffer buffer)
                            throws IndexOutOfBoundsException,
                                   IOException
```
    Helper method that counts the number of bytes that are considered part of the next alphanum block.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    a count of the number of bytes the next alphaum contains or zero if none is found.
    
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - isNextAlphaNum
```
public static boolean isNextAlphaNum(Buffer buffer)
                              throws IndexOutOfBoundsException,
                                     IOException
```
    Check whether next byte is a alpha numeric one.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if the next byte is a alpha numeric character, otherwise false
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - isAlphaNum
```
public static boolean isAlphaNum(char ch)
```
    Helper method for checking whether the supplied byte is a alphanumeric character or not.
    
    Parameters:
    
    b -
    
    Returns:
    
    true if the byte is indeed a alphanumeric character, false otherwise
  - isAlphaNum
```
public static boolean isAlphaNum(byte b)
```
  - isDigit
```
public static boolean isDigit(char ch)
```
  - isDigit
```
public static boolean isDigit(byte b)
```
  - consumeLWS
```
public static int consumeLWS(Buffer buffer)
                      throws SipParseException
```
    Consume linear whitespace (LWS), which according to RFC3261 section 25.1 Basic Rules is: LWS = [*WSP CRLF] 1*WSP ; linear whitespace
    
    Parameters:
    
    buffer -
    
    Returns:
    
    the number of bytes consumed
    
    Throws:
    
    SipParseException
  - consumeCRLF
```
public static int consumeCRLF(Buffer buffer)
                       throws SipParseException
```
    Consume CR + LF
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we indeed did consume CRLF, false otherwise
    
    Throws:
    
    SipParseException
  - expect
```
public static void expect(Buffer buffer,
                          byte expected)
                   throws SipParseException,
                          IOException
```
    Check so that the next byte in the passed in buffer is the expected one.
    
    Parameters:
    
    buffer - the buffer that we will check.
    
    expected - the buffer that contains the expected byte (note, it is 1 byte, not bytes)
    
    Throws:
    
    ParseException - in case the expected byte is not the next byte in the buffer
    
    SipParseException
    
    IOException
  - consumeWS
```
public static int consumeWS(Buffer buffer)
                     throws SipParseException
```
    Consume all the whitespace we find (WS)
    
    Parameters:
    
    buffer -
    
    Returns:
    
    true if we did consume something, false otherwise
    
    Throws:
    
    SipParseException
  - expect
```
public static void expect(Buffer buffer,
                          char ch)
                   throws SipParseException
```
    Check so that the next byte in the passed in buffer is the expected one.
    
    Parameters:
    
    buffer - the buffer that we will check.
    
    expected - the expected char
    
    Throws:
    
    SipParseException - in case the expected char is not the next char in the buffer or if there is an error reading from the underlying stream
  - nextHeaders
```
public static List<SipHeader> nextHeaders(Buffer buffer)
                                   throws SipParseException
```
    Throws:
    
    SipParseException
  - nextHeader
```
public static SipHeader nextHeader(Buffer buffer)
                            throws SipParseException
```
    Get the next header, which may actually be returning multiple if there are multiple headers on the same line.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    an array where the first element is the name of the buffer and the second element is the value of the buffer
    
    Throws:
    
    SipParseException
  - frame
```
public static SipMessage frame(Buffer buffer)
                        throws IOException
```
    Frame the supplied buffer into a SipMessage. No deep analysis of the message will be performed by this framer so there is no guarantee that this SipMessage is actually a well formed message.
    
    Parameters:
    
    buffer -
    
    Returns:
    
    the framed SipMessage
    
    Throws:
    
    IOException
  - couldBeSipMessage
```
public static boolean couldBeSipMessage(Buffer data)
                                 throws IOException
```
    Helper function that checks whether or not the data could be a SIP message. It is a very basic check but if it doesn't go through it definitely is not a SIP message.
    
    Parameters:
    
    data -
    
    Returns:
    
    Throws:
    
    IOException

Class SipParser

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_LOOK_AHEAD

USER

TTL

MADDR

METHOD

TRANSPORT

TRANSPORT_EQ

SIP2_0

SIP2_0_SLASH

SCHEME_SIP

SCHEME_SIP_COLON

SCHEME_SIPS

SCHEME_SIPS_COLON

AT

COLON

SEMI

DOUBLE_QOUTE

CR

LF

SP

HTAB

DASH

PERIOD

COMMA

EXCLAMATIONPOINT

PERCENT

STAR

UNDERSCORE

QUESTIONMARK

PLUS

BACKTICK

TICK

TILDE

EQ

SLASH

BACK_SLASH

LPAREN

RPAREN

RAQUOT

LAQUOT

DQUOT

UDP

TCP

TLS

SCTP

WS

framers

Constructor Detail

SipParser

Method Detail

expectSIP2_0

expectMethod

isUDP

isTCP

isTLS

isWS

isSCTP

isUDPLower

isTCPLower

isTLSLower

isWSLower

isSCTPLower

isSips

consumeGenericParams

consumeGenericParam

isNext

isNextDigit

expectDigit

expectHCOLON

expectSLASH

consumeSLASH

expectWS

consumeSWS

consumeSTAR