tcp-ack-suppression.tcl

Go to the documentation of this file.

##
# @brief Basic namespace for all Excentis Tcl extensions
#
namespace eval excentis {

##
# @brief This namespace holds all ByteBlower-related Tcl extensions, including the ByteBlower higher-layer Tcl API.
#
# These procedures are developed for higher-level usage of the ByteBlower API.
# They are mainly used to simplify running specific Test Scenarios similar to
# scenarios you know from the ByteBlower GUI.
#
namespace eval ByteBlower {

## \file
#
# @brief Core module that provides testing for TCP ack suppression scenarios.
#
# @copyright Excentis nv - www.excentis.com
#

proc TcpAckSuppression { args } {
    # This procedure will perform the TCP Ack Suppression test.
    # 1 ByteBlower port is given as a HTTP server and 1 or multiple ByteBlower ports
    # can be given as HTTP Clients.
    #
    # The HTTP Server and Clients will be automtically configured.
    # The test itself consist of starting the HTTP Server and Let all Clients simultaneouly
    # request a page for the given page size.
    # After all requests are finished, the number of TCP ACKs for each Client are counted
    # on the Client and Server and the nrOfSuppressed ACKs is calculated.
    #
    # A summary is printed for every Client.
    #
    # @param args
    #     @option -tx
    #         @desctiption Options for the transmitting port (server port).
    #                      @note Only one transmitting port can be used in this procedure.
    #                      The Tx port configuration consists of a ByteBlower port Object
    #                      and the TCP port for the server.
    #                      @note The port Object MUST be Layer2 and Layer3 configured.
    #                      -port <serverPortObject> -portNumber <tcpPortNumber>
    #
    #     @option -rx
    #         @desctiption Options for the receiving port (client port).
    #                      Multiple receiving ports can be used in this procedure.
    #                      The Rx port configuration consists of a ByteBlower port Object,
    #                      the TCP port for the client and (optional) the requestSize.
    #                      This last is the page size (in bits) the HTTP request will request
    #                      for, the default value is 1000000 (1Mb).
    #                      @note The port Object MUST be Layer2 and Layer3 configured.
    #                      -port <clientPortObject> -portNumber <tcpPortNumber> -requestSize <nrOfBytes>
    #
    # @return
    #     @description List of resultInfo as returned from @see.proc getHttpClientResults for each Client.

    set resultInfoList [ list ]

    # server object + server listen port
    set serverPortInfoList [ list ]
    set nrOfServerPorts -1
    # list of client objects + client source TCP port
    set clientPortInfoList [ list ]
    set nrOfClientPorts -1

    set httpServerInfo [ list ]
    set httpClientInfoList [ list ]

    #- Parse arguments
    set portInfoList [ eval parseTcpAckSuppressionParams $args ]
    set serverPortInfoList [ lindex $portInfoList 0 ]
    set clientPortInfoList [ lindex $portInfoList 1 ]

    if { [ set nrOfServerPorts [ llength $serverPortInfoList ] ] == 0 || [ set nrOfClientPorts [ llength $clientPortInfoList ] ] == 0} {
        error "Please provide at least one option -rx and one option -tx"
    }
    puts "Performing ACK Suppression Test on $nrOfServerPorts HTTP Servers and $nrOfClientPorts HTTP Clients"

    #- Initialize HTTP Server
    puts "Initializing HTTP Server"
    set serverPortInfo [ lindex $serverPortInfoList 0 ]
    set httpServerInfo [ initializeHttpServer $serverPortInfo ]

    #- Initialize HTTP Clients
    set httpClientNr 0
    foreach clientPortInfo $clientPortInfoList {
        puts "Initializing HTTP Client [ incr httpClientNr ]"
        lappend httpClientInfoList [ initializeHttpClient $clientPortInfo $serverPortInfo ]
    }

    #- Start HTTP Server
    puts "Starting HTTP Server"
    startHttpServer $httpServerInfo

    #- Start HTTP Clients
    set httpClientNr 0
    foreach httpClientInfo $httpClientInfoList {
        puts "Starting HTTP Client [ incr httpClientNr ]"
        startHttpClient $httpClientInfo
    }

    #- Wait for HTTP Clients to finish
    set httpClientNr 0
    foreach httpClientInfo $httpClientInfoList {
        puts "Waiting for HTTP Client [ incr httpClientNr ] to finish..."
        set httpClientStatus [ waitForHttpClientFinish $httpClientInfo ]
        puts "Current Status $httpClientStatus"
        set httpClientStatus [ stopHttpClient $httpClientInfo $httpClientNr ]
        puts "Final Status : $httpClientStatus"
    }

    #- Start HTTP Clients - 2
    #set httpClientNr 0
    #foreach httpClientInfo $httpClientInfoList {
    #    puts "Starting HTTP Client [ incr httpClientNr ]"
    #    startHttpClient $httpClientInfo
    #}

    #- Wait for HTTP Clients to finish - 2
    #set httpClientNr 0
    #foreach httpClientInfo $httpClientInfoList {
    #    puts "Waiting for HTTP Client [ incr httpClientNr ] to finish..."
    #    set httpClientStatus [ waitForHttpClientFinish $httpClientInfo ]
    #    set httpClientStatus [ stopHttpClient $httpClientInfo $httpClientNr ]
    #    puts "Final Status : $httpClientStatus"
    #}


    #- Getting HTTP Server Results --- 
    #- WARNING this can slow the code down
    #puts "Getting HTTP Server 1 results"
    #puts [ [ lindex $serverPortInfo 0 ] Description.Get ]

    #- Getting HTTP Client Results
    set httpClientNr 0
    foreach httpClientInfo $httpClientInfoList {
        puts "Getting HTTP Client [ incr httpClientNr ] results"

       # WARNING: This can slow the code down since
       # the capture description will contain the captured frames
        # puts [ [ lindex $clientPortInfo 0 ] Description.Get ]

        set resultInfo [ getHttpClientResults $httpClientInfo $httpServerInfo ]

        set statusInfo [ lindex $resultInfo 0 ]
        set tcpAckInfo [ lindex $resultInfo 1 ]

        if { [ lindex $statusInfo 0 ] == 1} {
            set statusIoChannel stdout
        } else {
            set statusIoChannel stderr
        }

        if { [ lindex $statusInfo 0 ] == 1} {
            set tcpAckIoChannel stdout
        } else {
            set tcpAckIoChannel stderr
        }

        puts $statusIoChannel "Final Client Status  : [ lindex $statusInfo 1 ]"
        puts $statusIoChannel "Received bytes       : [ lindex $statusInfo 2 ]"
        puts $tcpAckIoChannel "Transmitted TCP ACKs : [ lindex $tcpAckInfo 1 ]"
        puts $tcpAckIoChannel "Received TCP ACKs    : [ lindex $tcpAckInfo 2 ]"
        puts $tcpAckIoChannel "Suppressed TCP ACKs  : [ lindex $tcpAckInfo 3 ]"

        lappend resultInfoList $resultInfo

    }
    #- Stopping HTTP Server
    stopHttpServer $httpServerInfo

    return $resultInfoList

} ;# proc TcpAckSuppression

proc parseTcpAckSuppressionParams { args } {
    # See also @see.proc TcpAckSuppression for more information about the params
    #
    # @return
    #     @type list { list{<serverPortInfo> ...} list {<clientPortInfo> ...} }

    set serverPortInfoList [ list ]
    set clientPortInfoList [ list ]

    if { [ llength $args ] == 0 || [ llength $args ] % 2 != 0} {
        # TODO: Convert this to TCL Throw...
        error "Invalid number of arguments"
    }
    foreach {option value} $args {
        set portObject null
        set portNumber null
        set requestSize 1000000 ;# 1MB
        switch -- $option {
            -rx {
                set addCommand {lappend clientPortInfoList [ list $portObject $portNumber $requestSize ]}
            }
            -tx {
                if { [ llength $serverPortInfoList ] > 0 } {
                    error "Only one server is allowed."
                }
                #if { [ llength $value ] == 0 || [ llength $value ] % 2 != 0 } {
                #    # TODO: Convert this to TCL Throw...
                #    error "Invalid number of option <$option> arguments"
                #}
                set addCommand {lappend serverPortInfoList [ list $portObject $portNumber ]}
            }
            default {
                error "Unknown option <$option> = <$value>"
            }
        }
        if { [ llength $value ] == 0 || [ llength $value ] % 2 != 0} {
            # TODO: Convert this to TCL Throw...
            error "Invalid number of option <$option> arguments"
        }
        foreach {option2 value2} $value {
            switch -- $option2 {
                -port {
                    set portObject $value2
                }
                -portNumber {
                    set portNumber $value2
                }
                -requestSize {
                    if { [ string equal $option "-tx" ] } {
                        error "Unknown option <$option> value argument <$option2> = <$value2>"
                    }
                    set requestSize $value2
                }
                default {
                    error "Unknown option <$option> value argument <$option2> = <$value2>"
                }
            }
        }
        if { [ string equal $portObject "null" ] || [ string equal $portNumber "null" ]} {
            error "Please provide -port AND -portNumber to option <$option>"
        }
        eval $addCommand
    }

    return [ list $serverPortInfoList $clientPortInfoList ]
}

proc initializeHttpServer { serverPortInfo } {
    # Initialize the HTTP Server.
    #
    # @param serverPortInfo
    #     @description Port info as returned from @see.proc parseTcpAckSuppressionParams
    #                  List of ByteBlower Port and TCP port for the HTTP server.
    #
    # @return list {<httpServerObject>}

    set httpServer {}

    set serverPortObject [ lindex $serverPortInfo 0 ]
    set serverTcpPort [ lindex $serverPortInfo 1 ]

    puts stderr "Server Port $serverPortObject"

    #- Check current Servers
    set currentHttpServerList [ $serverPortObject Protocol.Http.Server.Get ]
    foreach currentHttpServer $currentHttpServerList {
        if { [ $currentHttpServer Port.Get ] == $serverTcpPort} {
            set httpServer $currentHttpServer
            puts "Initializing EXISTING HTTP SERVER : Listen Port == $serverTcpPort"
            #puts stderr "Using Previous HTTP Server $httpServer"
            break;
        }
    }
    if { $httpServer == {}} {
        puts "Initializing NEW HTTP SERVER : Listen Port == $serverTcpPort"
        set httpServer [ $serverPortObject Protocol.Http.Server.Add ]
        #puts stderr "Added New HTTP Server $httpServer"
        $httpServer Port.Set $serverTcpPort
    }

    puts stderr "HTTP Server Port $httpServer"

    return [ list $httpServer ]

}

proc initializeHttpClient { clientPortInfo serverPortInfo } {
    # Initialize the HTTP Client.
    #
    # @param clientPortInfo
    #     @description Client Port info as returned from @see.proc parseTcpAckSuppressionParams
    #                  List of ByteBlower Port, TCP port for the HTTP client and request size for the HTTP Client.
    # @param serverPortInfo
    #     @description Server Port info as returned from @see.proc parseTcpAckSuppressionParams
    #                  List of ByteBlower Port and TCP port for the HTTP server.
    #
    # @return
    # list {<httpClient> <requestSize> <clientCapture> <serverCapture>}

    set httpClientInfo [ list ]

    set httpClient {}

    set serverPortObject [ lindex $serverPortInfo 0 ]
    #    puts stderr "Server Port $serverPortObject"
    set serverTcpPort [ lindex $serverPortInfo 1 ]

    #- Get HTTP Server Layer3 configuration
    set serverLayer3 [ $serverPortObject Layer3.IPv4.Get ]
    set serverIpAddress [ $serverLayer3 Ip.Get ]

    #- Initialize HTTP Clients
    set clientPortObject [ lindex $clientPortInfo 0 ]
    set clientTcpPort [ lindex $clientPortInfo 1 ]
    set requestSize [ lindex $clientPortInfo 2 ]

    puts stderr "Client Port $clientPortObject"

    #- Get Layer3 configuration
    set clientLayer3 [ $clientPortObject Layer3.IPv4.Get ]

    #- Check current HTTP Clients
    set currentHttpClientList [ $clientPortObject Protocol.Http.Client.Get ]
    foreach currentHttpClient $currentHttpClientList {
        if { [ $currentHttpClient Local.Port.Get ] == $clientTcpPort &&
            [ $currentHttpClient Remote.Address.Get ] == $serverIpAddress &&
            [ $currentHttpClient Remote.Port.Get ] == $serverTcpPort} {
            set httpClient $currentHttpClient
            puts "Initializing EXISTING HTTP Client : Local Port == $clientTcpPort, Remote Address == $serverIpAddress, Remote Port == $serverTcpPort"

            #puts stderr "Using Previous HTTP Client $httpClient"
            break;
        }
    }
    if { $httpClient == {}} {
        puts "Initializing NEW HTTP Client : Local Port == $clientTcpPort, Remote Address == $serverIpAddress, Remote Port == $serverTcpPort"
        set httpClient [ $clientPortObject Protocol.Http.Client.Add ]
        #puts stderr "Added New HTTP Client $httpClient"

        $httpClient Remote.Address.Set $serverIpAddress
        $httpClient Remote.Port.Set $serverTcpPort
        #$httpClient Remote.Port.Set 80
        $httpClient Local.Port.Set $clientTcpPort
    }

    puts stderr "HTTP Client Port $httpClient"

    #- Create Captures
    set serverCapture [ $serverPortObject Rx.Capture.Basic.Add ]
    set clientCapture [ $clientPortObject Rx.Capture.Basic.Add ]

    #- Set Capture Filter
    $serverCapture Filter.Set "host [ $clientLayer3 Ip.Get ]"
    $clientCapture Filter.Set "host [ $clientLayer3 Ip.Get ]"

    #lappend httpClientInfoList [ list $httpClient $requestSize ]
    return [ list $httpClient $requestSize $clientCapture $serverCapture ]

}

proc startHttpServer { httpServerInfo } {
    # Start the HTTP Server.
    #
    # @param httpServerInfo
    #     @description List as returned from @see.proc initializeHttpServer
    #
    # @return void

    set httpServer [ lindex $httpServerInfo 0 ]

    $httpServer Start

    return

}

proc startHttpClient { httpClientInfo } {
    # Start the HTTP Client.
    # Also starts capturing.
    #
    # @param httpClientInfo
    #     @description List as returned from @see.proc initializeHttpClient
    #
    # @return void

    set httpClient [ lindex $httpClientInfo 0 ]
    set requestSize [ lindex $httpClientInfo 1 ]
    set clientCapture [ lindex $httpClientInfo 2 ]
    set serverCapture [ lindex $httpClientInfo 3 ]

    #- Start Captures
    $serverCapture Start
    $clientCapture Start



    #puts [ $httpClient Request.Page 1 ] ;# -> SERVER CRASH
    $httpClient Request.Size.Set $requestSize
    $httpClient Request.Start

    return

}

proc waitForHttpClientFinish { httpClientInfo } {
    # Wait for the HTTP Client to Finish its request.
    #
    # @param httpClientInfo
    #     @description List as returned from @see.proc initializeHttpClient
    #
    # @return
    #     @description Final Client status

    set httpClient [ lindex $httpClientInfo 0 ]
    #set requestSize [ lindex $httpClientInfo 1 ]
    set clientCapture [ lindex $httpClientInfo 2 ]
    set serverCapture [ lindex $httpClientInfo 3 ]

    set httpClientStatus "<UNKNOWN>"

    while { ![ $httpClient Finished.Get ]} {
        set wait 0
        after 1000 "set wait 1"
        vwait wait
        puts -nonewline "*"; flush stdout
        unset wait
       $httpClient Refresh
    }
    puts ""

    $httpClient Refresh
    return [ $httpClient Request.Status.Get ]

}

proc stopHttpClient { httpClientInfo httpClientId } {
    # Stop the HTTP Client.
    # Also stops the capturing.
    #
    # @param httpClientInfo
    #     @description List as returned from @see.proc initializeHttpClient
    # @param httpClientId
    #     @description An ID to add to the capture file name to uniquely
    #                  identify the client captures.
    #
    # @return
    #     @description Final Client status

    set httpClient [ lindex $httpClientInfo 0 ]
    set clientCapture [ lindex $httpClientInfo 2 ]
    set serverCapture [ lindex $httpClientInfo 3 ]

    #- Stopping HTTP client may reset (possible) error status
    #puts [ $httpClient Request.Stop ]

    set wait 0
    after 200 "set wait 1"
    vwait wait
    unset wait

   puts "Stopping captures.."
    $serverCapture Stop
    $clientCapture Stop

   puts "Saving captures.."; flush stdout
   puts "Saving captures: server"; flush stdout
    [ $serverCapture Result.Get ] Pcap.Save "httpServer${httpClientId}.pcap"
   puts "Saving captures: client"; flush stdout
    [ $clientCapture Result.Get ] Pcap.Save "httpClient${httpClientId}.pcap"
   puts "Saving captures: done"; flush stdout
    return [ $httpClient Request.Status.Get ]

}

proc stopHttpServer { httpServerInfo } {
    # Stop the HTTP Server.
    #
    # @param httpServerInfo
    #     @description List as returned from @see.proc initializeHttpServer
    #
    # @return void

    set httpServer [ lindex $httpServerInfo 0 ]

    $httpServer Stop

    return

}

proc getHttpClientResults { httpClientInfo httpServerInfo } {
    # Get the Test results for the HTTP Client.
    #
    # @param httpClientInfo
    #     @description List as returned from @see.proc initializeHttpClient
    #
    # @return
    #     @description List of results from @see.proc parseHttpClientStatusResults and
    #                  @see.proc parseHttpClientTcpAckResults
    #     @type list {<statusInfo> <tcpAckInfo>}

    set resultInfo [ list ]

    set httpServer [ lindex $httpServerInfo 0 ]
    set httpClient [ lindex $httpClientInfo 0 ]
    set requestSize [ lindex $httpClientInfo 1 ]

    set statusInfo [ parseHttpClientStatusResult $httpClient $requestSize ]
    set tcpAckInfo [ parseHttpClientTcpAckResult $httpClient $httpServer ]

    lappend resultInfo $statusInfo
    lappend resultInfo $tcpAckInfo

    return $resultInfo

}

proc parseHttpClientStatusResult { httpClient requestSize } {
    # The status of the httpClient @see.param httpClient is processed.
    # The received number of bits is compared with the requested number
    # of bits @see.param requestSize
    #
    # @param httpClient
    #     @description The ByteBlower HTTP Client Object
    # @param requestSize
    #     @description The requested number of bits.
    #
    # @return list {<passOrFail> <statusValue> <rxBytes>}

    set statusInfo [ list ]
    set pf 1

    set httpClientSessionInfo [ $httpClient Http.Session.Info.Get ]

    set result [ $httpClientSessionInfo Result.Get ]
    $result Refresh
    set rxBytes [ $result Rx.ByteCount.Total.Get ]

    set requestStatus [ $httpClient Request.Status.Get ]
    if { ![ string equal $requestStatus "finished" ] && ! [ string equal $requestStatus "stopped" ]} {
        puts stderr "The Client is not in a <finished> state"
        set pf 0
    }

    if { $rxBytes != $requestSize} {
        puts stderr "The Number of received bits is not the same as the number of requested bits."
        set pf 0
    }

    lappend statusInfo $pf
    lappend statusInfo $requestStatus
    lappend statusInfo $rxBytes

    return $statusInfo

}

proc parseHttpClientTcpAckResult { httpClient httpServer  } {
    # The HTTP Client and Server http Client and Server are used to check the 
    # number of transmitted and received TCP ACKs
    #
    # @param httpClient
    #     @description The HTTP Client Object.
    # @param httpServer
    #     @description The HTTP Server Object.
    #
    # @return list {<passOrFail> <txACKs> <rxACKs> <nrOfSuppressedACKs> }

    puts "HTTP Sessions available on the server: [ $httpServer Client.Identifiers.Get ]"
    set clientTcpSessionResult [ [ [ $httpClient Http.Session.Info.Get ] Tcp.Session.Info.Get ] Result.Get ]
   
    # We request the HTTP Server's Client Session Info from the HTTP Server.
    set scId [ $httpClient ServerClientId.Get ]
    set hasSession 0
    # Wait until the client session has been created:
    while { $hasSession == 0} {
        set hasSession [ $httpServer HasSession $scId ]
        if { $hasSession == 0} {
       set wait 0 ; after 500 "set wait 1" ; vwait wait ; unset wait
        }
    }
    set httpServerSessionInfo [ $httpServer Http.Session.Info.Get $scId ]

    set serverTcpSessionResult [ [ $httpServerSessionInfo Tcp.Session.Info.Get ] Result.Get ]
    $clientTcpSessionResult Refresh
    $serverTcpSessionResult Refresh

    puts stderr "clientTcpSession   : [ $clientTcpSessionResult Description.Get ]"
    puts stderr "serverTcpSession   : [ $serverTcpSessionResult Description.Get ]"

    set tcpAckInfo [ list ]
    set pf 1


    set nrOfSuppressedACKs -1


    set txSyns [ $clientTcpSessionResult NumberOfSynSent.Get ]
    set txSegments [ $clientTcpSessionResult Tx.SegmentCount.Total.Get ]
    set txACKs [ expr $txSegments - $txSyns ]
    puts stderr "Sent TCP ACKs      : $txACKs"

    set rxSyns [ $serverTcpSessionResult NumberOfSynReceived.Get ]
    set rxSegments [ $serverTcpSessionResult Rx.SegmentCount.Total.Get ]
    set rxACKs [ expr $rxSegments - $rxSyns ]
    puts stderr "Received TCP ACKs  : $rxACKs"


    if { $txACKs <= 0} {
        puts stderr "No ACKs transmitted"
        set pf 0
    } else {
        set nrOfSuppressedACKs [ expr $txACKs - $rxACKs ]
        puts stderr "$nrOfSuppressedACKs ACKs suppressed ($txACKs transmitted)"
    }

    lappend tcpAckInfo $pf
    lappend tcpAckInfo $txACKs
    lappend tcpAckInfo $rxACKs
    lappend tcpAckInfo $nrOfSuppressedACKs

    return $tcpAckInfo

}


}

}