86 lines
1.6 KiB
Go
86 lines
1.6 KiB
Go
package main
|
|
|
|
import (
|
|
`fmt`
|
|
`log`
|
|
"strconv"
|
|
)
|
|
|
|
const (
|
|
/*
|
|
This is a nonsensical example.
|
|
*/
|
|
vtfBits string = "01100000000000000000000000000000" // [0110 0000 0000 0000 0000 0000 0000 0000], or 1610612736 (0x60000000)
|
|
)
|
|
|
|
var (
|
|
vtfVOffset uint32 = 0x0000001c // 28
|
|
vtfVFlagMask uint32 = 0x0000000f // Mask to 4 bits
|
|
|
|
vtfTOffset uint32 = 0x00000014 // 20
|
|
vtfTFlagMask uint32 = 0x000000ff // mask to 8 bits
|
|
|
|
vtfFlowMask uint32 = 0x0000ffff
|
|
)
|
|
|
|
func ToVTF(ver, tc, flow uint32) (vtf uint32) {
|
|
|
|
vtf = (ver << vtfVOffset) | (tc << vtfTOffset) | (flow & vtfFlowMask)
|
|
|
|
return
|
|
}
|
|
|
|
func FromVTF(vtf uint32) (ver, tc, flow uint32) {
|
|
|
|
ver = (vtf >> vtfVOffset) & vtfVFlagMask
|
|
tc = (vtf >> vtfTOffset) & vtfTFlagMask
|
|
flow = vtf & vtfFlowMask
|
|
|
|
return
|
|
}
|
|
|
|
func main() {
|
|
|
|
var err error
|
|
var u64 uint64
|
|
var vtf uint32
|
|
var ver uint32
|
|
var tc uint32
|
|
var flow uint32
|
|
|
|
// Given a fragmentation configuration of vtfBits (see const at top)...
|
|
if u64, err = strconv.ParseUint(vtfBits, 2, 32); err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
vtf = uint32(u64)
|
|
// Prints:
|
|
/*
|
|
VTF is: 1610612736 (0x60000000)
|
|
*/
|
|
fmt.Printf("VTF is:\t\t\t%d (%#04x)\n", vtf, vtf)
|
|
|
|
ver, tc, flow = FromVTF(vtf)
|
|
// Prints:
|
|
/*
|
|
VTF is: 1610612736 (0x60000000)
|
|
Version: 6 (0x0006)
|
|
Traffic Class: 0 (0x0000)
|
|
Flow Label: 0 (0x0000)
|
|
*/
|
|
fmt.Printf(
|
|
"Version:\t\t%d (%#04x)\n"+
|
|
"Traffic Class:\t\t%d (%#04x)\n"+
|
|
"Flow Label:\t\t%d (%#04x)\n",
|
|
ver, ver,
|
|
tc, tc,
|
|
flow, flow,
|
|
)
|
|
|
|
vtf = ToVTF(ver, tc, flow)
|
|
// Prints:
|
|
/*
|
|
Confirmed V/T/F: 1610612736 (0x60000000)
|
|
*/
|
|
fmt.Printf("Confirmed V/T/F:\t%d (%#02x)\n", vtf, vtf)
|
|
}
|