framev4v6.tcl

Go to the documentation of this file.

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

##
# @brief Namespace for Excentis Tcl extensions for basic functions.
#
# This includes functionality such as:
# - Network frame generation
# - Address parsing and conversion
# - ...
#
namespace eval basic {

## \file
#
# @brief Utility module that eases the <b>construction of</b> all types of valid <b>network packets</b> as bytelists, which is the format used by the ByteBlower.
#
# The methods in this module typically take various header field values (such as source and destination IP) as arguments. Using these values, they can generate
# a valid ethernet frame. This created frame is then returned in a hexadecimal bytelist format ('0x01 0x02 0xFF...').
#
# @copyright Excentis nv - www.excentis.com
#

proc Frame.Udpv6.Set { DMAC SMAC DIP SIP DP SP dataOrLength {params DEFAULT} } {
    # Sets content of the frame to a UDP frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IP6 address (colon notation)
    # @param SIP Source IPv6 address (colon notation)
    # @param DP Destination UDP port (decimal)
    # @param SP Source UDP port (decimal)
    # @param dataOrLength data of the UDP frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -IP:
    #                      -version     : 6                (4 bits)
    #                      -trafClass   : 0x00             (8 bits)
    #                      -flowLabel   : 0x0 0x00 0x00    (20 bits)
    #                      -hopLimit    : 64               (8 bits)
    #                      -jumbo       : 0 or 1           (indicates the use of the Jumbo Payload option in the Hop-by-hop
    #                                                      extension header. 1 -> jumbo payload is used)
    #               -Ethernet
    #                      -MFT        : EtherII
    #                                    SNAP
    #                                    802.3
    #                      -Length     : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                              If total length exceeds maximum MTU (1518) then an error will be generated
    #                                  : x       : Ethernet data Length will be adjusted to <x>.
    #                                              If data exceeds <x> boundary then an error will be generated.
    #                                              If data is smaller than <x> then data will be stuffed with 0x00
    #
    # @apiexample
    #     @apisnippet{Frame.Udpv6.Set 00ff12000001 00ff12000002 2001:db8:1:81::1 2001:db8:1:81::2 10000 20000 {0xAA 0xAA 0xAA 0xAA 0xAA}}
    #     @apisnippet{Frame.Udpv6.Set 00ff12000001 00ff12000002 2001:db8:1:81::1 2001:db8:1:81::2 10000 20000 {-length 92}}
    # @endapiexample
    #
    ##

    set Ethernet DEFAULT
    set IP DEFAULT

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Udpv6.Set: Invalid param '${item}'" }
            } ;# switch close
        }
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]
    set dataLength [ llength $data ]

    # PseudoHeader fields in PH and header fields in H
    set length [ expr ( 8 + $dataLength ) ]
    set PH1 [ IPv6.To.Hex $SIP ]
    set PH2 [ IPv6.To.Hex $DIP ]
    set PH3 [ concat [ Short.To.Hex $length ] 0x00 0x00 0x00 [ Byte.To.Hex 17 ] ]
    set PH [ concat $PH1 $PH2 $PH3 ]
    set H1 [ concat [ Short.To.Hex $SP ] [ Short.To.Hex $DP ] ]
    set H2 [ concat [ Short.To.Hex $length ] 0x00 0x00 ]
    set PHH [ concat $PH $H1 $H2 ]
    set H [ concat $H1 $H2 ]
    set myContent [ concat $PHH $data ]
    if { [ expr ( [ llength $myContent ] % 2 ) ]} {
        lappend myContent 0x00
    }
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ concat $H $data ]
    set myContent [ eval lreplace {$myContent} 6 7 $checkSum ]
    # myContent now contains the UDP message

    set myContent [ Frame.Ipv6.Set $DMAC $SMAC $DIP $SIP 17 $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Udp.Set {DMAC SMAC DIP SIP DP SP dataOrLength { params DEFAULT }} {
    # Sets content of the frame to a UDP frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param DP Destination UDP port (decimal)
    # @param SP Source UDP port (decimal)
    # @param dataOrLength Data of the IP frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -IP:
    #                      -Version     : 4           : IP version
    #                      -IHL         : 5
    #                      -IPIdentif   : 0x00 0x00
    #                      -TTL         : 20
    #                      -FF          : 0x00 0x00
    #                      -ToS         : 0x00
    #               -Ethernet
    #                      -MFT         : EtherII
    #                                     SNAP
    #                                     802.3
    #                      -Length      : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                               If total length exceeds maximum MTU (1518) then an error will be generated
    #                                   : x       : Ethernet data Length will be adjusted to <x>.
    #                                               If data exceeds <x> boundary then an error will be generated.
    #                                               If data is smaller than <x> then data will be stuffed with 0x00
    #
    # @example Frame.Udp.Set 00ff12000001 00ff12000002 10.11.0.1 10.11.0.2 10000 20000 {0xAA 0xAA 0xAA 0xAA 0xAA}
    # @example Frame.Udp.Set 00ff12000001 00ff12000002 10.11.0.1 10.11.0.2 10000 20000 {-length 64}
    #
    ##

    set Ethernet DEFAULT
    set IP DEFAULT

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -ip       { set IP $value }
                -ethernet { set Ethernet $value }
                default   { error "Frame.Udp.Set: Invalid param '${item}'" }
            } ;#switch close
        }
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]
    set dataLength [ llength $data ]
    if { $dataLength < 4} {
        error "Frame.Udp.Set: data length must be > 4"
    }

    # pseudoheader fields in PH and header fields in H
    set length [ expr ( 8 + $dataLength ) ]
    set PH1 [ IP.To.Hex $SIP ]
    set PH2 [ IP.To.Hex $DIP ]
    set PH3 [ concat 0x00 0x11 [ Short.To.Hex $length ] ]
    set PH [ concat $PH1 $PH2 $PH3 ]
    set H1 [ concat [ Short.To.Hex $SP ] [ Short.To.Hex $DP ] ]
    set H2 [ concat [ Short.To.Hex $length ] 0x00 0x00 ]
    set PHH [ concat $PH $H1 $H2 ]
    set H [ concat $H1 $H2 ]
    set myContent [ concat $PHH $data ]
    if { [ expr ( $length % 2 ) ]} {
        lappend myContent 0x00
    }
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ concat $H $data ]
    set myContent [ eval lreplace {$myContent} 6 7 $checkSum ]
    # myContent now contains the UDP message

    set myContent [ Frame.Ipv4.Set $DMAC $SMAC $DIP $SIP 17 $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Tcp.Set { DMAC SMAC DIP SIP DP SP dataOrLength { params DEFAULT } } {
    # Sets content of the frame to a TCP frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param DP Destination TCP port (decimal)
    # @param SP Source TCP port (decimal)
    # @param dataOrLength Data of the TCP frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -TCP
    #                      -TCPSeq      : 0x10 0x00 0x01 0xa3
    #                      -TCPAck      : 0x10 0x00 0x01 0xa0
    #                      -TCPWindow   : 16384
    #                      -TCPByte1314 : 0x00 0x00
    #                      -TCPUrgent   : 0x00 0x00
    #               -IP:
    #                      -Version     : 4           : IP version
    #                      -IHL         : 5
    #                      -IPIdentif   : 0x00 0x00
    #                      -TTL         : 20
    #                      -FF          : 0x00 0x00
    #                      -ToS         : 0x00
    #               -Ethernet
    #                      -MFT         : EtherII
    #                                     SNAP
    #                                     802.3
    #                      -Length      : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                               If total length exceeds maximum MTU (1518) then an error will be generated
    #                                   : x       : Ethernet data Length will be adjusted to <x>.
    #                                               If data exceeds <x> boundary then an error will be generated.
    #                                               If data is smaller than <x> then data will be stuffed with 0x00
    #
    # @example Frame.Tcp.Set 00ff02000002 00ff02000001 10.11.0.2 10.11.0.1 1235 1234 {0x00 0x00} {-TCP {-TCPAck {0x10 0x00 0x01 0xa3}}}
    ##

    set Ethernet DEFAULT
    set IP DEFAULT
    set TCP DEFAULT

    set TCPSeq [ list 0x10 0x00 0x01 0xa3 ]
    set TCPAck [ list 0x10 0x00 0x01 0xa0 ]
    set TCPWindow 16384
    set TCPByte1314 [ list 0x50 0x00 ]
    set TCPUrgent [ list 0x00 0x00 ]

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -tcp        { set TCP      $value }
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Tcp.Set: Invalid param '${item}'" }
            } ;# switch close
        }
    }

    if { ![ string equal -nocase $TCP "DEFAULT" ]} {
        foreach {item value} $TCP {
            switch -- [ string tolower $item ] {
                -tcpseq      { set TCPSeq    $value }
                -tcpack      { set TCPAck    $value }
                -tcpwindow   { set TCPWindow $value }
                -tcpbyte1314 { set TCPByte1314 $value }
                -tcpurgent   { set TCPUrgent $value }
                default { error "Frame.Tcp.Set: Invalid TCP option '${item}'" }
            } ;# switch close
        }
    }

    # Check the TcpSeq
    if { [ llength $TCPSeq ] != 4 || ![ ByteList.Check $TCPSeq ]} {
        error "Frame.Tcp.Set: Invalid TCPSeq '$TCPSeq', expecting 4 bytes"
    }

    # Check the TCPAck
    if { [ llength $TCPAck ] != 4 || ![ ByteList.Check $TCPAck ]} {
        error "Frame.Tcp.Set: Invalid TCPAck '$TCPAck', expecting 4 bytes"
    }

    # Check the TCPWindow
    if { [ string equal $TCPWindow "" ] || ![ string is integer $TCPWindow ] || $TCPWindow < 0 || $TCPWindow > 0xFFFF} {
        error "Frame.Tcp.Set: Invalid TCPWindow value '$TCPWindow', MUST be <= 0xFFFF"
    }

    # Check the TCPByte1314
    if { [ llength $TCPByte1314 ] != 2 || ![ ByteList.Check $TCPByte1314 ]} {
        error "Frame.Tcp.Set: Invalid TCPByte1314 '$TCPByte1314', expecting 2 bytes"
    }

    # Check the TCPUrgent
    if { [ llength $TCPUrgent ] != 2 || ![ ByteList.Check $TCPUrgent ]} {
        error "Frame.Tcp.Set: Invalid TCPUrgent '$TCPUrgent', expecting 2 bytes"
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]

    set length [ expr ( 20 + [ llength $data ] ) ]

    set PH1 [ IP.To.Hex $SIP ]
    set PH2 [ IP.To.Hex $DIP ]
    set PH3 [ concat 0x00 0x06 [ Short.To.Hex $length ] ]
    set PH [ concat $PH1 $PH2 $PH3 ]

    set H1 [ concat [ Short.To.Hex $SP ] [ Short.To.Hex $DP ] ]
    set H2 $TCPSeq
    set H3 $TCPAck
    set H4 [ concat $TCPByte1314 [ Short.To.Hex $TCPWindow ] ]
    set H5 [ concat 0x00 0x00 $TCPUrgent ]

    set PHH [ concat $PH $H1 $H2 $H3 $H4 $H5 ]
    set H [ concat $H1 $H2 $H3 $H4 $H5 ]
    set myContent [ concat $PHH $data ]
    if { [ expr ( $length % 2 ) ]} {
        lappend myContent 0x00
    }
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ concat $H $data ]
    set myContent [ eval lreplace {$myContent} 16 17 $checkSum ]

    set myContent [ Frame.Ipv4.Set $DMAC $SMAC $DIP $SIP 6 $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Tcpv6.Set { DMAC SMAC DIP SIP DP SP dataOrLength { params DEFAULT } } {
    # Sets content of the frame to a TCP frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IPv6 address (colon notation)
    # @param SIP Source IPv6 address (colon notation)
    # @param DP Destination TCP port (decimal)
    # @param SP Source TCP port (decimal)
    # @param dataOrLength Data of the TCP frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -TCP
    #                      -TCPSeq      : 0x10 0x00 0x01 0xa3
    #                      -TCPAck      : 0x10 0x00 0x01 0xa0
    #                      -TCPWindow   : 16384
    #                      -TCPByte1314 : 0x00 0x00
    #                      -TCPUrgent   : 0x00 0x00
    #               -IP:
    #                      -version     : 6                (4 bits)
    #                      -trafClass   : 0x00             (8 bits)
    #                      -flowLabel   : 0x0 0x00 0x00    (20 bits)
    #                      -hopLimit    : 64               (8 bits)
    #                      -jumbo       : 0 or 1           (indicates the use of the Jumbo Payload option in the Hop-by-hop
    #                                                      extension header. 1 -> jumbo payload is used)
    #               -Ethernet
    #                      -MFT        : EtherII
    #                                    SNAP
    #                                    802.3
    #                      -Length     : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                              If total length exceeds maximum MTU (1518) then an error will be generated
    #                                  : x       : Ethernet data Length will be adjusted to <x>.
    #                                              If data exceeds <x> boundary then an error will be generated.
    #                                              If data is smaller than <x> then data will be stuffed with 0x00
    #
    # @example Frame.Tcpv6.Set 00ff02000002 00ff02000001 fe80::1 fe80::2 5678 1234 {-LENGTH 256} {-TCP {-TCPAck {0x09 0xa0 0x30 0xb8}}}
    #
    ##

    set Ethernet DEFAULT
    set IP DEFAULT
    set TCP DEFAULT

    set TCPSeq [ list 0x10 0x00 0x01 0xa3 ]
    set TCPAck [ list 0x10 0x00 0x01 0xa0 ]
    set TCPWindow 16384
    set TCPByte1314 [ list 0x50 0x00 ]
    set TCPUrgent [ list 0x00 0x00 ]

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -tcp        { set TCP      $value }
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Tcpv6.Set : Invalid param '${item}'" }
            } ;# switch close
        }
    }

    if { ![ string equal -nocase $TCP "DEFAULT" ]} {
        foreach {item value} $TCP {
            switch -- [ string tolower $item ] {
                -tcpseq      { set TCPSeq    $value }
                -tcpack      { set TCPAck    $value }
                -tcpwindow   { set TCPWindow $value }
                -tcpbyte1314 { set TCPByte1314 $value }
                -tcpurgent   { set TCPUrgent $value }
                default { error "Frame.Tcpv6.Set: Invalid TCP option '${item}'" }
            } ;# switch close
        }
    }

    # Check the TcpSeq
    if { [ llength $TCPSeq ] != 4 || ![ ByteList.Check $TCPSeq ]} {
        error "Frame.Tcpv6.Set: Invalid TCPSeq '$TCPSeq', expecting 4 bytes"
    }

    # Check the TCPAck
    if { [ llength $TCPAck ] != 4 || ![ ByteList.Check $TCPAck ]} {
        error "Frame.Tcpv6.Set: Invalid TCPAck '$TCPAck', expecting 4 bytes"
    }

    # Check the TCPWindow
    if { [ string equal $TCPWindow "" ] || ![ string is integer $TCPWindow ] || $TCPWindow < 0 || $TCPWindow > 0xFFFF} {
        error "Frame.Tcpv6.Set: Invalid TCPWindow value '$TCPWindow', MUST be <= 0xFFFF"
    }

    # Check the TCPByte1314
    if { [ llength $TCPByte1314 ] != 2 || ![ ByteList.Check $TCPByte1314 ]} {
        error "Frame.Tcpv6.Set: Invalid TCPByte1314 '$TCPByte1314', expecting 2 bytes"
    }

    # Check the TCPUrgent
    if { [ llength $TCPUrgent ] != 2 || ![ ByteList.Check $TCPUrgent ]} {
        error "Frame.Tcpv6.Set: Invalid TCPUrgent '$TCPUrgent', expecting 2 bytes"
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]

    set length [ expr ( 20 + [ llength $data ] ) ]
    set PH1 [ IPv6.To.Hex $SIP ]
    set PH2 [ IPv6.To.Hex $DIP ]
    set PH3 [ concat [ Short.To.Hex $length ] 0x00 0x00 0x00 [ Byte.To.Hex 6 ] ]
    set PH [ concat $PH1 $PH2 $PH3 ]

    set H1 [ concat [ Short.To.Hex $SP ] [ Short.To.Hex $DP ] ]
    set H2 $TCPSeq
    set H3 $TCPAck
    set H4 [ concat $TCPByte1314 [ Short.To.Hex $TCPWindow ] ]
    set H5 [ concat 0x00 0x00 $TCPUrgent ]

    set PHH [ concat $PH $H1 $H2 $H3 $H4 $H5 ]
    set H [ concat $H1 $H2 $H3 $H4 $H5 ]
    set myContent [ concat $PHH $data ]
    if { [ expr ( $length % 2 ) ]} {
        lappend myContent 0x00
    }
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ concat $H $data ]
    set myContent [ eval lreplace {$myContent} 16 17 $checkSum ]

    set myContent [ Frame.Ipv6.Set $DMAC $SMAC $DIP $SIP 6 $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Igmp.Set { SMAC SIP Type GroupAddress { params DEFAULT } } {
# Sets content of the frame to an IGMP frame.
#
#------------------------------------------------------------------------------
# @param SMAC Source MAC address
# @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
# @param Type
#         0 - IGMPv1 Join
#         1 - IGMPv2 Join
#         2 - IGMPv2 Leave
#         3 - IGMPv1 / IGMPv2 General Membership Query message
#         4 - IGMPv1 / IGMPv2 Group-Specific Membership Query message
#         5 - IGMPv3 Membership Report message
#         6 - IGMPv3 Leave Group message
#         7 - IGMPv3 General Membership Query message
#         8 - IGMPv3 Group-Specific Membership Query message
# @param GroupAddress Multicast Group Address to create the IGMP Frame for
#                     NOTE: The GroupAddress is unused for Type 3 (IGMPv1 /IGMPv2 General Membership Query)
#                           and Type 7 (IGMPv3 General Membership Query))
# @param params A pair list containing alternating a parameter and a value
#               Parameters are expected to be :
#               -IGMP
#                      -maxRespTime       : 0
#                      -sourceAddressList : [ list ]
#               -IP
#                      -Version     : 4           : IP version
#                      -IHL         : 5
#                      -IPIdentif   : 0x00 0x00
#                      -TTL         : 20
#                      -FF          : 0x00 0x00
#                      -ToS         : 0x00
#               -Ethernet
#                      -MFT         : EtherII
#                                     SNAP
#                                     802.3
#                      -Length      : Auto    : If no value is given then the frame will nicely encapsulate the <data>
#                                               If total length exceeds maximum MTU (1518) then an error will be generated
#                                   : x       : Ethernet data Length will be adjusted to <x>.
#                                               If data exceeds <x> boundary then an error will be generated.
#                                               If data is smaller than <x> then data will be stuffed with 0x00
#
#------------------------------------------------------------------------------
# Examples:
#
# @example Create an IGMPv1 Join frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 0 224.0.100.12
#          --> Remark: IGMPv1 Leave does not exist. In the first IGMP version the session has to time-out.  
# @example Create an IGMPv2 Join frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 1 224.0.100.12
# @example Create an IGMPv2 Leave:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 2 224.0.100.12
# @example Create an IGMPv1 General Query frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 3 0.0.0.0
#          --> Remark: GroupAddress is unused here
# @example Create an IGMPv1 Group-Specific Query frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 4 224.0.100.12
# @example Create an IGMPv2 General Query frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 3 0.0.0.0 [ list -IGMP [ list -maxRespTime 10 ] ]
#          --> Remark: respTime is only available from version 2
# @example Create an IGMPv2 Group-Specific Query frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 4 224.0.100.12 [ list -IGMP [ list -maxRespTime 10 ] ]
# @example Create an IGMPv3 Membership Report message frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 5 224.0.100.12
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 5 224.0.100.12 [ list -IGMP [ list -sourceAddressList [ list "10.3.3.71" "10.3.3.72" ] ] ]
# @example Create an IGMPv3 Leave Group message frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 6 224.0.100.12
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 6 224.0.100.12 [ list -IGMP [ list -sourceAddressList [ list "10.3.3.71" "10.3.3.72" ] ] ]
# @example Create an IGMPv3 General Query message frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 7 0.0.0.0
#          --> Remark: GroupAddress is unused here
# @example Create an IGMPv3 Group-Specific Query message frame:
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 8 224.0.100.12
#          Frame.Igmp.Set 00ff21000001 10.142.1.142 8 224.0.100.12 [ list -IGMP [ list -sourceAddressList [ list "10.3.3.71" "10.3.3.72" ] ] ]
#
#------------------------------------------------------------------------------
# Wireshark Remarks:
#
# Wireshark uses the IP Total Length for differentiating IGMPv1v2 from IGMPv3 Query messages. 
# Wireshark uses the respTime field for differentiating IGMPv1 from IGMPv2 Query messages (if <> 0, then it is IGMPv2 otherwise it is decoded as IGMPv1). 
#
#------------------------------------------------------------------------------
# From IGMPv2 RFC-2236 / RFC-3376:
#   
#    Message Type                  Destination IP Address        Destination Group Address
#    ------------                  ----------------------        -------------------------
#    General Query                 ALL-SYSTEMS (224.0.0.1)       0.0.0.0
#    Group-Specific Query          The group being queried       The group being queried
#    Membership Report             The group being reported      The group being reported
#    Leave Message                 ALL-ROUTERS (224.0.0.2)       The group being left
#
#------------------------------------------------------------------------------
# From IGMPv3 RFC-3376:
#
#    Version 3 Reports are sent with an IP destination address of 224.0.0.22
#
#------------------------------------------------------------------------------

    set Ethernet DEFAULT
    set IP DEFAULT
    set IGMP DEFAULT

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -igmp     { set IGMP $value }
                -ip       { set IP $value }
                -ethernet { set Ethernet $value }
                default   { error "Frame.Igmp.Set: Invalid param '${item}'" }
            } ;#switch close
        }
    }

    set maxResponseTime 0
    set sourceAddressList [ list ]
    if { ![ string equal -nocase $IGMP "DEFAULT" ]} {
        foreach {item value} $IGMP {
            switch -- [ string tolower $item ] {
                -maxresptime       { set maxResponseTime $value }
                -sourceaddresslist { set sourceAddressList $value }
                default { error "Frame.Igmp.Set: Invalid IGMP option '${item}'" }
            } ;# switch close
        }
    }

    switch -- $Type {
        0 { set DIP $GroupAddress }
        1 { set DIP $GroupAddress }
        2 { set DIP 224.0.0.2 } 
        3 { set DIP 224.0.0.1 } 
        4 { set DIP $GroupAddress }
        5 { set DIP 224.0.0.22 }
        6 { set DIP 224.0.0.22 }
        7 { set DIP 224.0.0.1 }
        8 { set DIP $GroupAddress }
    }


    # --- Ethernet
       
    # --- This converts the destination IP address to a multicast MAC-address
    #   + IANA [http://www.iana.org/assignments/ethernet-numbers]:
    #     An Ethernet multicast address consists of the multicast bit, the
    #     23-bit vendor component, and the 24-bit group identifier assigned by
    #     the vendor.
    #   + RFC-1112 :
    #     An IP host group address is mapped to an Ethernet multicast address
    #     by placing the low-order 23-bits of the IP address into the low-order
    #     23 bits of the Ethernet multicast address 01-00-5E-00-00-00 (hex).
    set DMAC [ Multicast.IP.To.Mac $DIP ]

    # --- IPv4
    set ipProtocol 0x02 ;# IGMP

    # --- IP Options : Router Alert
    #   + RFC-2236 : Every IGMP message described in this document is sent with an IP Time-to-Live of 1
    #   + RFC-2236 : Every IGMP message described in this document carries an IP Router Alert option [RFC-2113] in its IP header. 
    set IgmpIpOptions [ list -TTL 1 -IPOptions [ list 0x94 0x04 0x00 0x00 ] ]
    if { [ string equal -nocase $IP "DEFAULT" ]} {
        set IP $IgmpIpOptions
    } else {
        set IP [ eval list $IgmpIpOptions $IP ]
    }

    # --- IGMP

    #   + IGMPv2 RFC-2236:
    #     0x11 = Membership Query 
    #     0x16 = Version 2 Membership Report   
    #     0x17 = Leave Group
    #     There is an additional type of message:
    #     (for backwards-compatibility with IGMPv1)
    #     0x12 = Version 1 Membership Report

    #   + IGMPv3 RFC-3376:
    #     0x11 = Membership Query 
    #     0x22 = Version 3 Membership Report   
    switch -- $Type {
    0 {
        # --- IGMPv1 Join
        set IGMPPart1 { 0x12 0x00 }
        set IGMPPart2 [ IP.To.Hex $GroupAddress ]
    }
    1 {
        # --- IGMPv2 Join
        set IGMPPart1 { 0x16 0x00 }
        set IGMPPart2 [ IP.To.Hex $GroupAddress ]
    }
    2 {
        set IGMPPart1 { 0x17 0x00 }
        set IGMPPart2 [ IP.To.Hex $GroupAddress ]
    }
    3 {
        set IGMPPart1 [ list 0x11 [ Byte.To.Hex $maxResponseTime ] ]
        set IGMPPart2 [ list 0x00 0x00 0x00 0x00 ]
    }
    4 {
        set IGMPPart1 [ list 0x11 [ Byte.To.Hex $maxResponseTime ] ]
        set IGMPPart2 [ IP.To.Hex $GroupAddress ]
    }
    5 {
        # --- IGMPv3 Membership Report message
        set IGMPPart1 [ list 0x22 0x00 ]
        set nrOfGroupRecords 1
        if { [ llength $sourceAddressList ] > 0 } { set recordType 0x05 } else { set recordType 0x02 }
        set IGMPPart2 " 0x00 0x00 0x00 [ Short.To.Hex $nrOfGroupRecords ] $recordType 0x00 [ Short.To.Hex [ llength $sourceAddressList ] ] [ IP.To.Hex $GroupAddress ]"
    }
    6 {
        # --- IGMPv3 Leave Group message
        set IGMPPart1 [ list 0x22 0x00 ]
        if { [ llength $sourceAddressList ] > 0 } { set recordType 0x06 } else { set recordType 0x01 }
        set nrOfGroupRecords 1
        set IGMPPart2 " 0x00 0x00 [ Short.To.Hex $nrOfGroupRecords ] $recordType 0x00 [ Short.To.Hex [ llength $sourceAddressList ] ] [ IP.To.Hex $GroupAddress ]"
    }
    7 {
        # --- IGMPv3 General Membership Query
        set IGMPPart1 [ list 0x11 [ Byte.To.Hex $maxResponseTime ] ]
        set IGMPPart2 " 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 "
    }
    8 {
        # --- IGMPv3 Group-Specific Membership Query and Group-and-Source-Specific Membership Query
        set IGMPPart1 [ list 0x11 [ Byte.To.Hex $maxResponseTime ] ]
        set IGMPPart2 " [ IP.To.Hex $GroupAddress ] 0x00 0x00 [ Short.To.Hex [ llength $sourceAddressList ] ]"
    }
    }

    set myContent [ concat $IGMPPart1 { 0x00 0x00 } $IGMPPart2 ]
    set sourceSpecificAdresses [ list ]
    foreach sourceAddress $sourceAddressList {
        eval lappend myContent [ IP.To.Hex $address ]
    }

    # --- IGMP Checksum  
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ eval lreplace { $myContent } 2 3 $checkSum ]
    puts "IGMP : $myContent"

    set myContent [ Frame.Ipv4.Set $DMAC $SMAC $DIP $SIP $ipProtocol $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent
}

#**************************************************************************************************

proc Frame.Icmp.Echo.Set { DMAC SMAC DIP SIP ID seqNr dataOrLength { params DEFAULT } } {
    # Sets content of the frame to an ICMP Echo Request/Reply frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param ID Icmp Echo Identifier field (decimal)
    # @param seqNr Icmp Echo Sequence Number field (decimal)
    # @param dataOrLength Data of the ICMP Echo frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -ICMP
    #                      -Type        : 8        : Echo Request
    #                      -Code        : 0
    #               -IP
    #                      -Version     : 4           : IP version
    #                      -IHL         : 5
    #                      -IPIdentif   : 0x00 0x00
    #                      -TTL         : 20
    #                      -FF          : 0x00 0x00
    #                      -ToS         : 0x00
    #               -Ethernet
    #                      -MFT         : EtherII
    #                                     SNAP
    #                                     802.3
    #                      -Length      : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                               If total length exceeds maximum MTU (1518) then an error will be generated
    #                                   : x       : Ethernet data Length will be adjusted to <x>.
    #                                               If data exceeds <x> boundary then an error will be generated.
    #                                               If data is smaller than <x> then data will be stuffed with 0x00
    #
    # e.g.: ICMP Echo Request Frame with Identifier 0x1234, Sequence Number 0x5678 and Data 0xdd 0xdd 0xdd 0xdd 0xdd 0xdd
    # @example Frame.Icmp.Set 00ff02000002 00ff02000001 10.11.0.2 10.11.0.1 0x1234 0x5678 {-length 6}
    ##

    set icmpType 8
    set icmpCode 0

    set Ethernet DEFAULT
    set IP DEFAULT
    set ICMP DEFAULT

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -icmp       { set ICMP     $value }
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Icmp.Echo.Set : Invalid param '${item}'" }
            } ;# switch close
        }
    }

    if { ![ string equal -nocase $ICMP "DEFAULT" ]} {
        foreach {item value} $ICMP {
            switch -- [ string tolower $item ] {
                -type { set icmpType $value }
                -code { set icmpCode $value }
                default { error "Frame.Icmp.Echo.Set: Invalid ICMP option '${item}'" }
            } ;# switch close
        }
    }

    # Check the ID
    if { [ string equal $ID "" ] || ![ string is integer $ID ] || $ID < 0 || $ID > 0xFFFF} {
        error "Frame.Icmp.Echo.Set : Invalid ID value '$ID', MUST be <= 0xFFFF"
    }

    # Check the seqNr
    if { [ string equal $seqNr "" ] || ![ string is integer $seqNr ] || $seqNr < 0 || $seqNr > 0xFFFF} {
        error "Frame.Icmp.Echo.Set : Invalid seqNr value '$seqNr', MUST be <= 0xFFFF"
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]

    # ICMP ECHO
    set H1 [ Short.To.Hex $ID ]
    set H2 [ Short.To.Hex $seqNr ]
    set H [ concat $H1 $H2 ]
    set myContent [ concat $H $data ]

    set myContent [ Frame.Icmp.Set $DMAC $SMAC $DIP $SIP $icmpType $icmpCode $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Icmp.Set { DMAC SMAC DIP SIP Type Code dataOrLength { params DEFAULT } } {
    # Sets content of the frame to an ICMP frame.
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param DIP Destination IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param Type Icmp Type field (decimal)
    # @param Code Icmp Code field (decimal)
    # @param dataOrLength Data of the ICMP frame.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -IP:
    #                      -Version     : 4           : IP version
    #                      -IHL         : 5
    #                      -IPIdentif   : 0x00 0x00
    #                      -TTL         : 20
    #                      -FF          : 0x00 0x00
    #                      -ToS         : 0x00
    #               -Ethernet
    #                      -MFT         : EtherII
    #                                     SNAP
    #                                     802.3
    #                      -Length      : Auto    : If no value is given then the frame will nicely encapsulate the <data>
    #                                               If total length exceeds maximum MTU (1518) then an error will be generated
    #                                   : x       : Ethernet data Length will be adjusted to <x>.
    #                                               If data exceeds <x> boundary then an error will be generated.
    #                                               If data is smaller than <x> then data will be stuffed with 0x00
    #
    # e.g.: ICMP Echo Request Frame with Identifier 0x1234, Sequence Number 0x5678 and Data 0xdd 0xdd 0xdd 0xdd 0xdd 0xdd
    # @example Frame.Icmp.Set 00ff02000002 00ff02000001 10.11.0.2 10.11.0.1 0x08 0x00 {0x12 0x34 0x56 0x78 0xdd 0xdd 0xdd 0xdd 0xdd 0xdd}
    ##

    set Ethernet DEFAULT
    set IP DEFAULT

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Icmp.Set : Invalid param '${item}'" }
            } ;# switch close
        }
    }

    # Check the Type
    if { [ string equal $Type "" ] || ![ string is integer $Type ] || $Type < 0 || $Type > 0xFF} {
        error "Frame.Icmp.Set : Invalid Type value '$Type', MUST be <= 0xFF"
    }

    # Check the Code
    if { [ string equal $Code "" ] || ![ string is integer $Code ] || $Code < 0 || $Code > 0xFF} {
        error "Frame.Icmp.Set : Invalid Code value '$Code', MUST be <= 0xFF"
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]

    # ICMP
    set H1 [ Byte.To.Hex $Type ]
    set H2 [ Byte.To.Hex $Code ]
    set H [ concat $H1 $H2 ]
    set PlaceHolder [ list 0x00 0x00 ]
    set myContent [ concat $H $PlaceHolder $data ]
    set checkSum [ CheckSum.16 $myContent ]
    set myContent [ eval lreplace {$myContent} 2 3 $checkSum ]

    set myContent [ Frame.Ipv4.Set $DMAC $SMAC $DIP $SIP 0x01 $myContent [ list -IP $IP -Ethernet $Ethernet ] ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Ipv4.Set { DMAC SMAC DIP SIP protocol dataOrLength { params DEFAULT } } {
    # Sets the content of frame to the IPv4 frame specified by the parameters in @see.param params
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param SIP Source IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param DIP Destination IPv4 address (xxx.xxx.xxx.xxx formatted)
    # @param protocol Protocol field in IP header (6:TCP, 17:UDP) (decimal)
    # @param dataOrLength IP Data part (TCP frame, UDP frame, ...)
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -Version     : 4
    #               -IHL         : 5
    #               -IPIdentif   : 0x00 0x00
    #               -TTL         : 20
    #               -FF          : 0x00 0x00
    #               -ToS         : 0x00
    #
    # @example Frame.Ipv4.Set 10.11.0.1 10.2.3.4 6 {0x00 0x00 0x00} {-ToS 0x01}
    #
    ##

    set Ethernet DEFAULT
    set IP DEFAULT

    set Version 4
    set IHL 5
    set ToS 0x00
    set IPIdentif [ list 0x00 0x00 ]
    set FF [ list 0x00 0x00 ]
    set TTL 20
    set IPOptions [ list ]

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach { item value } $params {
            switch -- [ string tolower $item ] {
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Ipv4.Set: Invalid param '${item}'" }
            } ;# switch close
        }
    }

    set overrideIHL 0
    if { ![ string equal -nocase $IP "DEFAULT" ]} {
        foreach {item value} $IP {
            switch -- [ string tolower $item ] {
                -version     { set Version   $value }
                -ihl         { set IHL       $value; set overrideIHL 1 }
                -ipidentif   { set IPIdentif $value }
                -ttl         { set TTL       $value }
                -ff          { set FF        $value }
                -tos         { set ToS       $value }
                -ipoptions   { set IPOptions $value }
                default { error "Frame.Ipv4.Set: Invalid param '$item'" }
            }  ;#switch close
        }
    }

    # Check the Version
    if { [ string equal $Version "" ] || ![ string is integer $Version ] || $Version < 0 || $Version > 0xF} {
        error "Frame.Ipv4.Set: Invalid Version value '$Version', MUST be <= 0xF"
    }

    # Check the IPOptions
    if { [ expr ( [ llength $IPOptions ] % 4 ) ] != 0 || ![ ByteList.Check $IPOptions ]} {
        error "Frame.Ipv4.Set: Invalid IPOptions \`$IPOptions', expecting multiple of 4 bytes"
    }

    # Check the IHL
    if { $overrideIHL != 1} {
        set IHL [ expr 5 + ( [ llength $IPOptions ] / 4 ) ]
    }
    if { [ string equal $IHL "" ] || ![ string is integer $IHL ] || $IHL < 0 || $IHL > 0xF} {
        error "Frame.Ipv4.Set: Invalid IHL value '$IHL', MUST be <= 0xF"
    }

    # Check the IPIdentif
    if { [ llength $IPIdentif ] != 2 || ![ ByteList.Check $IPIdentif ]} {
        error "Frame.Ipv4.Set: Invalid IPIdentif '$IPIdentif', expecting 2 bytes"
    }

    # Check the TTL
    if { [ string equal $TTL "" ] || ![ string is integer $TTL ] || $TTL < 0 || $TTL > 0xFF} {
        error "Frame.Ipv4.Set: Invalid TTL value '$TTL', MUST be <= 0xFF"
    }

    # Check the FF value
    if { [ llength $FF ] != 2 || ![ ByteList.Check $FF ]} {
        error "Frame.Ipv4.Set: Invalid FF '$FF', expecting 2 bytes"
    }

    # Check the ToS
    if { [ string equal $ToS "" ] || ![ string is integer $ToS ] || $ToS < 0 || $ToS > 0xFF} {
        error "Frame.Ipv4.Set: Invalid ToS value '$Tos', MUST be <= 0xFF"
    }
    set ToS [ format "0x%02x" [ expr $ToS * 1 ] ]

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]
    set length [ Short.To.Hex [ expr ( 4 * $IHL + [ llength $data ] ) ] ]

    set H1 [ concat [ format "0x%02x" [ expr ( $Version << 4 ) & 0xF0 | ( $IHL & 0x0F ) ] ] "$ToS" $length ]
    set H2 [ concat $IPIdentif $FF ]
    set H3 [ list [ Byte.To.Hex $TTL ] [ Byte.To.Hex $protocol ] 0x00 0x00 ]
    set H4 [ IP.To.Hex $SIP ]
    set H5 [ IP.To.Hex $DIP ]
    set H6 $IPOptions
    set myContent [ concat $H1 $H2 $H3 $H4 $H5 $H6 ]

    set IPCheckSum [ CheckSum.16 $myContent ]
    set myContent [ eval lreplace {$myContent} 10 11 $IPCheckSum ]
    set myContent [ concat $myContent $data ]

    set myContent [ Frame.Mac.Set $DMAC $SMAC 0x0800 $myContent $Ethernet ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Ipv6.Set {DMAC SMAC DIP SIP nextHeader dataOrLength {params DEFAULT}} {
    # Sets the content of frame to the IPv6 frame specified by the parameters in @see.param params
    #
    # @param DMAC Destination MAC address
    # @param SMAC Source MAC address
    # @param SIP Source IPv6 address (colon notation)
    # @param DIP Destination IPv6 address (colon notation)
    # @param nextHeader Next-Header field in IP header (6: TCP, 17: UDP, 0: hop-by-hop options, 58: ICMPv6, ...) (decimal)
    # @param dataOrLength IP Data part (TCP frame, UDP frame, ...)
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -version     : 6              (4 bits)
    #               -trafClass   : 0x00           (8 bits)
    #               -flowLabel   : 0x0X 0xXX 0xXX (default: 0x00 0x00 0x00)    (20 bits)
    #               -hopLimit    : 64             (8 bits)
    #               -jumbo       : 0 or 1         (indicates the use of the Jumbo Payload option in the Hop-by-hop
    #                                              extension header. 1 -> jumbo payload is used)
    #
    # @example Frame.Ipv6.Set 2001:db8:1:55:e191:2216:e96:6038 2001:db8:1:55:f4fe:2d09:6631:9162 6 {0x00 0x00 0x00} {-hopLimit 32}
    #
    ##

    set Ethernet DEFAULT
    set IP DEFAULT

    set version 6
    set trafClass 0x00
    set flowLabel [ list 0x00 0x00 0x00 ]
    set hopLimit 64
    set jumbo 0

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -ip         { set IP       $value }
                -ethernet   { set Ethernet $value }
                default { error "Frame.Ipv6.Set : Invalid param '${item}'" }
            } ;# switch close
        }
    }

    if { ![ string equal -nocase $IP "DEFAULT" ]} {
        foreach {item value} $IP {
            switch -- [ string tolower $item ] {
                -version     { set version   $value }
                -trafclass   { set trafClass $value }
                -flowlabel   { set flowLabel $value }
                -hoplimit    { set hopLimit  $value }
                -jumbo      { set jumbo $value }
                default      { error "Frame.Ipv6.Set: Invalid param '$item'" }
            }  ;#switch close
        }
    }

    # Check the version
    if { [ string equal $version "" ] || ![ string is integer $version ] || $version < 0 || $version > 0xF} {
        error "Frame.Ipv6.Set: Invalid version value '$version', MUST be <= 0xF"
    }

    # Check the trafClass
    if { [ string equal $trafClass "" ] || ![ string is integer $trafClass ] || $trafClass < 0 || $trafClass > 0xFF} {
        error "Frame.Ipv6.Set: Invalid trafClass value '$trafClass', MUST be <= 0xFF"
    }

    # Check the flowLabel
    if { [ llength $flowLabel ] != 3 || ![ ByteList.Check $flowLabel ] || [ lindex $flowLabel 0 ] > 0xF} {
        error "Frame.Ipv6.Set: Invalid flowLabel '$flowLabel', expecting 20 bits"
    }

    # Check the hopLimit
    if { [ string equal $hopLimit "" ] || ![ string is integer $hopLimit ] || $hopLimit < 0 || $hopLimit > 0xFF} {
        error "Frame.Ipv6.Set: Invalid hopLimit value '$hopLimit', MUST be <= 0xFF"
    }

    # Check and convert the data
    set data [ x.Frame.DataOrLength.Parse $dataOrLength ]

    set H1 [ list ]
    lappend H1 [ format "0x%02x" [ expr ( ( $version << 4 ) & 0xF0 ) | ( ( $trafClass >> 4 ) & 0x0F ) ] ]
    lappend H1 [ format "0x%02x" [ expr ( ( $trafClass << 4 ) & 0xF0 ) | [ lindex $flowLabel 0 ] & 0x0F ] ]
    eval lappend H1 [ lrange $flowLabel 1 end ]
    if { !$jumbo} {
        set length [ Short.To.Hex [ llength $data ] ]
    } else {
        # For payload lengths > 65535, the payload length is set to 0 and the Jumbo Payload option is used in the
        # Hop-by-hop options extension header
        set length [ Short.To.Hex 0 ]
    }

    set H2 [ concat $length [ Byte.To.Hex $nextHeader ] [ Byte.To.Hex $hopLimit ] ]
    set H3 [ IPv6.To.Hex $SIP ]
    set H4 [ IPv6.To.Hex $DIP ]
    set myContent [ concat $H1 $H2 $H3 $H4 ]
    set myContent [ concat $myContent $data ]

    set myContent [ Frame.Mac.Set $DMAC $SMAC 0x86dd $myContent $Ethernet ]

    return $myContent

}

#**************************************************************************************************

proc Frame.Mac.Set { DMAC SMAC EtherType data { params DEFAULT } } {
    # Sets frame content to ethernet frame.
    #
    # @param SMAC Source MAC address
    # @param DMAC Destination MAC address
    # @param EtherType : 0x0800 : IPv4
    #                    0x0806 : Arp
    #                    0x814C : SNMP
    #                    0x86DD : IPv6
    # @param data payload, sometimes referred to as MACData (ByteList)
    #
    # @param params A pair list containing alternating a parameter and a value
    #               Parameters are expected to be :
    #               -length : Auto    : Total length of frame, including CRC
    #                                   If needed the length of the frame can be padded with 0x00
    #                                   Note that an Ethernet II frame has no length specified. If total length
    #                                   however exceeds 1518 (MTU ethernet) then an error will be generated.
    #               -MFT    : Media Frame Type - What encoding on ethernet level must be used?
    #                         EtherII : DMAC(6) SMAC(6) EtherType(2) Data(x)
    #                         SNAP    : DMAC(6) SMAC(6) LengthOfMacDataThatFollowsHere(2) LLC(3+5) Data(x)
    #                         802.3   : DMAC(6) SMAC(6) LengthOfMacDataThatFollowsHere(2) Data(x)
    #
    # @example Frame.Mac.Set 00-00-00-00-00-02 00-00-00-00-00-02 0x806 "0x00 0x00" {-Length Auto -MFT SNAP }
    #
    ##

    set EMFT EtherII
    set ELength auto

    if { ![ string equal -nocase $params "DEFAULT" ]} {
        foreach {item value} $params {
            switch -- [ string tolower $item ] {
                -mft { set EMFT $value }
                -length { set ELength $value }
                default { error "Frame.Mac.Set : Invalid Ethernet param '$item'" }
            } ;# switch close
        }
    }

    switch -- [ string tolower $EMFT ] {
        snap { set myContent [ x.Frame.SNAP.Set $DMAC $SMAC $EtherType $data $ELength ] }
        etherii { set myContent [ x.Frame.EtherII.Set $DMAC $SMAC $EtherType $data $ELength ] }
        802.3 { set myContent [ x.Frame.802.3.Set $DMAC $SMAC $data $ELength ] }
        default { error "Frame.Mac.Set :  Invalid Ethernet MFT (Media Frame Type) '$EMFT'" }
    }

    return $myContent

}

#**************************************************************************************************

proc Frame.Pad { frame {length 64} {padByte 0x00} } {
    # Will pad the @see.param frame's content with 0x00 till length matches @see.param length Bytes
    # if framelength already exceeds this new @see.param length then nothing will happen to the frame.
    #
    # @param frame The input frame.
    # @param length The length of the output frame.
    #
    # @note On Ethernet: Minimum length is 64 bytes (incl. 4 bytes CRC)
    #                    Maximum is 1518 bytes (incl. 4 bytes CRC)
    #
    ##

    # Check the padding byte
    set padByte [ Byte.To.Hex $padByte ]

    # Check the frame ByteList
    if { ![ ByteList.Check $frame ]} {
        error "Frame.Pad: Invalid frame ByteList: '${frame}'"
    }

    set frameLength [ llength $frame ]
    while { $frameLength < $length} {
        lappend frame $padByte
        incr frameLength
    }

    return $frame

}

#**************************************************************************************************

proc Frame.Vlan.Tag.Create { id priority dropeligable tpid } {
# Create a 802.1q VLAN tag.
#
# This tag can be inserted at the correct position in the MAC header.
# It is inserted just before the Ethernet header's EtherType bytes.
#
# These tags can be added multiple times to stack tags.
# In this case, the innnermost should be added first.
#
# @param id
#     The VLAN id, with values ranging from 0 to 4095.
# 
# @param priority
#     The priority class (values 0-7).
# 
# @param dropeligable
#     A drop eligable flag (value 0 or 1).
#
# @param tpid
#     The VLAN TPID to use. Value should be either C-TAG (customer tag) 0x8100
#     or S-TAG (service-provider tag) 0x88a8.
#     When stacking VLANs, the innermost VLAN should use the C-TAG 0x8100.
#     All other VLAN tags should use the S-TAG 0x88a8.
#
# @return
#     Byte list containing the VLAN tag
#
# @example
#     Frame.Vlan.Tag.Create 23 2 0
##

    # Check the id
    if { [ string equal $id "" ] || ![ string is integer $id ] || $id < 0 || $id > 0xFFF} {
        error "Frame.Vlan.Insert: Invalid id value '$id', MUST be <= 4095 (0xFFF)"
    }

    # Check the priority
    if { [ string equal $priority "" ] || ![ string is integer $priority ] || $priority < 0 || $priority > 7} {
        error "Frame.Vlan.Insert: Invalid priority value '$priority', MUST be <= 7"
    }

    # Check the dropeligable
    if { [ string equal $dropeligable "" ] || ![ string is integer $dropeligable ] || $dropeligable < 0 || $dropeligable > 1} {
        error "Frame.Vlan.Insert: Invalid dropeligable value '$dropeligable', MUST be 0 or 1"
    }

    # Check the tpid
    if { [ string equal $tpid "" ] || ![ string is integer $tpid ] || $tpid < 0 || $tpid > 0xFFFF} {
        error "Frame.Vlan.Insert: Invalid tpid value '$tpid', MUST be 0x8100 or 0x88a8"
    }
    if { $tpid != 0x8100 && $tpid != 0x88a8} {
        puts stderr "Frame.Vlan.Insert: WARNING: Using unsupported tpid value '$tpid', should be 0x8100 or 0x88a8."
    }

    # Create the VLAN Tag
    # Bit-level structure of T1 and T2: PPPDIIII IIIIIIII (P=priority, D=dropeligable, I= id)
    set T1 [ format "0x%02x" [ expr ( ( $priority << 5 ) & 0xE0 ) | ( ( $dropeligable << 4 ) & 0x10 ) | ( ( $id >> 8 ) & 0x0F ) ] ]
    set T2 [ format "0x%02x" [ expr ( $id % 256 ) ] ]

    return [ concat [ eval list [ Short.To.Hex $tpid ] $T1 $T2 ] ]
}

#**************************************************************************************************

proc Frame.Vlan.Insert { frame id priority dropeligable { tpid 0x8100 } } {
# Will insert the 802.1q VLAN tag into the @see.param frame content, at the correct position in
# the MAC header. It is inserted just before the EtherType bytes. Can be called multiple times
# to stack tags. In this case, the innnermost should be called first.
#
# @param id
#     The VLAN id, with values ranging from 0 to 4095.
# 
# @param priority
#     The priority class (values 0-7).
# 
# @param dropeligable
#     A drop eligable flag (value 0 or 1).
#
# @param tpid
#     The VLAN TPID to use. Value should be either C-TAG (customer tag) 0x8100
#     or S-TAG (service-provider tag) 0x88a8.
#     When stacking VLANs, the innermost VLAN should use the C-TAG 0x8100.
#     All other VLAN tags should use the S-TAG 0x88a8.
#     I.e. the S-TAG should be used for all but the first call to @ref Frame.Vlan.Insert
#     Default: 0x8100 (C-TAG)
#
# @example
#     Frame.Vlan.Insert $baseEthFrame 23 2 0
##

    # Check the frame ByteList
    if { ![ ByteList.Check $frame ]} {
        error "Frame.Vlan.Insert: Invalid frame ByteList: '${frame}'"
    }

    # Check if frame is long enough to contain a MAC header (14 bytes)
    if { [ llength $frame ] < 14} {
        error "Frame.Vlan.Insert: Could not insert Tag. ByteList is shorter than a MAC header (14 bytes)."
    }

    # Create the VLAN Tag
    set tag [ Frame.Vlan.Tag.Create $id $priority $dropeligable $tpid ]

    # Insert it into the MAC header, just before the Ethertype tag:
    return [ join [ linsert $frame 12 $tag ] ]
}

#**************************************************************************************************

proc Frame.PPP.ProtocolId.FromEtherType { ethernetEtherType } {
# Returns the "uncompressed" protocol Id, mapped from the Ethernet's EtherType.
#
##
    switch -- [ string tolower $ethernetEtherType ] {
    0x0800 { return 0x0021 }
    0x86dd { return 0x0057 }
    }

    error "Unsupported conversion from Ethernet EtherType '${ethernetEtherType}' to PPP Protocol ID"
}

#**************************************************************************************************

proc Frame.PPPoE.Session.Header.Create { sessionId payloadLength ethernetEtherType } {
# Creates PPPoE + PPP header for active PPPoE session.
#
# This method generates a PPPoE header which can be used to insert into an Ethernet frame.
#
# You can provide the EtherType of the higher-layer. It will be converted to a valid
# Protocol ID for the PPP header.
#
# When inserted into the Ethernet frame:
# - The EtherType for this header MUST be 0x8864 (PPPoE Session)
# - The header returned MUST be inserted right before the Ethernet payload.
#   (after possible VLAN tags and final EtherType).
# See also https://tools.ietf.org/html/rfc2516#page-4
#
# @param sessionId
#     PPPoE session ID (0-65535)
#
# @param payloadLength
#     Length of the payload above PPPoE/PPP headers (thus excluding the PPP headers).
#
# @param ethernetEtherType
#     Ethernet EtherType which will be converted to (uncompressed!) Protocol ID for PPP Header.
#     See also @ref Frame.PPP.ProtocolId.FromEtherType
#
# @return
#     PPPoE Session header including PPP Header
##

    set Version "0x01"
    set Type "0x01"
    set Code "0x00"; # PPPoE Session Data
    # @warning
    #     Since we only support IPv4 and IPv6 now (see Frame.PPP.ProtocolId.FromEtherType),
    #     we set a fixed length of 2 bytes.
    set PppHeaderLength 2

    # Check the Session ID
    if { [ string equal $sessionId "" ] || ![ string is integer $sessionId ] || $sessionId < 0 || $sessionId > 0xFFFF} {
        error "Frame.PPPoE.Session.Tag.Create: Invalid sessionId value '$sessionId', MUST be <= 65635 (0xffff)"
    }

    # Check the Payload Length
    if { [ string equal $payloadLength "" ] || ![ string is integer $payloadLength ] || $payloadLength < 0 || $payloadLength > ( 0xFFFF - $PppHeaderLength )} {
        error "Frame.PPPoE.Session.Tag.Create: Invalid payloadLength value '$payloadLength', MUST be <= [ expr 0xFFFF - $PppHeaderLength ] (0xffff - $PppHeaderLength)"
    }

    # --- Convert the UlProtocol type for PPP:
    if { [ catch { Frame.PPP.ProtocolId.FromEtherType $ethernetEtherType } pppProtocolId ]} {
        # --- Unsupported conversion
        # FIXME: What to do with this one?
        #        How do we send an unknown frame type over PPPoE???
        error "LinkLayer.AutoComplete: ${pppProtocolId}"
    }

    # --- Generate the PPPoE header

    # Bit-level structure of T1: VVVVTTTT (V=Version, T=Type)
    set versionAndType [ format "0x%02x" [ expr ( ( $Version << 4 ) & 0xF0 ) | ( $Type & 0x0F ) ] ]
    set Code [ format "0x%02x" [ expr ( $Code % 256 ) ] ]
    set sessionId [ Short.To.Hex $sessionId ]

    # ... + PPP UL Protocol length
    set payloadLength [ Short.To.Hex [ expr $payloadLength + $PppHeaderLength ] ]

    # Fill in the PPP header
    set pppProtocolHeader [ Short.To.Hex $pppProtocolId ]

    return [ concat [ eval list $versionAndType $Code $sessionId $payloadLength $pppProtocolHeader ] ]
}

#**************************************************************************************************

proc x.Frame.EtherII.Set { DMAC SMAC type data {length auto} } {
    # Sets frame content to ethernet frame (Ethernet II, where the <Type> Field > 0x05dc or 1500)
    # without CRC.
    # <SMAC> <DMAC> : Mac address
    # <Type> :
    #         IPv4 - 0x0800
    #         Arp  - 0x0806
    #         SNMP - 0x814C
    #        IPv6 - 0x86DD ...
    # <Data> : payload in 0x00 0x00 format
    # <Length> : If needed the length of the frame can be padded with 0x00
    #
    # @example x.Frame.EtherII.Set 00-00-00-00-00-02 00-00-00-00-00-02 0x806 "0x00 0x00"
    #
    # Note that an Ethernet II frame has no length specified. If total length however exceeds
    # 1514 (MTU ethernet) then an error will be generated.
    ##

    set myContent [ list ]
    eval lappend myContent [ Mac.To.Hex $DMAC ] [ Mac.To.Hex $SMAC ]
    if { $type <= 0x5dc} {
        error "x.Frame.EtherII.Set: EtherType '$type' must be higher than 0x5dc"
    }
    eval lappend myContent [ Short.To.Hex $type ]
    eval lappend myContent $data ;# Ethernet frame without CRC

    if { [ string equal -nocase $length "auto" ]} {
        set myContent [ Frame.Pad $myContent 60 ]
    } else {
        if { [ string equal $length "" ] || ![ string is integer $length ] || $length < 0} {
            error "x.Frame.EtherII.Set: Invalid integer value length='$length'"
        }
        if { [ llength $myContent ] > $length} {
            error "x.Frame.EtherII.Set: Can't reduce length to '$length', data already exceeds this value <[ llength $myContent ]>"
        }
        set myContent [ Frame.Pad $myContent $length ]
    }

#    set MTU 1514 ;# Ethernet frame without CRC
#    if { [ llength $myContent ] > $MTU } {
#        error "x.Frame.EtherII.Set: MTU exceeded, length was '[ llength $myContent ]', maximum is ${MTU}"
#    }

    return $myContent

}

#**************************************************************************************************

proc x.Frame.SNAP.Set { DMAC SMAC type data {length auto} } {
    # Sets the frame content to an ethernet SNAP frame (SubNetwork Access Protocol)
    # SNAP frames have DSAP and SSAP  = 0xAA, Control is always 0x03
    #
    # <SMAC> <DMAC> : Mac address
    # <Type> : = EtherType
    #         IPv4 - 0x0800
    #         Arp  - 0x0806
    #         SNMP - 0x814C
    #        IPv6 - 0x86DD ...
    # <Data> : payload in 0x00 0x00 format
    # <Length> : Auto : If no value is given then the SNAP frame will nicely encapsulate the <Data>
    #                   If total length exceeds maximum MTU (1518) then an error will be generated
    #            x    : Length will be adjusted to <x>.
    #                    If data exceeds <x> boundary then an error will be generated.
    #                    If data is smaller than <x> then data will be stuffed with 0x00
    #
    # eg: x.Frame.SNAP.Set 00-00-00-00-00-02 00-00-00-00-00-02 0x806 "0x00 0x00"
    #     x.Frame.SNAP.Set 00-00-00-00-00-02 00-00-00-00-00-02 0x806 "0x00 0x00" 600
    ##

    set myContent [ list ]
    eval lappend myContent [ Mac.To.Hex $DMAC ] [ Mac.To.Hex $SMAC ]
    lappend myContent 0x00 0x00 ;# Needs to be replaced in the future if length is known
    lappend myContent 0xaa 0xaa 0x03 0x00 0x00 0x00
    eval lappend myContent [ Short.To.Hex $type ]
    eval lappend myContent $data ;# Ethernet frame without CRC
    set frameWithoutDataLength [ expr [ llength $myContent ] - 8 - [ llength $data ] ]

    if { [ string equal -nocase $length "auto" ]} {
        set myContent [ Frame.Pad $myContent 64 ]
    } else {
        if { [ string equal $length "" ] || ![ string is integer $length ] || $length < 0} {
            error "x.Frame.SNAP.Set: Invalid integer value length='$length'"
        }
        if { [ llength $myContent ] > $length} {
            error "x.Frame.SNAP.Set: Can't set Length to '$length', data already exceeds this value '[ llength $myContent ]'"
        }
        set myContent [ Frame.Pad $myContent $length ]
    }

    set finalLength [ expr ( [ llength $myContent ] - $frameWithoutDataLength  ) ]
    set finalLengthHex [ Short.To.Hex $finalLength ]
    set myContent [ eval lreplace {$myContent} 12 13 $finalLengthHex ]

    set MTU 1514 ;# Ethernet frame without CRC
    if { $finalLength > $MTU - $frameWithoutDataLength} {
        error "x.Frame.802.3.Set: MTU exceeded, length was '[ expr $finalLength + $frameWithoutDataLength  ]', maximum is ${MTU}"
    }

    return $myContent

}

#**************************************************************************************************

proc x.Frame.802.3.Set { DMAC SMAC data {length auto} } {
    # Sets the frame content to an ethernet 802.3 encoded frame
    # Note that LLC header consists of the first 8 bytes of data
    # <SMAC> <DMAC> : Mac address
    # <Data> : payload in 0x00 0x00 format
    # <Length> : Auto : If no value is given then the SNAP frame will nicely encapsulate the <Data>
    #                   If total length exceeds maximum MTU (1518) then an error will be generated
    #            x    : Length will be adjusted to <x>.
    #                    If data exceeds <x> boundary then an error will be generated.
    #                    If data is smaller than <x> then data will be stuffed with 0x00
    #
    # eg: x.Frame.802.3.Set 00-00-00-00-00-02 00-00-00-00-00-02 "0x00 0x00"
    #     x.Frame.802.3.Set 00-00-00-00-00-02 00-00-00-00-00-02 "0x00 0x00" 600
    ##

    set myContent [ list ]
    eval lappend myContent [ Mac.To.Hex $DMAC ] [ Mac.To.Hex $SMAC ]
    lappend myContent 0x00 0x00 ;# Needs to be replaced in the future if length is known
    eval lappend myContent $data ;# Ethernet frame without CRC
    set frameWithoutDataLength [ expr [ llength $myContent ] - [ llength $data ] ]

    if { [ string equal -nocase $length "auto" ]} {
        set myContent [ Frame.Pad $myContent 64 ]
    } else {
        if { [ string equal $length "" ] || ![ string is integer $length ] || $length < 0} {
            error "x.Frame.802.3.Set: Invalid integer value length='$length'"
        }
        if { [ llength $myContent ] > $length} {
            error "x.Frame.802.3.Set: Can't set Length to '$length', data already exceeds this value '[ llength $myContent ]'"
        }
        set myContent [ Frame.Pad $myContent $length ]
    }

    set finalLength [ expr ( [ llength $myContent ] - $frameWithoutDataLength  ) ]
    set finalLengthHex [ Short.To.Hex $finalLength ]
    set myContent [ eval lreplace {$myContent} 12 13 $finalLengthHex ]

    set MTU 1514 ;# Ethernet frame without CRC
    if { $finalLength > $MTU - $frameWithoutDataLength} {
        error "x.Frame.802.3.Set: MTU exceeded, length was '[ expr $finalLength + $frameWithoutDataLength  ]', maximum is ${MTU}"
    }

    return $myContent

}

#**************************************************************************************************

proc x.Frame.DataOrLength.Parse { dataOrLength } {
    # Parse the dataOrLength Parameter and convert it to the real data.
    #
    # @param dataOrLength Data to return.
    #                     Can also specify a length if <dataOrLength> is a list
    #                     with '-length' as first element and an integer
    #                     specifying the datalength as a second element
    #
    # @return The data or the number of data bytes requested.
    #
    ##

    if { [ string equal -nocase [ lindex $dataOrLength 0 ] "-length" ]} {
        if { [ llength $dataOrLength ] != 2} {
            error "x.Frame.DataOrLength.Parse: dataOrLength MUST be '-length <integer length>' OR ByteList of data"
        }
        set data [list]
        set length [ lindex $dataOrLength 1 ]

        if { [ string equal $length "" ] || ![ string is integer $length ] || $length < 0} {
            error "x.Frame.DataOrLength.Parse: Invalid length '${length}'"
        }
        while { [ llength $data ] < $length} {
            lappend data 0xdd
        }
    } else {
        if { ![ ByteList.Check $dataOrLength ]} {
            error "x.Frame.DataOrLength.Parse: Invalid ByteList data == '${dataOrLength}"
        }
        set data [ string tolower $dataOrLength ]
    }

    return ${data}

}

#**************************************************************************************************

}

}