From 327f4627006ea1216d3d8a61b1cf6479a0c10789 Mon Sep 17 00:00:00 2001 From: Chris Hills Date: Tue, 25 Nov 2025 15:24:12 +0000 Subject: [PATCH] Add vendor files for Alcatel SR --- vendors/alcatelsr/dictionary.alcatelsr | 246 + vendors/alcatelsr/generate.go | 3 + vendors/alcatelsr/generated.go | 15308 +++++++++++++++++++++++ 3 files changed, 15557 insertions(+) create mode 100644 vendors/alcatelsr/dictionary.alcatelsr create mode 100644 vendors/alcatelsr/generate.go create mode 100644 vendors/alcatelsr/generated.go diff --git a/vendors/alcatelsr/dictionary.alcatelsr b/vendors/alcatelsr/dictionary.alcatelsr new file mode 100644 index 0000000..724b9b0 --- /dev/null +++ b/vendors/alcatelsr/dictionary.alcatelsr @@ -0,0 +1,246 @@ +VENDOR Alcatel-Lucent-Service-Router 6527 + +BEGIN-VENDOR Alcatel-Lucent-Service-Router + +ATTRIBUTE Timetra-Access 1 integer +ATTRIBUTE Timetra-Home-Directory 2 string +ATTRIBUTE Timetra-Restrict-To-Home 3 integer +ATTRIBUTE Timetra-Profile 4 string +ATTRIBUTE Timetra-Default-Action 5 integer +ATTRIBUTE Timetra-Cmd 6 string +ATTRIBUTE Timetra-Action 7 integer +ATTRIBUTE Timetra-Exec-File 8 string +ATTRIBUTE Alc-Primary-Dns 9 ipaddr +ATTRIBUTE Alc-Secondary-Dns 10 ipaddr +ATTRIBUTE Alc-Subsc-ID-Str 11 string +ATTRIBUTE Alc-Subsc-Prof-Str 12 string +ATTRIBUTE Alc-SLA-Prof-Str 13 string +ATTRIBUTE Alc-Force-Renew 14 string +ATTRIBUTE Alc-Create-Host 15 string +ATTRIBUTE Alc-ANCP-Str 16 string +ATTRIBUTE Alc-Retail-Serv-Id 17 integer +ATTRIBUTE Alc-Default-Router 18 ipaddr +ATTRIBUTE Alc-Acct-I-Inprof-Octets-64 19 octets +ATTRIBUTE Alc-Acct-I-Outprof-Octets-64 20 octets +ATTRIBUTE Alc-Acct-O-Inprof-Octets-64 21 octets +ATTRIBUTE Alc-Acct-O-Outprof-Octets-64 22 octets +ATTRIBUTE Alc-Acct-I-Inprof-Pkts-64 23 octets +ATTRIBUTE Alc-Acct-I-Outprof-Pkts-64 24 octets +ATTRIBUTE Alc-Acct-O-Inprof-Pkts-64 25 octets +ATTRIBUTE Alc-Acct-O-Outprof-Pkts-64 26 octets +ATTRIBUTE Alc-Client-Hardware-Addr 27 string +ATTRIBUTE Alc-Int-Dest-Id-Str 28 string +ATTRIBUTE Alc-Primary-Nbns 29 ipaddr +ATTRIBUTE Alc-Secondary-Nbns 30 ipaddr +ATTRIBUTE Alc-MSAP-Serv-Id 31 integer +ATTRIBUTE Alc-MSAP-Policy 32 string +ATTRIBUTE Alc-MSAP-Interface 33 string +ATTRIBUTE Alc-PPPoE-PADO-Delay 34 integer +ATTRIBUTE Alc-PPPoE-Service-Name 35 string +ATTRIBUTE Alc-DHCP-Vendor-Class-Id 36 string +ATTRIBUTE Alc-Acct-OC-I-Inprof-Octets-64 37 octets +ATTRIBUTE Alc-Acct-OC-I-Outprof-Octets-64 38 octets +ATTRIBUTE Alc-Acct-OC-O-Inprof-Octets-64 39 octets +ATTRIBUTE Alc-Acct-OC-O-Outprof-Octets-64 40 octets +ATTRIBUTE Alc-Acct-OC-I-Inprof-Pkts-64 41 octets +ATTRIBUTE Alc-Acct-OC-I-Outprof-Pkts-64 42 octets +ATTRIBUTE Alc-Acct-OC-O-Inprof-Pkts-64 43 octets +ATTRIBUTE Alc-Acct-OC-O-Outprof-Pkts-64 44 octets +ATTRIBUTE Alc-App-Prof-Str 45 string +ATTRIBUTE Alc-Tunnel-Group 46 string +ATTRIBUTE Alc-Tunnel-Algorithm 47 integer +ATTRIBUTE Alc-Tunnel-Max-Sessions 48 integer has_tag +ATTRIBUTE Alc-Tunnel-Idle-Timeout 49 integer has_tag +ATTRIBUTE Alc-Tunnel-Hello-Interval 50 integer has_tag +ATTRIBUTE Alc-Tunnel-Destruct-Timeout 51 integer has_tag +ATTRIBUTE Alc-Tunnel-Max-Retries-Estab 52 integer has_tag +ATTRIBUTE Alc-Tunnel-Max-Retries-Not-Estab 53 integer has_tag +ATTRIBUTE Alc-Tunnel-AVP-Hiding 54 integer has_tag +ATTRIBUTE Alc-BGP-Policy 55 string +ATTRIBUTE Alc-BGP-Auth-Keychain 56 string +ATTRIBUTE Alc-BGP-Auth-Key 57 octets +ATTRIBUTE Alc-BGP-Export-Policy 58 string +ATTRIBUTE Alc-BGP-Import-Policy 59 string +ATTRIBUTE Alc-BGP-PeerAS 60 integer +ATTRIBUTE Alc-IPsec-Serv-Id 61 integer +ATTRIBUTE Alc-IPsec-Interface 62 string +ATTRIBUTE Alc-IPsec-Tunnel-Template-Id 63 integer +ATTRIBUTE Alc-IPsec-SA-Lifetime 64 integer +ATTRIBUTE Alc-IPsec-SA-PFS-Group 65 integer +ATTRIBUTE Alc-IPsec-SA-Encr-Algorithm 66 integer +ATTRIBUTE Alc-IPsec-SA-Auth-Algorithm 67 integer +ATTRIBUTE Alc-IPsec-SA-Replay-Window 68 integer +ATTRIBUTE Alc-Acct-I-High-Octets-Drop_64 69 octets +ATTRIBUTE Alc-Acct-I-Low-Octets-Drop_64 70 octets +ATTRIBUTE Alc-Acct-I-High-Pack-Drop_64 71 octets +ATTRIBUTE Alc-Acct-I-Low-Pack-Drop_64 72 octets +ATTRIBUTE Alc-Acct-I-High-Octets-Offer_64 73 octets +ATTRIBUTE Alc-Acct-I-Low-Octets-Offer_64 74 octets +ATTRIBUTE Alc-Acct-I-High-Pack-Offer_64 75 octets +ATTRIBUTE Alc-Acct-I-Low-Pack-Offer_64 76 octets +ATTRIBUTE Alc-Acct-I-Unc-Octets-Offer_64 77 octets +ATTRIBUTE Alc-Acct-I-Unc-Pack-Offer_64 78 octets +ATTRIBUTE Alc-Acct-I-All-Octets-Offer_64 79 octets +ATTRIBUTE Alc-Acct-I-All-Pack-Offer_64 80 octets +ATTRIBUTE Alc-Acct-O-Inprof-Pack-Drop_64 81 octets +ATTRIBUTE Alc-Acct-O-Outprof-Pack-Drop_64 82 octets +ATTRIBUTE Alc-Acct-O-Inprof-Octs-Drop_64 83 octets +ATTRIBUTE Alc-Acct-O-Outprof-Octs-Drop_64 84 octets +ATTRIBUTE Alc-Acct-OC-I-All-Octs-Offer_64 85 octets +ATTRIBUTE Alc-Acct-OC-I-All-Pack-Offer_64 86 octets +ATTRIBUTE Alc-Acct-OC-I-Inpr-Octs-Drop_64 87 octets +ATTRIBUTE Alc-Acct-OC-I-Outpr-Octs-Drop_64 88 octets +ATTRIBUTE Alc-Acct-OC-I-Inpr-Pack-Drop_64 89 octets +ATTRIBUTE Alc-Acct-OC-I-Outpr-Pack-Drop_64 90 octets +ATTRIBUTE Alc-Acct-OC-O-Inpr-Pack-Drop_64 91 octets +ATTRIBUTE Alc-Acct-OC-O-Outpr-Pack-Drop_64 92 octets +ATTRIBUTE Alc-Acct-OC-O-Inpr-Octs-Drop_64 93 octets +ATTRIBUTE Alc-Acct-OC-O-Outpr-Octs-Drop_64 94 octets +ATTRIBUTE Alc-Credit-Control-CategoryMap 95 string +ATTRIBUTE Alc-Credit-Control-Quota 96 string +ATTRIBUTE Alc-Tunnel-Challenge 97 integer has_tag +ATTRIBUTE Alc-Force-Nak 98 string +ATTRIBUTE Alc-Ipv6-Address 99 ipv6addr +ATTRIBUTE Alc-Serv-Id 100 integer +ATTRIBUTE Alc-Interface 101 string +ATTRIBUTE Alc-ToServer-Dhcp-Options 102 octets +ATTRIBUTE Alc-ToClient-Dhcp-Options 103 octets +ATTRIBUTE Alc-Tunnel-Serv-Id 104 integer +ATTRIBUTE Alc-Ipv6-Primary-Dns 105 ipv6addr +ATTRIBUTE Alc-Ipv6-Secondary-Dns 106 ipv6addr +ATTRIBUTE Alc-Acct-I-statmode 107 string +ATTRIBUTE Alc-Acct-I-Hiprio-Octets_64 108 octets +ATTRIBUTE Alc-Acct-I-Lowprio-Octets_64 109 octets +ATTRIBUTE Alc-Acct-O-Hiprio-Octets_64 110 octets +ATTRIBUTE Alc-Acct-O-Lowprio-Octets_64 111 octets +ATTRIBUTE Alc-Acct-I-Hiprio-Packets_64 112 octets +ATTRIBUTE Alc-Acct-I-Lowprio-Packets_64 113 octets +ATTRIBUTE Alc-Acct-O-Hiprio-Packets_64 114 octets +ATTRIBUTE Alc-Acct-O-Lowprio-Packets_64 115 octets +ATTRIBUTE Alc-Acct-I-All-Octets_64 116 octets +ATTRIBUTE Alc-Acct-O-All-Octets_64 117 octets +ATTRIBUTE Alc-Acct-I-All-Packets_64 118 octets +ATTRIBUTE Alc-Acct-O-All-Packets_64 119 octets +ATTRIBUTE Alc-Tunnel-Rx-Window-Size 120 integer has_tag +ATTRIBUTE Alc-Nat-Port-Range 121 string +ATTRIBUTE Alc-LI-Action 122 integer encrypt=2 +ATTRIBUTE Alc-LI-Destination 123 string encrypt=2 +ATTRIBUTE Alc-LI-FC 124 integer encrypt=2 +ATTRIBUTE Alc-LI-Direction 125 integer encrypt=2 +ATTRIBUTE Alc-Subscriber-QoS-Override 126 string +ATTRIBUTE Alc-Acct-O-statmode 127 string +ATTRIBUTE Alc-ATM-Ingress-TD-Profile 128 integer +ATTRIBUTE Alc-ATM-Egress-TD-Profile 129 integer +ATTRIBUTE Alc-AA-Transit-IP 130 integer +ATTRIBUTE Alc-Delegated-IPv6-Pool 131 string +ATTRIBUTE Alc-Access-Loop-Rate-Down 132 integer +ATTRIBUTE Alc-Access-Loop-Encap-Offset 133 octets +ATTRIBUTE Alc-Subscriber-Filter 134 string +ATTRIBUTE Alc-PPP-Force-IPv6CP 135 integer +ATTRIBUTE Alc-Onetime-Http-Redirection-Filter-Id 136 string +ATTRIBUTE Alc-Authentication-Policy-Name 137 string +ATTRIBUTE Alc-LI-Intercept-Id 138 integer encrypt=2 +ATTRIBUTE Alc-LI-Session-Id 139 integer encrypt=2 +ATTRIBUTE Alc-Nat-Outside-Serv-Id 140 integer +ATTRIBUTE Alc-Nat-Outside-Ip-Addr 141 ipaddr +ATTRIBUTE Alc-APN-Password 142 string encrypt=2 +ATTRIBUTE Alc-APN-Name 143 string +ATTRIBUTE Alc-Tunnel-Acct-Policy 144 string has_tag +ATTRIBUTE Alc-Mgw-Interface-Type 145 integer +ATTRIBUTE Alc-Wlan-APN-Name 146 string +ATTRIBUTE Alc-MsIsdn 147 string +ATTRIBUTE Alc-RSSI 148 integer +ATTRIBUTE Alc-Num-Attached-UEs 149 integer +ATTRIBUTE Alc-Charging-Prof-ID 150 integer +ATTRIBUTE Alc-AA-Group-Partition-Isa-Id 156 string +ATTRIBUTE Alc-AA-Peer-Identifier 157 string +ATTRIBUTE Alc-Nas-Filter-Rule-Shared 158 string +ATTRIBUTE Alc-Ascend-Data-Filter-Host-Spec 159 octets +ATTRIBUTE Alc-Relative-Session-Timeout 160 integer +ATTRIBUTE Alc-Acct-Triggered-Reason 163 integer +ATTRIBUTE Alc-Wlan-Portal-Redirect 172 string +ATTRIBUTE Alc-Wlan-Portal-Url 173 string +ATTRIBUTE Alc-Lease-Time 174 integer +ATTRIBUTE Alc-DSL-Line-State 175 integer +ATTRIBUTE Alc-DSL-Type 176 integer +ATTRIBUTE Alc-Portal-Url 177 string +ATTRIBUTE Alc-Ipv6-Portal-Url 178 string +ATTRIBUTE Alc-SAP-Session-Index 180 integer +ATTRIBUTE Alc-SLAAC-IPv6-Pool 181 string +ATTRIBUTE Alc-WPP-ErrorCode 183 integer +ATTRIBUTE Alc-Onetime-Http-Redirect-Reactivate 185 string +ATTRIBUTE Alc-ToServer-Dhcp6-Options 191 octets +ATTRIBUTE Alc-ToClient-Dhcp6-Options 192 octets +ATTRIBUTE Alc-v6-Preferred-Lifetime 200 integer +ATTRIBUTE Alc-v6-Valid-Lifetime 201 integer +ATTRIBUTE Alc-Dhcp6-Renew-Time 202 integer +ATTRIBUTE Alc-Dhcp6-Rebind-Time 203 integer +ATTRIBUTE Alc-Wlan-SSID-VLAN 206 string +ATTRIBUTE Alc-UPnP-Sub-Override-Policy 217 string +ATTRIBUTE Alc-Trigger-Acct-Interim 228 string +ATTRIBUTE Alc-Acct-Interim-Level 232 integer has_tag +ATTRIBUTE Alc-DNAT-Override 234 string +ATTRIBUTE Alc-Remove-Override 238 string +ATTRIBUTE Alc-Radius-Py 242 octets +ATTRIBUTE Alc-Force-DHCP-Relay 244 string + +VALUE Alc-AA-Transit-IP host 1 +VALUE Alc-AA-Transit-IP audit-start 2 +VALUE Alc-AA-Transit-IP audit-end 3 +VALUE Alc-Acct-Triggered-Reason Framed-IP-Address-up 4 +VALUE Alc-Acct-Triggered-Reason Framed-IP-Address-down 5 +VALUE Alc-Acct-Triggered-Reason Alc-Ipv6-Address-up 6 +VALUE Alc-Acct-Triggered-Reason Alc-Ipv6-Address-down 7 +VALUE Alc-Acct-Triggered-Reason Delegated-IPv6-Prefix-up 8 +VALUE Alc-Acct-Triggered-Reason Delegated-IPv6-Prefix-down 9 +VALUE Alc-Acct-Triggered-Reason Framed-IPv6-Prefix-up 10 +VALUE Alc-Acct-Triggered-Reason Framed-IPv6-Prefix-down 11 +VALUE Alc-Acct-Triggered-Reason regular 1 +VALUE Alc-Acct-Triggered-Reason sla-start 2 +VALUE Alc-Acct-Triggered-Reason sla-stop 3 +VALUE Alc-IPsec-SA-Auth-Algorithm null 1 +VALUE Alc-IPsec-SA-Auth-Algorithm md5 2 +VALUE Alc-IPsec-SA-Auth-Algorithm sha1 3 +VALUE Alc-IPsec-SA-Encr-Algorithm null 1 +VALUE Alc-IPsec-SA-Encr-Algorithm des 2 +VALUE Alc-IPsec-SA-Encr-Algorithm des3 3 +VALUE Alc-IPsec-SA-Encr-Algorithm aes128 4 +VALUE Alc-IPsec-SA-Encr-Algorithm aes192 5 +VALUE Alc-IPsec-SA-Encr-Algorithm aes256 6 +VALUE Alc-IPsec-SA-PFS-Group group1 1 +VALUE Alc-IPsec-SA-PFS-Group group2 2 +VALUE Alc-IPsec-SA-PFS-Group group5 5 +VALUE Alc-LI-Action no-action 1 +VALUE Alc-LI-Action enable 2 +VALUE Alc-LI-Action disable 3 +VALUE Alc-LI-Direction ingress 1 +VALUE Alc-LI-Direction egress 2 +VALUE Alc-LI-FC be 0 +VALUE Alc-LI-FC l2 1 +VALUE Alc-LI-FC af 2 +VALUE Alc-LI-FC l1 3 +VALUE Alc-LI-FC h2 4 +VALUE Alc-LI-FC ef 5 +VALUE Alc-LI-FC h1 6 +VALUE Alc-LI-FC nc 7 +VALUE Alc-Mgw-Interface-Type gn 1 +VALUE Alc-Mgw-Interface-Type s2a 2 +VALUE Alc-Mgw-Interface-Type s2b 3 +VALUE Alc-Tunnel-AVP-Hiding nothing 1 +VALUE Alc-Tunnel-AVP-Hiding sensitive-only 2 +VALUE Alc-Tunnel-AVP-Hiding all 3 +VALUE Alc-Tunnel-Algorithm weighted-access 1 +VALUE Alc-Tunnel-Algorithm existing-first 2 +VALUE Alc-Tunnel-Challenge never 1 +VALUE Alc-Tunnel-Challenge always 2 +VALUE Timetra-Access ftp 1 +VALUE Timetra-Access console 2 +VALUE Timetra-Access both 3 +VALUE Timetra-Action deny 2 +VALUE Timetra-Default-Action permit-all 1 +VALUE Timetra-Default-Action deny-all 2 +VALUE Timetra-Default-Action none 3 +VALUE Timetra-Restrict-To-Home true 1 +VALUE Timetra-Restrict-To-Home false 2 + +END-VENDOR Alcatel-Lucent-Service-Router diff --git a/vendors/alcatelsr/generate.go b/vendors/alcatelsr/generate.go new file mode 100644 index 0000000..7670f96 --- /dev/null +++ b/vendors/alcatelsr/generate.go @@ -0,0 +1,3 @@ +//go:generate go run ../../cmd/radius-dict-gen/main.go -package alcatelsr -output generated.go dictionary.alcatelsr + +package alcatelsr diff --git a/vendors/alcatelsr/generated.go b/vendors/alcatelsr/generated.go new file mode 100644 index 0000000..e8ba358 --- /dev/null +++ b/vendors/alcatelsr/generated.go @@ -0,0 +1,15308 @@ +// Code generated by radius-dict-gen. DO NOT EDIT. + +package alcatelsr + +import ( + "crypto/rand" + "net" + "strconv" + + "layeh.com/radius" + "layeh.com/radius/rfc2865" +) + +const ( + _AlcatelLucentServiceRouter_VendorID = 6527 +) + +func _AlcatelLucentServiceRouter_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(_AlcatelLucentServiceRouter_VendorID, vendor) + if err != nil { + return + } + p.Add(rfc2865.VendorSpecific_Type, vsa) + return +} + +func _AlcatelLucentServiceRouter_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 != _AlcatelLucentServiceRouter_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 _AlcatelLucentServiceRouter_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 != _AlcatelLucentServiceRouter_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 _AlcatelLucentServiceRouter_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 != _AlcatelLucentServiceRouter_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 _AlcatelLucentServiceRouter_AddVendor(p, typ, attr) +} + +func _AlcatelLucentServiceRouter_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 != _AlcatelLucentServiceRouter_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 +} + +type TimetraAccess uint32 + +const ( + TimetraAccess_Value_Ftp TimetraAccess = 1 + TimetraAccess_Value_Console TimetraAccess = 2 + TimetraAccess_Value_Both TimetraAccess = 3 +) + +var TimetraAccess_Strings = map[TimetraAccess]string{ + TimetraAccess_Value_Ftp: "ftp", + TimetraAccess_Value_Console: "console", + TimetraAccess_Value_Both: "both", +} + +func (a TimetraAccess) String() string { + if str, ok := TimetraAccess_Strings[a]; ok { + return str + } + return "TimetraAccess(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TimetraAccess_Add(p *radius.Packet, value TimetraAccess) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 1, a) +} + +func TimetraAccess_Get(p *radius.Packet) (value TimetraAccess) { + value, _ = TimetraAccess_Lookup(p) + return +} + +func TimetraAccess_Gets(p *radius.Packet) (values []TimetraAccess, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 1) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TimetraAccess(i)) + } + return +} + +func TimetraAccess_Lookup(p *radius.Packet) (value TimetraAccess, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TimetraAccess(i) + return +} + +func TimetraAccess_Set(p *radius.Packet, value TimetraAccess) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 1, a) +} + +func TimetraAccess_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 1) +} + +func TimetraHomeDirectory_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 2, a) +} + +func TimetraHomeDirectory_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 2, a) +} + +func TimetraHomeDirectory_Get(p *radius.Packet) (value []byte) { + value, _ = TimetraHomeDirectory_Lookup(p) + return +} + +func TimetraHomeDirectory_GetString(p *radius.Packet) (value string) { + value, _ = TimetraHomeDirectory_LookupString(p) + return +} + +func TimetraHomeDirectory_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 2) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraHomeDirectory_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 2) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraHomeDirectory_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 2) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TimetraHomeDirectory_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 2) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TimetraHomeDirectory_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 2, a) +} + +func TimetraHomeDirectory_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 2, a) +} + +func TimetraHomeDirectory_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 2) +} + +type TimetraRestrictToHome uint32 + +const ( + TimetraRestrictToHome_Value_True TimetraRestrictToHome = 1 + TimetraRestrictToHome_Value_False TimetraRestrictToHome = 2 +) + +var TimetraRestrictToHome_Strings = map[TimetraRestrictToHome]string{ + TimetraRestrictToHome_Value_True: "true", + TimetraRestrictToHome_Value_False: "false", +} + +func (a TimetraRestrictToHome) String() string { + if str, ok := TimetraRestrictToHome_Strings[a]; ok { + return str + } + return "TimetraRestrictToHome(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TimetraRestrictToHome_Add(p *radius.Packet, value TimetraRestrictToHome) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 3, a) +} + +func TimetraRestrictToHome_Get(p *radius.Packet) (value TimetraRestrictToHome) { + value, _ = TimetraRestrictToHome_Lookup(p) + return +} + +func TimetraRestrictToHome_Gets(p *radius.Packet) (values []TimetraRestrictToHome, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 3) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TimetraRestrictToHome(i)) + } + return +} + +func TimetraRestrictToHome_Lookup(p *radius.Packet) (value TimetraRestrictToHome, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 3) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TimetraRestrictToHome(i) + return +} + +func TimetraRestrictToHome_Set(p *radius.Packet, value TimetraRestrictToHome) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 3, a) +} + +func TimetraRestrictToHome_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 3) +} + +func TimetraProfile_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 4, a) +} + +func TimetraProfile_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 4, a) +} + +func TimetraProfile_Get(p *radius.Packet) (value []byte) { + value, _ = TimetraProfile_Lookup(p) + return +} + +func TimetraProfile_GetString(p *radius.Packet) (value string) { + value, _ = TimetraProfile_LookupString(p) + return +} + +func TimetraProfile_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 4) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraProfile_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 4) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraProfile_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TimetraProfile_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TimetraProfile_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 4, a) +} + +func TimetraProfile_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 4, a) +} + +func TimetraProfile_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 4) +} + +type TimetraDefaultAction uint32 + +const ( + TimetraDefaultAction_Value_PermitAll TimetraDefaultAction = 1 + TimetraDefaultAction_Value_DenyAll TimetraDefaultAction = 2 + TimetraDefaultAction_Value_None TimetraDefaultAction = 3 +) + +var TimetraDefaultAction_Strings = map[TimetraDefaultAction]string{ + TimetraDefaultAction_Value_PermitAll: "permit-all", + TimetraDefaultAction_Value_DenyAll: "deny-all", + TimetraDefaultAction_Value_None: "none", +} + +func (a TimetraDefaultAction) String() string { + if str, ok := TimetraDefaultAction_Strings[a]; ok { + return str + } + return "TimetraDefaultAction(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TimetraDefaultAction_Add(p *radius.Packet, value TimetraDefaultAction) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 5, a) +} + +func TimetraDefaultAction_Get(p *radius.Packet) (value TimetraDefaultAction) { + value, _ = TimetraDefaultAction_Lookup(p) + return +} + +func TimetraDefaultAction_Gets(p *radius.Packet) (values []TimetraDefaultAction, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 5) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TimetraDefaultAction(i)) + } + return +} + +func TimetraDefaultAction_Lookup(p *radius.Packet) (value TimetraDefaultAction, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 5) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TimetraDefaultAction(i) + return +} + +func TimetraDefaultAction_Set(p *radius.Packet, value TimetraDefaultAction) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 5, a) +} + +func TimetraDefaultAction_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 5) +} + +func TimetraCmd_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 6, a) +} + +func TimetraCmd_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 6, a) +} + +func TimetraCmd_Get(p *radius.Packet) (value []byte) { + value, _ = TimetraCmd_Lookup(p) + return +} + +func TimetraCmd_GetString(p *radius.Packet) (value string) { + value, _ = TimetraCmd_LookupString(p) + return +} + +func TimetraCmd_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 6) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraCmd_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 6) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraCmd_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 6) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TimetraCmd_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 6) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TimetraCmd_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 6, a) +} + +func TimetraCmd_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 6, a) +} + +func TimetraCmd_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 6) +} + +type TimetraAction uint32 + +const ( + TimetraAction_Value_Deny TimetraAction = 2 +) + +var TimetraAction_Strings = map[TimetraAction]string{ + TimetraAction_Value_Deny: "deny", +} + +func (a TimetraAction) String() string { + if str, ok := TimetraAction_Strings[a]; ok { + return str + } + return "TimetraAction(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TimetraAction_Add(p *radius.Packet, value TimetraAction) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 7, a) +} + +func TimetraAction_Get(p *radius.Packet) (value TimetraAction) { + value, _ = TimetraAction_Lookup(p) + return +} + +func TimetraAction_Gets(p *radius.Packet) (values []TimetraAction, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 7) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TimetraAction(i)) + } + return +} + +func TimetraAction_Lookup(p *radius.Packet) (value TimetraAction, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 7) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TimetraAction(i) + return +} + +func TimetraAction_Set(p *radius.Packet, value TimetraAction) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 7, a) +} + +func TimetraAction_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 7) +} + +func TimetraExecFile_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 8, a) +} + +func TimetraExecFile_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 8, a) +} + +func TimetraExecFile_Get(p *radius.Packet) (value []byte) { + value, _ = TimetraExecFile_Lookup(p) + return +} + +func TimetraExecFile_GetString(p *radius.Packet) (value string) { + value, _ = TimetraExecFile_LookupString(p) + return +} + +func TimetraExecFile_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 8) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraExecFile_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 8) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TimetraExecFile_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 8) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TimetraExecFile_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 8) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TimetraExecFile_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 8, a) +} + +func TimetraExecFile_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 8, a) +} + +func TimetraExecFile_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 8) +} + +func AlcPrimaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 9, a) +} + +func AlcPrimaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcPrimaryDNS_Lookup(p) + return +} + +func AlcPrimaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 9) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPrimaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 9) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcPrimaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 9, a) +} + +func AlcPrimaryDNS_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 9) +} + +func AlcSecondaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 10, a) +} + +func AlcSecondaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcSecondaryDNS_Lookup(p) + return +} + +func AlcSecondaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 10) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSecondaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 10) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcSecondaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 10, a) +} + +func AlcSecondaryDNS_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 10) +} + +func AlcSubscIDStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 11, a) +} + +func AlcSubscIDStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 11, a) +} + +func AlcSubscIDStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSubscIDStr_Lookup(p) + return +} + +func AlcSubscIDStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcSubscIDStr_LookupString(p) + return +} + +func AlcSubscIDStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 11) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscIDStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 11) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscIDStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 11) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSubscIDStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 11) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSubscIDStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 11, a) +} + +func AlcSubscIDStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 11, a) +} + +func AlcSubscIDStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 11) +} + +func AlcSubscProfStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 12, a) +} + +func AlcSubscProfStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 12, a) +} + +func AlcSubscProfStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSubscProfStr_Lookup(p) + return +} + +func AlcSubscProfStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcSubscProfStr_LookupString(p) + return +} + +func AlcSubscProfStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 12) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscProfStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 12) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscProfStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 12) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSubscProfStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 12) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSubscProfStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 12, a) +} + +func AlcSubscProfStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 12, a) +} + +func AlcSubscProfStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 12) +} + +func AlcSLAProfStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 13, a) +} + +func AlcSLAProfStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 13, a) +} + +func AlcSLAProfStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSLAProfStr_Lookup(p) + return +} + +func AlcSLAProfStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcSLAProfStr_LookupString(p) + return +} + +func AlcSLAProfStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 13) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSLAProfStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 13) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSLAProfStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 13) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSLAProfStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 13) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSLAProfStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 13, a) +} + +func AlcSLAProfStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 13, a) +} + +func AlcSLAProfStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 13) +} + +func AlcForceRenew_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 14, a) +} + +func AlcForceRenew_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 14, a) +} + +func AlcForceRenew_Get(p *radius.Packet) (value []byte) { + value, _ = AlcForceRenew_Lookup(p) + return +} + +func AlcForceRenew_GetString(p *radius.Packet) (value string) { + value, _ = AlcForceRenew_LookupString(p) + return +} + +func AlcForceRenew_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 14) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceRenew_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 14) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceRenew_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 14) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcForceRenew_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 14) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcForceRenew_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 14, a) +} + +func AlcForceRenew_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 14, a) +} + +func AlcForceRenew_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 14) +} + +func AlcCreateHost_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 15, a) +} + +func AlcCreateHost_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 15, a) +} + +func AlcCreateHost_Get(p *radius.Packet) (value []byte) { + value, _ = AlcCreateHost_Lookup(p) + return +} + +func AlcCreateHost_GetString(p *radius.Packet) (value string) { + value, _ = AlcCreateHost_LookupString(p) + return +} + +func AlcCreateHost_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 15) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreateHost_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 15) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreateHost_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 15) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcCreateHost_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 15) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcCreateHost_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 15, a) +} + +func AlcCreateHost_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 15, a) +} + +func AlcCreateHost_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 15) +} + +func AlcANCPStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 16, a) +} + +func AlcANCPStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 16, a) +} + +func AlcANCPStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcANCPStr_Lookup(p) + return +} + +func AlcANCPStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcANCPStr_LookupString(p) + return +} + +func AlcANCPStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 16) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcANCPStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 16) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcANCPStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 16) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcANCPStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 16) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcANCPStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 16, a) +} + +func AlcANCPStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 16, a) +} + +func AlcANCPStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 16) +} + +type AlcRetailServID uint32 + +var AlcRetailServID_Strings = map[AlcRetailServID]string{} + +func (a AlcRetailServID) String() string { + if str, ok := AlcRetailServID_Strings[a]; ok { + return str + } + return "AlcRetailServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcRetailServID_Add(p *radius.Packet, value AlcRetailServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 17, a) +} + +func AlcRetailServID_Get(p *radius.Packet) (value AlcRetailServID) { + value, _ = AlcRetailServID_Lookup(p) + return +} + +func AlcRetailServID_Gets(p *radius.Packet) (values []AlcRetailServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 17) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcRetailServID(i)) + } + return +} + +func AlcRetailServID_Lookup(p *radius.Packet) (value AlcRetailServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 17) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcRetailServID(i) + return +} + +func AlcRetailServID_Set(p *radius.Packet, value AlcRetailServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 17, a) +} + +func AlcRetailServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 17) +} + +func AlcDefaultRouter_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 18, a) +} + +func AlcDefaultRouter_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcDefaultRouter_Lookup(p) + return +} + +func AlcDefaultRouter_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 18) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDefaultRouter_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 18) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcDefaultRouter_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 18, a) +} + +func AlcDefaultRouter_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 18) +} + +func AlcAcctIInprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 19, a) +} + +func AlcAcctIInprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 19, a) +} + +func AlcAcctIInprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIInprofOctets64_Lookup(p) + return +} + +func AlcAcctIInprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIInprofOctets64_LookupString(p) + return +} + +func AlcAcctIInprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 19) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIInprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 19) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIInprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 19) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIInprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 19) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIInprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 19, a) +} + +func AlcAcctIInprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 19, a) +} + +func AlcAcctIInprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 19) +} + +func AlcAcctIOutprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 20, a) +} + +func AlcAcctIOutprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 20, a) +} + +func AlcAcctIOutprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIOutprofOctets64_Lookup(p) + return +} + +func AlcAcctIOutprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIOutprofOctets64_LookupString(p) + return +} + +func AlcAcctIOutprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 20) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIOutprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 20) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIOutprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 20) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIOutprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 20) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIOutprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 20, a) +} + +func AlcAcctIOutprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 20, a) +} + +func AlcAcctIOutprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 20) +} + +func AlcAcctOInprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 21, a) +} + +func AlcAcctOInprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 21, a) +} + +func AlcAcctOInprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOInprofOctets64_Lookup(p) + return +} + +func AlcAcctOInprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOInprofOctets64_LookupString(p) + return +} + +func AlcAcctOInprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 21) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 21) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 21) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOInprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 21) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOInprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 21, a) +} + +func AlcAcctOInprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 21, a) +} + +func AlcAcctOInprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 21) +} + +func AlcAcctOOutprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 22, a) +} + +func AlcAcctOOutprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 22, a) +} + +func AlcAcctOOutprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOOutprofOctets64_Lookup(p) + return +} + +func AlcAcctOOutprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOOutprofOctets64_LookupString(p) + return +} + +func AlcAcctOOutprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 22) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 22) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOOutprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOOutprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 22, a) +} + +func AlcAcctOOutprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 22, a) +} + +func AlcAcctOOutprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 22) +} + +func AlcAcctIInprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 23, a) +} + +func AlcAcctIInprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 23, a) +} + +func AlcAcctIInprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIInprofPkts64_Lookup(p) + return +} + +func AlcAcctIInprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIInprofPkts64_LookupString(p) + return +} + +func AlcAcctIInprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 23) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIInprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 23) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIInprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 23) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIInprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 23) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIInprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 23, a) +} + +func AlcAcctIInprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 23, a) +} + +func AlcAcctIInprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 23) +} + +func AlcAcctIOutprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 24, a) +} + +func AlcAcctIOutprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 24, a) +} + +func AlcAcctIOutprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIOutprofPkts64_Lookup(p) + return +} + +func AlcAcctIOutprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIOutprofPkts64_LookupString(p) + return +} + +func AlcAcctIOutprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 24) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIOutprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 24) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIOutprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIOutprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIOutprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 24, a) +} + +func AlcAcctIOutprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 24, a) +} + +func AlcAcctIOutprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 24) +} + +func AlcAcctOInprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 25, a) +} + +func AlcAcctOInprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 25, a) +} + +func AlcAcctOInprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOInprofPkts64_Lookup(p) + return +} + +func AlcAcctOInprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOInprofPkts64_LookupString(p) + return +} + +func AlcAcctOInprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 25) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 25) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOInprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOInprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 25, a) +} + +func AlcAcctOInprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 25, a) +} + +func AlcAcctOInprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 25) +} + +func AlcAcctOOutprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 26, a) +} + +func AlcAcctOOutprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 26, a) +} + +func AlcAcctOOutprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOOutprofPkts64_Lookup(p) + return +} + +func AlcAcctOOutprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOOutprofPkts64_LookupString(p) + return +} + +func AlcAcctOOutprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 26) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 26) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 26) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOOutprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 26) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOOutprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 26, a) +} + +func AlcAcctOOutprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 26, a) +} + +func AlcAcctOOutprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 26) +} + +func AlcClientHardwareAddr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 27, a) +} + +func AlcClientHardwareAddr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 27, a) +} + +func AlcClientHardwareAddr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcClientHardwareAddr_Lookup(p) + return +} + +func AlcClientHardwareAddr_GetString(p *radius.Packet) (value string) { + value, _ = AlcClientHardwareAddr_LookupString(p) + return +} + +func AlcClientHardwareAddr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 27) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcClientHardwareAddr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 27) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcClientHardwareAddr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcClientHardwareAddr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcClientHardwareAddr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 27, a) +} + +func AlcClientHardwareAddr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 27, a) +} + +func AlcClientHardwareAddr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 27) +} + +func AlcIntDestIDStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 28, a) +} + +func AlcIntDestIDStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 28, a) +} + +func AlcIntDestIDStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcIntDestIDStr_Lookup(p) + return +} + +func AlcIntDestIDStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcIntDestIDStr_LookupString(p) + return +} + +func AlcIntDestIDStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 28) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIntDestIDStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 28) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIntDestIDStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcIntDestIDStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcIntDestIDStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 28, a) +} + +func AlcIntDestIDStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 28, a) +} + +func AlcIntDestIDStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 28) +} + +func AlcPrimaryNbns_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 29, a) +} + +func AlcPrimaryNbns_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcPrimaryNbns_Lookup(p) + return +} + +func AlcPrimaryNbns_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 29) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPrimaryNbns_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 29) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcPrimaryNbns_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 29, a) +} + +func AlcPrimaryNbns_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 29) +} + +func AlcSecondaryNbns_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 30, a) +} + +func AlcSecondaryNbns_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcSecondaryNbns_Lookup(p) + return +} + +func AlcSecondaryNbns_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 30) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSecondaryNbns_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 30) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcSecondaryNbns_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 30, a) +} + +func AlcSecondaryNbns_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 30) +} + +type AlcMSAPServID uint32 + +var AlcMSAPServID_Strings = map[AlcMSAPServID]string{} + +func (a AlcMSAPServID) String() string { + if str, ok := AlcMSAPServID_Strings[a]; ok { + return str + } + return "AlcMSAPServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcMSAPServID_Add(p *radius.Packet, value AlcMSAPServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 31, a) +} + +func AlcMSAPServID_Get(p *radius.Packet) (value AlcMSAPServID) { + value, _ = AlcMSAPServID_Lookup(p) + return +} + +func AlcMSAPServID_Gets(p *radius.Packet) (values []AlcMSAPServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 31) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcMSAPServID(i)) + } + return +} + +func AlcMSAPServID_Lookup(p *radius.Packet) (value AlcMSAPServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcMSAPServID(i) + return +} + +func AlcMSAPServID_Set(p *radius.Packet, value AlcMSAPServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 31, a) +} + +func AlcMSAPServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 31) +} + +func AlcMSAPPolicy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 32, a) +} + +func AlcMSAPPolicy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 32, a) +} + +func AlcMSAPPolicy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcMSAPPolicy_Lookup(p) + return +} + +func AlcMSAPPolicy_GetString(p *radius.Packet) (value string) { + value, _ = AlcMSAPPolicy_LookupString(p) + return +} + +func AlcMSAPPolicy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 32) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMSAPPolicy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 32) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMSAPPolicy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcMSAPPolicy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcMSAPPolicy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 32, a) +} + +func AlcMSAPPolicy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 32, a) +} + +func AlcMSAPPolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 32) +} + +func AlcMSAPInterface_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 33, a) +} + +func AlcMSAPInterface_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 33, a) +} + +func AlcMSAPInterface_Get(p *radius.Packet) (value []byte) { + value, _ = AlcMSAPInterface_Lookup(p) + return +} + +func AlcMSAPInterface_GetString(p *radius.Packet) (value string) { + value, _ = AlcMSAPInterface_LookupString(p) + return +} + +func AlcMSAPInterface_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 33) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMSAPInterface_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 33) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMSAPInterface_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 33) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcMSAPInterface_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 33) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcMSAPInterface_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 33, a) +} + +func AlcMSAPInterface_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 33, a) +} + +func AlcMSAPInterface_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 33) +} + +type AlcPPPoEPADODelay uint32 + +var AlcPPPoEPADODelay_Strings = map[AlcPPPoEPADODelay]string{} + +func (a AlcPPPoEPADODelay) String() string { + if str, ok := AlcPPPoEPADODelay_Strings[a]; ok { + return str + } + return "AlcPPPoEPADODelay(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcPPPoEPADODelay_Add(p *radius.Packet, value AlcPPPoEPADODelay) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 34, a) +} + +func AlcPPPoEPADODelay_Get(p *radius.Packet) (value AlcPPPoEPADODelay) { + value, _ = AlcPPPoEPADODelay_Lookup(p) + return +} + +func AlcPPPoEPADODelay_Gets(p *radius.Packet) (values []AlcPPPoEPADODelay, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 34) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcPPPoEPADODelay(i)) + } + return +} + +func AlcPPPoEPADODelay_Lookup(p *radius.Packet) (value AlcPPPoEPADODelay, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 34) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcPPPoEPADODelay(i) + return +} + +func AlcPPPoEPADODelay_Set(p *radius.Packet, value AlcPPPoEPADODelay) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 34, a) +} + +func AlcPPPoEPADODelay_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 34) +} + +func AlcPPPoEServiceName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 35, a) +} + +func AlcPPPoEServiceName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 35, a) +} + +func AlcPPPoEServiceName_Get(p *radius.Packet) (value []byte) { + value, _ = AlcPPPoEServiceName_Lookup(p) + return +} + +func AlcPPPoEServiceName_GetString(p *radius.Packet) (value string) { + value, _ = AlcPPPoEServiceName_LookupString(p) + return +} + +func AlcPPPoEServiceName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 35) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPPPoEServiceName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 35) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPPPoEServiceName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 35) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcPPPoEServiceName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 35) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcPPPoEServiceName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 35, a) +} + +func AlcPPPoEServiceName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 35, a) +} + +func AlcPPPoEServiceName_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 35) +} + +func AlcDHCPVendorClassID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 36, a) +} + +func AlcDHCPVendorClassID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 36, a) +} + +func AlcDHCPVendorClassID_Get(p *radius.Packet) (value []byte) { + value, _ = AlcDHCPVendorClassID_Lookup(p) + return +} + +func AlcDHCPVendorClassID_GetString(p *radius.Packet) (value string) { + value, _ = AlcDHCPVendorClassID_LookupString(p) + return +} + +func AlcDHCPVendorClassID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 36) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDHCPVendorClassID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 36) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDHCPVendorClassID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 36) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcDHCPVendorClassID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 36) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcDHCPVendorClassID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 36, a) +} + +func AlcDHCPVendorClassID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 36, a) +} + +func AlcDHCPVendorClassID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 36) +} + +func AlcAcctOCIInprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 37, a) +} + +func AlcAcctOCIInprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 37, a) +} + +func AlcAcctOCIInprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIInprofOctets64_Lookup(p) + return +} + +func AlcAcctOCIInprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIInprofOctets64_LookupString(p) + return +} + +func AlcAcctOCIInprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 37) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 37) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 37) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIInprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 37) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIInprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 37, a) +} + +func AlcAcctOCIInprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 37, a) +} + +func AlcAcctOCIInprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 37) +} + +func AlcAcctOCIOutprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 38, a) +} + +func AlcAcctOCIOutprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 38, a) +} + +func AlcAcctOCIOutprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIOutprofOctets64_Lookup(p) + return +} + +func AlcAcctOCIOutprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIOutprofOctets64_LookupString(p) + return +} + +func AlcAcctOCIOutprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 38) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 38) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 38) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIOutprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 38) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIOutprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 38, a) +} + +func AlcAcctOCIOutprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 38, a) +} + +func AlcAcctOCIOutprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 38) +} + +func AlcAcctOCOInprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 39, a) +} + +func AlcAcctOCOInprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 39, a) +} + +func AlcAcctOCOInprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOInprofOctets64_Lookup(p) + return +} + +func AlcAcctOCOInprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOInprofOctets64_LookupString(p) + return +} + +func AlcAcctOCOInprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 39) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 39) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOInprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOInprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 39, a) +} + +func AlcAcctOCOInprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 39, a) +} + +func AlcAcctOCOInprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 39) +} + +func AlcAcctOCOOutprofOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 40, a) +} + +func AlcAcctOCOOutprofOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 40, a) +} + +func AlcAcctOCOOutprofOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOOutprofOctets64_Lookup(p) + return +} + +func AlcAcctOCOOutprofOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOOutprofOctets64_LookupString(p) + return +} + +func AlcAcctOCOOutprofOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 40) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprofOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 40) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprofOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOOutprofOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOOutprofOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 40, a) +} + +func AlcAcctOCOOutprofOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 40, a) +} + +func AlcAcctOCOOutprofOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 40) +} + +func AlcAcctOCIInprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 41, a) +} + +func AlcAcctOCIInprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 41, a) +} + +func AlcAcctOCIInprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIInprofPkts64_Lookup(p) + return +} + +func AlcAcctOCIInprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIInprofPkts64_LookupString(p) + return +} + +func AlcAcctOCIInprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 41) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 41) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 41) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIInprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 41) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIInprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 41, a) +} + +func AlcAcctOCIInprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 41, a) +} + +func AlcAcctOCIInprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 41) +} + +func AlcAcctOCIOutprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 42, a) +} + +func AlcAcctOCIOutprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 42, a) +} + +func AlcAcctOCIOutprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIOutprofPkts64_Lookup(p) + return +} + +func AlcAcctOCIOutprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIOutprofPkts64_LookupString(p) + return +} + +func AlcAcctOCIOutprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 42) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 42) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 42) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIOutprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 42) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIOutprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 42, a) +} + +func AlcAcctOCIOutprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 42, a) +} + +func AlcAcctOCIOutprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 42) +} + +func AlcAcctOCOInprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 43, a) +} + +func AlcAcctOCOInprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 43, a) +} + +func AlcAcctOCOInprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOInprofPkts64_Lookup(p) + return +} + +func AlcAcctOCOInprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOInprofPkts64_LookupString(p) + return +} + +func AlcAcctOCOInprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 43) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 43) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 43) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOInprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 43) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOInprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 43, a) +} + +func AlcAcctOCOInprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 43, a) +} + +func AlcAcctOCOInprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 43) +} + +func AlcAcctOCOOutprofPkts64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 44, a) +} + +func AlcAcctOCOOutprofPkts64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 44, a) +} + +func AlcAcctOCOOutprofPkts64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOOutprofPkts64_Lookup(p) + return +} + +func AlcAcctOCOOutprofPkts64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOOutprofPkts64_LookupString(p) + return +} + +func AlcAcctOCOOutprofPkts64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 44) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprofPkts64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 44) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprofPkts64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 44) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOOutprofPkts64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 44) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOOutprofPkts64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 44, a) +} + +func AlcAcctOCOOutprofPkts64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 44, a) +} + +func AlcAcctOCOOutprofPkts64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 44) +} + +func AlcAppProfStr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 45, a) +} + +func AlcAppProfStr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 45, a) +} + +func AlcAppProfStr_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAppProfStr_Lookup(p) + return +} + +func AlcAppProfStr_GetString(p *radius.Packet) (value string) { + value, _ = AlcAppProfStr_LookupString(p) + return +} + +func AlcAppProfStr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 45) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAppProfStr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 45) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAppProfStr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 45) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAppProfStr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 45) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAppProfStr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 45, a) +} + +func AlcAppProfStr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 45, a) +} + +func AlcAppProfStr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 45) +} + +func AlcTunnelGroup_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 46, a) +} + +func AlcTunnelGroup_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 46, a) +} + +func AlcTunnelGroup_Get(p *radius.Packet) (value []byte) { + value, _ = AlcTunnelGroup_Lookup(p) + return +} + +func AlcTunnelGroup_GetString(p *radius.Packet) (value string) { + value, _ = AlcTunnelGroup_LookupString(p) + return +} + +func AlcTunnelGroup_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 46) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcTunnelGroup_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 46) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcTunnelGroup_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 46) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcTunnelGroup_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 46) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcTunnelGroup_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 46, a) +} + +func AlcTunnelGroup_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 46, a) +} + +func AlcTunnelGroup_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 46) +} + +type AlcTunnelAlgorithm uint32 + +const ( + AlcTunnelAlgorithm_Value_WeightedAccess AlcTunnelAlgorithm = 1 + AlcTunnelAlgorithm_Value_ExistingFirst AlcTunnelAlgorithm = 2 +) + +var AlcTunnelAlgorithm_Strings = map[AlcTunnelAlgorithm]string{ + AlcTunnelAlgorithm_Value_WeightedAccess: "weighted-access", + AlcTunnelAlgorithm_Value_ExistingFirst: "existing-first", +} + +func (a AlcTunnelAlgorithm) String() string { + if str, ok := AlcTunnelAlgorithm_Strings[a]; ok { + return str + } + return "AlcTunnelAlgorithm(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelAlgorithm_Add(p *radius.Packet, value AlcTunnelAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 47, a) +} + +func AlcTunnelAlgorithm_Get(p *radius.Packet) (value AlcTunnelAlgorithm) { + value, _ = AlcTunnelAlgorithm_Lookup(p) + return +} + +func AlcTunnelAlgorithm_Gets(p *radius.Packet) (values []AlcTunnelAlgorithm, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 47) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelAlgorithm(i)) + } + return +} + +func AlcTunnelAlgorithm_Lookup(p *radius.Packet) (value AlcTunnelAlgorithm, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 47) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelAlgorithm(i) + return +} + +func AlcTunnelAlgorithm_Set(p *radius.Packet, value AlcTunnelAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 47, a) +} + +func AlcTunnelAlgorithm_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 47) +} + +type AlcTunnelMaxSessions uint32 + +var AlcTunnelMaxSessions_Strings = map[AlcTunnelMaxSessions]string{} + +func (a AlcTunnelMaxSessions) String() string { + if str, ok := AlcTunnelMaxSessions_Strings[a]; ok { + return str + } + return "AlcTunnelMaxSessions(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelMaxSessions_Add(p *radius.Packet, tag byte, value AlcTunnelMaxSessions) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 48, a) +} + +func AlcTunnelMaxSessions_Get(p *radius.Packet) (tag byte, value AlcTunnelMaxSessions) { + tag, value, _ = AlcTunnelMaxSessions_Lookup(p) + return +} + +func AlcTunnelMaxSessions_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelMaxSessions, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 48) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelMaxSessions(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelMaxSessions_Lookup(p *radius.Packet) (tag byte, value AlcTunnelMaxSessions, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 48) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelMaxSessions(i) + return +} + +func AlcTunnelMaxSessions_Set(p *radius.Packet, tag byte, value AlcTunnelMaxSessions) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 48, a) +} + +func AlcTunnelMaxSessions_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 48) +} + +type AlcTunnelIdleTimeout uint32 + +var AlcTunnelIdleTimeout_Strings = map[AlcTunnelIdleTimeout]string{} + +func (a AlcTunnelIdleTimeout) String() string { + if str, ok := AlcTunnelIdleTimeout_Strings[a]; ok { + return str + } + return "AlcTunnelIdleTimeout(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelIdleTimeout_Add(p *radius.Packet, tag byte, value AlcTunnelIdleTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 49, a) +} + +func AlcTunnelIdleTimeout_Get(p *radius.Packet) (tag byte, value AlcTunnelIdleTimeout) { + tag, value, _ = AlcTunnelIdleTimeout_Lookup(p) + return +} + +func AlcTunnelIdleTimeout_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelIdleTimeout, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 49) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelIdleTimeout(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelIdleTimeout_Lookup(p *radius.Packet) (tag byte, value AlcTunnelIdleTimeout, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 49) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelIdleTimeout(i) + return +} + +func AlcTunnelIdleTimeout_Set(p *radius.Packet, tag byte, value AlcTunnelIdleTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 49, a) +} + +func AlcTunnelIdleTimeout_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 49) +} + +type AlcTunnelHelloInterval uint32 + +var AlcTunnelHelloInterval_Strings = map[AlcTunnelHelloInterval]string{} + +func (a AlcTunnelHelloInterval) String() string { + if str, ok := AlcTunnelHelloInterval_Strings[a]; ok { + return str + } + return "AlcTunnelHelloInterval(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelHelloInterval_Add(p *radius.Packet, tag byte, value AlcTunnelHelloInterval) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 50, a) +} + +func AlcTunnelHelloInterval_Get(p *radius.Packet) (tag byte, value AlcTunnelHelloInterval) { + tag, value, _ = AlcTunnelHelloInterval_Lookup(p) + return +} + +func AlcTunnelHelloInterval_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelHelloInterval, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 50) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelHelloInterval(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelHelloInterval_Lookup(p *radius.Packet) (tag byte, value AlcTunnelHelloInterval, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 50) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelHelloInterval(i) + return +} + +func AlcTunnelHelloInterval_Set(p *radius.Packet, tag byte, value AlcTunnelHelloInterval) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 50, a) +} + +func AlcTunnelHelloInterval_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 50) +} + +type AlcTunnelDestructTimeout uint32 + +var AlcTunnelDestructTimeout_Strings = map[AlcTunnelDestructTimeout]string{} + +func (a AlcTunnelDestructTimeout) String() string { + if str, ok := AlcTunnelDestructTimeout_Strings[a]; ok { + return str + } + return "AlcTunnelDestructTimeout(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelDestructTimeout_Add(p *radius.Packet, tag byte, value AlcTunnelDestructTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 51, a) +} + +func AlcTunnelDestructTimeout_Get(p *radius.Packet) (tag byte, value AlcTunnelDestructTimeout) { + tag, value, _ = AlcTunnelDestructTimeout_Lookup(p) + return +} + +func AlcTunnelDestructTimeout_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelDestructTimeout, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 51) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelDestructTimeout(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelDestructTimeout_Lookup(p *radius.Packet) (tag byte, value AlcTunnelDestructTimeout, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 51) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelDestructTimeout(i) + return +} + +func AlcTunnelDestructTimeout_Set(p *radius.Packet, tag byte, value AlcTunnelDestructTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 51, a) +} + +func AlcTunnelDestructTimeout_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 51) +} + +type AlcTunnelMaxRetriesEstab uint32 + +var AlcTunnelMaxRetriesEstab_Strings = map[AlcTunnelMaxRetriesEstab]string{} + +func (a AlcTunnelMaxRetriesEstab) String() string { + if str, ok := AlcTunnelMaxRetriesEstab_Strings[a]; ok { + return str + } + return "AlcTunnelMaxRetriesEstab(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelMaxRetriesEstab_Add(p *radius.Packet, tag byte, value AlcTunnelMaxRetriesEstab) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 52, a) +} + +func AlcTunnelMaxRetriesEstab_Get(p *radius.Packet) (tag byte, value AlcTunnelMaxRetriesEstab) { + tag, value, _ = AlcTunnelMaxRetriesEstab_Lookup(p) + return +} + +func AlcTunnelMaxRetriesEstab_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelMaxRetriesEstab, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 52) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelMaxRetriesEstab(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelMaxRetriesEstab_Lookup(p *radius.Packet) (tag byte, value AlcTunnelMaxRetriesEstab, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 52) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelMaxRetriesEstab(i) + return +} + +func AlcTunnelMaxRetriesEstab_Set(p *radius.Packet, tag byte, value AlcTunnelMaxRetriesEstab) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 52, a) +} + +func AlcTunnelMaxRetriesEstab_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 52) +} + +type AlcTunnelMaxRetriesNotEstab uint32 + +var AlcTunnelMaxRetriesNotEstab_Strings = map[AlcTunnelMaxRetriesNotEstab]string{} + +func (a AlcTunnelMaxRetriesNotEstab) String() string { + if str, ok := AlcTunnelMaxRetriesNotEstab_Strings[a]; ok { + return str + } + return "AlcTunnelMaxRetriesNotEstab(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelMaxRetriesNotEstab_Add(p *radius.Packet, tag byte, value AlcTunnelMaxRetriesNotEstab) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 53, a) +} + +func AlcTunnelMaxRetriesNotEstab_Get(p *radius.Packet) (tag byte, value AlcTunnelMaxRetriesNotEstab) { + tag, value, _ = AlcTunnelMaxRetriesNotEstab_Lookup(p) + return +} + +func AlcTunnelMaxRetriesNotEstab_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelMaxRetriesNotEstab, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 53) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelMaxRetriesNotEstab(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelMaxRetriesNotEstab_Lookup(p *radius.Packet) (tag byte, value AlcTunnelMaxRetriesNotEstab, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 53) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelMaxRetriesNotEstab(i) + return +} + +func AlcTunnelMaxRetriesNotEstab_Set(p *radius.Packet, tag byte, value AlcTunnelMaxRetriesNotEstab) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 53, a) +} + +func AlcTunnelMaxRetriesNotEstab_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 53) +} + +type AlcTunnelAVPHiding uint32 + +const ( + AlcTunnelAVPHiding_Value_Nothing AlcTunnelAVPHiding = 1 + AlcTunnelAVPHiding_Value_SensitiveOnly AlcTunnelAVPHiding = 2 + AlcTunnelAVPHiding_Value_All AlcTunnelAVPHiding = 3 +) + +var AlcTunnelAVPHiding_Strings = map[AlcTunnelAVPHiding]string{ + AlcTunnelAVPHiding_Value_Nothing: "nothing", + AlcTunnelAVPHiding_Value_SensitiveOnly: "sensitive-only", + AlcTunnelAVPHiding_Value_All: "all", +} + +func (a AlcTunnelAVPHiding) String() string { + if str, ok := AlcTunnelAVPHiding_Strings[a]; ok { + return str + } + return "AlcTunnelAVPHiding(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelAVPHiding_Add(p *radius.Packet, tag byte, value AlcTunnelAVPHiding) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 54, a) +} + +func AlcTunnelAVPHiding_Get(p *radius.Packet) (tag byte, value AlcTunnelAVPHiding) { + tag, value, _ = AlcTunnelAVPHiding_Lookup(p) + return +} + +func AlcTunnelAVPHiding_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelAVPHiding, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 54) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelAVPHiding(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelAVPHiding_Lookup(p *radius.Packet) (tag byte, value AlcTunnelAVPHiding, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 54) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelAVPHiding(i) + return +} + +func AlcTunnelAVPHiding_Set(p *radius.Packet, tag byte, value AlcTunnelAVPHiding) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 54, a) +} + +func AlcTunnelAVPHiding_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 54) +} + +func AlcBGPPolicy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 55, a) +} + +func AlcBGPPolicy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 55, a) +} + +func AlcBGPPolicy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcBGPPolicy_Lookup(p) + return +} + +func AlcBGPPolicy_GetString(p *radius.Packet) (value string) { + value, _ = AlcBGPPolicy_LookupString(p) + return +} + +func AlcBGPPolicy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 55) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPPolicy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 55) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPPolicy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 55) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcBGPPolicy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 55) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcBGPPolicy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 55, a) +} + +func AlcBGPPolicy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 55, a) +} + +func AlcBGPPolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 55) +} + +func AlcBGPAuthKeychain_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 56, a) +} + +func AlcBGPAuthKeychain_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 56, a) +} + +func AlcBGPAuthKeychain_Get(p *radius.Packet) (value []byte) { + value, _ = AlcBGPAuthKeychain_Lookup(p) + return +} + +func AlcBGPAuthKeychain_GetString(p *radius.Packet) (value string) { + value, _ = AlcBGPAuthKeychain_LookupString(p) + return +} + +func AlcBGPAuthKeychain_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 56) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPAuthKeychain_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 56) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPAuthKeychain_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 56) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcBGPAuthKeychain_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 56) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcBGPAuthKeychain_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 56, a) +} + +func AlcBGPAuthKeychain_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 56, a) +} + +func AlcBGPAuthKeychain_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 56) +} + +func AlcBGPAuthKey_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 57, a) +} + +func AlcBGPAuthKey_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 57, a) +} + +func AlcBGPAuthKey_Get(p *radius.Packet) (value []byte) { + value, _ = AlcBGPAuthKey_Lookup(p) + return +} + +func AlcBGPAuthKey_GetString(p *radius.Packet) (value string) { + value, _ = AlcBGPAuthKey_LookupString(p) + return +} + +func AlcBGPAuthKey_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 57) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPAuthKey_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 57) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPAuthKey_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 57) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcBGPAuthKey_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 57) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcBGPAuthKey_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 57, a) +} + +func AlcBGPAuthKey_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 57, a) +} + +func AlcBGPAuthKey_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 57) +} + +func AlcBGPExportPolicy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 58, a) +} + +func AlcBGPExportPolicy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 58, a) +} + +func AlcBGPExportPolicy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcBGPExportPolicy_Lookup(p) + return +} + +func AlcBGPExportPolicy_GetString(p *radius.Packet) (value string) { + value, _ = AlcBGPExportPolicy_LookupString(p) + return +} + +func AlcBGPExportPolicy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 58) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPExportPolicy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 58) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPExportPolicy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 58) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcBGPExportPolicy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 58) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcBGPExportPolicy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 58, a) +} + +func AlcBGPExportPolicy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 58, a) +} + +func AlcBGPExportPolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 58) +} + +func AlcBGPImportPolicy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 59, a) +} + +func AlcBGPImportPolicy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 59, a) +} + +func AlcBGPImportPolicy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcBGPImportPolicy_Lookup(p) + return +} + +func AlcBGPImportPolicy_GetString(p *radius.Packet) (value string) { + value, _ = AlcBGPImportPolicy_LookupString(p) + return +} + +func AlcBGPImportPolicy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 59) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPImportPolicy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 59) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcBGPImportPolicy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 59) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcBGPImportPolicy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 59) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcBGPImportPolicy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 59, a) +} + +func AlcBGPImportPolicy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 59, a) +} + +func AlcBGPImportPolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 59) +} + +type AlcBGPPeerAS uint32 + +var AlcBGPPeerAS_Strings = map[AlcBGPPeerAS]string{} + +func (a AlcBGPPeerAS) String() string { + if str, ok := AlcBGPPeerAS_Strings[a]; ok { + return str + } + return "AlcBGPPeerAS(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcBGPPeerAS_Add(p *radius.Packet, value AlcBGPPeerAS) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 60, a) +} + +func AlcBGPPeerAS_Get(p *radius.Packet) (value AlcBGPPeerAS) { + value, _ = AlcBGPPeerAS_Lookup(p) + return +} + +func AlcBGPPeerAS_Gets(p *radius.Packet) (values []AlcBGPPeerAS, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 60) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcBGPPeerAS(i)) + } + return +} + +func AlcBGPPeerAS_Lookup(p *radius.Packet) (value AlcBGPPeerAS, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 60) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcBGPPeerAS(i) + return +} + +func AlcBGPPeerAS_Set(p *radius.Packet, value AlcBGPPeerAS) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 60, a) +} + +func AlcBGPPeerAS_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 60) +} + +type AlcIPsecServID uint32 + +var AlcIPsecServID_Strings = map[AlcIPsecServID]string{} + +func (a AlcIPsecServID) String() string { + if str, ok := AlcIPsecServID_Strings[a]; ok { + return str + } + return "AlcIPsecServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecServID_Add(p *radius.Packet, value AlcIPsecServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 61, a) +} + +func AlcIPsecServID_Get(p *radius.Packet) (value AlcIPsecServID) { + value, _ = AlcIPsecServID_Lookup(p) + return +} + +func AlcIPsecServID_Gets(p *radius.Packet) (values []AlcIPsecServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 61) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecServID(i)) + } + return +} + +func AlcIPsecServID_Lookup(p *radius.Packet) (value AlcIPsecServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 61) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecServID(i) + return +} + +func AlcIPsecServID_Set(p *radius.Packet, value AlcIPsecServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 61, a) +} + +func AlcIPsecServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 61) +} + +func AlcIPsecInterface_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 62, a) +} + +func AlcIPsecInterface_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 62, a) +} + +func AlcIPsecInterface_Get(p *radius.Packet) (value []byte) { + value, _ = AlcIPsecInterface_Lookup(p) + return +} + +func AlcIPsecInterface_GetString(p *radius.Packet) (value string) { + value, _ = AlcIPsecInterface_LookupString(p) + return +} + +func AlcIPsecInterface_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 62) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIPsecInterface_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 62) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIPsecInterface_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 62) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcIPsecInterface_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 62) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcIPsecInterface_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 62, a) +} + +func AlcIPsecInterface_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 62, a) +} + +func AlcIPsecInterface_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 62) +} + +type AlcIPsecTunnelTemplateID uint32 + +var AlcIPsecTunnelTemplateID_Strings = map[AlcIPsecTunnelTemplateID]string{} + +func (a AlcIPsecTunnelTemplateID) String() string { + if str, ok := AlcIPsecTunnelTemplateID_Strings[a]; ok { + return str + } + return "AlcIPsecTunnelTemplateID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecTunnelTemplateID_Add(p *radius.Packet, value AlcIPsecTunnelTemplateID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 63, a) +} + +func AlcIPsecTunnelTemplateID_Get(p *radius.Packet) (value AlcIPsecTunnelTemplateID) { + value, _ = AlcIPsecTunnelTemplateID_Lookup(p) + return +} + +func AlcIPsecTunnelTemplateID_Gets(p *radius.Packet) (values []AlcIPsecTunnelTemplateID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 63) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecTunnelTemplateID(i)) + } + return +} + +func AlcIPsecTunnelTemplateID_Lookup(p *radius.Packet) (value AlcIPsecTunnelTemplateID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 63) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecTunnelTemplateID(i) + return +} + +func AlcIPsecTunnelTemplateID_Set(p *radius.Packet, value AlcIPsecTunnelTemplateID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 63, a) +} + +func AlcIPsecTunnelTemplateID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 63) +} + +type AlcIPsecSALifetime uint32 + +var AlcIPsecSALifetime_Strings = map[AlcIPsecSALifetime]string{} + +func (a AlcIPsecSALifetime) String() string { + if str, ok := AlcIPsecSALifetime_Strings[a]; ok { + return str + } + return "AlcIPsecSALifetime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecSALifetime_Add(p *radius.Packet, value AlcIPsecSALifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 64, a) +} + +func AlcIPsecSALifetime_Get(p *radius.Packet) (value AlcIPsecSALifetime) { + value, _ = AlcIPsecSALifetime_Lookup(p) + return +} + +func AlcIPsecSALifetime_Gets(p *radius.Packet) (values []AlcIPsecSALifetime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 64) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecSALifetime(i)) + } + return +} + +func AlcIPsecSALifetime_Lookup(p *radius.Packet) (value AlcIPsecSALifetime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 64) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecSALifetime(i) + return +} + +func AlcIPsecSALifetime_Set(p *radius.Packet, value AlcIPsecSALifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 64, a) +} + +func AlcIPsecSALifetime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 64) +} + +type AlcIPsecSAPFSGroup uint32 + +const ( + AlcIPsecSAPFSGroup_Value_Group1 AlcIPsecSAPFSGroup = 1 + AlcIPsecSAPFSGroup_Value_Group2 AlcIPsecSAPFSGroup = 2 + AlcIPsecSAPFSGroup_Value_Group5 AlcIPsecSAPFSGroup = 5 +) + +var AlcIPsecSAPFSGroup_Strings = map[AlcIPsecSAPFSGroup]string{ + AlcIPsecSAPFSGroup_Value_Group1: "group1", + AlcIPsecSAPFSGroup_Value_Group2: "group2", + AlcIPsecSAPFSGroup_Value_Group5: "group5", +} + +func (a AlcIPsecSAPFSGroup) String() string { + if str, ok := AlcIPsecSAPFSGroup_Strings[a]; ok { + return str + } + return "AlcIPsecSAPFSGroup(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecSAPFSGroup_Add(p *radius.Packet, value AlcIPsecSAPFSGroup) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 65, a) +} + +func AlcIPsecSAPFSGroup_Get(p *radius.Packet) (value AlcIPsecSAPFSGroup) { + value, _ = AlcIPsecSAPFSGroup_Lookup(p) + return +} + +func AlcIPsecSAPFSGroup_Gets(p *radius.Packet) (values []AlcIPsecSAPFSGroup, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 65) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecSAPFSGroup(i)) + } + return +} + +func AlcIPsecSAPFSGroup_Lookup(p *radius.Packet) (value AlcIPsecSAPFSGroup, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 65) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecSAPFSGroup(i) + return +} + +func AlcIPsecSAPFSGroup_Set(p *radius.Packet, value AlcIPsecSAPFSGroup) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 65, a) +} + +func AlcIPsecSAPFSGroup_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 65) +} + +type AlcIPsecSAEncrAlgorithm uint32 + +const ( + AlcIPsecSAEncrAlgorithm_Value_Null AlcIPsecSAEncrAlgorithm = 1 + AlcIPsecSAEncrAlgorithm_Value_Des AlcIPsecSAEncrAlgorithm = 2 + AlcIPsecSAEncrAlgorithm_Value_Des3 AlcIPsecSAEncrAlgorithm = 3 + AlcIPsecSAEncrAlgorithm_Value_Aes128 AlcIPsecSAEncrAlgorithm = 4 + AlcIPsecSAEncrAlgorithm_Value_Aes192 AlcIPsecSAEncrAlgorithm = 5 + AlcIPsecSAEncrAlgorithm_Value_Aes256 AlcIPsecSAEncrAlgorithm = 6 +) + +var AlcIPsecSAEncrAlgorithm_Strings = map[AlcIPsecSAEncrAlgorithm]string{ + AlcIPsecSAEncrAlgorithm_Value_Null: "null", + AlcIPsecSAEncrAlgorithm_Value_Des: "des", + AlcIPsecSAEncrAlgorithm_Value_Des3: "des3", + AlcIPsecSAEncrAlgorithm_Value_Aes128: "aes128", + AlcIPsecSAEncrAlgorithm_Value_Aes192: "aes192", + AlcIPsecSAEncrAlgorithm_Value_Aes256: "aes256", +} + +func (a AlcIPsecSAEncrAlgorithm) String() string { + if str, ok := AlcIPsecSAEncrAlgorithm_Strings[a]; ok { + return str + } + return "AlcIPsecSAEncrAlgorithm(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecSAEncrAlgorithm_Add(p *radius.Packet, value AlcIPsecSAEncrAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 66, a) +} + +func AlcIPsecSAEncrAlgorithm_Get(p *radius.Packet) (value AlcIPsecSAEncrAlgorithm) { + value, _ = AlcIPsecSAEncrAlgorithm_Lookup(p) + return +} + +func AlcIPsecSAEncrAlgorithm_Gets(p *radius.Packet) (values []AlcIPsecSAEncrAlgorithm, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 66) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecSAEncrAlgorithm(i)) + } + return +} + +func AlcIPsecSAEncrAlgorithm_Lookup(p *radius.Packet) (value AlcIPsecSAEncrAlgorithm, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 66) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecSAEncrAlgorithm(i) + return +} + +func AlcIPsecSAEncrAlgorithm_Set(p *radius.Packet, value AlcIPsecSAEncrAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 66, a) +} + +func AlcIPsecSAEncrAlgorithm_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 66) +} + +type AlcIPsecSAAuthAlgorithm uint32 + +const ( + AlcIPsecSAAuthAlgorithm_Value_Null AlcIPsecSAAuthAlgorithm = 1 + AlcIPsecSAAuthAlgorithm_Value_Md5 AlcIPsecSAAuthAlgorithm = 2 + AlcIPsecSAAuthAlgorithm_Value_Sha1 AlcIPsecSAAuthAlgorithm = 3 +) + +var AlcIPsecSAAuthAlgorithm_Strings = map[AlcIPsecSAAuthAlgorithm]string{ + AlcIPsecSAAuthAlgorithm_Value_Null: "null", + AlcIPsecSAAuthAlgorithm_Value_Md5: "md5", + AlcIPsecSAAuthAlgorithm_Value_Sha1: "sha1", +} + +func (a AlcIPsecSAAuthAlgorithm) String() string { + if str, ok := AlcIPsecSAAuthAlgorithm_Strings[a]; ok { + return str + } + return "AlcIPsecSAAuthAlgorithm(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecSAAuthAlgorithm_Add(p *radius.Packet, value AlcIPsecSAAuthAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 67, a) +} + +func AlcIPsecSAAuthAlgorithm_Get(p *radius.Packet) (value AlcIPsecSAAuthAlgorithm) { + value, _ = AlcIPsecSAAuthAlgorithm_Lookup(p) + return +} + +func AlcIPsecSAAuthAlgorithm_Gets(p *radius.Packet) (values []AlcIPsecSAAuthAlgorithm, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 67) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecSAAuthAlgorithm(i)) + } + return +} + +func AlcIPsecSAAuthAlgorithm_Lookup(p *radius.Packet) (value AlcIPsecSAAuthAlgorithm, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 67) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecSAAuthAlgorithm(i) + return +} + +func AlcIPsecSAAuthAlgorithm_Set(p *radius.Packet, value AlcIPsecSAAuthAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 67, a) +} + +func AlcIPsecSAAuthAlgorithm_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 67) +} + +type AlcIPsecSAReplayWindow uint32 + +var AlcIPsecSAReplayWindow_Strings = map[AlcIPsecSAReplayWindow]string{} + +func (a AlcIPsecSAReplayWindow) String() string { + if str, ok := AlcIPsecSAReplayWindow_Strings[a]; ok { + return str + } + return "AlcIPsecSAReplayWindow(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcIPsecSAReplayWindow_Add(p *radius.Packet, value AlcIPsecSAReplayWindow) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 68, a) +} + +func AlcIPsecSAReplayWindow_Get(p *radius.Packet) (value AlcIPsecSAReplayWindow) { + value, _ = AlcIPsecSAReplayWindow_Lookup(p) + return +} + +func AlcIPsecSAReplayWindow_Gets(p *radius.Packet) (values []AlcIPsecSAReplayWindow, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 68) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcIPsecSAReplayWindow(i)) + } + return +} + +func AlcIPsecSAReplayWindow_Lookup(p *radius.Packet) (value AlcIPsecSAReplayWindow, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 68) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcIPsecSAReplayWindow(i) + return +} + +func AlcIPsecSAReplayWindow_Set(p *radius.Packet, value AlcIPsecSAReplayWindow) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 68, a) +} + +func AlcIPsecSAReplayWindow_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 68) +} + +func AlcAcctIHighOctetsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 69, a) +} + +func AlcAcctIHighOctetsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 69, a) +} + +func AlcAcctIHighOctetsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHighOctetsDrop64_Lookup(p) + return +} + +func AlcAcctIHighOctetsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHighOctetsDrop64_LookupString(p) + return +} + +func AlcAcctIHighOctetsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 69) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighOctetsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 69) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighOctetsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 69) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHighOctetsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 69) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHighOctetsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 69, a) +} + +func AlcAcctIHighOctetsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 69, a) +} + +func AlcAcctIHighOctetsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 69) +} + +func AlcAcctILowOctetsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 70, a) +} + +func AlcAcctILowOctetsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 70, a) +} + +func AlcAcctILowOctetsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowOctetsDrop64_Lookup(p) + return +} + +func AlcAcctILowOctetsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowOctetsDrop64_LookupString(p) + return +} + +func AlcAcctILowOctetsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 70) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowOctetsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 70) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowOctetsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 70) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowOctetsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 70) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowOctetsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 70, a) +} + +func AlcAcctILowOctetsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 70, a) +} + +func AlcAcctILowOctetsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 70) +} + +func AlcAcctIHighPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 71, a) +} + +func AlcAcctIHighPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 71, a) +} + +func AlcAcctIHighPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHighPackDrop64_Lookup(p) + return +} + +func AlcAcctIHighPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHighPackDrop64_LookupString(p) + return +} + +func AlcAcctIHighPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 71) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 71) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 71) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHighPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 71) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHighPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 71, a) +} + +func AlcAcctIHighPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 71, a) +} + +func AlcAcctIHighPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 71) +} + +func AlcAcctILowPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 72, a) +} + +func AlcAcctILowPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 72, a) +} + +func AlcAcctILowPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowPackDrop64_Lookup(p) + return +} + +func AlcAcctILowPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowPackDrop64_LookupString(p) + return +} + +func AlcAcctILowPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 72) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 72) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 72) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 72) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 72, a) +} + +func AlcAcctILowPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 72, a) +} + +func AlcAcctILowPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 72) +} + +func AlcAcctIHighOctetsOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 73, a) +} + +func AlcAcctIHighOctetsOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 73, a) +} + +func AlcAcctIHighOctetsOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHighOctetsOffer64_Lookup(p) + return +} + +func AlcAcctIHighOctetsOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHighOctetsOffer64_LookupString(p) + return +} + +func AlcAcctIHighOctetsOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 73) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighOctetsOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 73) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighOctetsOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 73) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHighOctetsOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 73) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHighOctetsOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 73, a) +} + +func AlcAcctIHighOctetsOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 73, a) +} + +func AlcAcctIHighOctetsOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 73) +} + +func AlcAcctILowOctetsOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 74, a) +} + +func AlcAcctILowOctetsOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 74, a) +} + +func AlcAcctILowOctetsOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowOctetsOffer64_Lookup(p) + return +} + +func AlcAcctILowOctetsOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowOctetsOffer64_LookupString(p) + return +} + +func AlcAcctILowOctetsOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 74) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowOctetsOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 74) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowOctetsOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 74) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowOctetsOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 74) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowOctetsOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 74, a) +} + +func AlcAcctILowOctetsOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 74, a) +} + +func AlcAcctILowOctetsOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 74) +} + +func AlcAcctIHighPackOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 75, a) +} + +func AlcAcctIHighPackOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 75, a) +} + +func AlcAcctIHighPackOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHighPackOffer64_Lookup(p) + return +} + +func AlcAcctIHighPackOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHighPackOffer64_LookupString(p) + return +} + +func AlcAcctIHighPackOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 75) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighPackOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 75) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHighPackOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 75) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHighPackOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 75) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHighPackOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 75, a) +} + +func AlcAcctIHighPackOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 75, a) +} + +func AlcAcctIHighPackOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 75) +} + +func AlcAcctILowPackOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 76, a) +} + +func AlcAcctILowPackOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 76, a) +} + +func AlcAcctILowPackOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowPackOffer64_Lookup(p) + return +} + +func AlcAcctILowPackOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowPackOffer64_LookupString(p) + return +} + +func AlcAcctILowPackOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 76) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowPackOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 76) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowPackOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 76) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowPackOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 76) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowPackOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 76, a) +} + +func AlcAcctILowPackOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 76, a) +} + +func AlcAcctILowPackOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 76) +} + +func AlcAcctIUncOctetsOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 77, a) +} + +func AlcAcctIUncOctetsOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 77, a) +} + +func AlcAcctIUncOctetsOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIUncOctetsOffer64_Lookup(p) + return +} + +func AlcAcctIUncOctetsOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIUncOctetsOffer64_LookupString(p) + return +} + +func AlcAcctIUncOctetsOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 77) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIUncOctetsOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 77) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIUncOctetsOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 77) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIUncOctetsOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 77) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIUncOctetsOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 77, a) +} + +func AlcAcctIUncOctetsOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 77, a) +} + +func AlcAcctIUncOctetsOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 77) +} + +func AlcAcctIUncPackOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 78, a) +} + +func AlcAcctIUncPackOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 78, a) +} + +func AlcAcctIUncPackOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIUncPackOffer64_Lookup(p) + return +} + +func AlcAcctIUncPackOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIUncPackOffer64_LookupString(p) + return +} + +func AlcAcctIUncPackOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 78) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIUncPackOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 78) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIUncPackOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 78) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIUncPackOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 78) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIUncPackOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 78, a) +} + +func AlcAcctIUncPackOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 78, a) +} + +func AlcAcctIUncPackOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 78) +} + +func AlcAcctIAllOctetsOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 79, a) +} + +func AlcAcctIAllOctetsOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 79, a) +} + +func AlcAcctIAllOctetsOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIAllOctetsOffer64_Lookup(p) + return +} + +func AlcAcctIAllOctetsOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIAllOctetsOffer64_LookupString(p) + return +} + +func AlcAcctIAllOctetsOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 79) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllOctetsOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 79) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllOctetsOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 79) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIAllOctetsOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 79) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIAllOctetsOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 79, a) +} + +func AlcAcctIAllOctetsOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 79, a) +} + +func AlcAcctIAllOctetsOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 79) +} + +func AlcAcctIAllPackOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 80, a) +} + +func AlcAcctIAllPackOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 80, a) +} + +func AlcAcctIAllPackOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIAllPackOffer64_Lookup(p) + return +} + +func AlcAcctIAllPackOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIAllPackOffer64_LookupString(p) + return +} + +func AlcAcctIAllPackOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 80) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllPackOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 80) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllPackOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 80) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIAllPackOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 80) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIAllPackOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 80, a) +} + +func AlcAcctIAllPackOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 80, a) +} + +func AlcAcctIAllPackOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 80) +} + +func AlcAcctOInprofPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 81, a) +} + +func AlcAcctOInprofPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 81, a) +} + +func AlcAcctOInprofPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOInprofPackDrop64_Lookup(p) + return +} + +func AlcAcctOInprofPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOInprofPackDrop64_LookupString(p) + return +} + +func AlcAcctOInprofPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 81) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 81) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOInprofPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOInprofPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 81, a) +} + +func AlcAcctOInprofPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 81, a) +} + +func AlcAcctOInprofPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 81) +} + +func AlcAcctOOutprofPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 82, a) +} + +func AlcAcctOOutprofPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 82, a) +} + +func AlcAcctOOutprofPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOOutprofPackDrop64_Lookup(p) + return +} + +func AlcAcctOOutprofPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOOutprofPackDrop64_LookupString(p) + return +} + +func AlcAcctOOutprofPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 82) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 82) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOOutprofPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOOutprofPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 82, a) +} + +func AlcAcctOOutprofPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 82, a) +} + +func AlcAcctOOutprofPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 82) +} + +func AlcAcctOInprofOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 83, a) +} + +func AlcAcctOInprofOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 83, a) +} + +func AlcAcctOInprofOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOInprofOctsDrop64_Lookup(p) + return +} + +func AlcAcctOInprofOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOInprofOctsDrop64_LookupString(p) + return +} + +func AlcAcctOInprofOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 83) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 83) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOInprofOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 83) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOInprofOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 83) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOInprofOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 83, a) +} + +func AlcAcctOInprofOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 83, a) +} + +func AlcAcctOInprofOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 83) +} + +func AlcAcctOOutprofOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 84, a) +} + +func AlcAcctOOutprofOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 84, a) +} + +func AlcAcctOOutprofOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOOutprofOctsDrop64_Lookup(p) + return +} + +func AlcAcctOOutprofOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOOutprofOctsDrop64_LookupString(p) + return +} + +func AlcAcctOOutprofOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 84) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 84) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOOutprofOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 84) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOOutprofOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 84) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOOutprofOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 84, a) +} + +func AlcAcctOOutprofOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 84, a) +} + +func AlcAcctOOutprofOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 84) +} + +func AlcAcctOCIAllOctsOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 85, a) +} + +func AlcAcctOCIAllOctsOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 85, a) +} + +func AlcAcctOCIAllOctsOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIAllOctsOffer64_Lookup(p) + return +} + +func AlcAcctOCIAllOctsOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIAllOctsOffer64_LookupString(p) + return +} + +func AlcAcctOCIAllOctsOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 85) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIAllOctsOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 85) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIAllOctsOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 85) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIAllOctsOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 85) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIAllOctsOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 85, a) +} + +func AlcAcctOCIAllOctsOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 85, a) +} + +func AlcAcctOCIAllOctsOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 85) +} + +func AlcAcctOCIAllPackOffer64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 86, a) +} + +func AlcAcctOCIAllPackOffer64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 86, a) +} + +func AlcAcctOCIAllPackOffer64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIAllPackOffer64_Lookup(p) + return +} + +func AlcAcctOCIAllPackOffer64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIAllPackOffer64_LookupString(p) + return +} + +func AlcAcctOCIAllPackOffer64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 86) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIAllPackOffer64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 86) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIAllPackOffer64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 86) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIAllPackOffer64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 86) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIAllPackOffer64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 86, a) +} + +func AlcAcctOCIAllPackOffer64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 86, a) +} + +func AlcAcctOCIAllPackOffer64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 86) +} + +func AlcAcctOCIInprOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 87, a) +} + +func AlcAcctOCIInprOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 87, a) +} + +func AlcAcctOCIInprOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIInprOctsDrop64_Lookup(p) + return +} + +func AlcAcctOCIInprOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIInprOctsDrop64_LookupString(p) + return +} + +func AlcAcctOCIInprOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 87) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 87) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 87) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIInprOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 87) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIInprOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 87, a) +} + +func AlcAcctOCIInprOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 87, a) +} + +func AlcAcctOCIInprOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 87) +} + +func AlcAcctOCIOutprOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 88, a) +} + +func AlcAcctOCIOutprOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 88, a) +} + +func AlcAcctOCIOutprOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIOutprOctsDrop64_Lookup(p) + return +} + +func AlcAcctOCIOutprOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIOutprOctsDrop64_LookupString(p) + return +} + +func AlcAcctOCIOutprOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 88) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 88) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 88) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIOutprOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 88) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIOutprOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 88, a) +} + +func AlcAcctOCIOutprOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 88, a) +} + +func AlcAcctOCIOutprOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 88) +} + +func AlcAcctOCIInprPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 89, a) +} + +func AlcAcctOCIInprPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 89, a) +} + +func AlcAcctOCIInprPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIInprPackDrop64_Lookup(p) + return +} + +func AlcAcctOCIInprPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIInprPackDrop64_LookupString(p) + return +} + +func AlcAcctOCIInprPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 89) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 89) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIInprPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 89) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIInprPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 89) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIInprPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 89, a) +} + +func AlcAcctOCIInprPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 89, a) +} + +func AlcAcctOCIInprPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 89) +} + +func AlcAcctOCIOutprPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 90, a) +} + +func AlcAcctOCIOutprPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 90, a) +} + +func AlcAcctOCIOutprPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCIOutprPackDrop64_Lookup(p) + return +} + +func AlcAcctOCIOutprPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCIOutprPackDrop64_LookupString(p) + return +} + +func AlcAcctOCIOutprPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 90) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 90) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCIOutprPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 90) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCIOutprPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 90) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCIOutprPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 90, a) +} + +func AlcAcctOCIOutprPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 90, a) +} + +func AlcAcctOCIOutprPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 90) +} + +func AlcAcctOCOInprPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 91, a) +} + +func AlcAcctOCOInprPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 91, a) +} + +func AlcAcctOCOInprPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOInprPackDrop64_Lookup(p) + return +} + +func AlcAcctOCOInprPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOInprPackDrop64_LookupString(p) + return +} + +func AlcAcctOCOInprPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 91) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 91) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 91) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOInprPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 91) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOInprPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 91, a) +} + +func AlcAcctOCOInprPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 91, a) +} + +func AlcAcctOCOInprPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 91) +} + +func AlcAcctOCOOutprPackDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 92, a) +} + +func AlcAcctOCOOutprPackDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 92, a) +} + +func AlcAcctOCOOutprPackDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOOutprPackDrop64_Lookup(p) + return +} + +func AlcAcctOCOOutprPackDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOOutprPackDrop64_LookupString(p) + return +} + +func AlcAcctOCOOutprPackDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 92) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprPackDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 92) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprPackDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 92) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOOutprPackDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 92) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOOutprPackDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 92, a) +} + +func AlcAcctOCOOutprPackDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 92, a) +} + +func AlcAcctOCOOutprPackDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 92) +} + +func AlcAcctOCOInprOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 93, a) +} + +func AlcAcctOCOInprOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 93, a) +} + +func AlcAcctOCOInprOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOInprOctsDrop64_Lookup(p) + return +} + +func AlcAcctOCOInprOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOInprOctsDrop64_LookupString(p) + return +} + +func AlcAcctOCOInprOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 93) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 93) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOInprOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 93) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOInprOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 93) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOInprOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 93, a) +} + +func AlcAcctOCOInprOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 93, a) +} + +func AlcAcctOCOInprOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 93) +} + +func AlcAcctOCOOutprOctsDrop64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 94, a) +} + +func AlcAcctOCOOutprOctsDrop64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 94, a) +} + +func AlcAcctOCOOutprOctsDrop64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOCOOutprOctsDrop64_Lookup(p) + return +} + +func AlcAcctOCOOutprOctsDrop64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOCOOutprOctsDrop64_LookupString(p) + return +} + +func AlcAcctOCOOutprOctsDrop64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 94) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprOctsDrop64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 94) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOCOOutprOctsDrop64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOCOOutprOctsDrop64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOCOOutprOctsDrop64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 94, a) +} + +func AlcAcctOCOOutprOctsDrop64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 94, a) +} + +func AlcAcctOCOOutprOctsDrop64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 94) +} + +func AlcCreditControlCategoryMap_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 95, a) +} + +func AlcCreditControlCategoryMap_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 95, a) +} + +func AlcCreditControlCategoryMap_Get(p *radius.Packet) (value []byte) { + value, _ = AlcCreditControlCategoryMap_Lookup(p) + return +} + +func AlcCreditControlCategoryMap_GetString(p *radius.Packet) (value string) { + value, _ = AlcCreditControlCategoryMap_LookupString(p) + return +} + +func AlcCreditControlCategoryMap_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 95) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreditControlCategoryMap_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 95) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreditControlCategoryMap_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 95) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcCreditControlCategoryMap_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 95) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcCreditControlCategoryMap_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 95, a) +} + +func AlcCreditControlCategoryMap_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 95, a) +} + +func AlcCreditControlCategoryMap_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 95) +} + +func AlcCreditControlQuota_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 96, a) +} + +func AlcCreditControlQuota_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 96, a) +} + +func AlcCreditControlQuota_Get(p *radius.Packet) (value []byte) { + value, _ = AlcCreditControlQuota_Lookup(p) + return +} + +func AlcCreditControlQuota_GetString(p *radius.Packet) (value string) { + value, _ = AlcCreditControlQuota_LookupString(p) + return +} + +func AlcCreditControlQuota_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 96) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreditControlQuota_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 96) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcCreditControlQuota_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 96) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcCreditControlQuota_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 96) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcCreditControlQuota_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 96, a) +} + +func AlcCreditControlQuota_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 96, a) +} + +func AlcCreditControlQuota_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 96) +} + +type AlcTunnelChallenge uint32 + +const ( + AlcTunnelChallenge_Value_Never AlcTunnelChallenge = 1 + AlcTunnelChallenge_Value_Always AlcTunnelChallenge = 2 +) + +var AlcTunnelChallenge_Strings = map[AlcTunnelChallenge]string{ + AlcTunnelChallenge_Value_Never: "never", + AlcTunnelChallenge_Value_Always: "always", +} + +func (a AlcTunnelChallenge) String() string { + if str, ok := AlcTunnelChallenge_Strings[a]; ok { + return str + } + return "AlcTunnelChallenge(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelChallenge_Add(p *radius.Packet, tag byte, value AlcTunnelChallenge) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 97, a) +} + +func AlcTunnelChallenge_Get(p *radius.Packet) (tag byte, value AlcTunnelChallenge) { + tag, value, _ = AlcTunnelChallenge_Lookup(p) + return +} + +func AlcTunnelChallenge_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelChallenge, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 97) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelChallenge(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelChallenge_Lookup(p *radius.Packet) (tag byte, value AlcTunnelChallenge, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 97) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelChallenge(i) + return +} + +func AlcTunnelChallenge_Set(p *radius.Packet, tag byte, value AlcTunnelChallenge) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 97, a) +} + +func AlcTunnelChallenge_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 97) +} + +func AlcForceNak_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 98, a) +} + +func AlcForceNak_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 98, a) +} + +func AlcForceNak_Get(p *radius.Packet) (value []byte) { + value, _ = AlcForceNak_Lookup(p) + return +} + +func AlcForceNak_GetString(p *radius.Packet) (value string) { + value, _ = AlcForceNak_LookupString(p) + return +} + +func AlcForceNak_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 98) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceNak_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 98) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceNak_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 98) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcForceNak_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 98) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcForceNak_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 98, a) +} + +func AlcForceNak_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 98, a) +} + +func AlcForceNak_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 98) +} + +func AlcIpv6Address_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 99, a) +} + +func AlcIpv6Address_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcIpv6Address_Lookup(p) + return +} + +func AlcIpv6Address_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 99) { + i, err = radius.IPv6Addr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIpv6Address_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 99) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Addr(a) + return +} + +func AlcIpv6Address_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 99, a) +} + +func AlcIpv6Address_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 99) +} + +type AlcServID uint32 + +var AlcServID_Strings = map[AlcServID]string{} + +func (a AlcServID) String() string { + if str, ok := AlcServID_Strings[a]; ok { + return str + } + return "AlcServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcServID_Add(p *radius.Packet, value AlcServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 100, a) +} + +func AlcServID_Get(p *radius.Packet) (value AlcServID) { + value, _ = AlcServID_Lookup(p) + return +} + +func AlcServID_Gets(p *radius.Packet) (values []AlcServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 100) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcServID(i)) + } + return +} + +func AlcServID_Lookup(p *radius.Packet) (value AlcServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 100) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcServID(i) + return +} + +func AlcServID_Set(p *radius.Packet, value AlcServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 100, a) +} + +func AlcServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 100) +} + +func AlcInterface_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 101, a) +} + +func AlcInterface_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 101, a) +} + +func AlcInterface_Get(p *radius.Packet) (value []byte) { + value, _ = AlcInterface_Lookup(p) + return +} + +func AlcInterface_GetString(p *radius.Packet) (value string) { + value, _ = AlcInterface_LookupString(p) + return +} + +func AlcInterface_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 101) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcInterface_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 101) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcInterface_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 101) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcInterface_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 101) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcInterface_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 101, a) +} + +func AlcInterface_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 101, a) +} + +func AlcInterface_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 101) +} + +func AlcToServerDhcpOptions_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 102, a) +} + +func AlcToServerDhcpOptions_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 102, a) +} + +func AlcToServerDhcpOptions_Get(p *radius.Packet) (value []byte) { + value, _ = AlcToServerDhcpOptions_Lookup(p) + return +} + +func AlcToServerDhcpOptions_GetString(p *radius.Packet) (value string) { + value, _ = AlcToServerDhcpOptions_LookupString(p) + return +} + +func AlcToServerDhcpOptions_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 102) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToServerDhcpOptions_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 102) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToServerDhcpOptions_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 102) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcToServerDhcpOptions_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 102) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcToServerDhcpOptions_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 102, a) +} + +func AlcToServerDhcpOptions_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 102, a) +} + +func AlcToServerDhcpOptions_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 102) +} + +func AlcToClientDhcpOptions_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 103, a) +} + +func AlcToClientDhcpOptions_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 103, a) +} + +func AlcToClientDhcpOptions_Get(p *radius.Packet) (value []byte) { + value, _ = AlcToClientDhcpOptions_Lookup(p) + return +} + +func AlcToClientDhcpOptions_GetString(p *radius.Packet) (value string) { + value, _ = AlcToClientDhcpOptions_LookupString(p) + return +} + +func AlcToClientDhcpOptions_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 103) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToClientDhcpOptions_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 103) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToClientDhcpOptions_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 103) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcToClientDhcpOptions_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 103) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcToClientDhcpOptions_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 103, a) +} + +func AlcToClientDhcpOptions_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 103, a) +} + +func AlcToClientDhcpOptions_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 103) +} + +type AlcTunnelServID uint32 + +var AlcTunnelServID_Strings = map[AlcTunnelServID]string{} + +func (a AlcTunnelServID) String() string { + if str, ok := AlcTunnelServID_Strings[a]; ok { + return str + } + return "AlcTunnelServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelServID_Add(p *radius.Packet, value AlcTunnelServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 104, a) +} + +func AlcTunnelServID_Get(p *radius.Packet) (value AlcTunnelServID) { + value, _ = AlcTunnelServID_Lookup(p) + return +} + +func AlcTunnelServID_Gets(p *radius.Packet) (values []AlcTunnelServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 104) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelServID(i)) + } + return +} + +func AlcTunnelServID_Lookup(p *radius.Packet) (value AlcTunnelServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 104) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelServID(i) + return +} + +func AlcTunnelServID_Set(p *radius.Packet, value AlcTunnelServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 104, a) +} + +func AlcTunnelServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 104) +} + +func AlcIpv6PrimaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 105, a) +} + +func AlcIpv6PrimaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcIpv6PrimaryDNS_Lookup(p) + return +} + +func AlcIpv6PrimaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 105) { + i, err = radius.IPv6Addr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIpv6PrimaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 105) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Addr(a) + return +} + +func AlcIpv6PrimaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 105, a) +} + +func AlcIpv6PrimaryDNS_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 105) +} + +func AlcIpv6SecondaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 106, a) +} + +func AlcIpv6SecondaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcIpv6SecondaryDNS_Lookup(p) + return +} + +func AlcIpv6SecondaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 106) { + i, err = radius.IPv6Addr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIpv6SecondaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 106) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Addr(a) + return +} + +func AlcIpv6SecondaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 106, a) +} + +func AlcIpv6SecondaryDNS_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 106) +} + +func AlcAcctIStatmode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 107, a) +} + +func AlcAcctIStatmode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 107, a) +} + +func AlcAcctIStatmode_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIStatmode_Lookup(p) + return +} + +func AlcAcctIStatmode_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIStatmode_LookupString(p) + return +} + +func AlcAcctIStatmode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 107) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIStatmode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 107) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIStatmode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 107) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIStatmode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 107) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIStatmode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 107, a) +} + +func AlcAcctIStatmode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 107, a) +} + +func AlcAcctIStatmode_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 107) +} + +func AlcAcctIHiprioOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 108, a) +} + +func AlcAcctIHiprioOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 108, a) +} + +func AlcAcctIHiprioOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHiprioOctets64_Lookup(p) + return +} + +func AlcAcctIHiprioOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHiprioOctets64_LookupString(p) + return +} + +func AlcAcctIHiprioOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 108) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHiprioOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 108) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHiprioOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 108) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHiprioOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 108) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHiprioOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 108, a) +} + +func AlcAcctIHiprioOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 108, a) +} + +func AlcAcctIHiprioOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 108) +} + +func AlcAcctILowprioOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 109, a) +} + +func AlcAcctILowprioOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 109, a) +} + +func AlcAcctILowprioOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowprioOctets64_Lookup(p) + return +} + +func AlcAcctILowprioOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowprioOctets64_LookupString(p) + return +} + +func AlcAcctILowprioOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 109) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowprioOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 109) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowprioOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 109) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowprioOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 109) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowprioOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 109, a) +} + +func AlcAcctILowprioOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 109, a) +} + +func AlcAcctILowprioOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 109) +} + +func AlcAcctOHiprioOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 110, a) +} + +func AlcAcctOHiprioOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 110, a) +} + +func AlcAcctOHiprioOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOHiprioOctets64_Lookup(p) + return +} + +func AlcAcctOHiprioOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOHiprioOctets64_LookupString(p) + return +} + +func AlcAcctOHiprioOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 110) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOHiprioOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 110) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOHiprioOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 110) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOHiprioOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 110) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOHiprioOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 110, a) +} + +func AlcAcctOHiprioOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 110, a) +} + +func AlcAcctOHiprioOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 110) +} + +func AlcAcctOLowprioOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 111, a) +} + +func AlcAcctOLowprioOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 111, a) +} + +func AlcAcctOLowprioOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOLowprioOctets64_Lookup(p) + return +} + +func AlcAcctOLowprioOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOLowprioOctets64_LookupString(p) + return +} + +func AlcAcctOLowprioOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 111) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOLowprioOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 111) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOLowprioOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 111) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOLowprioOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 111) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOLowprioOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 111, a) +} + +func AlcAcctOLowprioOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 111, a) +} + +func AlcAcctOLowprioOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 111) +} + +func AlcAcctIHiprioPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 112, a) +} + +func AlcAcctIHiprioPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 112, a) +} + +func AlcAcctIHiprioPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIHiprioPackets64_Lookup(p) + return +} + +func AlcAcctIHiprioPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIHiprioPackets64_LookupString(p) + return +} + +func AlcAcctIHiprioPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 112) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHiprioPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 112) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIHiprioPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 112) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIHiprioPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 112) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIHiprioPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 112, a) +} + +func AlcAcctIHiprioPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 112, a) +} + +func AlcAcctIHiprioPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 112) +} + +func AlcAcctILowprioPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 113, a) +} + +func AlcAcctILowprioPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 113, a) +} + +func AlcAcctILowprioPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctILowprioPackets64_Lookup(p) + return +} + +func AlcAcctILowprioPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctILowprioPackets64_LookupString(p) + return +} + +func AlcAcctILowprioPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 113) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowprioPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 113) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctILowprioPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 113) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctILowprioPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 113) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctILowprioPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 113, a) +} + +func AlcAcctILowprioPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 113, a) +} + +func AlcAcctILowprioPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 113) +} + +func AlcAcctOHiprioPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 114, a) +} + +func AlcAcctOHiprioPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 114, a) +} + +func AlcAcctOHiprioPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOHiprioPackets64_Lookup(p) + return +} + +func AlcAcctOHiprioPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOHiprioPackets64_LookupString(p) + return +} + +func AlcAcctOHiprioPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 114) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOHiprioPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 114) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOHiprioPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 114) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOHiprioPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 114) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOHiprioPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 114, a) +} + +func AlcAcctOHiprioPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 114, a) +} + +func AlcAcctOHiprioPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 114) +} + +func AlcAcctOLowprioPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 115, a) +} + +func AlcAcctOLowprioPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 115, a) +} + +func AlcAcctOLowprioPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOLowprioPackets64_Lookup(p) + return +} + +func AlcAcctOLowprioPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOLowprioPackets64_LookupString(p) + return +} + +func AlcAcctOLowprioPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 115) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOLowprioPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 115) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOLowprioPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 115) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOLowprioPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 115) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOLowprioPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 115, a) +} + +func AlcAcctOLowprioPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 115, a) +} + +func AlcAcctOLowprioPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 115) +} + +func AlcAcctIAllOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 116, a) +} + +func AlcAcctIAllOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 116, a) +} + +func AlcAcctIAllOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIAllOctets64_Lookup(p) + return +} + +func AlcAcctIAllOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIAllOctets64_LookupString(p) + return +} + +func AlcAcctIAllOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 116) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 116) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 116) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIAllOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 116) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIAllOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 116, a) +} + +func AlcAcctIAllOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 116, a) +} + +func AlcAcctIAllOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 116) +} + +func AlcAcctOAllOctets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 117, a) +} + +func AlcAcctOAllOctets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 117, a) +} + +func AlcAcctOAllOctets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOAllOctets64_Lookup(p) + return +} + +func AlcAcctOAllOctets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOAllOctets64_LookupString(p) + return +} + +func AlcAcctOAllOctets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 117) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOAllOctets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 117) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOAllOctets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 117) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOAllOctets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 117) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOAllOctets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 117, a) +} + +func AlcAcctOAllOctets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 117, a) +} + +func AlcAcctOAllOctets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 117) +} + +func AlcAcctIAllPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 118, a) +} + +func AlcAcctIAllPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 118, a) +} + +func AlcAcctIAllPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctIAllPackets64_Lookup(p) + return +} + +func AlcAcctIAllPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctIAllPackets64_LookupString(p) + return +} + +func AlcAcctIAllPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 118) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 118) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctIAllPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 118) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctIAllPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 118) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctIAllPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 118, a) +} + +func AlcAcctIAllPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 118, a) +} + +func AlcAcctIAllPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 118) +} + +func AlcAcctOAllPackets64_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 119, a) +} + +func AlcAcctOAllPackets64_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 119, a) +} + +func AlcAcctOAllPackets64_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOAllPackets64_Lookup(p) + return +} + +func AlcAcctOAllPackets64_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOAllPackets64_LookupString(p) + return +} + +func AlcAcctOAllPackets64_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 119) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOAllPackets64_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 119) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOAllPackets64_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 119) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOAllPackets64_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 119) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOAllPackets64_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 119, a) +} + +func AlcAcctOAllPackets64_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 119, a) +} + +func AlcAcctOAllPackets64_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 119) +} + +type AlcTunnelRxWindowSize uint32 + +var AlcTunnelRxWindowSize_Strings = map[AlcTunnelRxWindowSize]string{} + +func (a AlcTunnelRxWindowSize) String() string { + if str, ok := AlcTunnelRxWindowSize_Strings[a]; ok { + return str + } + return "AlcTunnelRxWindowSize(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcTunnelRxWindowSize_Add(p *radius.Packet, tag byte, value AlcTunnelRxWindowSize) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 120, a) +} + +func AlcTunnelRxWindowSize_Get(p *radius.Packet) (tag byte, value AlcTunnelRxWindowSize) { + tag, value, _ = AlcTunnelRxWindowSize_Lookup(p) + return +} + +func AlcTunnelRxWindowSize_Gets(p *radius.Packet) (tags []byte, values []AlcTunnelRxWindowSize, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 120) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcTunnelRxWindowSize(i)) + tags = append(tags, tag) + } + return +} + +func AlcTunnelRxWindowSize_Lookup(p *radius.Packet) (tag byte, value AlcTunnelRxWindowSize, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 120) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcTunnelRxWindowSize(i) + return +} + +func AlcTunnelRxWindowSize_Set(p *radius.Packet, tag byte, value AlcTunnelRxWindowSize) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 120, a) +} + +func AlcTunnelRxWindowSize_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 120) +} + +func AlcNatPortRange_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 121, a) +} + +func AlcNatPortRange_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 121, a) +} + +func AlcNatPortRange_Get(p *radius.Packet) (value []byte) { + value, _ = AlcNatPortRange_Lookup(p) + return +} + +func AlcNatPortRange_GetString(p *radius.Packet) (value string) { + value, _ = AlcNatPortRange_LookupString(p) + return +} + +func AlcNatPortRange_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 121) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcNatPortRange_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 121) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcNatPortRange_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 121) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcNatPortRange_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 121) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcNatPortRange_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 121, a) +} + +func AlcNatPortRange_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 121, a) +} + +func AlcNatPortRange_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 121) +} + +type AlcLIAction uint32 + +const ( + AlcLIAction_Value_NoAction AlcLIAction = 1 + AlcLIAction_Value_Enable AlcLIAction = 2 + AlcLIAction_Value_Disable AlcLIAction = 3 +) + +var AlcLIAction_Strings = map[AlcLIAction]string{ + AlcLIAction_Value_NoAction: "no-action", + AlcLIAction_Value_Enable: "enable", + AlcLIAction_Value_Disable: "disable", +} + +func (a AlcLIAction) String() string { + if str, ok := AlcLIAction_Strings[a]; ok { + return str + } + return "AlcLIAction(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLIAction_Add(p *radius.Packet, value AlcLIAction) (err error) { + a := radius.NewInteger(uint32(value)) + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(a, salt[:], p.Secret, p.Authenticator[:]) + return _AlcatelLucentServiceRouter_AddVendor(p, 122, a) +} + +func AlcLIAction_Get(p, q *radius.Packet) (value AlcLIAction) { + value, _ = AlcLIAction_Lookup(p, q) + return +} + +func AlcLIAction_Gets(p, q *radius.Packet) (values []AlcLIAction, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 122) { + attr, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLIAction(i)) + } + return +} + +func AlcLIAction_Lookup(p, q *radius.Packet) (value AlcLIAction, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 122) + if !ok { + err = radius.ErrNoAttribute + return + } + a, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLIAction(i) + return +} + +func AlcLIAction_Set(p *radius.Packet, value AlcLIAction) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 122, a) +} + +func AlcLIAction_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 122) +} + +func AlcLIDestination_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(value, salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 123, a) +} + +func AlcLIDestination_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword([]byte(value), salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 123, a) +} + +func AlcLIDestination_Get(p, q *radius.Packet) (value []byte) { + value, _ = AlcLIDestination_Lookup(p, q) + return +} + +func AlcLIDestination_GetString(p, q *radius.Packet) (value string) { + value, _ = AlcLIDestination_LookupString(p, q) + return +} + +func AlcLIDestination_Gets(p, q *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 123) { + i, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcLIDestination_GetStrings(p, q *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 123) { + var up []byte + up, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err == nil { + i = string(up) + } + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcLIDestination_Lookup(p, q *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 123) + if !ok { + err = radius.ErrNoAttribute + return + } + value, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + return +} + +func AlcLIDestination_LookupString(p, q *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 123) + if !ok { + err = radius.ErrNoAttribute + return + } + var b []byte + b, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err == nil { + value = string(b) + } + return +} + +func AlcLIDestination_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(value, salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 123, a) +} + +func AlcLIDestination_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword([]byte(value), salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 123, a) +} + +func AlcLIDestination_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 123) +} + +type AlcLIFC uint32 + +const ( + AlcLIFC_Value_Be AlcLIFC = 0 + AlcLIFC_Value_L2 AlcLIFC = 1 + AlcLIFC_Value_Af AlcLIFC = 2 + AlcLIFC_Value_L1 AlcLIFC = 3 + AlcLIFC_Value_H2 AlcLIFC = 4 + AlcLIFC_Value_Ef AlcLIFC = 5 + AlcLIFC_Value_H1 AlcLIFC = 6 + AlcLIFC_Value_Nc AlcLIFC = 7 +) + +var AlcLIFC_Strings = map[AlcLIFC]string{ + AlcLIFC_Value_Be: "be", + AlcLIFC_Value_L2: "l2", + AlcLIFC_Value_Af: "af", + AlcLIFC_Value_L1: "l1", + AlcLIFC_Value_H2: "h2", + AlcLIFC_Value_Ef: "ef", + AlcLIFC_Value_H1: "h1", + AlcLIFC_Value_Nc: "nc", +} + +func (a AlcLIFC) String() string { + if str, ok := AlcLIFC_Strings[a]; ok { + return str + } + return "AlcLIFC(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLIFC_Add(p *radius.Packet, value AlcLIFC) (err error) { + a := radius.NewInteger(uint32(value)) + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(a, salt[:], p.Secret, p.Authenticator[:]) + return _AlcatelLucentServiceRouter_AddVendor(p, 124, a) +} + +func AlcLIFC_Get(p, q *radius.Packet) (value AlcLIFC) { + value, _ = AlcLIFC_Lookup(p, q) + return +} + +func AlcLIFC_Gets(p, q *radius.Packet) (values []AlcLIFC, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 124) { + attr, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLIFC(i)) + } + return +} + +func AlcLIFC_Lookup(p, q *radius.Packet) (value AlcLIFC, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 124) + if !ok { + err = radius.ErrNoAttribute + return + } + a, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLIFC(i) + return +} + +func AlcLIFC_Set(p *radius.Packet, value AlcLIFC) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 124, a) +} + +func AlcLIFC_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 124) +} + +type AlcLIDirection uint32 + +const ( + AlcLIDirection_Value_Ingress AlcLIDirection = 1 + AlcLIDirection_Value_Egress AlcLIDirection = 2 +) + +var AlcLIDirection_Strings = map[AlcLIDirection]string{ + AlcLIDirection_Value_Ingress: "ingress", + AlcLIDirection_Value_Egress: "egress", +} + +func (a AlcLIDirection) String() string { + if str, ok := AlcLIDirection_Strings[a]; ok { + return str + } + return "AlcLIDirection(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLIDirection_Add(p *radius.Packet, value AlcLIDirection) (err error) { + a := radius.NewInteger(uint32(value)) + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(a, salt[:], p.Secret, p.Authenticator[:]) + return _AlcatelLucentServiceRouter_AddVendor(p, 125, a) +} + +func AlcLIDirection_Get(p, q *radius.Packet) (value AlcLIDirection) { + value, _ = AlcLIDirection_Lookup(p, q) + return +} + +func AlcLIDirection_Gets(p, q *radius.Packet) (values []AlcLIDirection, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 125) { + attr, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLIDirection(i)) + } + return +} + +func AlcLIDirection_Lookup(p, q *radius.Packet) (value AlcLIDirection, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 125) + if !ok { + err = radius.ErrNoAttribute + return + } + a, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLIDirection(i) + return +} + +func AlcLIDirection_Set(p *radius.Packet, value AlcLIDirection) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 125, a) +} + +func AlcLIDirection_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 125) +} + +func AlcSubscriberQoSOverride_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 126, a) +} + +func AlcSubscriberQoSOverride_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 126, a) +} + +func AlcSubscriberQoSOverride_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSubscriberQoSOverride_Lookup(p) + return +} + +func AlcSubscriberQoSOverride_GetString(p *radius.Packet) (value string) { + value, _ = AlcSubscriberQoSOverride_LookupString(p) + return +} + +func AlcSubscriberQoSOverride_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 126) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscriberQoSOverride_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 126) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscriberQoSOverride_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 126) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSubscriberQoSOverride_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 126) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSubscriberQoSOverride_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 126, a) +} + +func AlcSubscriberQoSOverride_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 126, a) +} + +func AlcSubscriberQoSOverride_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 126) +} + +func AlcAcctOStatmode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 127, a) +} + +func AlcAcctOStatmode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 127, a) +} + +func AlcAcctOStatmode_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAcctOStatmode_Lookup(p) + return +} + +func AlcAcctOStatmode_GetString(p *radius.Packet) (value string) { + value, _ = AlcAcctOStatmode_LookupString(p) + return +} + +func AlcAcctOStatmode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 127) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOStatmode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 127) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAcctOStatmode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 127) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAcctOStatmode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 127) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAcctOStatmode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 127, a) +} + +func AlcAcctOStatmode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 127, a) +} + +func AlcAcctOStatmode_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 127) +} + +type AlcATMIngressTDProfile uint32 + +var AlcATMIngressTDProfile_Strings = map[AlcATMIngressTDProfile]string{} + +func (a AlcATMIngressTDProfile) String() string { + if str, ok := AlcATMIngressTDProfile_Strings[a]; ok { + return str + } + return "AlcATMIngressTDProfile(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcATMIngressTDProfile_Add(p *radius.Packet, value AlcATMIngressTDProfile) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 128, a) +} + +func AlcATMIngressTDProfile_Get(p *radius.Packet) (value AlcATMIngressTDProfile) { + value, _ = AlcATMIngressTDProfile_Lookup(p) + return +} + +func AlcATMIngressTDProfile_Gets(p *radius.Packet) (values []AlcATMIngressTDProfile, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 128) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcATMIngressTDProfile(i)) + } + return +} + +func AlcATMIngressTDProfile_Lookup(p *radius.Packet) (value AlcATMIngressTDProfile, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 128) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcATMIngressTDProfile(i) + return +} + +func AlcATMIngressTDProfile_Set(p *radius.Packet, value AlcATMIngressTDProfile) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 128, a) +} + +func AlcATMIngressTDProfile_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 128) +} + +type AlcATMEgressTDProfile uint32 + +var AlcATMEgressTDProfile_Strings = map[AlcATMEgressTDProfile]string{} + +func (a AlcATMEgressTDProfile) String() string { + if str, ok := AlcATMEgressTDProfile_Strings[a]; ok { + return str + } + return "AlcATMEgressTDProfile(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcATMEgressTDProfile_Add(p *radius.Packet, value AlcATMEgressTDProfile) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 129, a) +} + +func AlcATMEgressTDProfile_Get(p *radius.Packet) (value AlcATMEgressTDProfile) { + value, _ = AlcATMEgressTDProfile_Lookup(p) + return +} + +func AlcATMEgressTDProfile_Gets(p *radius.Packet) (values []AlcATMEgressTDProfile, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 129) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcATMEgressTDProfile(i)) + } + return +} + +func AlcATMEgressTDProfile_Lookup(p *radius.Packet) (value AlcATMEgressTDProfile, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 129) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcATMEgressTDProfile(i) + return +} + +func AlcATMEgressTDProfile_Set(p *radius.Packet, value AlcATMEgressTDProfile) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 129, a) +} + +func AlcATMEgressTDProfile_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 129) +} + +type AlcAATransitIP uint32 + +const ( + AlcAATransitIP_Value_Host AlcAATransitIP = 1 + AlcAATransitIP_Value_AuditStart AlcAATransitIP = 2 + AlcAATransitIP_Value_AuditEnd AlcAATransitIP = 3 +) + +var AlcAATransitIP_Strings = map[AlcAATransitIP]string{ + AlcAATransitIP_Value_Host: "host", + AlcAATransitIP_Value_AuditStart: "audit-start", + AlcAATransitIP_Value_AuditEnd: "audit-end", +} + +func (a AlcAATransitIP) String() string { + if str, ok := AlcAATransitIP_Strings[a]; ok { + return str + } + return "AlcAATransitIP(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcAATransitIP_Add(p *radius.Packet, value AlcAATransitIP) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 130, a) +} + +func AlcAATransitIP_Get(p *radius.Packet) (value AlcAATransitIP) { + value, _ = AlcAATransitIP_Lookup(p) + return +} + +func AlcAATransitIP_Gets(p *radius.Packet) (values []AlcAATransitIP, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 130) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcAATransitIP(i)) + } + return +} + +func AlcAATransitIP_Lookup(p *radius.Packet) (value AlcAATransitIP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 130) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcAATransitIP(i) + return +} + +func AlcAATransitIP_Set(p *radius.Packet, value AlcAATransitIP) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 130, a) +} + +func AlcAATransitIP_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 130) +} + +func AlcDelegatedIPv6Pool_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 131, a) +} + +func AlcDelegatedIPv6Pool_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 131, a) +} + +func AlcDelegatedIPv6Pool_Get(p *radius.Packet) (value []byte) { + value, _ = AlcDelegatedIPv6Pool_Lookup(p) + return +} + +func AlcDelegatedIPv6Pool_GetString(p *radius.Packet) (value string) { + value, _ = AlcDelegatedIPv6Pool_LookupString(p) + return +} + +func AlcDelegatedIPv6Pool_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 131) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDelegatedIPv6Pool_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 131) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDelegatedIPv6Pool_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 131) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcDelegatedIPv6Pool_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 131) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcDelegatedIPv6Pool_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 131, a) +} + +func AlcDelegatedIPv6Pool_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 131, a) +} + +func AlcDelegatedIPv6Pool_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 131) +} + +type AlcAccessLoopRateDown uint32 + +var AlcAccessLoopRateDown_Strings = map[AlcAccessLoopRateDown]string{} + +func (a AlcAccessLoopRateDown) String() string { + if str, ok := AlcAccessLoopRateDown_Strings[a]; ok { + return str + } + return "AlcAccessLoopRateDown(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcAccessLoopRateDown_Add(p *radius.Packet, value AlcAccessLoopRateDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 132, a) +} + +func AlcAccessLoopRateDown_Get(p *radius.Packet) (value AlcAccessLoopRateDown) { + value, _ = AlcAccessLoopRateDown_Lookup(p) + return +} + +func AlcAccessLoopRateDown_Gets(p *radius.Packet) (values []AlcAccessLoopRateDown, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 132) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcAccessLoopRateDown(i)) + } + return +} + +func AlcAccessLoopRateDown_Lookup(p *radius.Packet) (value AlcAccessLoopRateDown, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 132) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcAccessLoopRateDown(i) + return +} + +func AlcAccessLoopRateDown_Set(p *radius.Packet, value AlcAccessLoopRateDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 132, a) +} + +func AlcAccessLoopRateDown_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 132) +} + +func AlcAccessLoopEncapOffset_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 133, a) +} + +func AlcAccessLoopEncapOffset_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 133, a) +} + +func AlcAccessLoopEncapOffset_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAccessLoopEncapOffset_Lookup(p) + return +} + +func AlcAccessLoopEncapOffset_GetString(p *radius.Packet) (value string) { + value, _ = AlcAccessLoopEncapOffset_LookupString(p) + return +} + +func AlcAccessLoopEncapOffset_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 133) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAccessLoopEncapOffset_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 133) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAccessLoopEncapOffset_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 133) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAccessLoopEncapOffset_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 133) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAccessLoopEncapOffset_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 133, a) +} + +func AlcAccessLoopEncapOffset_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 133, a) +} + +func AlcAccessLoopEncapOffset_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 133) +} + +func AlcSubscriberFilter_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 134, a) +} + +func AlcSubscriberFilter_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 134, a) +} + +func AlcSubscriberFilter_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSubscriberFilter_Lookup(p) + return +} + +func AlcSubscriberFilter_GetString(p *radius.Packet) (value string) { + value, _ = AlcSubscriberFilter_LookupString(p) + return +} + +func AlcSubscriberFilter_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 134) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscriberFilter_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 134) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSubscriberFilter_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 134) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSubscriberFilter_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 134) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSubscriberFilter_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 134, a) +} + +func AlcSubscriberFilter_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 134, a) +} + +func AlcSubscriberFilter_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 134) +} + +type AlcPPPForceIPv6CP uint32 + +var AlcPPPForceIPv6CP_Strings = map[AlcPPPForceIPv6CP]string{} + +func (a AlcPPPForceIPv6CP) String() string { + if str, ok := AlcPPPForceIPv6CP_Strings[a]; ok { + return str + } + return "AlcPPPForceIPv6CP(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcPPPForceIPv6CP_Add(p *radius.Packet, value AlcPPPForceIPv6CP) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 135, a) +} + +func AlcPPPForceIPv6CP_Get(p *radius.Packet) (value AlcPPPForceIPv6CP) { + value, _ = AlcPPPForceIPv6CP_Lookup(p) + return +} + +func AlcPPPForceIPv6CP_Gets(p *radius.Packet) (values []AlcPPPForceIPv6CP, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 135) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcPPPForceIPv6CP(i)) + } + return +} + +func AlcPPPForceIPv6CP_Lookup(p *radius.Packet) (value AlcPPPForceIPv6CP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 135) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcPPPForceIPv6CP(i) + return +} + +func AlcPPPForceIPv6CP_Set(p *radius.Packet, value AlcPPPForceIPv6CP) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 135, a) +} + +func AlcPPPForceIPv6CP_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 135) +} + +func AlcOnetimeHTTPRedirectionFilterID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 136, a) +} + +func AlcOnetimeHTTPRedirectionFilterID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 136, a) +} + +func AlcOnetimeHTTPRedirectionFilterID_Get(p *radius.Packet) (value []byte) { + value, _ = AlcOnetimeHTTPRedirectionFilterID_Lookup(p) + return +} + +func AlcOnetimeHTTPRedirectionFilterID_GetString(p *radius.Packet) (value string) { + value, _ = AlcOnetimeHTTPRedirectionFilterID_LookupString(p) + return +} + +func AlcOnetimeHTTPRedirectionFilterID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 136) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcOnetimeHTTPRedirectionFilterID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 136) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcOnetimeHTTPRedirectionFilterID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 136) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcOnetimeHTTPRedirectionFilterID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 136) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcOnetimeHTTPRedirectionFilterID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 136, a) +} + +func AlcOnetimeHTTPRedirectionFilterID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 136, a) +} + +func AlcOnetimeHTTPRedirectionFilterID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 136) +} + +func AlcAuthenticationPolicyName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 137, a) +} + +func AlcAuthenticationPolicyName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 137, a) +} + +func AlcAuthenticationPolicyName_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAuthenticationPolicyName_Lookup(p) + return +} + +func AlcAuthenticationPolicyName_GetString(p *radius.Packet) (value string) { + value, _ = AlcAuthenticationPolicyName_LookupString(p) + return +} + +func AlcAuthenticationPolicyName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 137) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAuthenticationPolicyName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 137) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAuthenticationPolicyName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 137) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAuthenticationPolicyName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 137) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAuthenticationPolicyName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 137, a) +} + +func AlcAuthenticationPolicyName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 137, a) +} + +func AlcAuthenticationPolicyName_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 137) +} + +type AlcLIInterceptID uint32 + +var AlcLIInterceptID_Strings = map[AlcLIInterceptID]string{} + +func (a AlcLIInterceptID) String() string { + if str, ok := AlcLIInterceptID_Strings[a]; ok { + return str + } + return "AlcLIInterceptID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLIInterceptID_Add(p *radius.Packet, value AlcLIInterceptID) (err error) { + a := radius.NewInteger(uint32(value)) + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(a, salt[:], p.Secret, p.Authenticator[:]) + return _AlcatelLucentServiceRouter_AddVendor(p, 138, a) +} + +func AlcLIInterceptID_Get(p, q *radius.Packet) (value AlcLIInterceptID) { + value, _ = AlcLIInterceptID_Lookup(p, q) + return +} + +func AlcLIInterceptID_Gets(p, q *radius.Packet) (values []AlcLIInterceptID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 138) { + attr, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLIInterceptID(i)) + } + return +} + +func AlcLIInterceptID_Lookup(p, q *radius.Packet) (value AlcLIInterceptID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 138) + if !ok { + err = radius.ErrNoAttribute + return + } + a, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLIInterceptID(i) + return +} + +func AlcLIInterceptID_Set(p *radius.Packet, value AlcLIInterceptID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 138, a) +} + +func AlcLIInterceptID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 138) +} + +type AlcLISessionID uint32 + +var AlcLISessionID_Strings = map[AlcLISessionID]string{} + +func (a AlcLISessionID) String() string { + if str, ok := AlcLISessionID_Strings[a]; ok { + return str + } + return "AlcLISessionID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLISessionID_Add(p *radius.Packet, value AlcLISessionID) (err error) { + a := radius.NewInteger(uint32(value)) + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(a, salt[:], p.Secret, p.Authenticator[:]) + return _AlcatelLucentServiceRouter_AddVendor(p, 139, a) +} + +func AlcLISessionID_Get(p, q *radius.Packet) (value AlcLISessionID) { + value, _ = AlcLISessionID_Lookup(p, q) + return +} + +func AlcLISessionID_Gets(p, q *radius.Packet) (values []AlcLISessionID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 139) { + attr, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLISessionID(i)) + } + return +} + +func AlcLISessionID_Lookup(p, q *radius.Packet) (value AlcLISessionID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 139) + if !ok { + err = radius.ErrNoAttribute + return + } + a, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLISessionID(i) + return +} + +func AlcLISessionID_Set(p *radius.Packet, value AlcLISessionID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 139, a) +} + +func AlcLISessionID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 139) +} + +type AlcNatOutsideServID uint32 + +var AlcNatOutsideServID_Strings = map[AlcNatOutsideServID]string{} + +func (a AlcNatOutsideServID) String() string { + if str, ok := AlcNatOutsideServID_Strings[a]; ok { + return str + } + return "AlcNatOutsideServID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcNatOutsideServID_Add(p *radius.Packet, value AlcNatOutsideServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 140, a) +} + +func AlcNatOutsideServID_Get(p *radius.Packet) (value AlcNatOutsideServID) { + value, _ = AlcNatOutsideServID_Lookup(p) + return +} + +func AlcNatOutsideServID_Gets(p *radius.Packet) (values []AlcNatOutsideServID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 140) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcNatOutsideServID(i)) + } + return +} + +func AlcNatOutsideServID_Lookup(p *radius.Packet) (value AlcNatOutsideServID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 140) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcNatOutsideServID(i) + return +} + +func AlcNatOutsideServID_Set(p *radius.Packet, value AlcNatOutsideServID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 140, a) +} + +func AlcNatOutsideServID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 140) +} + +func AlcNatOutsideIPAddr_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 141, a) +} + +func AlcNatOutsideIPAddr_Get(p *radius.Packet) (value net.IP) { + value, _ = AlcNatOutsideIPAddr_Lookup(p) + return +} + +func AlcNatOutsideIPAddr_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 141) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcNatOutsideIPAddr_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 141) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func AlcNatOutsideIPAddr_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 141, a) +} + +func AlcNatOutsideIPAddr_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 141) +} + +func AlcAPNPassword_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(value, salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 142, a) +} + +func AlcAPNPassword_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword([]byte(value), salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 142, a) +} + +func AlcAPNPassword_Get(p, q *radius.Packet) (value []byte) { + value, _ = AlcAPNPassword_Lookup(p, q) + return +} + +func AlcAPNPassword_GetString(p, q *radius.Packet) (value string) { + value, _ = AlcAPNPassword_LookupString(p, q) + return +} + +func AlcAPNPassword_Gets(p, q *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 142) { + i, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAPNPassword_GetStrings(p, q *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 142) { + var up []byte + up, _, err = radius.TunnelPassword(attr, p.Secret, q.Authenticator[:]) + if err == nil { + i = string(up) + } + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAPNPassword_Lookup(p, q *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 142) + if !ok { + err = radius.ErrNoAttribute + return + } + value, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + return +} + +func AlcAPNPassword_LookupString(p, q *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 142) + if !ok { + err = radius.ErrNoAttribute + return + } + var b []byte + b, _, err = radius.TunnelPassword(a, p.Secret, q.Authenticator[:]) + if err == nil { + value = string(b) + } + return +} + +func AlcAPNPassword_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword(value, salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 142, a) +} + +func AlcAPNPassword_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + var salt [2]byte + _, err = rand.Read(salt[:]) + if err != nil { + return + } + salt[0] |= 1 << 7 + a, err = radius.NewTunnelPassword([]byte(value), salt[:], p.Secret, p.Authenticator[:]) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 142, a) +} + +func AlcAPNPassword_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 142) +} + +func AlcAPNName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 143, a) +} + +func AlcAPNName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 143, a) +} + +func AlcAPNName_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAPNName_Lookup(p) + return +} + +func AlcAPNName_GetString(p *radius.Packet) (value string) { + value, _ = AlcAPNName_LookupString(p) + return +} + +func AlcAPNName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 143) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAPNName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 143) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAPNName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 143) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAPNName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 143) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAPNName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 143, a) +} + +func AlcAPNName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 143, a) +} + +func AlcAPNName_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 143) +} + +func AlcTunnelAcctPolicy_Add(p *radius.Packet, tag byte, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + if tag <= 0x1F { + a = append(radius.Attribute{tag}, a...) + } + return _AlcatelLucentServiceRouter_AddVendor(p, 144, a) +} + +func AlcTunnelAcctPolicy_AddString(p *radius.Packet, tag byte, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + if tag <= 0x1F { + a = append(radius.Attribute{tag}, a...) + } + return _AlcatelLucentServiceRouter_AddVendor(p, 144, a) +} + +func AlcTunnelAcctPolicy_Get(p *radius.Packet) (tag byte, value []byte) { + tag, value, _ = AlcTunnelAcctPolicy_Lookup(p) + return +} + +func AlcTunnelAcctPolicy_GetString(p *radius.Packet) (tag byte, value string) { + tag, value, _ = AlcTunnelAcctPolicy_LookupString(p) + return +} + +func AlcTunnelAcctPolicy_Gets(p *radius.Packet) (tags []byte, values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 144) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr = attr[1:] + } + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + tags = append(tags, tag) + } + return +} + +func AlcTunnelAcctPolicy_GetStrings(p *radius.Packet) (tags []byte, values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 144) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr = attr[1:] + } + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + tags = append(tags, tag) + } + return +} + +func AlcTunnelAcctPolicy_Lookup(p *radius.Packet) (tag byte, value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 144) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a = a[1:] + } + value = radius.Bytes(a) + return +} + +func AlcTunnelAcctPolicy_LookupString(p *radius.Packet) (tag byte, value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 144) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a = a[1:] + } + value = radius.String(a) + return +} + +func AlcTunnelAcctPolicy_Set(p *radius.Packet, tag byte, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + if tag <= 0x1F { + a = append(radius.Attribute{tag}, a...) + } + return _AlcatelLucentServiceRouter_SetVendor(p, 144, a) +} + +func AlcTunnelAcctPolicy_SetString(p *radius.Packet, tag byte, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + if tag <= 0x1F { + a = append(radius.Attribute{tag}, a...) + } + return _AlcatelLucentServiceRouter_SetVendor(p, 144, a) +} + +func AlcTunnelAcctPolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 144) +} + +type AlcMgwInterfaceType uint32 + +const ( + AlcMgwInterfaceType_Value_Gn AlcMgwInterfaceType = 1 + AlcMgwInterfaceType_Value_S2a AlcMgwInterfaceType = 2 + AlcMgwInterfaceType_Value_S2b AlcMgwInterfaceType = 3 +) + +var AlcMgwInterfaceType_Strings = map[AlcMgwInterfaceType]string{ + AlcMgwInterfaceType_Value_Gn: "gn", + AlcMgwInterfaceType_Value_S2a: "s2a", + AlcMgwInterfaceType_Value_S2b: "s2b", +} + +func (a AlcMgwInterfaceType) String() string { + if str, ok := AlcMgwInterfaceType_Strings[a]; ok { + return str + } + return "AlcMgwInterfaceType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcMgwInterfaceType_Add(p *radius.Packet, value AlcMgwInterfaceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 145, a) +} + +func AlcMgwInterfaceType_Get(p *radius.Packet) (value AlcMgwInterfaceType) { + value, _ = AlcMgwInterfaceType_Lookup(p) + return +} + +func AlcMgwInterfaceType_Gets(p *radius.Packet) (values []AlcMgwInterfaceType, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 145) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcMgwInterfaceType(i)) + } + return +} + +func AlcMgwInterfaceType_Lookup(p *radius.Packet) (value AlcMgwInterfaceType, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 145) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcMgwInterfaceType(i) + return +} + +func AlcMgwInterfaceType_Set(p *radius.Packet, value AlcMgwInterfaceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 145, a) +} + +func AlcMgwInterfaceType_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 145) +} + +func AlcWlanAPNName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 146, a) +} + +func AlcWlanAPNName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 146, a) +} + +func AlcWlanAPNName_Get(p *radius.Packet) (value []byte) { + value, _ = AlcWlanAPNName_Lookup(p) + return +} + +func AlcWlanAPNName_GetString(p *radius.Packet) (value string) { + value, _ = AlcWlanAPNName_LookupString(p) + return +} + +func AlcWlanAPNName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 146) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanAPNName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 146) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanAPNName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 146) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcWlanAPNName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 146) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcWlanAPNName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 146, a) +} + +func AlcWlanAPNName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 146, a) +} + +func AlcWlanAPNName_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 146) +} + +func AlcMsIsdn_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 147, a) +} + +func AlcMsIsdn_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 147, a) +} + +func AlcMsIsdn_Get(p *radius.Packet) (value []byte) { + value, _ = AlcMsIsdn_Lookup(p) + return +} + +func AlcMsIsdn_GetString(p *radius.Packet) (value string) { + value, _ = AlcMsIsdn_LookupString(p) + return +} + +func AlcMsIsdn_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 147) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMsIsdn_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 147) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcMsIsdn_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 147) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcMsIsdn_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 147) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcMsIsdn_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 147, a) +} + +func AlcMsIsdn_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 147, a) +} + +func AlcMsIsdn_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 147) +} + +type AlcRSSI uint32 + +var AlcRSSI_Strings = map[AlcRSSI]string{} + +func (a AlcRSSI) String() string { + if str, ok := AlcRSSI_Strings[a]; ok { + return str + } + return "AlcRSSI(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcRSSI_Add(p *radius.Packet, value AlcRSSI) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 148, a) +} + +func AlcRSSI_Get(p *radius.Packet) (value AlcRSSI) { + value, _ = AlcRSSI_Lookup(p) + return +} + +func AlcRSSI_Gets(p *radius.Packet) (values []AlcRSSI, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 148) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcRSSI(i)) + } + return +} + +func AlcRSSI_Lookup(p *radius.Packet) (value AlcRSSI, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 148) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcRSSI(i) + return +} + +func AlcRSSI_Set(p *radius.Packet, value AlcRSSI) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 148, a) +} + +func AlcRSSI_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 148) +} + +type AlcNumAttachedUEs uint32 + +var AlcNumAttachedUEs_Strings = map[AlcNumAttachedUEs]string{} + +func (a AlcNumAttachedUEs) String() string { + if str, ok := AlcNumAttachedUEs_Strings[a]; ok { + return str + } + return "AlcNumAttachedUEs(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcNumAttachedUEs_Add(p *radius.Packet, value AlcNumAttachedUEs) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 149, a) +} + +func AlcNumAttachedUEs_Get(p *radius.Packet) (value AlcNumAttachedUEs) { + value, _ = AlcNumAttachedUEs_Lookup(p) + return +} + +func AlcNumAttachedUEs_Gets(p *radius.Packet) (values []AlcNumAttachedUEs, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 149) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcNumAttachedUEs(i)) + } + return +} + +func AlcNumAttachedUEs_Lookup(p *radius.Packet) (value AlcNumAttachedUEs, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 149) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcNumAttachedUEs(i) + return +} + +func AlcNumAttachedUEs_Set(p *radius.Packet, value AlcNumAttachedUEs) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 149, a) +} + +func AlcNumAttachedUEs_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 149) +} + +type AlcChargingProfID uint32 + +var AlcChargingProfID_Strings = map[AlcChargingProfID]string{} + +func (a AlcChargingProfID) String() string { + if str, ok := AlcChargingProfID_Strings[a]; ok { + return str + } + return "AlcChargingProfID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcChargingProfID_Add(p *radius.Packet, value AlcChargingProfID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 150, a) +} + +func AlcChargingProfID_Get(p *radius.Packet) (value AlcChargingProfID) { + value, _ = AlcChargingProfID_Lookup(p) + return +} + +func AlcChargingProfID_Gets(p *radius.Packet) (values []AlcChargingProfID, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 150) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcChargingProfID(i)) + } + return +} + +func AlcChargingProfID_Lookup(p *radius.Packet) (value AlcChargingProfID, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 150) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcChargingProfID(i) + return +} + +func AlcChargingProfID_Set(p *radius.Packet, value AlcChargingProfID) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 150, a) +} + +func AlcChargingProfID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 150) +} + +func AlcAAGroupPartitionIsaID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 156, a) +} + +func AlcAAGroupPartitionIsaID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 156, a) +} + +func AlcAAGroupPartitionIsaID_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAAGroupPartitionIsaID_Lookup(p) + return +} + +func AlcAAGroupPartitionIsaID_GetString(p *radius.Packet) (value string) { + value, _ = AlcAAGroupPartitionIsaID_LookupString(p) + return +} + +func AlcAAGroupPartitionIsaID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 156) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAAGroupPartitionIsaID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 156) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAAGroupPartitionIsaID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 156) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAAGroupPartitionIsaID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 156) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAAGroupPartitionIsaID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 156, a) +} + +func AlcAAGroupPartitionIsaID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 156, a) +} + +func AlcAAGroupPartitionIsaID_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 156) +} + +func AlcAAPeerIdentifier_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 157, a) +} + +func AlcAAPeerIdentifier_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 157, a) +} + +func AlcAAPeerIdentifier_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAAPeerIdentifier_Lookup(p) + return +} + +func AlcAAPeerIdentifier_GetString(p *radius.Packet) (value string) { + value, _ = AlcAAPeerIdentifier_LookupString(p) + return +} + +func AlcAAPeerIdentifier_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 157) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAAPeerIdentifier_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 157) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAAPeerIdentifier_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 157) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAAPeerIdentifier_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 157) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAAPeerIdentifier_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 157, a) +} + +func AlcAAPeerIdentifier_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 157, a) +} + +func AlcAAPeerIdentifier_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 157) +} + +func AlcNasFilterRuleShared_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 158, a) +} + +func AlcNasFilterRuleShared_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 158, a) +} + +func AlcNasFilterRuleShared_Get(p *radius.Packet) (value []byte) { + value, _ = AlcNasFilterRuleShared_Lookup(p) + return +} + +func AlcNasFilterRuleShared_GetString(p *radius.Packet) (value string) { + value, _ = AlcNasFilterRuleShared_LookupString(p) + return +} + +func AlcNasFilterRuleShared_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 158) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcNasFilterRuleShared_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 158) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcNasFilterRuleShared_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 158) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcNasFilterRuleShared_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 158) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcNasFilterRuleShared_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 158, a) +} + +func AlcNasFilterRuleShared_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 158, a) +} + +func AlcNasFilterRuleShared_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 158) +} + +func AlcAscendDataFilterHostSpec_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 159, a) +} + +func AlcAscendDataFilterHostSpec_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 159, a) +} + +func AlcAscendDataFilterHostSpec_Get(p *radius.Packet) (value []byte) { + value, _ = AlcAscendDataFilterHostSpec_Lookup(p) + return +} + +func AlcAscendDataFilterHostSpec_GetString(p *radius.Packet) (value string) { + value, _ = AlcAscendDataFilterHostSpec_LookupString(p) + return +} + +func AlcAscendDataFilterHostSpec_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 159) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAscendDataFilterHostSpec_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 159) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcAscendDataFilterHostSpec_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 159) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcAscendDataFilterHostSpec_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 159) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcAscendDataFilterHostSpec_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 159, a) +} + +func AlcAscendDataFilterHostSpec_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 159, a) +} + +func AlcAscendDataFilterHostSpec_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 159) +} + +type AlcRelativeSessionTimeout uint32 + +var AlcRelativeSessionTimeout_Strings = map[AlcRelativeSessionTimeout]string{} + +func (a AlcRelativeSessionTimeout) String() string { + if str, ok := AlcRelativeSessionTimeout_Strings[a]; ok { + return str + } + return "AlcRelativeSessionTimeout(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcRelativeSessionTimeout_Add(p *radius.Packet, value AlcRelativeSessionTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 160, a) +} + +func AlcRelativeSessionTimeout_Get(p *radius.Packet) (value AlcRelativeSessionTimeout) { + value, _ = AlcRelativeSessionTimeout_Lookup(p) + return +} + +func AlcRelativeSessionTimeout_Gets(p *radius.Packet) (values []AlcRelativeSessionTimeout, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 160) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcRelativeSessionTimeout(i)) + } + return +} + +func AlcRelativeSessionTimeout_Lookup(p *radius.Packet) (value AlcRelativeSessionTimeout, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 160) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcRelativeSessionTimeout(i) + return +} + +func AlcRelativeSessionTimeout_Set(p *radius.Packet, value AlcRelativeSessionTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 160, a) +} + +func AlcRelativeSessionTimeout_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 160) +} + +type AlcAcctTriggeredReason uint32 + +const ( + AlcAcctTriggeredReason_Value_Regular AlcAcctTriggeredReason = 1 + AlcAcctTriggeredReason_Value_SLAStart AlcAcctTriggeredReason = 2 + AlcAcctTriggeredReason_Value_SLAStop AlcAcctTriggeredReason = 3 + AlcAcctTriggeredReason_Value_FramedIPAddressUp AlcAcctTriggeredReason = 4 + AlcAcctTriggeredReason_Value_FramedIPAddressDown AlcAcctTriggeredReason = 5 + AlcAcctTriggeredReason_Value_AlcIpv6AddressUp AlcAcctTriggeredReason = 6 + AlcAcctTriggeredReason_Value_AlcIpv6AddressDown AlcAcctTriggeredReason = 7 + AlcAcctTriggeredReason_Value_DelegatedIPv6PrefixUp AlcAcctTriggeredReason = 8 + AlcAcctTriggeredReason_Value_DelegatedIPv6PrefixDown AlcAcctTriggeredReason = 9 + AlcAcctTriggeredReason_Value_FramedIPv6PrefixUp AlcAcctTriggeredReason = 10 + AlcAcctTriggeredReason_Value_FramedIPv6PrefixDown AlcAcctTriggeredReason = 11 +) + +var AlcAcctTriggeredReason_Strings = map[AlcAcctTriggeredReason]string{ + AlcAcctTriggeredReason_Value_Regular: "regular", + AlcAcctTriggeredReason_Value_SLAStart: "sla-start", + AlcAcctTriggeredReason_Value_SLAStop: "sla-stop", + AlcAcctTriggeredReason_Value_FramedIPAddressUp: "Framed-IP-Address-up", + AlcAcctTriggeredReason_Value_FramedIPAddressDown: "Framed-IP-Address-down", + AlcAcctTriggeredReason_Value_AlcIpv6AddressUp: "Alc-Ipv6-Address-up", + AlcAcctTriggeredReason_Value_AlcIpv6AddressDown: "Alc-Ipv6-Address-down", + AlcAcctTriggeredReason_Value_DelegatedIPv6PrefixUp: "Delegated-IPv6-Prefix-up", + AlcAcctTriggeredReason_Value_DelegatedIPv6PrefixDown: "Delegated-IPv6-Prefix-down", + AlcAcctTriggeredReason_Value_FramedIPv6PrefixUp: "Framed-IPv6-Prefix-up", + AlcAcctTriggeredReason_Value_FramedIPv6PrefixDown: "Framed-IPv6-Prefix-down", +} + +func (a AlcAcctTriggeredReason) String() string { + if str, ok := AlcAcctTriggeredReason_Strings[a]; ok { + return str + } + return "AlcAcctTriggeredReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcAcctTriggeredReason_Add(p *radius.Packet, value AlcAcctTriggeredReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 163, a) +} + +func AlcAcctTriggeredReason_Get(p *radius.Packet) (value AlcAcctTriggeredReason) { + value, _ = AlcAcctTriggeredReason_Lookup(p) + return +} + +func AlcAcctTriggeredReason_Gets(p *radius.Packet) (values []AlcAcctTriggeredReason, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 163) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcAcctTriggeredReason(i)) + } + return +} + +func AlcAcctTriggeredReason_Lookup(p *radius.Packet) (value AlcAcctTriggeredReason, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 163) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcAcctTriggeredReason(i) + return +} + +func AlcAcctTriggeredReason_Set(p *radius.Packet, value AlcAcctTriggeredReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 163, a) +} + +func AlcAcctTriggeredReason_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 163) +} + +func AlcWlanPortalRedirect_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 172, a) +} + +func AlcWlanPortalRedirect_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 172, a) +} + +func AlcWlanPortalRedirect_Get(p *radius.Packet) (value []byte) { + value, _ = AlcWlanPortalRedirect_Lookup(p) + return +} + +func AlcWlanPortalRedirect_GetString(p *radius.Packet) (value string) { + value, _ = AlcWlanPortalRedirect_LookupString(p) + return +} + +func AlcWlanPortalRedirect_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 172) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanPortalRedirect_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 172) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanPortalRedirect_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 172) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcWlanPortalRedirect_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 172) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcWlanPortalRedirect_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 172, a) +} + +func AlcWlanPortalRedirect_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 172, a) +} + +func AlcWlanPortalRedirect_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 172) +} + +func AlcWlanPortalURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 173, a) +} + +func AlcWlanPortalURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 173, a) +} + +func AlcWlanPortalURL_Get(p *radius.Packet) (value []byte) { + value, _ = AlcWlanPortalURL_Lookup(p) + return +} + +func AlcWlanPortalURL_GetString(p *radius.Packet) (value string) { + value, _ = AlcWlanPortalURL_LookupString(p) + return +} + +func AlcWlanPortalURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 173) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanPortalURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 173) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanPortalURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 173) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcWlanPortalURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 173) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcWlanPortalURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 173, a) +} + +func AlcWlanPortalURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 173, a) +} + +func AlcWlanPortalURL_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 173) +} + +type AlcLeaseTime uint32 + +var AlcLeaseTime_Strings = map[AlcLeaseTime]string{} + +func (a AlcLeaseTime) String() string { + if str, ok := AlcLeaseTime_Strings[a]; ok { + return str + } + return "AlcLeaseTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcLeaseTime_Add(p *radius.Packet, value AlcLeaseTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 174, a) +} + +func AlcLeaseTime_Get(p *radius.Packet) (value AlcLeaseTime) { + value, _ = AlcLeaseTime_Lookup(p) + return +} + +func AlcLeaseTime_Gets(p *radius.Packet) (values []AlcLeaseTime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 174) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcLeaseTime(i)) + } + return +} + +func AlcLeaseTime_Lookup(p *radius.Packet) (value AlcLeaseTime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 174) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcLeaseTime(i) + return +} + +func AlcLeaseTime_Set(p *radius.Packet, value AlcLeaseTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 174, a) +} + +func AlcLeaseTime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 174) +} + +type AlcDSLLineState uint32 + +var AlcDSLLineState_Strings = map[AlcDSLLineState]string{} + +func (a AlcDSLLineState) String() string { + if str, ok := AlcDSLLineState_Strings[a]; ok { + return str + } + return "AlcDSLLineState(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcDSLLineState_Add(p *radius.Packet, value AlcDSLLineState) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 175, a) +} + +func AlcDSLLineState_Get(p *radius.Packet) (value AlcDSLLineState) { + value, _ = AlcDSLLineState_Lookup(p) + return +} + +func AlcDSLLineState_Gets(p *radius.Packet) (values []AlcDSLLineState, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 175) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcDSLLineState(i)) + } + return +} + +func AlcDSLLineState_Lookup(p *radius.Packet) (value AlcDSLLineState, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 175) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcDSLLineState(i) + return +} + +func AlcDSLLineState_Set(p *radius.Packet, value AlcDSLLineState) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 175, a) +} + +func AlcDSLLineState_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 175) +} + +type AlcDSLType uint32 + +var AlcDSLType_Strings = map[AlcDSLType]string{} + +func (a AlcDSLType) String() string { + if str, ok := AlcDSLType_Strings[a]; ok { + return str + } + return "AlcDSLType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcDSLType_Add(p *radius.Packet, value AlcDSLType) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 176, a) +} + +func AlcDSLType_Get(p *radius.Packet) (value AlcDSLType) { + value, _ = AlcDSLType_Lookup(p) + return +} + +func AlcDSLType_Gets(p *radius.Packet) (values []AlcDSLType, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 176) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcDSLType(i)) + } + return +} + +func AlcDSLType_Lookup(p *radius.Packet) (value AlcDSLType, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 176) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcDSLType(i) + return +} + +func AlcDSLType_Set(p *radius.Packet, value AlcDSLType) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 176, a) +} + +func AlcDSLType_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 176) +} + +func AlcPortalURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 177, a) +} + +func AlcPortalURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 177, a) +} + +func AlcPortalURL_Get(p *radius.Packet) (value []byte) { + value, _ = AlcPortalURL_Lookup(p) + return +} + +func AlcPortalURL_GetString(p *radius.Packet) (value string) { + value, _ = AlcPortalURL_LookupString(p) + return +} + +func AlcPortalURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 177) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPortalURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 177) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcPortalURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 177) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcPortalURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 177) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcPortalURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 177, a) +} + +func AlcPortalURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 177, a) +} + +func AlcPortalURL_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 177) +} + +func AlcIpv6PortalURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 178, a) +} + +func AlcIpv6PortalURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 178, a) +} + +func AlcIpv6PortalURL_Get(p *radius.Packet) (value []byte) { + value, _ = AlcIpv6PortalURL_Lookup(p) + return +} + +func AlcIpv6PortalURL_GetString(p *radius.Packet) (value string) { + value, _ = AlcIpv6PortalURL_LookupString(p) + return +} + +func AlcIpv6PortalURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 178) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIpv6PortalURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 178) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcIpv6PortalURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 178) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcIpv6PortalURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 178) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcIpv6PortalURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 178, a) +} + +func AlcIpv6PortalURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 178, a) +} + +func AlcIpv6PortalURL_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 178) +} + +type AlcSAPSessionIndex uint32 + +var AlcSAPSessionIndex_Strings = map[AlcSAPSessionIndex]string{} + +func (a AlcSAPSessionIndex) String() string { + if str, ok := AlcSAPSessionIndex_Strings[a]; ok { + return str + } + return "AlcSAPSessionIndex(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcSAPSessionIndex_Add(p *radius.Packet, value AlcSAPSessionIndex) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 180, a) +} + +func AlcSAPSessionIndex_Get(p *radius.Packet) (value AlcSAPSessionIndex) { + value, _ = AlcSAPSessionIndex_Lookup(p) + return +} + +func AlcSAPSessionIndex_Gets(p *radius.Packet) (values []AlcSAPSessionIndex, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 180) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcSAPSessionIndex(i)) + } + return +} + +func AlcSAPSessionIndex_Lookup(p *radius.Packet) (value AlcSAPSessionIndex, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 180) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcSAPSessionIndex(i) + return +} + +func AlcSAPSessionIndex_Set(p *radius.Packet, value AlcSAPSessionIndex) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 180, a) +} + +func AlcSAPSessionIndex_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 180) +} + +func AlcSLAACIPv6Pool_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 181, a) +} + +func AlcSLAACIPv6Pool_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 181, a) +} + +func AlcSLAACIPv6Pool_Get(p *radius.Packet) (value []byte) { + value, _ = AlcSLAACIPv6Pool_Lookup(p) + return +} + +func AlcSLAACIPv6Pool_GetString(p *radius.Packet) (value string) { + value, _ = AlcSLAACIPv6Pool_LookupString(p) + return +} + +func AlcSLAACIPv6Pool_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 181) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSLAACIPv6Pool_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 181) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcSLAACIPv6Pool_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 181) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcSLAACIPv6Pool_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 181) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcSLAACIPv6Pool_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 181, a) +} + +func AlcSLAACIPv6Pool_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 181, a) +} + +func AlcSLAACIPv6Pool_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 181) +} + +type AlcWPPErrorCode uint32 + +var AlcWPPErrorCode_Strings = map[AlcWPPErrorCode]string{} + +func (a AlcWPPErrorCode) String() string { + if str, ok := AlcWPPErrorCode_Strings[a]; ok { + return str + } + return "AlcWPPErrorCode(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcWPPErrorCode_Add(p *radius.Packet, value AlcWPPErrorCode) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 183, a) +} + +func AlcWPPErrorCode_Get(p *radius.Packet) (value AlcWPPErrorCode) { + value, _ = AlcWPPErrorCode_Lookup(p) + return +} + +func AlcWPPErrorCode_Gets(p *radius.Packet) (values []AlcWPPErrorCode, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 183) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcWPPErrorCode(i)) + } + return +} + +func AlcWPPErrorCode_Lookup(p *radius.Packet) (value AlcWPPErrorCode, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 183) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcWPPErrorCode(i) + return +} + +func AlcWPPErrorCode_Set(p *radius.Packet, value AlcWPPErrorCode) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 183, a) +} + +func AlcWPPErrorCode_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 183) +} + +func AlcOnetimeHTTPRedirectReactivate_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 185, a) +} + +func AlcOnetimeHTTPRedirectReactivate_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 185, a) +} + +func AlcOnetimeHTTPRedirectReactivate_Get(p *radius.Packet) (value []byte) { + value, _ = AlcOnetimeHTTPRedirectReactivate_Lookup(p) + return +} + +func AlcOnetimeHTTPRedirectReactivate_GetString(p *radius.Packet) (value string) { + value, _ = AlcOnetimeHTTPRedirectReactivate_LookupString(p) + return +} + +func AlcOnetimeHTTPRedirectReactivate_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 185) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcOnetimeHTTPRedirectReactivate_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 185) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcOnetimeHTTPRedirectReactivate_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 185) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcOnetimeHTTPRedirectReactivate_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 185) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcOnetimeHTTPRedirectReactivate_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 185, a) +} + +func AlcOnetimeHTTPRedirectReactivate_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 185, a) +} + +func AlcOnetimeHTTPRedirectReactivate_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 185) +} + +func AlcToServerDhcp6Options_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 191, a) +} + +func AlcToServerDhcp6Options_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 191, a) +} + +func AlcToServerDhcp6Options_Get(p *radius.Packet) (value []byte) { + value, _ = AlcToServerDhcp6Options_Lookup(p) + return +} + +func AlcToServerDhcp6Options_GetString(p *radius.Packet) (value string) { + value, _ = AlcToServerDhcp6Options_LookupString(p) + return +} + +func AlcToServerDhcp6Options_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 191) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToServerDhcp6Options_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 191) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToServerDhcp6Options_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 191) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcToServerDhcp6Options_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 191) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcToServerDhcp6Options_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 191, a) +} + +func AlcToServerDhcp6Options_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 191, a) +} + +func AlcToServerDhcp6Options_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 191) +} + +func AlcToClientDhcp6Options_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 192, a) +} + +func AlcToClientDhcp6Options_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 192, a) +} + +func AlcToClientDhcp6Options_Get(p *radius.Packet) (value []byte) { + value, _ = AlcToClientDhcp6Options_Lookup(p) + return +} + +func AlcToClientDhcp6Options_GetString(p *radius.Packet) (value string) { + value, _ = AlcToClientDhcp6Options_LookupString(p) + return +} + +func AlcToClientDhcp6Options_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 192) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToClientDhcp6Options_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 192) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcToClientDhcp6Options_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 192) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcToClientDhcp6Options_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 192) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcToClientDhcp6Options_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 192, a) +} + +func AlcToClientDhcp6Options_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 192, a) +} + +func AlcToClientDhcp6Options_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 192) +} + +type AlcV6PreferredLifetime uint32 + +var AlcV6PreferredLifetime_Strings = map[AlcV6PreferredLifetime]string{} + +func (a AlcV6PreferredLifetime) String() string { + if str, ok := AlcV6PreferredLifetime_Strings[a]; ok { + return str + } + return "AlcV6PreferredLifetime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcV6PreferredLifetime_Add(p *radius.Packet, value AlcV6PreferredLifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 200, a) +} + +func AlcV6PreferredLifetime_Get(p *radius.Packet) (value AlcV6PreferredLifetime) { + value, _ = AlcV6PreferredLifetime_Lookup(p) + return +} + +func AlcV6PreferredLifetime_Gets(p *radius.Packet) (values []AlcV6PreferredLifetime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 200) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcV6PreferredLifetime(i)) + } + return +} + +func AlcV6PreferredLifetime_Lookup(p *radius.Packet) (value AlcV6PreferredLifetime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 200) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcV6PreferredLifetime(i) + return +} + +func AlcV6PreferredLifetime_Set(p *radius.Packet, value AlcV6PreferredLifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 200, a) +} + +func AlcV6PreferredLifetime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 200) +} + +type AlcV6ValidLifetime uint32 + +var AlcV6ValidLifetime_Strings = map[AlcV6ValidLifetime]string{} + +func (a AlcV6ValidLifetime) String() string { + if str, ok := AlcV6ValidLifetime_Strings[a]; ok { + return str + } + return "AlcV6ValidLifetime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcV6ValidLifetime_Add(p *radius.Packet, value AlcV6ValidLifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 201, a) +} + +func AlcV6ValidLifetime_Get(p *radius.Packet) (value AlcV6ValidLifetime) { + value, _ = AlcV6ValidLifetime_Lookup(p) + return +} + +func AlcV6ValidLifetime_Gets(p *radius.Packet) (values []AlcV6ValidLifetime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 201) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcV6ValidLifetime(i)) + } + return +} + +func AlcV6ValidLifetime_Lookup(p *radius.Packet) (value AlcV6ValidLifetime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 201) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcV6ValidLifetime(i) + return +} + +func AlcV6ValidLifetime_Set(p *radius.Packet, value AlcV6ValidLifetime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 201, a) +} + +func AlcV6ValidLifetime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 201) +} + +type AlcDhcp6RenewTime uint32 + +var AlcDhcp6RenewTime_Strings = map[AlcDhcp6RenewTime]string{} + +func (a AlcDhcp6RenewTime) String() string { + if str, ok := AlcDhcp6RenewTime_Strings[a]; ok { + return str + } + return "AlcDhcp6RenewTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcDhcp6RenewTime_Add(p *radius.Packet, value AlcDhcp6RenewTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 202, a) +} + +func AlcDhcp6RenewTime_Get(p *radius.Packet) (value AlcDhcp6RenewTime) { + value, _ = AlcDhcp6RenewTime_Lookup(p) + return +} + +func AlcDhcp6RenewTime_Gets(p *radius.Packet) (values []AlcDhcp6RenewTime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 202) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcDhcp6RenewTime(i)) + } + return +} + +func AlcDhcp6RenewTime_Lookup(p *radius.Packet) (value AlcDhcp6RenewTime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 202) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcDhcp6RenewTime(i) + return +} + +func AlcDhcp6RenewTime_Set(p *radius.Packet, value AlcDhcp6RenewTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 202, a) +} + +func AlcDhcp6RenewTime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 202) +} + +type AlcDhcp6RebindTime uint32 + +var AlcDhcp6RebindTime_Strings = map[AlcDhcp6RebindTime]string{} + +func (a AlcDhcp6RebindTime) String() string { + if str, ok := AlcDhcp6RebindTime_Strings[a]; ok { + return str + } + return "AlcDhcp6RebindTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcDhcp6RebindTime_Add(p *radius.Packet, value AlcDhcp6RebindTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_AddVendor(p, 203, a) +} + +func AlcDhcp6RebindTime_Get(p *radius.Packet) (value AlcDhcp6RebindTime) { + value, _ = AlcDhcp6RebindTime_Lookup(p) + return +} + +func AlcDhcp6RebindTime_Gets(p *radius.Packet) (values []AlcDhcp6RebindTime, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 203) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcDhcp6RebindTime(i)) + } + return +} + +func AlcDhcp6RebindTime_Lookup(p *radius.Packet) (value AlcDhcp6RebindTime, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 203) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcDhcp6RebindTime(i) + return +} + +func AlcDhcp6RebindTime_Set(p *radius.Packet, value AlcDhcp6RebindTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _AlcatelLucentServiceRouter_SetVendor(p, 203, a) +} + +func AlcDhcp6RebindTime_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 203) +} + +func AlcWlanSSIDVLAN_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 206, a) +} + +func AlcWlanSSIDVLAN_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 206, a) +} + +func AlcWlanSSIDVLAN_Get(p *radius.Packet) (value []byte) { + value, _ = AlcWlanSSIDVLAN_Lookup(p) + return +} + +func AlcWlanSSIDVLAN_GetString(p *radius.Packet) (value string) { + value, _ = AlcWlanSSIDVLAN_LookupString(p) + return +} + +func AlcWlanSSIDVLAN_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 206) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanSSIDVLAN_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 206) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcWlanSSIDVLAN_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 206) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcWlanSSIDVLAN_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 206) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcWlanSSIDVLAN_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 206, a) +} + +func AlcWlanSSIDVLAN_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 206, a) +} + +func AlcWlanSSIDVLAN_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 206) +} + +func AlcUPnPSubOverridePolicy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 217, a) +} + +func AlcUPnPSubOverridePolicy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 217, a) +} + +func AlcUPnPSubOverridePolicy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcUPnPSubOverridePolicy_Lookup(p) + return +} + +func AlcUPnPSubOverridePolicy_GetString(p *radius.Packet) (value string) { + value, _ = AlcUPnPSubOverridePolicy_LookupString(p) + return +} + +func AlcUPnPSubOverridePolicy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 217) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcUPnPSubOverridePolicy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 217) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcUPnPSubOverridePolicy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 217) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcUPnPSubOverridePolicy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 217) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcUPnPSubOverridePolicy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 217, a) +} + +func AlcUPnPSubOverridePolicy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 217, a) +} + +func AlcUPnPSubOverridePolicy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 217) +} + +func AlcTriggerAcctInterim_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 228, a) +} + +func AlcTriggerAcctInterim_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 228, a) +} + +func AlcTriggerAcctInterim_Get(p *radius.Packet) (value []byte) { + value, _ = AlcTriggerAcctInterim_Lookup(p) + return +} + +func AlcTriggerAcctInterim_GetString(p *radius.Packet) (value string) { + value, _ = AlcTriggerAcctInterim_LookupString(p) + return +} + +func AlcTriggerAcctInterim_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 228) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcTriggerAcctInterim_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 228) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcTriggerAcctInterim_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 228) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcTriggerAcctInterim_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 228) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcTriggerAcctInterim_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 228, a) +} + +func AlcTriggerAcctInterim_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 228, a) +} + +func AlcTriggerAcctInterim_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 228) +} + +type AlcAcctInterimLevel uint32 + +var AlcAcctInterimLevel_Strings = map[AlcAcctInterimLevel]string{} + +func (a AlcAcctInterimLevel) String() string { + if str, ok := AlcAcctInterimLevel_Strings[a]; ok { + return str + } + return "AlcAcctInterimLevel(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AlcAcctInterimLevel_Add(p *radius.Packet, tag byte, value AlcAcctInterimLevel) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_AddVendor(p, 232, a) +} + +func AlcAcctInterimLevel_Get(p *radius.Packet) (tag byte, value AlcAcctInterimLevel) { + tag, value, _ = AlcAcctInterimLevel_Lookup(p) + return +} + +func AlcAcctInterimLevel_Gets(p *radius.Packet) (tags []byte, values []AlcAcctInterimLevel, err error) { + var i uint32 + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 232) { + var tag byte + if len(attr) >= 1 && attr[0] <= 0x1F { + tag = attr[0] + attr[0] = 0x00 + } + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AlcAcctInterimLevel(i)) + tags = append(tags, tag) + } + return +} + +func AlcAcctInterimLevel_Lookup(p *radius.Packet) (tag byte, value AlcAcctInterimLevel, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 232) + if !ok { + err = radius.ErrNoAttribute + return + } + if len(a) >= 1 && a[0] <= 0x1F { + tag = a[0] + a[0] = 0x00 + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AlcAcctInterimLevel(i) + return +} + +func AlcAcctInterimLevel_Set(p *radius.Packet, tag byte, value AlcAcctInterimLevel) (err error) { + a := radius.NewInteger(uint32(value)) + if tag >= 0x01 && tag <= 0x1F { + a[0] = tag + } else { + a[0] = 0x00 + } + return _AlcatelLucentServiceRouter_SetVendor(p, 232, a) +} + +func AlcAcctInterimLevel_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 232) +} + +func AlcDNATOverride_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 234, a) +} + +func AlcDNATOverride_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 234, a) +} + +func AlcDNATOverride_Get(p *radius.Packet) (value []byte) { + value, _ = AlcDNATOverride_Lookup(p) + return +} + +func AlcDNATOverride_GetString(p *radius.Packet) (value string) { + value, _ = AlcDNATOverride_LookupString(p) + return +} + +func AlcDNATOverride_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 234) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDNATOverride_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 234) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcDNATOverride_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 234) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcDNATOverride_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 234) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcDNATOverride_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 234, a) +} + +func AlcDNATOverride_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 234, a) +} + +func AlcDNATOverride_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 234) +} + +func AlcRemoveOverride_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 238, a) +} + +func AlcRemoveOverride_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 238, a) +} + +func AlcRemoveOverride_Get(p *radius.Packet) (value []byte) { + value, _ = AlcRemoveOverride_Lookup(p) + return +} + +func AlcRemoveOverride_GetString(p *radius.Packet) (value string) { + value, _ = AlcRemoveOverride_LookupString(p) + return +} + +func AlcRemoveOverride_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 238) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcRemoveOverride_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 238) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcRemoveOverride_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 238) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcRemoveOverride_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 238) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcRemoveOverride_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 238, a) +} + +func AlcRemoveOverride_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 238, a) +} + +func AlcRemoveOverride_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 238) +} + +func AlcRadiusPy_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 242, a) +} + +func AlcRadiusPy_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 242, a) +} + +func AlcRadiusPy_Get(p *radius.Packet) (value []byte) { + value, _ = AlcRadiusPy_Lookup(p) + return +} + +func AlcRadiusPy_GetString(p *radius.Packet) (value string) { + value, _ = AlcRadiusPy_LookupString(p) + return +} + +func AlcRadiusPy_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 242) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcRadiusPy_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 242) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcRadiusPy_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 242) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcRadiusPy_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 242) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcRadiusPy_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 242, a) +} + +func AlcRadiusPy_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 242, a) +} + +func AlcRadiusPy_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 242) +} + +func AlcForceDHCPRelay_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 244, a) +} + +func AlcForceDHCPRelay_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_AddVendor(p, 244, a) +} + +func AlcForceDHCPRelay_Get(p *radius.Packet) (value []byte) { + value, _ = AlcForceDHCPRelay_Lookup(p) + return +} + +func AlcForceDHCPRelay_GetString(p *radius.Packet) (value string) { + value, _ = AlcForceDHCPRelay_LookupString(p) + return +} + +func AlcForceDHCPRelay_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 244) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceDHCPRelay_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _AlcatelLucentServiceRouter_GetsVendor(p, 244) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AlcForceDHCPRelay_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 244) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AlcForceDHCPRelay_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _AlcatelLucentServiceRouter_LookupVendor(p, 244) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AlcForceDHCPRelay_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 244, a) +} + +func AlcForceDHCPRelay_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _AlcatelLucentServiceRouter_SetVendor(p, 244, a) +} + +func AlcForceDHCPRelay_Del(p *radius.Packet) { + _AlcatelLucentServiceRouter_DelVendor(p, 244) +}