mirror of https://github.com/k3s-io/k3s
119 lines
3.5 KiB
Go
119 lines
3.5 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package iptables
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
)
|
|
|
|
var (
|
|
commitBytes = []byte("COMMIT")
|
|
spaceBytes = []byte(" ")
|
|
)
|
|
|
|
// MakeChainLine return an iptables-save/restore formatted chain line given a Chain
|
|
func MakeChainLine(chain Chain) string {
|
|
return fmt.Sprintf(":%s - [0:0]", chain)
|
|
}
|
|
|
|
// GetChainLines parses a table's iptables-save data to find chains in the table.
|
|
// It returns a map of iptables.Chain to []byte where the []byte is the chain line
|
|
// from save (with counters etc.).
|
|
// Note that to avoid allocations memory is SHARED with save.
|
|
func GetChainLines(table Table, save []byte) map[Chain][]byte {
|
|
chainsMap := make(map[Chain][]byte)
|
|
tablePrefix := []byte("*" + string(table))
|
|
readIndex := 0
|
|
// find beginning of table
|
|
for readIndex < len(save) {
|
|
line, n := readLine(readIndex, save)
|
|
readIndex = n
|
|
if bytes.HasPrefix(line, tablePrefix) {
|
|
break
|
|
}
|
|
}
|
|
// parse table lines
|
|
for readIndex < len(save) {
|
|
line, n := readLine(readIndex, save)
|
|
readIndex = n
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
if bytes.HasPrefix(line, commitBytes) || line[0] == '*' {
|
|
break
|
|
} else if line[0] == '#' {
|
|
continue
|
|
} else if line[0] == ':' && len(line) > 1 {
|
|
// We assume that the <line> contains space - chain lines have 3 fields,
|
|
// space delimited. If there is no space, this line will panic.
|
|
chain := Chain(line[1:bytes.Index(line, spaceBytes)])
|
|
chainsMap[chain] = line
|
|
}
|
|
}
|
|
return chainsMap
|
|
}
|
|
|
|
func readLine(readIndex int, byteArray []byte) ([]byte, int) {
|
|
currentReadIndex := readIndex
|
|
|
|
// consume left spaces
|
|
for currentReadIndex < len(byteArray) {
|
|
if byteArray[currentReadIndex] == ' ' {
|
|
currentReadIndex++
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
|
|
// leftTrimIndex stores the left index of the line after the line is left-trimmed
|
|
leftTrimIndex := currentReadIndex
|
|
|
|
// rightTrimIndex stores the right index of the line after the line is right-trimmed
|
|
// it is set to -1 since the correct value has not yet been determined.
|
|
rightTrimIndex := -1
|
|
|
|
for ; currentReadIndex < len(byteArray); currentReadIndex++ {
|
|
if byteArray[currentReadIndex] == ' ' {
|
|
// set rightTrimIndex
|
|
if rightTrimIndex == -1 {
|
|
rightTrimIndex = currentReadIndex
|
|
}
|
|
} else if (byteArray[currentReadIndex] == '\n') || (currentReadIndex == (len(byteArray) - 1)) {
|
|
// end of line or byte buffer is reached
|
|
if currentReadIndex <= leftTrimIndex {
|
|
return nil, currentReadIndex + 1
|
|
}
|
|
// set the rightTrimIndex
|
|
if rightTrimIndex == -1 {
|
|
rightTrimIndex = currentReadIndex
|
|
if currentReadIndex == (len(byteArray)-1) && (byteArray[currentReadIndex] != '\n') {
|
|
// ensure that the last character is part of the returned string,
|
|
// unless the last character is '\n'
|
|
rightTrimIndex = currentReadIndex + 1
|
|
}
|
|
}
|
|
// Avoid unnecessary allocation.
|
|
return byteArray[leftTrimIndex:rightTrimIndex], currentReadIndex + 1
|
|
} else {
|
|
// unset rightTrimIndex
|
|
rightTrimIndex = -1
|
|
}
|
|
}
|
|
return nil, currentReadIndex
|
|
}
|