From f6dbf9755b8ffd4da49c12e13c06ec8e6a3ff677 Mon Sep 17 00:00:00 2001 From: Chris Hills Date: Sat, 29 Nov 2025 20:56:05 +0000 Subject: [PATCH] Add vendor files for CableLabs --- vendors/cablelabs/dictionary.cablelabs | 142 + vendors/cablelabs/generate.go | 3 + vendors/cablelabs/generated.go | 5338 ++++++++++++++++++++++++ 3 files changed, 5483 insertions(+) create mode 100644 vendors/cablelabs/dictionary.cablelabs create mode 100644 vendors/cablelabs/generate.go create mode 100644 vendors/cablelabs/generated.go diff --git a/vendors/cablelabs/dictionary.cablelabs b/vendors/cablelabs/dictionary.cablelabs new file mode 100644 index 00000000..c93212ff --- /dev/null +++ b/vendors/cablelabs/dictionary.cablelabs @@ -0,0 +1,142 @@ +VENDOR cablelabs 4491 + +BEGIN-VENDOR cablelabs + +ATTRIBUTE Reserved 0 octets +ATTRIBUTE Event-Message 1 octets +ATTRIBUTE MTA-Endpoint-Name 3 string +ATTRIBUTE Calling-Party-Number 4 string +ATTRIBUTE Called-Party-Number 5 string +ATTRIBUTE Database-ID 6 string +ATTRIBUTE Query-Type 7 integer +ATTRIBUTE Returned-Number 9 string +ATTRIBUTE Call-Termination-Cause 11 octets +ATTRIBUTE Related-Call-Billing-Crl-ID 13 octets +ATTRIBUTE First-Call-Calling-Party-Num 14 string +ATTRIBUTE Second-Call-Calling-Party-Num 15 string +ATTRIBUTE Charge-Number 16 string +ATTRIBUTE Forwarded-Number 17 string +ATTRIBUTE Service-Name 18 string +ATTRIBUTE Intl-Code 20 string +ATTRIBUTE Dial-Around-Code 21 string +ATTRIBUTE Location-Routing-Number 22 string +ATTRIBUTE Carrier-Identification-Code 23 string +ATTRIBUTE Trunk-Group-ID 24 octets +ATTRIBUTE Routing-Number 25 string +ATTRIBUTE MTA-UDP-Portnum 26 integer +ATTRIBUTE Channel-State 29 integer +ATTRIBUTE SF-ID 30 integer +ATTRIBUTE Error-Description 31 string +ATTRIBUTE QoS-Descriptor 32 octets +ATTRIBUTE Direction-indicator 37 integer +ATTRIBUTE Time-Adjustment 38 octets +ATTRIBUTE SDP-Upstream 39 string +ATTRIBUTE SDP-Downstream 40 string +ATTRIBUTE User-Input 41 string +ATTRIBUTE Translation-Input 42 string +ATTRIBUTE Redirected-From-Info 43 octets +ATTRIBUTE Electronic-Surveillance-Ind 44 octets +ATTRIBUTE Redirected-From-Party-Number 45 string +ATTRIBUTE Redirected-To-Party-Number 46 string +ATTRIBUTE El-Surveillance-DF-Security 47 octets +ATTRIBUTE CCC-ID 48 octets +ATTRIBUTE Financial-Entity-ID 49 string +ATTRIBUTE Flow-Direction 50 integer +ATTRIBUTE Signal-Type 51 integer +ATTRIBUTE Alerting-Signal 52 integer +ATTRIBUTE Subject-Audible-Signal 53 integer +ATTRIBUTE Terminal-Display-Info 54 octets +ATTRIBUTE Switch-Hook-Flash 55 string +ATTRIBUTE Dialed-Digits 56 string +ATTRIBUTE Misc-Signaling-Information 57 string +ATTRIBUTE AM-Opaque-Data 61 integer +ATTRIBUTE Subscriber-ID 62 integer +ATTRIBUTE Volume-Usage-Limit 63 integer +ATTRIBUTE Gate-Usage-Info 64 integer +ATTRIBUTE Element-Requesting-QoS 65 integer +ATTRIBUTE QoS-Release-Reason 66 integer +ATTRIBUTE Policy-Denied-Reason 67 integer +ATTRIBUTE Policy-Deleted-Reason 68 integer +ATTRIBUTE Policy-Update-Reason 69 integer +ATTRIBUTE Policy-Decision-Status 70 integer +ATTRIBUTE Application-Manager-ID 71 integer +ATTRIBUTE Time-Usage-Limit 72 integer +ATTRIBUTE Gate-Time-Info 73 integer +ATTRIBUTE Account-Code 80 string +ATTRIBUTE Authorization-Code 81 string + +VALUE Alerting-Signal Reserved-0 0 +VALUE Alerting-Signal Ringing 1 +VALUE Alerting-Signal Distinctive-Ringing-2 2 +VALUE Alerting-Signal Distinctive-Ringing-3 3 +VALUE Alerting-Signal Distinctive-Ringing-4 4 +VALUE Alerting-Signal Ringsplash 5 +VALUE Alerting-Signal Call-Waiting-Tone-1 6 +VALUE Alerting-Signal Call-Waiting-Tone-2 7 +VALUE Alerting-Signal Call-Waiting-Tone-3 8 +VALUE Alerting-Signal Call-Waiting-Tone-4 9 +VALUE Alerting-Signal Reserved-10 10 +VALUE Alerting-Signal Distinctive-Ringing-0 11 +VALUE Alerting-Signal Distinctive-Ringing-1 12 +VALUE Alerting-Signal Distinctive-Ringing-5 13 +VALUE Alerting-Signal Distinctive-Ringing-6 14 +VALUE Alerting-Signal Distinctive-Ringing-7 15 +VALUE AM-Opaque-Data Reserved-0 0 +VALUE AM-Opaque-Data Dial-Tone 1 +VALUE AM-Opaque-Data Stutter-Dial-Tone 2 +VALUE AM-Opaque-Data Ring-Back-Tone 3 +VALUE AM-Opaque-Data Reorder-Tone 4 +VALUE AM-Opaque-Data Busy-Tone 5 +VALUE AM-Opaque-Data Confirmation-Tone 6 +VALUE AM-Opaque-Data Reserved-7 7 +VALUE AM-Opaque-Data Message-Waiting-Indicator 8 +VALUE AM-Opaque-Data Off-hook-Warning-Tone 9 +VALUE Channel-State Reserved 0 +VALUE Channel-State Open 1 +VALUE Channel-State Change 2 +VALUE Channel-State Close 3 +VALUE Direction-indicator Undefined 0 +VALUE Direction-indicator Originating 1 +VALUE Direction-indicator Terminating 2 +VALUE Element-Requesting-QoS Client 0 +VALUE Element-Requesting-QoS Policy-Server 1 +VALUE Element-Requesting-QoS Embedded-Client 2 +VALUE Flow-Direction Reserved 0 +VALUE Flow-Direction Upstream 1 +VALUE Flow-Direction Downstream 2 +VALUE Policy-Denied-Reason Policy-Server-Admission-Control-Failure 1 +VALUE Policy-Denied-Reason Insufficient-Resources 2 +VALUE Policy-Denied-Reason Unknown-Subscriber 3 +VALUE Policy-Denied-Reason Unauthorized-AMID 4 +VALUE Policy-Denied-Reason Undefined-Service-Class-Name 5 +VALUE Policy-Denied-Reason Incompatible-Envelope 6 +VALUE Policy-Denied-Reason Other 127 +VALUE Policy-Deleted-Reason Application-Manager-Request 1 +VALUE Policy-Deleted-Reason CMTS-Decistion 2 +VALUE Policy-Deleted-Reason Other 127 +VALUE Policy-Update-REason Traffic-Profile 1 +VALUE Policy-Update-REason Classifier 2 +VALUE Policy-Update-REason Volume-Limit 3 +VALUE Policy-Update-REason Time-Limit 4 +VALUE Policy-Update-REason Opaque-Data 5 +VALUE Policy-Update-REason Multiple-Updates 6 +VALUE Policy-Update-REason Other 127 +VALUE Policy-Decision-Status Policy-Approved 1 +VALUE Policy-Decision-Status Policy-Denied 2 +VALUE QoS-Release-Reason Gate-Closed-By-PS 1 +VALUE QoS-Release-Reason Inactivity-Resource-Recovery-Timer-Expiration 2 +VALUE QoS-Release-Reason CM-Failure 3 +VALUE QoS-Release-Reason Pre-Empted 4 +VALUE QoS-Release-Reason RSVP-PathTear-request 5 +VALUE QoS-Release-Reason CM-Request 6 +VALUE QoS-Release-Reason Admitted-Timer-Expiration 7 +VALUE QoS-Release-Reason Other 127 +VALUE Query-Type Reserved 0 +VALUE Query-Type Toll-Free-Number-Looukp 1 +VALUE Query-Type LNP-Number-Lookup 2 +VALUE Query-Type Calling-Name-Delivery-Lookup 3 +VALUE Signal-Type Reserved 0 +VALUE Signal-Type Network-Signal 1 +VALUE Signal-Type Subject-Signal 2 + +END-VENDOR cablelabs diff --git a/vendors/cablelabs/generate.go b/vendors/cablelabs/generate.go new file mode 100644 index 00000000..01766b79 --- /dev/null +++ b/vendors/cablelabs/generate.go @@ -0,0 +1,3 @@ +//go:generate go run ../../cmd/radius-dict-gen/main.go -package cablelabs -output generated.go dictionary.cablelabs + +package cablelabs diff --git a/vendors/cablelabs/generated.go b/vendors/cablelabs/generated.go new file mode 100644 index 00000000..f82ac771 --- /dev/null +++ b/vendors/cablelabs/generated.go @@ -0,0 +1,5338 @@ +// Code generated by radius-dict-gen. DO NOT EDIT. + +package cablelabs + +import ( + "strconv" + + "layeh.com/radius" + "layeh.com/radius/rfc2865" +) + +const ( + _Cablelabs_VendorID = 4491 +) + +func _Cablelabs_AddVendor(p *radius.Packet, typ byte, attr radius.Attribute) (err error) { + var vsa radius.Attribute + vendor := make(radius.Attribute, 2+len(attr)) + vendor[0] = typ + vendor[1] = byte(len(vendor)) + copy(vendor[2:], attr) + vsa, err = radius.NewVendorSpecific(_Cablelabs_VendorID, vendor) + if err != nil { + return + } + p.Add(rfc2865.VendorSpecific_Type, vsa) + return +} + +func _Cablelabs_GetsVendor(p *radius.Packet, typ byte) (values []radius.Attribute) { + for _, avp := range p.Attributes { + if avp.Type != rfc2865.VendorSpecific_Type { + continue + } + attr := avp.Attribute + vendorID, vsa, err := radius.VendorSpecific(attr) + if err != nil || vendorID != _Cablelabs_VendorID { + continue + } + for len(vsa) >= 3 { + vsaTyp, vsaLen := vsa[0], vsa[1] + if int(vsaLen) > len(vsa) || vsaLen < 3 { + break + } + if vsaTyp == typ { + values = append(values, vsa[2:int(vsaLen)]) + } + vsa = vsa[int(vsaLen):] + } + } + return +} + +func _Cablelabs_LookupVendor(p *radius.Packet, typ byte) (attr radius.Attribute, ok bool) { + for _, avp := range p.Attributes { + if avp.Type != rfc2865.VendorSpecific_Type { + continue + } + attr := avp.Attribute + vendorID, vsa, err := radius.VendorSpecific(attr) + if err != nil || vendorID != _Cablelabs_VendorID { + continue + } + for len(vsa) >= 3 { + vsaTyp, vsaLen := vsa[0], vsa[1] + if int(vsaLen) > len(vsa) || vsaLen < 3 { + break + } + if vsaTyp == typ { + return vsa[2:int(vsaLen)], true + } + vsa = vsa[int(vsaLen):] + } + } + return +} + +func _Cablelabs_SetVendor(p *radius.Packet, typ byte, attr radius.Attribute) (err error) { + for i := 0; i < len(p.Attributes); { + avp := p.Attributes[i] + if avp.Type != rfc2865.VendorSpecific_Type { + i++ + continue + } + vendorID, vsa, err := radius.VendorSpecific(avp.Attribute) + if err != nil || vendorID != _Cablelabs_VendorID { + i++ + continue + } + for j := 0; len(vsa[j:]) >= 3; { + vsaTyp, vsaLen := vsa[0], vsa[1] + if int(vsaLen) > len(vsa[j:]) || vsaLen < 3 { + i++ + break + } + if vsaTyp == typ { + vsa = append(vsa[:j], vsa[j+int(vsaLen):]...) + } + j += int(vsaLen) + } + if len(vsa) > 0 { + copy(avp.Attribute[4:], vsa) + i++ + } else { + p.Attributes = append(p.Attributes[:i], p.Attributes[i+i:]...) + } + } + return _Cablelabs_AddVendor(p, typ, attr) +} + +func _Cablelabs_DelVendor(p *radius.Packet, typ byte) { +vsaLoop: + for i := 0; i < len(p.Attributes); { + avp := p.Attributes[i] + if avp.Type != rfc2865.VendorSpecific_Type { + i++ + continue + } + vendorID, vsa, err := radius.VendorSpecific(avp.Attribute) + if err != nil || vendorID != _Cablelabs_VendorID { + i++ + continue + } + offset := 0 + for len(vsa[offset:]) >= 3 { + vsaTyp, vsaLen := vsa[offset], vsa[offset+1] + if int(vsaLen) > len(vsa) || vsaLen < 3 { + continue vsaLoop + } + if vsaTyp == typ { + copy(vsa[offset:], vsa[offset+int(vsaLen):]) + vsa = vsa[:len(vsa)-int(vsaLen)] + } else { + offset += int(vsaLen) + } + } + if offset == 0 { + p.Attributes = append(p.Attributes[:i], p.Attributes[i+1:]...) + } else { + i++ + } + } + return +} + +func Reserved_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 0, a) +} + +func Reserved_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 0, a) +} + +func Reserved_Get(p *radius.Packet) (value []byte) { + value, _ = Reserved_Lookup(p) + return +} + +func Reserved_GetString(p *radius.Packet) (value string) { + value, _ = Reserved_LookupString(p) + return +} + +func Reserved_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 0) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func Reserved_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 0) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func Reserved_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 0) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func Reserved_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 0) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func Reserved_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 0, a) +} + +func Reserved_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 0, a) +} + +func Reserved_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 0) +} + +func EventMessage_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 1, a) +} + +func EventMessage_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 1, a) +} + +func EventMessage_Get(p *radius.Packet) (value []byte) { + value, _ = EventMessage_Lookup(p) + return +} + +func EventMessage_GetString(p *radius.Packet) (value string) { + value, _ = EventMessage_LookupString(p) + return +} + +func EventMessage_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 1) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func EventMessage_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 1) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func EventMessage_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func EventMessage_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func EventMessage_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 1, a) +} + +func EventMessage_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 1, a) +} + +func EventMessage_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 1) +} + +func MTAEndpointName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 3, a) +} + +func MTAEndpointName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 3, a) +} + +func MTAEndpointName_Get(p *radius.Packet) (value []byte) { + value, _ = MTAEndpointName_Lookup(p) + return +} + +func MTAEndpointName_GetString(p *radius.Packet) (value string) { + value, _ = MTAEndpointName_LookupString(p) + return +} + +func MTAEndpointName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 3) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MTAEndpointName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 3) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MTAEndpointName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 3) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func MTAEndpointName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 3) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func MTAEndpointName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 3, a) +} + +func MTAEndpointName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 3, a) +} + +func MTAEndpointName_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 3) +} + +func CallingPartyNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 4, a) +} + +func CallingPartyNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 4, a) +} + +func CallingPartyNumber_Get(p *radius.Packet) (value []byte) { + value, _ = CallingPartyNumber_Lookup(p) + return +} + +func CallingPartyNumber_GetString(p *radius.Packet) (value string) { + value, _ = CallingPartyNumber_LookupString(p) + return +} + +func CallingPartyNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 4) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CallingPartyNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 4) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CallingPartyNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CallingPartyNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CallingPartyNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 4, a) +} + +func CallingPartyNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 4, a) +} + +func CallingPartyNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 4) +} + +func CalledPartyNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 5, a) +} + +func CalledPartyNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 5, a) +} + +func CalledPartyNumber_Get(p *radius.Packet) (value []byte) { + value, _ = CalledPartyNumber_Lookup(p) + return +} + +func CalledPartyNumber_GetString(p *radius.Packet) (value string) { + value, _ = CalledPartyNumber_LookupString(p) + return +} + +func CalledPartyNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 5) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CalledPartyNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 5) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CalledPartyNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 5) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CalledPartyNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 5) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CalledPartyNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 5, a) +} + +func CalledPartyNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 5, a) +} + +func CalledPartyNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 5) +} + +func DatabaseID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 6, a) +} + +func DatabaseID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 6, a) +} + +func DatabaseID_Get(p *radius.Packet) (value []byte) { + value, _ = DatabaseID_Lookup(p) + return +} + +func DatabaseID_GetString(p *radius.Packet) (value string) { + value, _ = DatabaseID_LookupString(p) + return +} + +func DatabaseID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 6) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DatabaseID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 6) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DatabaseID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 6) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DatabaseID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 6) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DatabaseID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 6, a) +} + +func DatabaseID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 6, a) +} + +func DatabaseID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 6) +} + +type QueryType uint32 + +const ( + QueryType_Value_Reserved QueryType = 0 + QueryType_Value_TollFreeNumberLooukp QueryType = 1 + QueryType_Value_LNPNumberLookup QueryType = 2 + QueryType_Value_CallingNameDeliveryLookup QueryType = 3 +) + +var QueryType_Strings = map[QueryType]string{ + QueryType_Value_Reserved: "Reserved", + QueryType_Value_TollFreeNumberLooukp: "Toll-Free-Number-Looukp", + QueryType_Value_LNPNumberLookup: "LNP-Number-Lookup", + QueryType_Value_CallingNameDeliveryLookup: "Calling-Name-Delivery-Lookup", +} + +func (a QueryType) String() string { + if str, ok := QueryType_Strings[a]; ok { + return str + } + return "QueryType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QueryType_Add(p *radius.Packet, value QueryType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 7, a) +} + +func QueryType_Get(p *radius.Packet) (value QueryType) { + value, _ = QueryType_Lookup(p) + return +} + +func QueryType_Gets(p *radius.Packet) (values []QueryType, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 7) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QueryType(i)) + } + return +} + +func QueryType_Lookup(p *radius.Packet) (value QueryType, err error) { + a, ok := _Cablelabs_LookupVendor(p, 7) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QueryType(i) + return +} + +func QueryType_Set(p *radius.Packet, value QueryType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 7, a) +} + +func QueryType_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 7) +} + +func ReturnedNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 9, a) +} + +func ReturnedNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 9, a) +} + +func ReturnedNumber_Get(p *radius.Packet) (value []byte) { + value, _ = ReturnedNumber_Lookup(p) + return +} + +func ReturnedNumber_GetString(p *radius.Packet) (value string) { + value, _ = ReturnedNumber_LookupString(p) + return +} + +func ReturnedNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 9) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ReturnedNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 9) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ReturnedNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 9) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ReturnedNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 9) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ReturnedNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 9, a) +} + +func ReturnedNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 9, a) +} + +func ReturnedNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 9) +} + +func CallTerminationCause_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 11, a) +} + +func CallTerminationCause_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 11, a) +} + +func CallTerminationCause_Get(p *radius.Packet) (value []byte) { + value, _ = CallTerminationCause_Lookup(p) + return +} + +func CallTerminationCause_GetString(p *radius.Packet) (value string) { + value, _ = CallTerminationCause_LookupString(p) + return +} + +func CallTerminationCause_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 11) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CallTerminationCause_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 11) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CallTerminationCause_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 11) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CallTerminationCause_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 11) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CallTerminationCause_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 11, a) +} + +func CallTerminationCause_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 11, a) +} + +func CallTerminationCause_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 11) +} + +func RelatedCallBillingCrlID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 13, a) +} + +func RelatedCallBillingCrlID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 13, a) +} + +func RelatedCallBillingCrlID_Get(p *radius.Packet) (value []byte) { + value, _ = RelatedCallBillingCrlID_Lookup(p) + return +} + +func RelatedCallBillingCrlID_GetString(p *radius.Packet) (value string) { + value, _ = RelatedCallBillingCrlID_LookupString(p) + return +} + +func RelatedCallBillingCrlID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 13) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RelatedCallBillingCrlID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 13) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RelatedCallBillingCrlID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 13) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func RelatedCallBillingCrlID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 13) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func RelatedCallBillingCrlID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 13, a) +} + +func RelatedCallBillingCrlID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 13, a) +} + +func RelatedCallBillingCrlID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 13) +} + +func FirstCallCallingPartyNum_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 14, a) +} + +func FirstCallCallingPartyNum_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 14, a) +} + +func FirstCallCallingPartyNum_Get(p *radius.Packet) (value []byte) { + value, _ = FirstCallCallingPartyNum_Lookup(p) + return +} + +func FirstCallCallingPartyNum_GetString(p *radius.Packet) (value string) { + value, _ = FirstCallCallingPartyNum_LookupString(p) + return +} + +func FirstCallCallingPartyNum_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 14) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FirstCallCallingPartyNum_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 14) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FirstCallCallingPartyNum_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 14) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FirstCallCallingPartyNum_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 14) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FirstCallCallingPartyNum_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 14, a) +} + +func FirstCallCallingPartyNum_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 14, a) +} + +func FirstCallCallingPartyNum_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 14) +} + +func SecondCallCallingPartyNum_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 15, a) +} + +func SecondCallCallingPartyNum_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 15, a) +} + +func SecondCallCallingPartyNum_Get(p *radius.Packet) (value []byte) { + value, _ = SecondCallCallingPartyNum_Lookup(p) + return +} + +func SecondCallCallingPartyNum_GetString(p *radius.Packet) (value string) { + value, _ = SecondCallCallingPartyNum_LookupString(p) + return +} + +func SecondCallCallingPartyNum_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 15) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SecondCallCallingPartyNum_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 15) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SecondCallCallingPartyNum_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 15) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func SecondCallCallingPartyNum_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 15) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func SecondCallCallingPartyNum_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 15, a) +} + +func SecondCallCallingPartyNum_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 15, a) +} + +func SecondCallCallingPartyNum_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 15) +} + +func ChargeNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 16, a) +} + +func ChargeNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 16, a) +} + +func ChargeNumber_Get(p *radius.Packet) (value []byte) { + value, _ = ChargeNumber_Lookup(p) + return +} + +func ChargeNumber_GetString(p *radius.Packet) (value string) { + value, _ = ChargeNumber_LookupString(p) + return +} + +func ChargeNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 16) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ChargeNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 16) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ChargeNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 16) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ChargeNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 16) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ChargeNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 16, a) +} + +func ChargeNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 16, a) +} + +func ChargeNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 16) +} + +func ForwardedNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 17, a) +} + +func ForwardedNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 17, a) +} + +func ForwardedNumber_Get(p *radius.Packet) (value []byte) { + value, _ = ForwardedNumber_Lookup(p) + return +} + +func ForwardedNumber_GetString(p *radius.Packet) (value string) { + value, _ = ForwardedNumber_LookupString(p) + return +} + +func ForwardedNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 17) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ForwardedNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 17) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ForwardedNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 17) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ForwardedNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 17) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ForwardedNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 17, a) +} + +func ForwardedNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 17, a) +} + +func ForwardedNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 17) +} + +func ServiceName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 18, a) +} + +func ServiceName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 18, a) +} + +func ServiceName_Get(p *radius.Packet) (value []byte) { + value, _ = ServiceName_Lookup(p) + return +} + +func ServiceName_GetString(p *radius.Packet) (value string) { + value, _ = ServiceName_LookupString(p) + return +} + +func ServiceName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 18) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ServiceName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 18) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ServiceName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 18) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ServiceName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 18) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ServiceName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 18, a) +} + +func ServiceName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 18, a) +} + +func ServiceName_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 18) +} + +func IntlCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 20, a) +} + +func IntlCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 20, a) +} + +func IntlCode_Get(p *radius.Packet) (value []byte) { + value, _ = IntlCode_Lookup(p) + return +} + +func IntlCode_GetString(p *radius.Packet) (value string) { + value, _ = IntlCode_LookupString(p) + return +} + +func IntlCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 20) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IntlCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 20) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IntlCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 20) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func IntlCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 20) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func IntlCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 20, a) +} + +func IntlCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 20, a) +} + +func IntlCode_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 20) +} + +func DialAroundCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 21, a) +} + +func DialAroundCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 21, a) +} + +func DialAroundCode_Get(p *radius.Packet) (value []byte) { + value, _ = DialAroundCode_Lookup(p) + return +} + +func DialAroundCode_GetString(p *radius.Packet) (value string) { + value, _ = DialAroundCode_LookupString(p) + return +} + +func DialAroundCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 21) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DialAroundCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 21) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DialAroundCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 21) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DialAroundCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 21) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DialAroundCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 21, a) +} + +func DialAroundCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 21, a) +} + +func DialAroundCode_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 21) +} + +func LocationRoutingNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 22, a) +} + +func LocationRoutingNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 22, a) +} + +func LocationRoutingNumber_Get(p *radius.Packet) (value []byte) { + value, _ = LocationRoutingNumber_Lookup(p) + return +} + +func LocationRoutingNumber_GetString(p *radius.Packet) (value string) { + value, _ = LocationRoutingNumber_LookupString(p) + return +} + +func LocationRoutingNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 22) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LocationRoutingNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 22) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LocationRoutingNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func LocationRoutingNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func LocationRoutingNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 22, a) +} + +func LocationRoutingNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 22, a) +} + +func LocationRoutingNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 22) +} + +func CarrierIdentificationCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 23, a) +} + +func CarrierIdentificationCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 23, a) +} + +func CarrierIdentificationCode_Get(p *radius.Packet) (value []byte) { + value, _ = CarrierIdentificationCode_Lookup(p) + return +} + +func CarrierIdentificationCode_GetString(p *radius.Packet) (value string) { + value, _ = CarrierIdentificationCode_LookupString(p) + return +} + +func CarrierIdentificationCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 23) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CarrierIdentificationCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 23) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CarrierIdentificationCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 23) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CarrierIdentificationCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 23) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CarrierIdentificationCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 23, a) +} + +func CarrierIdentificationCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 23, a) +} + +func CarrierIdentificationCode_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 23) +} + +func TrunkGroupID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 24, a) +} + +func TrunkGroupID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 24, a) +} + +func TrunkGroupID_Get(p *radius.Packet) (value []byte) { + value, _ = TrunkGroupID_Lookup(p) + return +} + +func TrunkGroupID_GetString(p *radius.Packet) (value string) { + value, _ = TrunkGroupID_LookupString(p) + return +} + +func TrunkGroupID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 24) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TrunkGroupID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 24) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TrunkGroupID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TrunkGroupID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TrunkGroupID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 24, a) +} + +func TrunkGroupID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 24, a) +} + +func TrunkGroupID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 24) +} + +func RoutingNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 25, a) +} + +func RoutingNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 25, a) +} + +func RoutingNumber_Get(p *radius.Packet) (value []byte) { + value, _ = RoutingNumber_Lookup(p) + return +} + +func RoutingNumber_GetString(p *radius.Packet) (value string) { + value, _ = RoutingNumber_LookupString(p) + return +} + +func RoutingNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 25) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RoutingNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 25) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RoutingNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func RoutingNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func RoutingNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 25, a) +} + +func RoutingNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 25, a) +} + +func RoutingNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 25) +} + +type MTAUDPPortnum uint32 + +var MTAUDPPortnum_Strings = map[MTAUDPPortnum]string{} + +func (a MTAUDPPortnum) String() string { + if str, ok := MTAUDPPortnum_Strings[a]; ok { + return str + } + return "MTAUDPPortnum(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func MTAUDPPortnum_Add(p *radius.Packet, value MTAUDPPortnum) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 26, a) +} + +func MTAUDPPortnum_Get(p *radius.Packet) (value MTAUDPPortnum) { + value, _ = MTAUDPPortnum_Lookup(p) + return +} + +func MTAUDPPortnum_Gets(p *radius.Packet) (values []MTAUDPPortnum, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 26) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, MTAUDPPortnum(i)) + } + return +} + +func MTAUDPPortnum_Lookup(p *radius.Packet) (value MTAUDPPortnum, err error) { + a, ok := _Cablelabs_LookupVendor(p, 26) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = MTAUDPPortnum(i) + return +} + +func MTAUDPPortnum_Set(p *radius.Packet, value MTAUDPPortnum) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 26, a) +} + +func MTAUDPPortnum_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 26) +} + +type ChannelState uint32 + +const ( + ChannelState_Value_Reserved ChannelState = 0 + ChannelState_Value_Open ChannelState = 1 + ChannelState_Value_Change ChannelState = 2 + ChannelState_Value_Close ChannelState = 3 +) + +var ChannelState_Strings = map[ChannelState]string{ + ChannelState_Value_Reserved: "Reserved", + ChannelState_Value_Open: "Open", + ChannelState_Value_Change: "Change", + ChannelState_Value_Close: "Close", +} + +func (a ChannelState) String() string { + if str, ok := ChannelState_Strings[a]; ok { + return str + } + return "ChannelState(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ChannelState_Add(p *radius.Packet, value ChannelState) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 29, a) +} + +func ChannelState_Get(p *radius.Packet) (value ChannelState) { + value, _ = ChannelState_Lookup(p) + return +} + +func ChannelState_Gets(p *radius.Packet) (values []ChannelState, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 29) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ChannelState(i)) + } + return +} + +func ChannelState_Lookup(p *radius.Packet) (value ChannelState, err error) { + a, ok := _Cablelabs_LookupVendor(p, 29) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ChannelState(i) + return +} + +func ChannelState_Set(p *radius.Packet, value ChannelState) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 29, a) +} + +func ChannelState_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 29) +} + +type SFID uint32 + +var SFID_Strings = map[SFID]string{} + +func (a SFID) String() string { + if str, ok := SFID_Strings[a]; ok { + return str + } + return "SFID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func SFID_Add(p *radius.Packet, value SFID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 30, a) +} + +func SFID_Get(p *radius.Packet) (value SFID) { + value, _ = SFID_Lookup(p) + return +} + +func SFID_Gets(p *radius.Packet) (values []SFID, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 30) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, SFID(i)) + } + return +} + +func SFID_Lookup(p *radius.Packet) (value SFID, err error) { + a, ok := _Cablelabs_LookupVendor(p, 30) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = SFID(i) + return +} + +func SFID_Set(p *radius.Packet, value SFID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 30, a) +} + +func SFID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 30) +} + +func ErrorDescription_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 31, a) +} + +func ErrorDescription_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 31, a) +} + +func ErrorDescription_Get(p *radius.Packet) (value []byte) { + value, _ = ErrorDescription_Lookup(p) + return +} + +func ErrorDescription_GetString(p *radius.Packet) (value string) { + value, _ = ErrorDescription_LookupString(p) + return +} + +func ErrorDescription_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 31) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ErrorDescription_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 31) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ErrorDescription_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ErrorDescription_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ErrorDescription_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 31, a) +} + +func ErrorDescription_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 31, a) +} + +func ErrorDescription_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 31) +} + +func QoSDescriptor_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 32, a) +} + +func QoSDescriptor_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 32, a) +} + +func QoSDescriptor_Get(p *radius.Packet) (value []byte) { + value, _ = QoSDescriptor_Lookup(p) + return +} + +func QoSDescriptor_GetString(p *radius.Packet) (value string) { + value, _ = QoSDescriptor_LookupString(p) + return +} + +func QoSDescriptor_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 32) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSDescriptor_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 32) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSDescriptor_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QoSDescriptor_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QoSDescriptor_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 32, a) +} + +func QoSDescriptor_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 32, a) +} + +func QoSDescriptor_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 32) +} + +type DirectionIndicator uint32 + +const ( + DirectionIndicator_Value_Undefined DirectionIndicator = 0 + DirectionIndicator_Value_Originating DirectionIndicator = 1 + DirectionIndicator_Value_Terminating DirectionIndicator = 2 +) + +var DirectionIndicator_Strings = map[DirectionIndicator]string{ + DirectionIndicator_Value_Undefined: "Undefined", + DirectionIndicator_Value_Originating: "Originating", + DirectionIndicator_Value_Terminating: "Terminating", +} + +func (a DirectionIndicator) String() string { + if str, ok := DirectionIndicator_Strings[a]; ok { + return str + } + return "DirectionIndicator(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func DirectionIndicator_Add(p *radius.Packet, value DirectionIndicator) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 37, a) +} + +func DirectionIndicator_Get(p *radius.Packet) (value DirectionIndicator) { + value, _ = DirectionIndicator_Lookup(p) + return +} + +func DirectionIndicator_Gets(p *radius.Packet) (values []DirectionIndicator, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 37) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, DirectionIndicator(i)) + } + return +} + +func DirectionIndicator_Lookup(p *radius.Packet) (value DirectionIndicator, err error) { + a, ok := _Cablelabs_LookupVendor(p, 37) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = DirectionIndicator(i) + return +} + +func DirectionIndicator_Set(p *radius.Packet, value DirectionIndicator) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 37, a) +} + +func DirectionIndicator_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 37) +} + +func TimeAdjustment_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 38, a) +} + +func TimeAdjustment_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 38, a) +} + +func TimeAdjustment_Get(p *radius.Packet) (value []byte) { + value, _ = TimeAdjustment_Lookup(p) + return +} + +func TimeAdjustment_GetString(p *radius.Packet) (value string) { + value, _ = TimeAdjustment_LookupString(p) + return +} + +func TimeAdjustment_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 38) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimeAdjustment_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 38) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimeAdjustment_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 38) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TimeAdjustment_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 38) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TimeAdjustment_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 38, a) +} + +func TimeAdjustment_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 38, a) +} + +func TimeAdjustment_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 38) +} + +func SDPUpstream_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 39, a) +} + +func SDPUpstream_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 39, a) +} + +func SDPUpstream_Get(p *radius.Packet) (value []byte) { + value, _ = SDPUpstream_Lookup(p) + return +} + +func SDPUpstream_GetString(p *radius.Packet) (value string) { + value, _ = SDPUpstream_LookupString(p) + return +} + +func SDPUpstream_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 39) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SDPUpstream_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 39) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SDPUpstream_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func SDPUpstream_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func SDPUpstream_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 39, a) +} + +func SDPUpstream_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 39, a) +} + +func SDPUpstream_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 39) +} + +func SDPDownstream_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 40, a) +} + +func SDPDownstream_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 40, a) +} + +func SDPDownstream_Get(p *radius.Packet) (value []byte) { + value, _ = SDPDownstream_Lookup(p) + return +} + +func SDPDownstream_GetString(p *radius.Packet) (value string) { + value, _ = SDPDownstream_LookupString(p) + return +} + +func SDPDownstream_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 40) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SDPDownstream_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 40) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SDPDownstream_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func SDPDownstream_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func SDPDownstream_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 40, a) +} + +func SDPDownstream_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 40, a) +} + +func SDPDownstream_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 40) +} + +func UserInput_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 41, a) +} + +func UserInput_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 41, a) +} + +func UserInput_Get(p *radius.Packet) (value []byte) { + value, _ = UserInput_Lookup(p) + return +} + +func UserInput_GetString(p *radius.Packet) (value string) { + value, _ = UserInput_LookupString(p) + return +} + +func UserInput_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 41) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserInput_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 41) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserInput_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 41) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func UserInput_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 41) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func UserInput_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 41, a) +} + +func UserInput_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 41, a) +} + +func UserInput_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 41) +} + +func TranslationInput_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 42, a) +} + +func TranslationInput_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 42, a) +} + +func TranslationInput_Get(p *radius.Packet) (value []byte) { + value, _ = TranslationInput_Lookup(p) + return +} + +func TranslationInput_GetString(p *radius.Packet) (value string) { + value, _ = TranslationInput_LookupString(p) + return +} + +func TranslationInput_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 42) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TranslationInput_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 42) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TranslationInput_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 42) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TranslationInput_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 42) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TranslationInput_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 42, a) +} + +func TranslationInput_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 42, a) +} + +func TranslationInput_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 42) +} + +func RedirectedFromInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 43, a) +} + +func RedirectedFromInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 43, a) +} + +func RedirectedFromInfo_Get(p *radius.Packet) (value []byte) { + value, _ = RedirectedFromInfo_Lookup(p) + return +} + +func RedirectedFromInfo_GetString(p *radius.Packet) (value string) { + value, _ = RedirectedFromInfo_LookupString(p) + return +} + +func RedirectedFromInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 43) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedFromInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 43) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedFromInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 43) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func RedirectedFromInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 43) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func RedirectedFromInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 43, a) +} + +func RedirectedFromInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 43, a) +} + +func RedirectedFromInfo_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 43) +} + +func ElectronicSurveillanceInd_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 44, a) +} + +func ElectronicSurveillanceInd_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 44, a) +} + +func ElectronicSurveillanceInd_Get(p *radius.Packet) (value []byte) { + value, _ = ElectronicSurveillanceInd_Lookup(p) + return +} + +func ElectronicSurveillanceInd_GetString(p *radius.Packet) (value string) { + value, _ = ElectronicSurveillanceInd_LookupString(p) + return +} + +func ElectronicSurveillanceInd_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 44) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ElectronicSurveillanceInd_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 44) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ElectronicSurveillanceInd_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 44) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ElectronicSurveillanceInd_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 44) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ElectronicSurveillanceInd_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 44, a) +} + +func ElectronicSurveillanceInd_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 44, a) +} + +func ElectronicSurveillanceInd_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 44) +} + +func RedirectedFromPartyNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 45, a) +} + +func RedirectedFromPartyNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 45, a) +} + +func RedirectedFromPartyNumber_Get(p *radius.Packet) (value []byte) { + value, _ = RedirectedFromPartyNumber_Lookup(p) + return +} + +func RedirectedFromPartyNumber_GetString(p *radius.Packet) (value string) { + value, _ = RedirectedFromPartyNumber_LookupString(p) + return +} + +func RedirectedFromPartyNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 45) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedFromPartyNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 45) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedFromPartyNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 45) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func RedirectedFromPartyNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 45) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func RedirectedFromPartyNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 45, a) +} + +func RedirectedFromPartyNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 45, a) +} + +func RedirectedFromPartyNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 45) +} + +func RedirectedToPartyNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 46, a) +} + +func RedirectedToPartyNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 46, a) +} + +func RedirectedToPartyNumber_Get(p *radius.Packet) (value []byte) { + value, _ = RedirectedToPartyNumber_Lookup(p) + return +} + +func RedirectedToPartyNumber_GetString(p *radius.Packet) (value string) { + value, _ = RedirectedToPartyNumber_LookupString(p) + return +} + +func RedirectedToPartyNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 46) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedToPartyNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 46) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func RedirectedToPartyNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 46) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func RedirectedToPartyNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 46) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func RedirectedToPartyNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 46, a) +} + +func RedirectedToPartyNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 46, a) +} + +func RedirectedToPartyNumber_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 46) +} + +func ElSurveillanceDFSecurity_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 47, a) +} + +func ElSurveillanceDFSecurity_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 47, a) +} + +func ElSurveillanceDFSecurity_Get(p *radius.Packet) (value []byte) { + value, _ = ElSurveillanceDFSecurity_Lookup(p) + return +} + +func ElSurveillanceDFSecurity_GetString(p *radius.Packet) (value string) { + value, _ = ElSurveillanceDFSecurity_LookupString(p) + return +} + +func ElSurveillanceDFSecurity_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 47) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ElSurveillanceDFSecurity_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 47) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ElSurveillanceDFSecurity_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 47) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ElSurveillanceDFSecurity_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 47) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ElSurveillanceDFSecurity_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 47, a) +} + +func ElSurveillanceDFSecurity_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 47, a) +} + +func ElSurveillanceDFSecurity_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 47) +} + +func CCCID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 48, a) +} + +func CCCID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 48, a) +} + +func CCCID_Get(p *radius.Packet) (value []byte) { + value, _ = CCCID_Lookup(p) + return +} + +func CCCID_GetString(p *radius.Packet) (value string) { + value, _ = CCCID_LookupString(p) + return +} + +func CCCID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 48) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CCCID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 48) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CCCID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 48) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CCCID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 48) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CCCID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 48, a) +} + +func CCCID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 48, a) +} + +func CCCID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 48) +} + +func FinancialEntityID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 49, a) +} + +func FinancialEntityID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 49, a) +} + +func FinancialEntityID_Get(p *radius.Packet) (value []byte) { + value, _ = FinancialEntityID_Lookup(p) + return +} + +func FinancialEntityID_GetString(p *radius.Packet) (value string) { + value, _ = FinancialEntityID_LookupString(p) + return +} + +func FinancialEntityID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 49) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FinancialEntityID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 49) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FinancialEntityID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 49) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FinancialEntityID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 49) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FinancialEntityID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 49, a) +} + +func FinancialEntityID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 49, a) +} + +func FinancialEntityID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 49) +} + +type FlowDirection uint32 + +const ( + FlowDirection_Value_Reserved FlowDirection = 0 + FlowDirection_Value_Upstream FlowDirection = 1 + FlowDirection_Value_Downstream FlowDirection = 2 +) + +var FlowDirection_Strings = map[FlowDirection]string{ + FlowDirection_Value_Reserved: "Reserved", + FlowDirection_Value_Upstream: "Upstream", + FlowDirection_Value_Downstream: "Downstream", +} + +func (a FlowDirection) String() string { + if str, ok := FlowDirection_Strings[a]; ok { + return str + } + return "FlowDirection(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func FlowDirection_Add(p *radius.Packet, value FlowDirection) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 50, a) +} + +func FlowDirection_Get(p *radius.Packet) (value FlowDirection) { + value, _ = FlowDirection_Lookup(p) + return +} + +func FlowDirection_Gets(p *radius.Packet) (values []FlowDirection, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 50) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, FlowDirection(i)) + } + return +} + +func FlowDirection_Lookup(p *radius.Packet) (value FlowDirection, err error) { + a, ok := _Cablelabs_LookupVendor(p, 50) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = FlowDirection(i) + return +} + +func FlowDirection_Set(p *radius.Packet, value FlowDirection) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 50, a) +} + +func FlowDirection_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 50) +} + +type SignalType uint32 + +const ( + SignalType_Value_Reserved SignalType = 0 + SignalType_Value_NetworkSignal SignalType = 1 + SignalType_Value_SubjectSignal SignalType = 2 +) + +var SignalType_Strings = map[SignalType]string{ + SignalType_Value_Reserved: "Reserved", + SignalType_Value_NetworkSignal: "Network-Signal", + SignalType_Value_SubjectSignal: "Subject-Signal", +} + +func (a SignalType) String() string { + if str, ok := SignalType_Strings[a]; ok { + return str + } + return "SignalType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func SignalType_Add(p *radius.Packet, value SignalType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 51, a) +} + +func SignalType_Get(p *radius.Packet) (value SignalType) { + value, _ = SignalType_Lookup(p) + return +} + +func SignalType_Gets(p *radius.Packet) (values []SignalType, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 51) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, SignalType(i)) + } + return +} + +func SignalType_Lookup(p *radius.Packet) (value SignalType, err error) { + a, ok := _Cablelabs_LookupVendor(p, 51) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = SignalType(i) + return +} + +func SignalType_Set(p *radius.Packet, value SignalType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 51, a) +} + +func SignalType_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 51) +} + +type AlertingSignal uint32 + +const ( + AlertingSignal_Value_Reserved0 AlertingSignal = 0 + AlertingSignal_Value_Ringing AlertingSignal = 1 + AlertingSignal_Value_DistinctiveRinging2 AlertingSignal = 2 + AlertingSignal_Value_DistinctiveRinging3 AlertingSignal = 3 + AlertingSignal_Value_DistinctiveRinging4 AlertingSignal = 4 + AlertingSignal_Value_Ringsplash AlertingSignal = 5 + AlertingSignal_Value_CallWaitingTone1 AlertingSignal = 6 + AlertingSignal_Value_CallWaitingTone2 AlertingSignal = 7 + AlertingSignal_Value_CallWaitingTone3 AlertingSignal = 8 + AlertingSignal_Value_CallWaitingTone4 AlertingSignal = 9 + AlertingSignal_Value_Reserved10 AlertingSignal = 10 + AlertingSignal_Value_DistinctiveRinging0 AlertingSignal = 11 + AlertingSignal_Value_DistinctiveRinging1 AlertingSignal = 12 + AlertingSignal_Value_DistinctiveRinging5 AlertingSignal = 13 + AlertingSignal_Value_DistinctiveRinging6 AlertingSignal = 14 + AlertingSignal_Value_DistinctiveRinging7 AlertingSignal = 15 +) + +var AlertingSignal_Strings = map[AlertingSignal]string{ + AlertingSignal_Value_Reserved0: "Reserved-0", + AlertingSignal_Value_Ringing: "Ringing", + AlertingSignal_Value_DistinctiveRinging2: "Distinctive-Ringing-2", + AlertingSignal_Value_DistinctiveRinging3: "Distinctive-Ringing-3", + AlertingSignal_Value_DistinctiveRinging4: "Distinctive-Ringing-4", + AlertingSignal_Value_Ringsplash: "Ringsplash", + AlertingSignal_Value_CallWaitingTone1: "Call-Waiting-Tone-1", + AlertingSignal_Value_CallWaitingTone2: "Call-Waiting-Tone-2", + AlertingSignal_Value_CallWaitingTone3: "Call-Waiting-Tone-3", + AlertingSignal_Value_CallWaitingTone4: "Call-Waiting-Tone-4", + AlertingSignal_Value_Reserved10: "Reserved-10", + AlertingSignal_Value_DistinctiveRinging0: "Distinctive-Ringing-0", + AlertingSignal_Value_DistinctiveRinging1: "Distinctive-Ringing-1", + AlertingSignal_Value_DistinctiveRinging5: "Distinctive-Ringing-5", + AlertingSignal_Value_DistinctiveRinging6: "Distinctive-Ringing-6", + AlertingSignal_Value_DistinctiveRinging7: "Distinctive-Ringing-7", +} + +func (a AlertingSignal) String() string { + if str, ok := AlertingSignal_Strings[a]; ok { + return str + } + return "AlertingSignal(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlertingSignal_Add(p *radius.Packet, value AlertingSignal) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 52, a) +} + +func AlertingSignal_Get(p *radius.Packet) (value AlertingSignal) { + value, _ = AlertingSignal_Lookup(p) + return +} + +func AlertingSignal_Gets(p *radius.Packet) (values []AlertingSignal, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 52) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlertingSignal(i)) + } + return +} + +func AlertingSignal_Lookup(p *radius.Packet) (value AlertingSignal, err error) { + a, ok := _Cablelabs_LookupVendor(p, 52) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlertingSignal(i) + return +} + +func AlertingSignal_Set(p *radius.Packet, value AlertingSignal) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 52, a) +} + +func AlertingSignal_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 52) +} + +type SubjectAudibleSignal uint32 + +var SubjectAudibleSignal_Strings = map[SubjectAudibleSignal]string{} + +func (a SubjectAudibleSignal) String() string { + if str, ok := SubjectAudibleSignal_Strings[a]; ok { + return str + } + return "SubjectAudibleSignal(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func SubjectAudibleSignal_Add(p *radius.Packet, value SubjectAudibleSignal) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 53, a) +} + +func SubjectAudibleSignal_Get(p *radius.Packet) (value SubjectAudibleSignal) { + value, _ = SubjectAudibleSignal_Lookup(p) + return +} + +func SubjectAudibleSignal_Gets(p *radius.Packet) (values []SubjectAudibleSignal, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 53) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, SubjectAudibleSignal(i)) + } + return +} + +func SubjectAudibleSignal_Lookup(p *radius.Packet) (value SubjectAudibleSignal, err error) { + a, ok := _Cablelabs_LookupVendor(p, 53) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = SubjectAudibleSignal(i) + return +} + +func SubjectAudibleSignal_Set(p *radius.Packet, value SubjectAudibleSignal) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 53, a) +} + +func SubjectAudibleSignal_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 53) +} + +func TerminalDisplayInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 54, a) +} + +func TerminalDisplayInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 54, a) +} + +func TerminalDisplayInfo_Get(p *radius.Packet) (value []byte) { + value, _ = TerminalDisplayInfo_Lookup(p) + return +} + +func TerminalDisplayInfo_GetString(p *radius.Packet) (value string) { + value, _ = TerminalDisplayInfo_LookupString(p) + return +} + +func TerminalDisplayInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 54) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TerminalDisplayInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 54) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TerminalDisplayInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 54) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TerminalDisplayInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 54) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TerminalDisplayInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 54, a) +} + +func TerminalDisplayInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 54, a) +} + +func TerminalDisplayInfo_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 54) +} + +func SwitchHookFlash_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 55, a) +} + +func SwitchHookFlash_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 55, a) +} + +func SwitchHookFlash_Get(p *radius.Packet) (value []byte) { + value, _ = SwitchHookFlash_Lookup(p) + return +} + +func SwitchHookFlash_GetString(p *radius.Packet) (value string) { + value, _ = SwitchHookFlash_LookupString(p) + return +} + +func SwitchHookFlash_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 55) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SwitchHookFlash_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 55) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SwitchHookFlash_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 55) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func SwitchHookFlash_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 55) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func SwitchHookFlash_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 55, a) +} + +func SwitchHookFlash_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 55, a) +} + +func SwitchHookFlash_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 55) +} + +func DialedDigits_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 56, a) +} + +func DialedDigits_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 56, a) +} + +func DialedDigits_Get(p *radius.Packet) (value []byte) { + value, _ = DialedDigits_Lookup(p) + return +} + +func DialedDigits_GetString(p *radius.Packet) (value string) { + value, _ = DialedDigits_LookupString(p) + return +} + +func DialedDigits_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 56) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DialedDigits_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 56) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DialedDigits_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 56) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DialedDigits_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 56) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DialedDigits_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 56, a) +} + +func DialedDigits_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 56, a) +} + +func DialedDigits_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 56) +} + +func MiscSignalingInformation_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 57, a) +} + +func MiscSignalingInformation_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 57, a) +} + +func MiscSignalingInformation_Get(p *radius.Packet) (value []byte) { + value, _ = MiscSignalingInformation_Lookup(p) + return +} + +func MiscSignalingInformation_GetString(p *radius.Packet) (value string) { + value, _ = MiscSignalingInformation_LookupString(p) + return +} + +func MiscSignalingInformation_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 57) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MiscSignalingInformation_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 57) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MiscSignalingInformation_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 57) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func MiscSignalingInformation_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 57) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func MiscSignalingInformation_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 57, a) +} + +func MiscSignalingInformation_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 57, a) +} + +func MiscSignalingInformation_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 57) +} + +type AMOpaqueData uint32 + +const ( + AMOpaqueData_Value_Reserved0 AMOpaqueData = 0 + AMOpaqueData_Value_DialTone AMOpaqueData = 1 + AMOpaqueData_Value_StutterDialTone AMOpaqueData = 2 + AMOpaqueData_Value_RingBackTone AMOpaqueData = 3 + AMOpaqueData_Value_ReorderTone AMOpaqueData = 4 + AMOpaqueData_Value_BusyTone AMOpaqueData = 5 + AMOpaqueData_Value_ConfirmationTone AMOpaqueData = 6 + AMOpaqueData_Value_Reserved7 AMOpaqueData = 7 + AMOpaqueData_Value_MessageWaitingIndicator AMOpaqueData = 8 + AMOpaqueData_Value_OffHookWarningTone AMOpaqueData = 9 +) + +var AMOpaqueData_Strings = map[AMOpaqueData]string{ + AMOpaqueData_Value_Reserved0: "Reserved-0", + AMOpaqueData_Value_DialTone: "Dial-Tone", + AMOpaqueData_Value_StutterDialTone: "Stutter-Dial-Tone", + AMOpaqueData_Value_RingBackTone: "Ring-Back-Tone", + AMOpaqueData_Value_ReorderTone: "Reorder-Tone", + AMOpaqueData_Value_BusyTone: "Busy-Tone", + AMOpaqueData_Value_ConfirmationTone: "Confirmation-Tone", + AMOpaqueData_Value_Reserved7: "Reserved-7", + AMOpaqueData_Value_MessageWaitingIndicator: "Message-Waiting-Indicator", + AMOpaqueData_Value_OffHookWarningTone: "Off-hook-Warning-Tone", +} + +func (a AMOpaqueData) String() string { + if str, ok := AMOpaqueData_Strings[a]; ok { + return str + } + return "AMOpaqueData(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AMOpaqueData_Add(p *radius.Packet, value AMOpaqueData) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 61, a) +} + +func AMOpaqueData_Get(p *radius.Packet) (value AMOpaqueData) { + value, _ = AMOpaqueData_Lookup(p) + return +} + +func AMOpaqueData_Gets(p *radius.Packet) (values []AMOpaqueData, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 61) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AMOpaqueData(i)) + } + return +} + +func AMOpaqueData_Lookup(p *radius.Packet) (value AMOpaqueData, err error) { + a, ok := _Cablelabs_LookupVendor(p, 61) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AMOpaqueData(i) + return +} + +func AMOpaqueData_Set(p *radius.Packet, value AMOpaqueData) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 61, a) +} + +func AMOpaqueData_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 61) +} + +type SubscriberID uint32 + +var SubscriberID_Strings = map[SubscriberID]string{} + +func (a SubscriberID) String() string { + if str, ok := SubscriberID_Strings[a]; ok { + return str + } + return "SubscriberID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func SubscriberID_Add(p *radius.Packet, value SubscriberID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 62, a) +} + +func SubscriberID_Get(p *radius.Packet) (value SubscriberID) { + value, _ = SubscriberID_Lookup(p) + return +} + +func SubscriberID_Gets(p *radius.Packet) (values []SubscriberID, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 62) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, SubscriberID(i)) + } + return +} + +func SubscriberID_Lookup(p *radius.Packet) (value SubscriberID, err error) { + a, ok := _Cablelabs_LookupVendor(p, 62) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = SubscriberID(i) + return +} + +func SubscriberID_Set(p *radius.Packet, value SubscriberID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 62, a) +} + +func SubscriberID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 62) +} + +type VolumeUsageLimit uint32 + +var VolumeUsageLimit_Strings = map[VolumeUsageLimit]string{} + +func (a VolumeUsageLimit) String() string { + if str, ok := VolumeUsageLimit_Strings[a]; ok { + return str + } + return "VolumeUsageLimit(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func VolumeUsageLimit_Add(p *radius.Packet, value VolumeUsageLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 63, a) +} + +func VolumeUsageLimit_Get(p *radius.Packet) (value VolumeUsageLimit) { + value, _ = VolumeUsageLimit_Lookup(p) + return +} + +func VolumeUsageLimit_Gets(p *radius.Packet) (values []VolumeUsageLimit, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 63) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, VolumeUsageLimit(i)) + } + return +} + +func VolumeUsageLimit_Lookup(p *radius.Packet) (value VolumeUsageLimit, err error) { + a, ok := _Cablelabs_LookupVendor(p, 63) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = VolumeUsageLimit(i) + return +} + +func VolumeUsageLimit_Set(p *radius.Packet, value VolumeUsageLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 63, a) +} + +func VolumeUsageLimit_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 63) +} + +type GateUsageInfo uint32 + +var GateUsageInfo_Strings = map[GateUsageInfo]string{} + +func (a GateUsageInfo) String() string { + if str, ok := GateUsageInfo_Strings[a]; ok { + return str + } + return "GateUsageInfo(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func GateUsageInfo_Add(p *radius.Packet, value GateUsageInfo) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 64, a) +} + +func GateUsageInfo_Get(p *radius.Packet) (value GateUsageInfo) { + value, _ = GateUsageInfo_Lookup(p) + return +} + +func GateUsageInfo_Gets(p *radius.Packet) (values []GateUsageInfo, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 64) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, GateUsageInfo(i)) + } + return +} + +func GateUsageInfo_Lookup(p *radius.Packet) (value GateUsageInfo, err error) { + a, ok := _Cablelabs_LookupVendor(p, 64) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = GateUsageInfo(i) + return +} + +func GateUsageInfo_Set(p *radius.Packet, value GateUsageInfo) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 64, a) +} + +func GateUsageInfo_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 64) +} + +type ElementRequestingQoS uint32 + +const ( + ElementRequestingQoS_Value_Client ElementRequestingQoS = 0 + ElementRequestingQoS_Value_PolicyServer ElementRequestingQoS = 1 + ElementRequestingQoS_Value_EmbeddedClient ElementRequestingQoS = 2 +) + +var ElementRequestingQoS_Strings = map[ElementRequestingQoS]string{ + ElementRequestingQoS_Value_Client: "Client", + ElementRequestingQoS_Value_PolicyServer: "Policy-Server", + ElementRequestingQoS_Value_EmbeddedClient: "Embedded-Client", +} + +func (a ElementRequestingQoS) String() string { + if str, ok := ElementRequestingQoS_Strings[a]; ok { + return str + } + return "ElementRequestingQoS(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ElementRequestingQoS_Add(p *radius.Packet, value ElementRequestingQoS) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 65, a) +} + +func ElementRequestingQoS_Get(p *radius.Packet) (value ElementRequestingQoS) { + value, _ = ElementRequestingQoS_Lookup(p) + return +} + +func ElementRequestingQoS_Gets(p *radius.Packet) (values []ElementRequestingQoS, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 65) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ElementRequestingQoS(i)) + } + return +} + +func ElementRequestingQoS_Lookup(p *radius.Packet) (value ElementRequestingQoS, err error) { + a, ok := _Cablelabs_LookupVendor(p, 65) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ElementRequestingQoS(i) + return +} + +func ElementRequestingQoS_Set(p *radius.Packet, value ElementRequestingQoS) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 65, a) +} + +func ElementRequestingQoS_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 65) +} + +type QoSReleaseReason uint32 + +const ( + QoSReleaseReason_Value_GateClosedByPS QoSReleaseReason = 1 + QoSReleaseReason_Value_InactivityResourceRecoveryTimerExpiration QoSReleaseReason = 2 + QoSReleaseReason_Value_CMFailure QoSReleaseReason = 3 + QoSReleaseReason_Value_PreEmpted QoSReleaseReason = 4 + QoSReleaseReason_Value_RSVPPathTearRequest QoSReleaseReason = 5 + QoSReleaseReason_Value_CMRequest QoSReleaseReason = 6 + QoSReleaseReason_Value_AdmittedTimerExpiration QoSReleaseReason = 7 + QoSReleaseReason_Value_Other QoSReleaseReason = 127 +) + +var QoSReleaseReason_Strings = map[QoSReleaseReason]string{ + QoSReleaseReason_Value_GateClosedByPS: "Gate-Closed-By-PS", + QoSReleaseReason_Value_InactivityResourceRecoveryTimerExpiration: "Inactivity-Resource-Recovery-Timer-Expiration", + QoSReleaseReason_Value_CMFailure: "CM-Failure", + QoSReleaseReason_Value_PreEmpted: "Pre-Empted", + QoSReleaseReason_Value_RSVPPathTearRequest: "RSVP-PathTear-request", + QoSReleaseReason_Value_CMRequest: "CM-Request", + QoSReleaseReason_Value_AdmittedTimerExpiration: "Admitted-Timer-Expiration", + QoSReleaseReason_Value_Other: "Other", +} + +func (a QoSReleaseReason) String() string { + if str, ok := QoSReleaseReason_Strings[a]; ok { + return str + } + return "QoSReleaseReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QoSReleaseReason_Add(p *radius.Packet, value QoSReleaseReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 66, a) +} + +func QoSReleaseReason_Get(p *radius.Packet) (value QoSReleaseReason) { + value, _ = QoSReleaseReason_Lookup(p) + return +} + +func QoSReleaseReason_Gets(p *radius.Packet) (values []QoSReleaseReason, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 66) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QoSReleaseReason(i)) + } + return +} + +func QoSReleaseReason_Lookup(p *radius.Packet) (value QoSReleaseReason, err error) { + a, ok := _Cablelabs_LookupVendor(p, 66) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QoSReleaseReason(i) + return +} + +func QoSReleaseReason_Set(p *radius.Packet, value QoSReleaseReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 66, a) +} + +func QoSReleaseReason_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 66) +} + +type PolicyDeniedReason uint32 + +const ( + PolicyDeniedReason_Value_PolicyServerAdmissionControlFailure PolicyDeniedReason = 1 + PolicyDeniedReason_Value_InsufficientResources PolicyDeniedReason = 2 + PolicyDeniedReason_Value_UnknownSubscriber PolicyDeniedReason = 3 + PolicyDeniedReason_Value_UnauthorizedAMID PolicyDeniedReason = 4 + PolicyDeniedReason_Value_UndefinedServiceClassName PolicyDeniedReason = 5 + PolicyDeniedReason_Value_IncompatibleEnvelope PolicyDeniedReason = 6 + PolicyDeniedReason_Value_Other PolicyDeniedReason = 127 +) + +var PolicyDeniedReason_Strings = map[PolicyDeniedReason]string{ + PolicyDeniedReason_Value_PolicyServerAdmissionControlFailure: "Policy-Server-Admission-Control-Failure", + PolicyDeniedReason_Value_InsufficientResources: "Insufficient-Resources", + PolicyDeniedReason_Value_UnknownSubscriber: "Unknown-Subscriber", + PolicyDeniedReason_Value_UnauthorizedAMID: "Unauthorized-AMID", + PolicyDeniedReason_Value_UndefinedServiceClassName: "Undefined-Service-Class-Name", + PolicyDeniedReason_Value_IncompatibleEnvelope: "Incompatible-Envelope", + PolicyDeniedReason_Value_Other: "Other", +} + +func (a PolicyDeniedReason) String() string { + if str, ok := PolicyDeniedReason_Strings[a]; ok { + return str + } + return "PolicyDeniedReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PolicyDeniedReason_Add(p *radius.Packet, value PolicyDeniedReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 67, a) +} + +func PolicyDeniedReason_Get(p *radius.Packet) (value PolicyDeniedReason) { + value, _ = PolicyDeniedReason_Lookup(p) + return +} + +func PolicyDeniedReason_Gets(p *radius.Packet) (values []PolicyDeniedReason, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 67) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PolicyDeniedReason(i)) + } + return +} + +func PolicyDeniedReason_Lookup(p *radius.Packet) (value PolicyDeniedReason, err error) { + a, ok := _Cablelabs_LookupVendor(p, 67) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PolicyDeniedReason(i) + return +} + +func PolicyDeniedReason_Set(p *radius.Packet, value PolicyDeniedReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 67, a) +} + +func PolicyDeniedReason_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 67) +} + +type PolicyDeletedReason uint32 + +const ( + PolicyDeletedReason_Value_ApplicationManagerRequest PolicyDeletedReason = 1 + PolicyDeletedReason_Value_CMTSDecistion PolicyDeletedReason = 2 + PolicyDeletedReason_Value_Other PolicyDeletedReason = 127 +) + +var PolicyDeletedReason_Strings = map[PolicyDeletedReason]string{ + PolicyDeletedReason_Value_ApplicationManagerRequest: "Application-Manager-Request", + PolicyDeletedReason_Value_CMTSDecistion: "CMTS-Decistion", + PolicyDeletedReason_Value_Other: "Other", +} + +func (a PolicyDeletedReason) String() string { + if str, ok := PolicyDeletedReason_Strings[a]; ok { + return str + } + return "PolicyDeletedReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PolicyDeletedReason_Add(p *radius.Packet, value PolicyDeletedReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 68, a) +} + +func PolicyDeletedReason_Get(p *radius.Packet) (value PolicyDeletedReason) { + value, _ = PolicyDeletedReason_Lookup(p) + return +} + +func PolicyDeletedReason_Gets(p *radius.Packet) (values []PolicyDeletedReason, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 68) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PolicyDeletedReason(i)) + } + return +} + +func PolicyDeletedReason_Lookup(p *radius.Packet) (value PolicyDeletedReason, err error) { + a, ok := _Cablelabs_LookupVendor(p, 68) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PolicyDeletedReason(i) + return +} + +func PolicyDeletedReason_Set(p *radius.Packet, value PolicyDeletedReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 68, a) +} + +func PolicyDeletedReason_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 68) +} + +type PolicyUpdateReason uint32 + +var PolicyUpdateReason_Strings = map[PolicyUpdateReason]string{} + +func (a PolicyUpdateReason) String() string { + if str, ok := PolicyUpdateReason_Strings[a]; ok { + return str + } + return "PolicyUpdateReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PolicyUpdateReason_Add(p *radius.Packet, value PolicyUpdateReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 69, a) +} + +func PolicyUpdateReason_Get(p *radius.Packet) (value PolicyUpdateReason) { + value, _ = PolicyUpdateReason_Lookup(p) + return +} + +func PolicyUpdateReason_Gets(p *radius.Packet) (values []PolicyUpdateReason, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 69) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PolicyUpdateReason(i)) + } + return +} + +func PolicyUpdateReason_Lookup(p *radius.Packet) (value PolicyUpdateReason, err error) { + a, ok := _Cablelabs_LookupVendor(p, 69) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PolicyUpdateReason(i) + return +} + +func PolicyUpdateReason_Set(p *radius.Packet, value PolicyUpdateReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 69, a) +} + +func PolicyUpdateReason_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 69) +} + +type PolicyDecisionStatus uint32 + +const ( + PolicyDecisionStatus_Value_PolicyApproved PolicyDecisionStatus = 1 + PolicyDecisionStatus_Value_PolicyDenied PolicyDecisionStatus = 2 +) + +var PolicyDecisionStatus_Strings = map[PolicyDecisionStatus]string{ + PolicyDecisionStatus_Value_PolicyApproved: "Policy-Approved", + PolicyDecisionStatus_Value_PolicyDenied: "Policy-Denied", +} + +func (a PolicyDecisionStatus) String() string { + if str, ok := PolicyDecisionStatus_Strings[a]; ok { + return str + } + return "PolicyDecisionStatus(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PolicyDecisionStatus_Add(p *radius.Packet, value PolicyDecisionStatus) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 70, a) +} + +func PolicyDecisionStatus_Get(p *radius.Packet) (value PolicyDecisionStatus) { + value, _ = PolicyDecisionStatus_Lookup(p) + return +} + +func PolicyDecisionStatus_Gets(p *radius.Packet) (values []PolicyDecisionStatus, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 70) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PolicyDecisionStatus(i)) + } + return +} + +func PolicyDecisionStatus_Lookup(p *radius.Packet) (value PolicyDecisionStatus, err error) { + a, ok := _Cablelabs_LookupVendor(p, 70) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PolicyDecisionStatus(i) + return +} + +func PolicyDecisionStatus_Set(p *radius.Packet, value PolicyDecisionStatus) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 70, a) +} + +func PolicyDecisionStatus_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 70) +} + +type ApplicationManagerID uint32 + +var ApplicationManagerID_Strings = map[ApplicationManagerID]string{} + +func (a ApplicationManagerID) String() string { + if str, ok := ApplicationManagerID_Strings[a]; ok { + return str + } + return "ApplicationManagerID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ApplicationManagerID_Add(p *radius.Packet, value ApplicationManagerID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 71, a) +} + +func ApplicationManagerID_Get(p *radius.Packet) (value ApplicationManagerID) { + value, _ = ApplicationManagerID_Lookup(p) + return +} + +func ApplicationManagerID_Gets(p *radius.Packet) (values []ApplicationManagerID, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 71) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ApplicationManagerID(i)) + } + return +} + +func ApplicationManagerID_Lookup(p *radius.Packet) (value ApplicationManagerID, err error) { + a, ok := _Cablelabs_LookupVendor(p, 71) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ApplicationManagerID(i) + return +} + +func ApplicationManagerID_Set(p *radius.Packet, value ApplicationManagerID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 71, a) +} + +func ApplicationManagerID_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 71) +} + +type TimeUsageLimit uint32 + +var TimeUsageLimit_Strings = map[TimeUsageLimit]string{} + +func (a TimeUsageLimit) String() string { + if str, ok := TimeUsageLimit_Strings[a]; ok { + return str + } + return "TimeUsageLimit(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TimeUsageLimit_Add(p *radius.Packet, value TimeUsageLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 72, a) +} + +func TimeUsageLimit_Get(p *radius.Packet) (value TimeUsageLimit) { + value, _ = TimeUsageLimit_Lookup(p) + return +} + +func TimeUsageLimit_Gets(p *radius.Packet) (values []TimeUsageLimit, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 72) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TimeUsageLimit(i)) + } + return +} + +func TimeUsageLimit_Lookup(p *radius.Packet) (value TimeUsageLimit, err error) { + a, ok := _Cablelabs_LookupVendor(p, 72) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TimeUsageLimit(i) + return +} + +func TimeUsageLimit_Set(p *radius.Packet, value TimeUsageLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 72, a) +} + +func TimeUsageLimit_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 72) +} + +type GateTimeInfo uint32 + +var GateTimeInfo_Strings = map[GateTimeInfo]string{} + +func (a GateTimeInfo) String() string { + if str, ok := GateTimeInfo_Strings[a]; ok { + return str + } + return "GateTimeInfo(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func GateTimeInfo_Add(p *radius.Packet, value GateTimeInfo) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_AddVendor(p, 73, a) +} + +func GateTimeInfo_Get(p *radius.Packet) (value GateTimeInfo) { + value, _ = GateTimeInfo_Lookup(p) + return +} + +func GateTimeInfo_Gets(p *radius.Packet) (values []GateTimeInfo, err error) { + var i uint32 + for _, attr := range _Cablelabs_GetsVendor(p, 73) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, GateTimeInfo(i)) + } + return +} + +func GateTimeInfo_Lookup(p *radius.Packet) (value GateTimeInfo, err error) { + a, ok := _Cablelabs_LookupVendor(p, 73) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = GateTimeInfo(i) + return +} + +func GateTimeInfo_Set(p *radius.Packet, value GateTimeInfo) (err error) { + a := radius.NewInteger(uint32(value)) + return _Cablelabs_SetVendor(p, 73, a) +} + +func GateTimeInfo_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 73) +} + +func AccountCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 80, a) +} + +func AccountCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 80, a) +} + +func AccountCode_Get(p *radius.Packet) (value []byte) { + value, _ = AccountCode_Lookup(p) + return +} + +func AccountCode_GetString(p *radius.Packet) (value string) { + value, _ = AccountCode_LookupString(p) + return +} + +func AccountCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 80) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccountCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 80) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccountCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 80) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AccountCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 80) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AccountCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 80, a) +} + +func AccountCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 80, a) +} + +func AccountCode_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 80) +} + +func AuthorizationCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 81, a) +} + +func AuthorizationCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_AddVendor(p, 81, a) +} + +func AuthorizationCode_Get(p *radius.Packet) (value []byte) { + value, _ = AuthorizationCode_Lookup(p) + return +} + +func AuthorizationCode_GetString(p *radius.Packet) (value string) { + value, _ = AuthorizationCode_LookupString(p) + return +} + +func AuthorizationCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Cablelabs_GetsVendor(p, 81) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AuthorizationCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Cablelabs_GetsVendor(p, 81) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AuthorizationCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Cablelabs_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AuthorizationCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Cablelabs_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AuthorizationCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 81, a) +} + +func AuthorizationCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Cablelabs_SetVendor(p, 81, a) +} + +func AuthorizationCode_Del(p *radius.Packet) { + _Cablelabs_DelVendor(p, 81) +}