this is cool and all but the tables don't render properly
This commit is contained in:
447
cmd/subnetter/funcs_tpl.go
Normal file
447
cmd/subnetter/funcs_tpl.go
Normal file
@@ -0,0 +1,447 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
`encoding/binary`
|
||||
`fmt`
|
||||
`net`
|
||||
`net/netip`
|
||||
`reflect`
|
||||
`strconv`
|
||||
`strings`
|
||||
|
||||
`github.com/TwiN/go-color`
|
||||
`github.com/projectdiscovery/mapcidr`
|
||||
`go4.org/netipx`
|
||||
`subnetter/netsplit`
|
||||
)
|
||||
|
||||
/*
|
||||
tplClass4Iter should only be called if legacy info is enabled.
|
||||
It returns a tableLegacy4Sizer and a slice of tableLegacy4.
|
||||
|
||||
It takes no input.
|
||||
*/
|
||||
func tplClass4Iter() (legacySpec *tableLegacy4Ret, err error) {
|
||||
|
||||
// This whole thing feels dirty.
|
||||
// It's like adding a microcontroller to a rock.
|
||||
// But it works.
|
||||
var pfx *net.IPNet
|
||||
var classNets []*netip.Prefix
|
||||
var netRange netipx.IPRange
|
||||
var v *netsplit.VLSMSplitter = &netsplit.VLSMSplitter{
|
||||
Ascending: false,
|
||||
PrefixLengths: []uint8{
|
||||
1, // A
|
||||
2, // B
|
||||
3, // C
|
||||
4, // D
|
||||
4, // E
|
||||
},
|
||||
BaseSplitter: new(netsplit.BaseSplitter),
|
||||
}
|
||||
|
||||
if _, pfx, err = net.ParseCIDR("0.0.0.0/0"); err != nil {
|
||||
return
|
||||
}
|
||||
v.SetParent(*pfx)
|
||||
if classNets, _, err = v.Split(); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
legacySpec = &tableLegacy4Ret{
|
||||
Sizer: &tableLegacy4Sizer{
|
||||
Class: 5, // "CLASS"
|
||||
CIDR: 4, // "BITS"
|
||||
Start: 5, // "START"
|
||||
End: 3, // "END"
|
||||
},
|
||||
Rows: make([]tableLegacy4, 5),
|
||||
}
|
||||
for idx, cls := range []string{
|
||||
"A", "B", "C", "D", "E",
|
||||
} {
|
||||
legacySpec.Rows[idx] = tableLegacy4{
|
||||
Class: cls,
|
||||
CIDR: classNets[idx].String(),
|
||||
NetCIDR: *classNets[idx],
|
||||
}
|
||||
netRange = netipx.RangeOfPrefix(legacySpec.Rows[idx].NetCIDR)
|
||||
legacySpec.Rows[idx].NetStart = netRange.From()
|
||||
legacySpec.Rows[idx].NetEnd = netRange.To()
|
||||
legacySpec.Rows[idx].Start = legacySpec.Rows[idx].NetStart.String()
|
||||
legacySpec.Rows[idx].End = legacySpec.Rows[idx].NetEnd.String()
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
tplAddrIter takes a 4 or 6 for inet family/version and returns a tableAddrSizer and
|
||||
slice of tableAddr.
|
||||
tableAddr is sorted from smallest prefix/largest network to largest prefix/smallest network.
|
||||
*/
|
||||
func tplAddrIter(ipVer uint8) (addrs *tableAddrRet, err error) {
|
||||
|
||||
var dummyAddr netip.Addr
|
||||
var dummyNet *net.IPNet
|
||||
var l int
|
||||
|
||||
addrs = &tableAddrRet{
|
||||
Sizer: &tableAddrSizer{
|
||||
Prefix: 6, // "PREFIX"
|
||||
Bits: 4, // "BITS"
|
||||
Addresses: 9, // "ADDRESSES"
|
||||
Hosts: 5, // "HOSTS"
|
||||
},
|
||||
}
|
||||
|
||||
switch ipVer {
|
||||
case 4:
|
||||
if dummyAddr, err = netip.ParseAddr("0.0.0.0"); err != nil {
|
||||
return
|
||||
}
|
||||
case 6:
|
||||
if dummyAddr, err = netip.ParseAddr("::"); err != nil {
|
||||
return
|
||||
}
|
||||
default:
|
||||
err = errBadNet
|
||||
return
|
||||
}
|
||||
|
||||
// Before we size, we generate the tableAddrs.
|
||||
addrs.Rows = make([]tableAddr, dummyAddr.BitLen()+1)
|
||||
for i := 0; i <= dummyAddr.BitLen(); i++ {
|
||||
addrs.Rows[i] = tableAddr{
|
||||
Prefix: uint8(i),
|
||||
Bits: uint8(dummyAddr.BitLen() - i),
|
||||
}
|
||||
if addrs.Rows[i].NetPrefix, err = dummyAddr.Prefix(i); err != nil {
|
||||
return
|
||||
}
|
||||
dummyNet = netipx.PrefixIPNet(addrs.Rows[i].NetPrefix.Masked())
|
||||
addrs.Rows[i].Addresses = mapcidr.CountIPsInCIDR(true, true, dummyNet)
|
||||
addrs.Rows[i].Hosts = mapcidr.CountIPsInCIDR(false, false, dummyNet)
|
||||
}
|
||||
|
||||
// Now the sizer. The padding itself is handled in different logic, just need the length of the longest value as a string.
|
||||
for _, addr := range addrs.Rows {
|
||||
// I *abhor* walrus operators in anything but loops.
|
||||
l = len(strconv.Itoa(int(addr.Prefix)))
|
||||
if int(addrs.Sizer.Prefix) < l {
|
||||
addrs.Sizer.Prefix = uint8(l)
|
||||
}
|
||||
l = len(strconv.Itoa(int(addr.Bits)))
|
||||
if int(addrs.Sizer.Bits) < l {
|
||||
addrs.Sizer.Bits = uint8(l)
|
||||
}
|
||||
// Use the full numeric length.
|
||||
l = len(addr.Addresses.String())
|
||||
if int(addrs.Sizer.Addresses) < l {
|
||||
addrs.Sizer.Addresses = uint8(l)
|
||||
}
|
||||
l = len(addr.Hosts.String())
|
||||
if int(addrs.Sizer.Hosts) < l {
|
||||
addrs.Sizer.Hosts = uint8(l)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
tplMaskIter4 returns a slice of IPv4 netmasks and returns a slice of tableMask4.
|
||||
Sorted from smallest prefix/largest network to largest prefix/smallest network.
|
||||
*/
|
||||
func tplMaskIter4() (masks *tableMask4Ret, err error) {
|
||||
|
||||
var dummyAddr netip.Addr
|
||||
var pfx netip.Prefix
|
||||
var dummyNet *net.IPNet
|
||||
var l int
|
||||
|
||||
masks = &tableMask4Ret{
|
||||
Sizer: &tableMask4Sizer{
|
||||
Prefix: 6, // "PREFIX"
|
||||
Netmask: 7, // "NETMASK"
|
||||
Hex: 3, // "HEX"
|
||||
Dec: 3, // "DEC"
|
||||
Bin: 3, // "BIN"
|
||||
},
|
||||
}
|
||||
|
||||
if dummyAddr, err = netip.ParseAddr("0.0.0.0"); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
masks.Rows = make([]tableMask4, dummyAddr.BitLen()+1)
|
||||
for i := 0; i <= dummyAddr.BitLen(); i++ {
|
||||
if pfx, err = dummyAddr.Prefix(i); err != nil {
|
||||
return
|
||||
}
|
||||
dummyNet = netipx.PrefixIPNet(pfx.Masked())
|
||||
masks.Rows[i] = tableMask4{
|
||||
Prefix: uint8(i),
|
||||
Netmask: netsplit.MaskFmt(
|
||||
dummyNet.Mask,
|
||||
"d", ".", "",
|
||||
1, 0,
|
||||
),
|
||||
Hex: dummyNet.Mask.String(),
|
||||
Dec: binary.BigEndian.Uint32(dummyNet.Mask),
|
||||
Bin: netsplit.MaskFmt(
|
||||
dummyNet.Mask,
|
||||
"08b", ".", "",
|
||||
1, 0,
|
||||
),
|
||||
Mask: dummyNet.Mask,
|
||||
}
|
||||
}
|
||||
|
||||
// Now the sizer.
|
||||
for _, mask := range masks.Rows {
|
||||
l = len(strconv.Itoa(int(mask.Prefix)))
|
||||
if int(masks.Sizer.Prefix) < l {
|
||||
masks.Sizer.Prefix = uint8(l)
|
||||
}
|
||||
l = len(mask.Netmask)
|
||||
if int(masks.Sizer.Netmask) < l {
|
||||
masks.Sizer.Netmask = uint8(l)
|
||||
}
|
||||
l = len(mask.Hex)
|
||||
if int(masks.Sizer.Hex) < l {
|
||||
masks.Sizer.Hex = uint8(l)
|
||||
}
|
||||
l = len(strconv.FormatUint(uint64(mask.Dec), 10))
|
||||
if int(masks.Sizer.Dec) < l {
|
||||
masks.Sizer.Dec = uint8(l)
|
||||
}
|
||||
l = len(mask.Bin)
|
||||
if int(masks.Sizer.Bin) < l {
|
||||
masks.Sizer.Bin = uint8(l)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// do not include in template funcs; used externally
|
||||
func hdrRender(hdrVal reflect.Value, indent string, plain bool) (out string) {
|
||||
|
||||
var val reflect.Value
|
||||
var field reflect.StructField
|
||||
var fieldVal reflect.Value
|
||||
var colLen uint8
|
||||
var colTitle string
|
||||
var lastField int
|
||||
var valType reflect.Type
|
||||
var tfmt *tableFormatter = tblFmts[plain]
|
||||
var sb *strings.Builder = new(strings.Builder)
|
||||
|
||||
val = hdrVal
|
||||
valType = val.Type()
|
||||
|
||||
// Avoid the edge case where a struct's last field is skipped rendering
|
||||
for i := val.NumField(); i > 0; i-- {
|
||||
field = valType.Field(i - 1)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
lastField = i
|
||||
break
|
||||
}
|
||||
|
||||
// Top-most line.
|
||||
sb.WriteString(indent)
|
||||
sb.WriteString(tfmt.TopLeftHdr)
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
field = valType.Field(i)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
fieldVal = val.Field(i)
|
||||
colLen = uint8(fieldVal.Uint())
|
||||
sb.WriteString(strings.Repeat(tfmt.TopFillHdr, int(colLen)+fixedPad))
|
||||
if i == lastField {
|
||||
sb.WriteString(tfmt.TopRightHdr)
|
||||
} else {
|
||||
sb.WriteString(tfmt.TopColSepHdr)
|
||||
}
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
|
||||
// Column titles
|
||||
sb.WriteString(indent)
|
||||
sb.WriteString(tfmt.Left)
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
field = valType.Field(i)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
fieldVal = val.Field(i)
|
||||
colLen = uint8(fieldVal.Uint()) + uint8(fixedPad)
|
||||
colTitle = field.Name
|
||||
if !tfmt.NoUpperTitle {
|
||||
colTitle = strings.ToUpper(colTitle)
|
||||
}
|
||||
if !tfmt.NoBoldTitle {
|
||||
sb.WriteString(color.InBold(padStr(colTitle, colLen)))
|
||||
} else {
|
||||
sb.WriteString(padStr(colTitle, colLen))
|
||||
}
|
||||
if i == lastField {
|
||||
sb.WriteString(tfmt.Right)
|
||||
} else {
|
||||
sb.WriteString(tfmt.ColSepHdr)
|
||||
}
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
|
||||
// Header bottom line; headers always include bottom separators.
|
||||
sb.WriteString(indent)
|
||||
sb.WriteString(tfmt.BottomLeftHdr)
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
field = valType.Field(i)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
fieldVal = val.Field(i)
|
||||
colLen = uint8(fieldVal.Uint())
|
||||
sb.WriteString(strings.Repeat(tfmt.BottomFillHdr, int(colLen)+fixedPad))
|
||||
if i == lastField {
|
||||
sb.WriteString(tfmt.BottomRightHdr)
|
||||
} else {
|
||||
sb.WriteString(tfmt.BottomColSepHdr)
|
||||
}
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
|
||||
out = sb.String()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// do not include in template funcs; used externally
|
||||
func hdrLineRender(hdrVal reflect.Value, indent string, plain bool, rowIdx int, numRows int) (out string) {
|
||||
|
||||
var val reflect.Value
|
||||
var field reflect.StructField
|
||||
var fieldVal reflect.Value
|
||||
var colLen uint8
|
||||
var lastField int
|
||||
var isLastLine bool
|
||||
var valType reflect.Type
|
||||
var tfmt *tableFormatter = tblFmts[plain]
|
||||
var sb *strings.Builder = new(strings.Builder)
|
||||
|
||||
isLastLine = rowIdx == (numRows - 1)
|
||||
if !isLastLine && tfmt.SuppressLineSep {
|
||||
return
|
||||
}
|
||||
|
||||
val = hdrVal
|
||||
valType = val.Type()
|
||||
lastField = valType.NumField() - 1
|
||||
|
||||
for i := val.NumField(); i >= 0; i-- {
|
||||
field = valType.Field(i - 1)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
lastField = i
|
||||
break
|
||||
}
|
||||
|
||||
sb.WriteString(indent)
|
||||
if isLastLine {
|
||||
sb.WriteString(tfmt.LastLeft)
|
||||
} else {
|
||||
sb.WriteString(tfmt.LineLeft)
|
||||
}
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
field = valType.Field(i)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
fieldVal = val.Field(i)
|
||||
colLen = uint8(fieldVal.Uint())
|
||||
if isLastLine {
|
||||
sb.WriteString(strings.Repeat(tfmt.LastFill, int(colLen)+fixedPad))
|
||||
} else {
|
||||
sb.WriteString(strings.Repeat(tfmt.Fill, int(colLen)+fixedPad))
|
||||
}
|
||||
if i == lastField {
|
||||
if isLastLine {
|
||||
sb.WriteString(tfmt.LastRight)
|
||||
} else {
|
||||
sb.WriteString(tfmt.LineRight)
|
||||
}
|
||||
} else {
|
||||
if isLastLine {
|
||||
sb.WriteString(tfmt.LastSep)
|
||||
} else {
|
||||
sb.WriteString(tfmt.LineColSep)
|
||||
}
|
||||
}
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
|
||||
out = sb.String()
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// do not include in template funcs; used externally
|
||||
func rowRender(val reflect.Value, sizerVal reflect.Value, indent string, plain bool) (out string) {
|
||||
|
||||
var field reflect.StructField
|
||||
var fieldVal reflect.Value
|
||||
var colLen uint8
|
||||
var sizerName string
|
||||
var sizerField reflect.Value
|
||||
var callVal string
|
||||
var valType reflect.Type = val.Type()
|
||||
var tfmt *tableFormatter = tblFmts[plain]
|
||||
var sb *strings.Builder = new(strings.Builder)
|
||||
|
||||
sb.WriteString(indent)
|
||||
for i := 0; i < val.NumField(); i++ {
|
||||
field = valType.Field(i)
|
||||
if field.Tag.Get("render") == "-" {
|
||||
continue
|
||||
}
|
||||
sb.WriteString(tfmt.Left)
|
||||
fieldVal = val.Field(i)
|
||||
sizerName = field.Tag.Get("renderSizeName")
|
||||
if sizerName == "" {
|
||||
sizerName = field.Name
|
||||
}
|
||||
sizerField = sizerVal.FieldByName(sizerName)
|
||||
colLen = uint8(sizerField.Uint()) + uint8(fixedPad)
|
||||
switch fieldVal.Kind() {
|
||||
// This is tailored specifically to this implementation.
|
||||
case reflect.String:
|
||||
sb.WriteString(fieldVal.String())
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
sb.WriteString(padStr(fmt.Sprintf("%d", fieldVal.Int()), colLen))
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
||||
sb.WriteString(padStr(fmt.Sprintf("%d", fieldVal.Uint()), colLen))
|
||||
case reflect.Ptr:
|
||||
// It's a *big.Int.
|
||||
if fieldVal.IsNil() {
|
||||
sb.WriteString(padStr(strings.Repeat(padChars, int(colLen)), colLen))
|
||||
} else {
|
||||
// TIL you can even *do* this in reflection.
|
||||
fieldVal = fieldVal.MethodByName("String").Call(nil)[0]
|
||||
callVal = fieldVal.String()
|
||||
sb.WriteString(padStr(callVal, colLen))
|
||||
}
|
||||
}
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
|
||||
out = sb.String()
|
||||
|
||||
return
|
||||
}
|
||||
Reference in New Issue
Block a user