r00t2/AnnNet
SHA256
1
0
Fork 0
Code Activity

initial publication

Browse Source
This commit is contained in:
brent saner
2025-08-28 07:38:42 -04:00
commit 8039ad7935
10 changed files with 1982 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
examples/de.go Normal file
View File

@@ -0,0 +1,74 @@
package main
import (
`fmt`
`log`
"strconv"
)
const (
/*
This is a nonsensical example.
The actual values are sort of scattered around a multitude of RFCs.
*/
deBits string = "01010101" // [0101 0101], or 85 (0x55)
)
var (
deLowerMask uint8 = 0x03 // 3
)
func ToDE(dscp, ecn uint8) (de byte) {
de = (dscp << 2) | (ecn & deLowerMask)
return
}
func FromDE(de byte) (dscp, ecn uint8) {
dscp = de >> 2
ecn = de & deLowerMask
return
}
func main() {
var err error
var u64 uint64
var de byte
var dscp uint8
var ecn uint8
// Given a D/E of deBits (see const at top)...
if u64, err = strconv.ParseUint(deBits, 2, 8); err != nil {
log.Panicln(err)
}
de = uint8(u64)
// Prints:
/*
D/E is: 85 (0x55)
*/
fmt.Printf("D/E is:\t\t%d (%#02x)\n", de, de)
dscp, ecn = FromDE(de)
// Prints:
/*
DSCP: 21 (0x15)
ECN: 1 (0x01)
*/
fmt.Printf(
"DSCP:\t\t%d (%#02x)\n"+
"ECN:\t\t%d (%#02x)\n",
dscp, dscp,
ecn, ecn,
)
de = ToDE(dscp, ecn)
// Prints:
/*
Confirmed D/E: 85 (0x55)
*/
fmt.Printf("Confirmed D/E:\t%d (%#02x)\n", de, de)
}

64
examples/extractversion.go Normal file
View File

@@ -0,0 +1,64 @@
package main
import (
"encoding/binary"
"fmt"
)
const (
posMajor int = 1 + iota
posMinor
posPatch
posRelFlag
)
var (
singleValVer uint32
singleValVerBytes []byte = []byte{
0x01, 0x02, 0x03, 0x01, // A version of 1.2.3 with the PreRelease release flag enabled
}
ord binary.ByteOrder = binary.BigEndian
)
func main() {
var verVal uint8
singleValVer = ord.Uint32(singleValVerBytes)
// fmt's Printf, for some silly reason, strips leading 0's from hex formatting unless you explicitly pad or align precision.
fmt.Printf("%d\n%#.8x\n", singleValVer, singleValVer)
// Prints:
/*
16909057
0x01020301
*/
/*
The individual versions can be fetched by the following. This comment is an explanation of the condensed form below in code.
1. n = 8 * i // i is the version component you want. See the pos* constants at the top. 8 to align to a byte (8 bits).
2. offset = 32 - n // 32 because singleValVar is a uint32 (and thus 4 bytes, or 32 bits, in memory).
3. cmp = singleValVer >> offset // Shift to the bit offset we're interested in.
4. val32 = cmp & 0xff // It's then AND'd with 0xff (256) to get the set bits -- but still a uint32, so
5. verVal = uint8(val32)
*/
// For example:
for i, verNm := range map[int]string{
posMajor: "Major",
posMinor: "Minor",
posPatch: "Patch",
posRelFlag: "Release Flag(s)",
} {
verVal = uint8((singleValVer >> (32 - (8 * i))) & 0xff)
fmt.Printf("%s: %d (%#02x)\n", verNm, verVal, verVal)
}
// Prints:
/*
Major: 1 (0x01)
Minor: 2 (0x02)
Patch: 3 (0x03)
Release Flag(s): 1 (0x01)
*/
}

75
examples/frag.go Normal file
View File

@@ -0,0 +1,75 @@
package main
import (
`fmt`
`log`
"strconv"
)
const (
/*
This is a nonsensical example.
*/
fragBits string = "0101010101000100" // [0101 0101 0100 0100], or 21828 (0x5544)
)
var (
fragOffset uint16 = 0x000d // 13
fragFlagMask uint16 = 0x07 // 0b0000111 to mask 3 bits
fragOffsetMask uint16 = 0x1fff // 8191, a 13-bit mask
)
func ToFrag(flags, fo uint16) (frag uint16) {
frag = (flags << fragOffset) | (fo & fragOffsetMask)
return
}
func FromFrag(frag uint16) (flags, fo uint16) {
flags = (frag >> fragOffset) & fragFlagMask
fo = frag & fragOffsetMask
return
}
func main() {
var err error
var u64 uint64
var frag uint16
var flags uint16
var fo uint16
// Given a fragmentation configuration of fragBits (see const at top)...
if u64, err = strconv.ParseUint(fragBits, 2, 16); err != nil {
log.Panicln(err)
}
frag = uint16(u64)
// Prints:
/*
Frag is: 21828 (0x5544)
*/
fmt.Printf("Frag is:\t\t%d (%#04x)\n", frag, frag)
flags, fo = FromFrag(frag)
// Prints:
/*
Flags: 2 (0x0002)
Fragmentation Offset: 5444 (0x1544)
*/
fmt.Printf(
"Flags:\t\t\t%d (%#04x)\n"+
"Fragmentation Offset:\t%d (%#04x)\n",
flags, flags,
fo, fo,
)
frag = ToFrag(flags, fo)
// Prints:
/*
Confirmed Frag: 21828 (0x5544)
*/
fmt.Printf("Confirmed Frag:\t\t%d (%#02x)\n", frag, frag)
}

59
examples/hasflag.go Normal file
View File

@@ -0,0 +1,59 @@
package main
import (
"fmt"
)
const anetNone uint8 = 0
const (
anetPreRel uint8 = 1 << iota
anetUnstable
anetExperiment
anetBeta = anetPreRel | anetUnstable
anetAlpha = anetBeta | anetExperiment
)
var (
// In Golang, a byte is exactly equivalent to a uint8.
// Use the same value extracted in the example `extractversion.go`.
// A value of 0x01 (1) indicates Pre-Release flag is set, with no other myFlags set.
myFlags byte = 0x01
)
func main() {
fmt.Printf("Flags:\t%d\t%#02x\n\n", myFlags, myFlags)
// Prints:
/*
Flags: 1 0x01
*/
for flag, flagNm := range map[uint8]string{
anetPreRel: "Pre-release",
anetUnstable: "Unstable",
anetExperiment: "Experimental",
anetBeta: "Beta release",
anetAlpha: "Alpha release",
} {
fmt.Printf(
"Has flag '%s' (%d, %#02x):\t%v\n\n",
flagNm, flag, flag, myFlags&flag == flag,
)
}
// Prints:
/*
Flags: 1 0x01
Has flag 'Pre-release' (1, 0x01): true
Has flag 'Unstable' (2, 0x02): false
Has flag 'Experimental' (4, 0x04): false
Has flag 'Beta release' (3, 0x03): false
Has flag 'Alpha release' (7, 0x07): false
*/
}

73
examples/vihl.go Normal file
View File

@@ -0,0 +1,73 @@
package main
import (
`fmt`
`log`
"strconv"
)
const (
vihlBits string = "01000101" // [0100 0101], or 69 (0x45)
ipVer uint8 = 0x04 // 4; unused in this program, but represented for completion's sake.
)
var (
vihlLowerMask uint8 = 0x0f // 15
)
func ToVIHL(ver, ihl uint8) (vihl byte) {
// In Go, a byte is exactly equal to a uint8
// so type casting/conversion is unnecessary here.
vihl = (ver << 4) | (ihl & vihlLowerMask)
return
}
func FromVIHL(vihl byte) (ver, ihl uint8) {
ver = vihl >> 4
ihl = vihl & vihlLowerMask
return
}
func main() {
var err error
var u64 uint64
var vihl byte
var ver uint8
var ihl uint8
// Given a V/IHL of vihlBits (see const at top)...
if u64, err = strconv.ParseUint(vihlBits, 2, 8); err != nil {
log.Panicln(err)
}
vihl = uint8(u64)
// Prints:
/*
V/IHL is: 69 (0x45)
*/
fmt.Printf("V/IHL is:\t\t%d (%#02x)\n", vihl, vihl)
ver, ihl = FromVIHL(vihl)
// Prints:
/*
Version: 4 (0x04)
IHL: 5 (0x05)
*/
fmt.Printf(
"Version:\t\t%d (%#02x)\n"+
"IHL:\t\t\t%d (%#02x)\n",
ver, ver,
ihl, ihl,
)
vihl = ToVIHL(ver, ihl)
// Prints:
/*
Confirmed V/IHL: 69 (0x45)
*/
fmt.Printf("Confirmed V/IHL:\t%d (%#02x)\n", vihl, vihl)
}

85
examples/vtf.go Normal file
View File

@@ -0,0 +1,85 @@
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)
}