141 lines
3.0 KiB
Go
141 lines
3.0 KiB
Go
package radius
|
|
|
|
import (
|
|
"errors"
|
|
)
|
|
|
|
// Type is the RADIUS attribute type.
|
|
type Type int
|
|
|
|
// TypeInvalid is a Type that can be used to represent an invalid RADIUS
|
|
// attribute type.
|
|
const TypeInvalid Type = -1
|
|
|
|
// AVP is an attribute-value pair.
|
|
// It contains an attribute type and its wire data.
|
|
type AVP struct {
|
|
Type
|
|
Attribute
|
|
}
|
|
|
|
// Attributes is a list of RADIUS attributes.
|
|
type Attributes []*AVP
|
|
|
|
// ParseAttributes parses the wire-encoded RADIUS attributes and returns a new
|
|
// Attributes value. An error is returned if the buffer is malformed.
|
|
func ParseAttributes(b []byte) (Attributes, error) {
|
|
var attrs Attributes
|
|
|
|
for len(b) > 0 {
|
|
if len(b) < 2 {
|
|
return nil, errors.New("short buffer")
|
|
}
|
|
length := int(b[1])
|
|
if length > len(b) || length < 2 || length > 255 {
|
|
return nil, errors.New("invalid attribute length")
|
|
}
|
|
|
|
avp := &AVP{
|
|
Type: Type(b[0]),
|
|
}
|
|
if length > 2 {
|
|
avp.Attribute = append(Attribute(nil), b[2:length]...)
|
|
}
|
|
attrs = append(attrs, avp)
|
|
|
|
b = b[length:]
|
|
}
|
|
|
|
return attrs, nil
|
|
}
|
|
|
|
// Add appends the given Attribute to the list of attributes.
|
|
func (a *Attributes) Add(key Type, value Attribute) {
|
|
*a = append(*a, &AVP{
|
|
Type: key,
|
|
Attribute: value,
|
|
})
|
|
}
|
|
|
|
// Del removes all Attributes of the given type from a.
|
|
func (a *Attributes) Del(key Type) {
|
|
for i := 0; i < len(*a); {
|
|
if (*a)[i].Type == key {
|
|
*a = append((*a)[:i], (*a)[i+1:]...)
|
|
} else {
|
|
i++
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get returns the first Attribute of Type key. nil is returned if no Attribute
|
|
// of Type key exists in a.
|
|
func (a *Attributes) Get(key Type) Attribute {
|
|
attr, _ := a.Lookup(key)
|
|
return attr
|
|
}
|
|
|
|
// Lookup returns the first Attribute of Type key. nil and false is returned if
|
|
// no Attribute of Type key exists in a.
|
|
func (a *Attributes) Lookup(key Type) (Attribute, bool) {
|
|
for _, attr := range *a {
|
|
if attr.Type == key {
|
|
return attr.Attribute, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
// Set removes all Attributes of Type key and appends value.
|
|
func (a *Attributes) Set(key Type, value Attribute) {
|
|
foundKey := false
|
|
for i := 0; i < len(*a); {
|
|
if (*a)[i].Type == key {
|
|
if foundKey {
|
|
*a = append((*a)[:i], (*a)[i+1:]...)
|
|
} else {
|
|
(*a)[i] = &AVP{
|
|
Type: key,
|
|
Attribute: value,
|
|
}
|
|
foundKey = true
|
|
i++
|
|
}
|
|
} else {
|
|
i++
|
|
}
|
|
}
|
|
if !foundKey {
|
|
a.Add(key, value)
|
|
}
|
|
}
|
|
|
|
func (a Attributes) encodeTo(b []byte) {
|
|
for _, attr := range a {
|
|
if attr.Type < 0 || 255 < attr.Type || len(attr.Attribute) > 253 {
|
|
continue
|
|
}
|
|
size := 1 + 1 + len(attr.Attribute)
|
|
b[0] = byte(attr.Type)
|
|
b[1] = byte(size)
|
|
copy(b[2:], attr.Attribute)
|
|
b = b[size:]
|
|
}
|
|
}
|
|
|
|
// AttributesEncodedLen returns the encoded length of all attributes in a. An error is
|
|
// returned if any attribute in a exceeds the permitted size.
|
|
func AttributesEncodedLen(a Attributes) (int, error) {
|
|
var n int
|
|
for _, attr := range a {
|
|
if attr.Type < 0 || 255 < attr.Type {
|
|
continue
|
|
}
|
|
if len(attr.Attribute) > 253 {
|
|
return 0, errors.New("radius: attribute too large")
|
|
}
|
|
n += 1 + 1 + len(attr.Attribute)
|
|
}
|
|
return n, nil
|
|
}
|