BasicSipStream (Pkts Streams 3.0.10 API)

java.lang.Object
- io.pkts.streams.impl.BasicSipStream

All Implemented Interfaces:

SipStream, Stream<SipPacket>
```
public class BasicSipStream
extends Object
implements SipStream
```
The BasicSipStream only does some very basic analysis of the SIP messages in order to determine which dialog the message belongs to. It is faster and consumes less memory than the DefaultSipStream but is not capable of detecting so-called derived dialogs since it (falsely) assumes it can use the call-id as a unique key for each dialog. Also, if multiple pcaps are merged it will not always handle the case where e.g. the initial message indicating the start of the stream shows up after we have already seen other messages in the stream (could happen if you merge two pcaps where the first pcap contains messages that arrived later time - hence, you didn't merge the pcaps in cronological order). If you need this accuracy, then you should be using the DefaultSipStream instead.

Author:

jonas@jonasborjesson.com

Nested Class Summary
- Nested classes/interfaces inherited from interface io.pkts.streams.SipStream
  SipStream.CallState

Constructor Summary

Constructors
Constructor and Description

BasicSipStream(PcapGlobalHeader globalHeader, StreamId streamIdentifier)

Constructors
Constructor and Description
`BasicSipStream(PcapGlobalHeader globalHeader, StreamId streamIdentifier)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addMessage(SipPacket message)` Add a `SipPacket` to this `SipStream`.
`SipStream`	`createEmptyClone()` Create an empty clone of this `SipStream`.
`SDP`	`get200OkSDP()` Convenience method for returning the `SDP` found on the 200 OK to the first INVITE request.
`SipStream.CallState`	`getCallState()` Which `SipStream.CallState` the call is in.
`long`	`getDuration()` The duration for a `SipStream` is calculated differently depending on what the stream is capturing.
`SDP`	`getInviteSDP()` Convenience method for returning the `SDP` found on the first INVITE request.
`List<SipPacket>`	`getPackets()` Get all the `SipPacket`s that belongs to this `Stream`.
`long`	`getPostDialDelay()` Post Dial Delay (PDD) is defined as the time it takes between the INVITE and until some sort of ringing signal is received (18x responses).
`StreamId`	`getStreamIdentifier()` Get the identifier used for grouping the `SipPacket`s together.
`long`	`getTimeOfFirstPacket()` Get the arrival time of the very first packet in this stream.
`long`	`getTimeOfLastPacket()` Get the arrival time of the last packet in this stream.
`boolean`	`handshakeComplete()` Indicates whether the INVITE handshake was completed.
`boolean`	`isTerminated()` Check whether this `SipStream` is in the terminated state, which it is if any of the following is true: For INVITE streams: If the initial handshake failed with an error response (which will include CANCEL scenarios) If the call was successfully established and a BYE request and the corresponding final response has been processed
`boolean`	`reTranmitsDetected()` Indicates whether there were retransmissions detected.
`void`	`save(OutputStream out)` Save this `SipStream` to the specified `OutputStream`.
`void`	`save(String filename)` Save this `SipStream` to the specified file.
`void`	`write(OutputStream out)` Write this `Stream` to the specified `OutputStream`.

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

- Constructor Detail
  - BasicSipStream
```
public BasicSipStream(PcapGlobalHeader globalHeader,
                      StreamId streamIdentifier)
```
- Method Detail
  - addMessage
```
public void addMessage(SipPacket message)
                throws SipPacketParseException
```
    Description copied from interface: SipStream
    
    Add a SipPacket to this SipStream. By doing so you will force the SipStream to move its internal state machine along since it just "received" a new SipPacket.
    
    Specified by:
    
    addMessage in interface SipStream
    
    Throws:
    
    SipPacketParseException - in case something goes wrong while parsing the SipPacket
  - isTerminated
```
public boolean isTerminated()
```
    Description copied from interface: SipStream
    Check whether this SipStream is in the terminated state, which it is if any of the following is true: For INVITE streams:
    - If the initial handshake failed with an error response (which will include CANCEL scenarios)
    - If the call was successfully established and a BYE request and the corresponding final response has been processed
    Specified by:
    
    isTerminated in interface SipStream
    
    Returns:
  - getPackets
```
public List<SipPacket> getPackets()
```
    Get all the SipPackets that belongs to this Stream. Get all Packets that belongs to this stream.
    
    Specified by:
    
    getPackets in interface SipStream
    
    Specified by:
    
    getPackets in interface Stream<SipPacket>
    
    Returns:
  - getPostDialDelay
```
public long getPostDialDelay()
                      throws SipPacketParseException
```
    Post Dial Delay (PDD) is defined as the time it takes between the INVITE and until some sort of ringing signal is received (18x responses). PDD only applies to INVITE scenarios.
    
    Specified by:
    
    getPostDialDelay in interface SipStream
    
    Returns:
    
    the PDD in milliseconds or -1 (negative one) in case it hasn't been calculated yet or because this SipStream is not an INVITE scenario.
    
    Throws:
    
    SipPacketParseException - in case anything goes wrong while trying to calculate the PDD.
  - getDuration
```
public long getDuration()
```
    The duration for a SipStream is calculated differently depending on what the stream is capturing. For dialogs (INVITE, SUBSCRIBE, REFER) the duration is equal to the duration of the dialog. As such, any re-transmissions of the terminating event etc will NOT be taken into consideration when calculating the duration. However, if the underlying sip stream is not a dialog, then the duration will simply be the time between the first and last message that we recorded. Get the duration in microseconds of the stream. Note, see comment on Packet.getArrivalTime() regarding the microsecond precision. Depending on the underlying protocol this can be as simple as the time between the first to the last packet, which is what the RtpStream does. Or, it can be more complicated as with a SipStream that checks the duration of the dialog (if one was established).
    
    Specified by:
    
    getDuration in interface SipStream
    
    Specified by:
    
    getDuration in interface Stream<SipPacket>
    
    Returns:
    
    the duration (in milliseconds) of this Stream. If the duration cannot be calulated for whatever reason (no packets at all? Only one packet?), then -1 (negative one) will be returned.
  - getStreamIdentifier
```
public StreamId getStreamIdentifier()
```
    Get the identifier used for grouping the SipPackets together. Currently, this is the same as the call-id. Note, perhaps this should be a dialog id instead since ideally that is what we should be using for grouping together SipStreams. On the other hand, using the dialog-id as an identifier can make things messy for forked dialogs etc. This works and keeps things simple so we will stick with it for now.
    
    Specified by:
    
    getStreamIdentifier in interface SipStream
    
    Specified by:
    
    getStreamIdentifier in interface Stream<SipPacket>
    
    Returns:
  - write
```
public void write(OutputStream out)
           throws IOException
```
    Description copied from interface: Stream
    
    Write this Stream to the specified OutputStream. Also see Pcap.createOutputStream(OutputStream).
    
    Specified by:
    
    write in interface Stream<SipPacket>
    
    Parameters:
    
    out - the OutputStream, which typically is a PcapOutputStream.
    
    Throws:
    
    IOException
  - getCallState
```
public SipStream.CallState getCallState()
```
    Description copied from interface: SipStream
    
    Which SipStream.CallState the call is in. NOTE: this only applies to INVITE dialogs.
    
    Specified by:
    
    getCallState in interface SipStream
    
    Returns:
    
    the current SipStream.CallState.
  - handshakeComplete
```
public boolean handshakeComplete()
```
    Description copied from interface: SipStream
    
    Indicates whether the INVITE handshake was completed. I.e., did we see the ACK to the final response to the INVITE. Note, this does not mean that the call was successfully setup, after all, the INVITE setup can be error out for various reasons.
    
    Specified by:
    
    handshakeComplete in interface SipStream
    
    Returns:
  - reTranmitsDetected
```
public boolean reTranmitsDetected()
```
    Description copied from interface: SipStream
    
    Indicates whether there were retransmissions detected. If it was the INVITE that was re-transmitted, or some other request is not conveyed through this method. It just indicates that there were retransmissions in this flow.
    
    Specified by:
    
    reTranmitsDetected in interface SipStream
    
    Returns:
  - save
```
public void save(String filename)
          throws IOException
```
    Description copied from interface: SipStream
    
    Save this SipStream to the specified file.
    
    Specified by:
    
    save in interface SipStream
    
    Throws:
    
    IOException
  - save
```
public void save(OutputStream out)
          throws IOException
```
    Description copied from interface: SipStream
    
    Save this SipStream to the specified OutputStream. The difference between this method and Stream.write(OutputStream) is that the latter assumes that the pcap headers etc already have been written to the stream. However, this method will write this SipStream as a standalone pcap.
    
    Specified by:
    
    save in interface SipStream
    
    Throws:
    
    IOException
  - getTimeOfFirstPacket
```
public long getTimeOfFirstPacket()
```
    Description copied from interface: Stream
    
    Get the arrival time of the very first packet in this stream. Note, see comment on Packet.getArrivalTime() regarding the microsecond precision.
    
    Specified by:
    
    getTimeOfFirstPacket in interface Stream<SipPacket>
    
    Returns:
    
    the arrival time of the first packet (in microseconds), -1 (negative one) in case this Stream doesn't contain any packets.
  - getTimeOfLastPacket
```
public long getTimeOfLastPacket()
```
    Description copied from interface: Stream
    
    Get the arrival time of the last packet in this stream. Note, see comment on Packet.getArrivalTime() regarding the microsecond precision.
    
    Specified by:
    
    getTimeOfLastPacket in interface Stream<SipPacket>
    
    Returns:
    
    the arrival time of the last packet (in microseconds), -1 (negative one) in case this Stream doesn't contain any packets.
  - createEmptyClone
```
public SipStream createEmptyClone()
```
    Description copied from interface: SipStream
    
    Create an empty clone of this SipStream. What this means is that you get a SipStream with the same StreamId and underlying PcapGlobalHeader (which you really do not need to know) but otherwise it is empty. I.e., it doesn't contain any SipPackets. Use this method when you e.g. have a SipStream that you want to split in two. A typical scenario is if you have a SipStream that went through a SIP Proxy but you want to split this stream in one "left" side and one "right" side. You do so by figuring out which message belongs to each side and then create two empty clones and then drive the traffic from each side through the new SipStreams. This will then give you two separate SipStream but that still will have the stats available.
    
    Specified by:
    
    createEmptyClone in interface SipStream
    
    Returns:
  - getInviteSDP
```
public SDP getInviteSDP()
                 throws SipPacketParseException
```
    Description copied from interface: SipStream
    
    Convenience method for returning the SDP found on the first INVITE request. Note, if you want to find the SDP for a re-invite, then you will have to SipStream.getPackets() and find the particular INVITE you are looking for.
    
    Specified by:
    
    getInviteSDP in interface SipStream
    
    Returns:
    
    the SDP found in the first INVITE request or null if no INVITE was found in the stream or if that INVITE simply didn't contain an SDP
    
    Throws:
    
    SipPacketParseException
  - get200OkSDP
```
public SDP get200OkSDP()
                throws SipPacketParseException
```
    Description copied from interface: SipStream
    
    Convenience method for returning the SDP found on the 200 OK to the first INVITE request. Note, if you want to find the SDP for 200 OK to a re-invite, then you will have to SipStream.getPackets() and find the particular response you are looking for.
    
    Specified by:
    
    get200OkSDP in interface SipStream
    
    Returns:
    
    the SDP found in the first INVITE request or null if no INVITE was found in the stream or if that INVITE simply didn't contain an SDP
    
    Throws:
    
    SipPacketParseException

Class BasicSipStream

Nested Class Summary

Nested classes/interfaces inherited from interface io.pkts.streams.SipStream

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BasicSipStream

Method Detail

addMessage

isTerminated

getPackets

getPostDialDelay

getDuration

getStreamIdentifier

write

getCallState

handshakeComplete

reTranmitsDetected

save

save

getTimeOfFirstPacket

getTimeOfLastPacket

createEmptyClone

getInviteSDP

get200OkSDP