// Package pktline implements reading payloads form pkt-lines and creating pkt-lines from payloads.
package pktline
import (
"bytes"
"errors"
"io"
"strings"
)
const (
// MaxPayloadSize is the maximum payload size of a pkt-line in bytes.
MaxPayloadSize = 65516
)
var (
flush = []byte{'0', '0', '0', '0'}
)
// PktLines values represent a succession of pkt-lines. Values from
// this type are not zero-value safe, use the New function instead.
type PktLines struct {
r io.Reader
}
var (
// ErrPayloadTooLong is returned by the Add methods when any of the
// provided payloads is bigger than MaxPayloadSize.
ErrPayloadTooLong = errors.New("payload is too long")
// ErrEmptyPayload is returned by the Add methods when an empty
// payload is provided.
ErrEmptyPayload = errors.New("cannot add empty payloads")
)
// New returns an empty PktLines (with no payloads) ready to be used.
func New() *PktLines {
return &PktLines{
r: bytes.NewReader(nil),
}
}
// AddFlush adds a flush-pkt to p.
func (p *PktLines) AddFlush() {
p.r = io.MultiReader(p.r, bytes.NewReader(flush))
}
// Add adds the slices in pp as the payloads of a
// corresponding number of pktlines.
func (p *PktLines) Add(pp ...[]byte) error {
tmp := []io.Reader{p.r}
for _, p := range pp {
if err := add(&tmp, p); err != nil {
return err
}
}
p.r = io.MultiReader(tmp...)
return nil
}
func add(dst *[]io.Reader, e []byte) error {
if err := checkPayloadLength(len(e)); err != nil {
return err
}
n := len(e) + 4
*dst = append(*dst, bytes.NewReader(asciiHex16(n)))
*dst = append(*dst, bytes.NewReader(e))
return nil
}
func checkPayloadLength(n int) error {
switch {
case n < 0:
panic("unexpected negative payload length")
case n == 0:
return ErrEmptyPayload
case n > MaxPayloadSize:
return ErrPayloadTooLong
default:
return nil
}
}
// Returns the hexadecimal ascii representation of the 16 less
// significant bits of n. The length of the returned slice will always
// be 4. Example: if n is 1234 (0x4d2), the return value will be
// []byte{'0', '4', 'd', '2'}.
func asciiHex16(n int) []byte {
var ret [4]byte
ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12))
ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8))
ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4))
ret[3] = byteToASCIIHex(byte(n & 0x000f))
return ret[:]
}
// turns a byte into its hexadecimal ascii representation. Example:
// from 11 (0xb) to 'b'.
func byteToASCIIHex(n byte) byte {
if n < 10 {
return '0' + n
}
return 'a' - 10 + n
}
// AddString adds the strings in pp as payloads of a
// corresponding number of pktlines.
func (p *PktLines) AddString(pp ...string) error {
tmp := []io.Reader{p.r}
for _, p := range pp {
if err := addString(&tmp, p); err != nil {
return err
}
}
p.r = io.MultiReader(tmp...)
return nil
}
func addString(dst *[]io.Reader, s string) error {
if err := checkPayloadLength(len(s)); err != nil {
return err
}
n := len(s) + 4
*dst = append(*dst, bytes.NewReader(asciiHex16(n)))
*dst = append(*dst, strings.NewReader(s))
return nil
}
// Read reads the pktlines for the payloads added so far.
func (p *PktLines) Read(b []byte) (n int, err error) {
return p.r.Read(b)
}
