diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..9404e48 --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +OS?= +CMD_BUILD=GOOS=${OS} go build +VENDORS=huawei zte + +dictgen: cmd/radius-dict-gen/main.go + ${CMD_BUILD} -o $@ $^ + +define GEN_DICT + ./vendors/$(1)/generated.go : ./vendors/$(1)/dictionary.$(1) + ./dictgen -output $$@ -package $(1) $$< +endef + +$(foreach v, $(VENDORS), $(eval $(call GEN_DICT,$(v)))) + +gen: \ + $(foreach v, $(VENDORS), ./vendors/$(v)/generated.go) + + diff --git a/attributes.go b/attributes.go index 11f838c..cef72de 100644 --- a/attributes.go +++ b/attributes.go @@ -2,11 +2,14 @@ package radius import ( "errors" + "strconv" ) // Type is the RADIUS attribute type. type Type int +var _TypeName map[Type]string = map[Type]string{} + // TypeInvalid is a Type that can be used to represent an invalid RADIUS // attribute type. const TypeInvalid Type = -1 @@ -138,3 +141,14 @@ func AttributesEncodedLen(a Attributes) (int, error) { } return n, nil } + +func AddType(t Type, name string) { + _TypeName[t] = name +} + +func (t Type) String() string { + if s, ok := _TypeName[t]; ok { + return s + } + return "Type(" + strconv.FormatUint(uint64(t), 10) + ")" +} diff --git a/client.go b/client.go index 6c826bc..e788d3e 100644 --- a/client.go +++ b/client.go @@ -27,6 +27,8 @@ type Client struct { // InsecureSkipVerify controls whether the client should skip verifying // response packets received. InsecureSkipVerify bool + + Timeout time.Duration } // DefaultClient is the RADIUS client used by the Exchange function. @@ -98,6 +100,9 @@ func (c *Client) Exchange(ctx context.Context, packet *Packet, addr string) (*Pa var incoming [MaxPacketLength]byte for { + if c.Timeout > 0 { + conn.SetReadDeadline(time.Now().Add(c.Timeout)) + } n, err := conn.Read(incoming[:]) if err != nil { select { diff --git a/dictionarygen/generator.go b/dictionarygen/generator.go index 15629e6..3074678 100644 --- a/dictionarygen/generator.go +++ b/dictionarygen/generator.go @@ -277,6 +277,14 @@ func (g *Generator) Generate(dict *dictionary.Dictionary) ([]byte, error) { p(&w, `)`) } + p(&w) + p(&w, `func init() {`) + for _, attr := range attrs { + p(&w, ` radius.AddType(`, identifier(attr.Name), `_Type, "`, identifier(attr.Name), `")`) + } + p(&w, `}`) + p(&w) + for _, exAttr := range externalAttributes { p(&w) p(&w, `func init() {`) diff --git a/rfc2865/generated.go b/rfc2865/generated.go index 7ec9e2e..92774a2 100644 --- a/rfc2865/generated.go +++ b/rfc2865/generated.go @@ -53,6 +53,50 @@ const ( LoginLATPort_Type radius.Type = 63 ) +func init() { + radius.AddType(UserName_Type, "UserName") + radius.AddType(UserPassword_Type, "UserPassword") + radius.AddType(CHAPPassword_Type, "CHAPPassword") + radius.AddType(NASIPAddress_Type, "NASIPAddress") + radius.AddType(NASPort_Type, "NASPort") + radius.AddType(ServiceType_Type, "ServiceType") + radius.AddType(FramedProtocol_Type, "FramedProtocol") + radius.AddType(FramedIPAddress_Type, "FramedIPAddress") + radius.AddType(FramedIPNetmask_Type, "FramedIPNetmask") + radius.AddType(FramedRouting_Type, "FramedRouting") + radius.AddType(FilterID_Type, "FilterID") + radius.AddType(FramedMTU_Type, "FramedMTU") + radius.AddType(FramedCompression_Type, "FramedCompression") + radius.AddType(LoginIPHost_Type, "LoginIPHost") + radius.AddType(LoginService_Type, "LoginService") + radius.AddType(LoginTCPPort_Type, "LoginTCPPort") + radius.AddType(ReplyMessage_Type, "ReplyMessage") + radius.AddType(CallbackNumber_Type, "CallbackNumber") + radius.AddType(CallbackID_Type, "CallbackID") + radius.AddType(FramedRoute_Type, "FramedRoute") + radius.AddType(FramedIPXNetwork_Type, "FramedIPXNetwork") + radius.AddType(State_Type, "State") + radius.AddType(Class_Type, "Class") + radius.AddType(VendorSpecific_Type, "VendorSpecific") + radius.AddType(SessionTimeout_Type, "SessionTimeout") + radius.AddType(IdleTimeout_Type, "IdleTimeout") + radius.AddType(TerminationAction_Type, "TerminationAction") + radius.AddType(CalledStationID_Type, "CalledStationID") + radius.AddType(CallingStationID_Type, "CallingStationID") + radius.AddType(NASIdentifier_Type, "NASIdentifier") + radius.AddType(ProxyState_Type, "ProxyState") + radius.AddType(LoginLATService_Type, "LoginLATService") + radius.AddType(LoginLATNode_Type, "LoginLATNode") + radius.AddType(LoginLATGroup_Type, "LoginLATGroup") + radius.AddType(FramedAppleTalkLink_Type, "FramedAppleTalkLink") + radius.AddType(FramedAppleTalkNetwork_Type, "FramedAppleTalkNetwork") + radius.AddType(FramedAppleTalkZone_Type, "FramedAppleTalkZone") + radius.AddType(CHAPChallenge_Type, "CHAPChallenge") + radius.AddType(NASPortType_Type, "NASPortType") + radius.AddType(PortLimit_Type, "PortLimit") + radius.AddType(LoginLATPort_Type, "LoginLATPort") +} + func UserName_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc2866/generated.go b/rfc2866/generated.go index 8c91e30..20b5c1c 100644 --- a/rfc2866/generated.go +++ b/rfc2866/generated.go @@ -23,6 +23,21 @@ const ( AcctLinkCount_Type radius.Type = 51 ) +func init() { + radius.AddType(AcctStatusType_Type, "AcctStatusType") + radius.AddType(AcctDelayTime_Type, "AcctDelayTime") + radius.AddType(AcctInputOctets_Type, "AcctInputOctets") + radius.AddType(AcctOutputOctets_Type, "AcctOutputOctets") + radius.AddType(AcctSessionID_Type, "AcctSessionID") + radius.AddType(AcctAuthentic_Type, "AcctAuthentic") + radius.AddType(AcctSessionTime_Type, "AcctSessionTime") + radius.AddType(AcctInputPackets_Type, "AcctInputPackets") + radius.AddType(AcctOutputPackets_Type, "AcctOutputPackets") + radius.AddType(AcctTerminateCause_Type, "AcctTerminateCause") + radius.AddType(AcctMultiSessionID_Type, "AcctMultiSessionID") + radius.AddType(AcctLinkCount_Type, "AcctLinkCount") +} + type AcctStatusType uint32 const ( diff --git a/rfc2867/generated.go b/rfc2867/generated.go index 801489c..3258dd6 100644 --- a/rfc2867/generated.go +++ b/rfc2867/generated.go @@ -15,6 +15,11 @@ const ( AcctTunnelPacketsLost_Type radius.Type = 86 ) +func init() { + radius.AddType(AcctTunnelConnection_Type, "AcctTunnelConnection") + radius.AddType(AcctTunnelPacketsLost_Type, "AcctTunnelPacketsLost") +} + func init() { AcctStatusType_Strings[AcctStatusType_Value_TunnelStart] = "Tunnel-Start" AcctStatusType_Strings[AcctStatusType_Value_TunnelStop] = "Tunnel-Stop" diff --git a/rfc2868/generated.go b/rfc2868/generated.go index bfe95d2..ee774f0 100644 --- a/rfc2868/generated.go +++ b/rfc2868/generated.go @@ -22,6 +22,19 @@ const ( TunnelServerAuthID_Type radius.Type = 91 ) +func init() { + radius.AddType(TunnelType_Type, "TunnelType") + radius.AddType(TunnelMediumType_Type, "TunnelMediumType") + radius.AddType(TunnelClientEndpoint_Type, "TunnelClientEndpoint") + radius.AddType(TunnelServerEndpoint_Type, "TunnelServerEndpoint") + radius.AddType(TunnelPassword_Type, "TunnelPassword") + radius.AddType(TunnelPrivateGroupID_Type, "TunnelPrivateGroupID") + radius.AddType(TunnelAssignmentID_Type, "TunnelAssignmentID") + radius.AddType(TunnelPreference_Type, "TunnelPreference") + radius.AddType(TunnelClientAuthID_Type, "TunnelClientAuthID") + radius.AddType(TunnelServerAuthID_Type, "TunnelServerAuthID") +} + type TunnelType uint32 const ( diff --git a/rfc2869/generated.go b/rfc2869/generated.go index 185ede8..2da15ba 100644 --- a/rfc2869/generated.go +++ b/rfc2869/generated.go @@ -31,6 +31,27 @@ const ( FramedPool_Type radius.Type = 88 ) +func init() { + radius.AddType(AcctInputGigawords_Type, "AcctInputGigawords") + radius.AddType(AcctOutputGigawords_Type, "AcctOutputGigawords") + radius.AddType(EventTimestamp_Type, "EventTimestamp") + radius.AddType(ARAPPassword_Type, "ARAPPassword") + radius.AddType(ARAPFeatures_Type, "ARAPFeatures") + radius.AddType(ARAPZoneAccess_Type, "ARAPZoneAccess") + radius.AddType(ARAPSecurity_Type, "ARAPSecurity") + radius.AddType(ARAPSecurityData_Type, "ARAPSecurityData") + radius.AddType(PasswordRetry_Type, "PasswordRetry") + radius.AddType(Prompt_Type, "Prompt") + radius.AddType(ConnectInfo_Type, "ConnectInfo") + radius.AddType(ConfigurationToken_Type, "ConfigurationToken") + radius.AddType(EAPMessage_Type, "EAPMessage") + radius.AddType(MessageAuthenticator_Type, "MessageAuthenticator") + radius.AddType(ARAPChallengeResponse_Type, "ARAPChallengeResponse") + radius.AddType(AcctInterimInterval_Type, "AcctInterimInterval") + radius.AddType(NASPortID_Type, "NASPortID") + radius.AddType(FramedPool_Type, "FramedPool") +} + type AcctInputGigawords uint32 var AcctInputGigawords_Strings = map[AcctInputGigawords]string{} diff --git a/rfc3162/generated.go b/rfc3162/generated.go index 571e6cc..70c235f 100644 --- a/rfc3162/generated.go +++ b/rfc3162/generated.go @@ -17,6 +17,15 @@ const ( FramedIPv6Pool_Type radius.Type = 100 ) +func init() { + radius.AddType(NASIPv6Address_Type, "NASIPv6Address") + radius.AddType(FramedInterfaceID_Type, "FramedInterfaceID") + radius.AddType(FramedIPv6Prefix_Type, "FramedIPv6Prefix") + radius.AddType(LoginIPv6Host_Type, "LoginIPv6Host") + radius.AddType(FramedIPv6Route_Type, "FramedIPv6Route") + radius.AddType(FramedIPv6Pool_Type, "FramedIPv6Pool") +} + func NASIPv6Address_Add(p *radius.Packet, value net.IP) (err error) { var a radius.Attribute a, err = radius.NewIPv6Addr(value) diff --git a/rfc3576/generated.go b/rfc3576/generated.go index 7cebc63..369794d 100644 --- a/rfc3576/generated.go +++ b/rfc3576/generated.go @@ -14,6 +14,10 @@ const ( ErrorCause_Type radius.Type = 101 ) +func init() { + radius.AddType(ErrorCause_Type, "ErrorCause") +} + func init() { ServiceType_Strings[ServiceType_Value_AuthorizeOnly] = "Authorize-Only" } diff --git a/rfc3580/generated.go b/rfc3580/generated.go index 05fc767..0bc4a77 100644 --- a/rfc3580/generated.go +++ b/rfc3580/generated.go @@ -8,6 +8,9 @@ import ( . "layeh.com/radius/rfc2868" ) +func init() { +} + func init() { AcctTerminateCause_Strings[AcctTerminateCause_Value_SupplicantRestart] = "Supplicant-Restart" AcctTerminateCause_Strings[AcctTerminateCause_Value_ReauthenticationFailure] = "Reauthentication-Failure" diff --git a/rfc4072/generated.go b/rfc4072/generated.go index e2febca..40664d7 100644 --- a/rfc4072/generated.go +++ b/rfc4072/generated.go @@ -10,6 +10,10 @@ const ( EAPKeyName_Type radius.Type = 102 ) +func init() { + radius.AddType(EAPKeyName_Type, "EAPKeyName") +} + func EAPKeyName_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc4372/generated.go b/rfc4372/generated.go index c6219cf..ff99bcf 100644 --- a/rfc4372/generated.go +++ b/rfc4372/generated.go @@ -10,6 +10,10 @@ const ( ChargeableUserIdentity_Type radius.Type = 89 ) +func init() { + radius.AddType(ChargeableUserIdentity_Type, "ChargeableUserIdentity") +} + func init() { } diff --git a/rfc4603/generated.go b/rfc4603/generated.go index 8eb4941..42aa363 100644 --- a/rfc4603/generated.go +++ b/rfc4603/generated.go @@ -6,6 +6,9 @@ import ( . "layeh.com/radius/rfc2865" ) +func init() { +} + func init() { NASPortType_Strings[NASPortType_Value_PPPoA] = "PPPoA" NASPortType_Strings[NASPortType_Value_PPPoEoA] = "PPPoEoA" diff --git a/rfc4675/generated.go b/rfc4675/generated.go index 00afdaf..8d12980 100644 --- a/rfc4675/generated.go +++ b/rfc4675/generated.go @@ -15,6 +15,13 @@ const ( UserPriorityTable_Type radius.Type = 59 ) +func init() { + radius.AddType(EgressVLANID_Type, "EgressVLANID") + radius.AddType(IngressFilters_Type, "IngressFilters") + radius.AddType(EgressVLANName_Type, "EgressVLANName") + radius.AddType(UserPriorityTable_Type, "UserPriorityTable") +} + type EgressVLANID uint32 var EgressVLANID_Strings = map[EgressVLANID]string{} diff --git a/rfc4679/generated.go b/rfc4679/generated.go index b27d8b9..763ba41 100644 --- a/rfc4679/generated.go +++ b/rfc4679/generated.go @@ -13,6 +13,9 @@ const ( _ADSLForum_VendorID = 3561 ) +func init() { +} + func _ADSLForum_AddVendor(p *radius.Packet, typ byte, attr radius.Attribute) (err error) { var vsa radius.Attribute vendor := make(radius.Attribute, 2+len(attr)) diff --git a/rfc4818/generated.go b/rfc4818/generated.go index 89941c5..282c7f7 100644 --- a/rfc4818/generated.go +++ b/rfc4818/generated.go @@ -12,6 +12,10 @@ const ( DelegatedIPv6Prefix_Type radius.Type = 123 ) +func init() { + radius.AddType(DelegatedIPv6Prefix_Type, "DelegatedIPv6Prefix") +} + func DelegatedIPv6Prefix_Add(p *radius.Packet, value *net.IPNet) (err error) { var a radius.Attribute a, err = radius.NewIPv6Prefix(value) diff --git a/rfc4849/generated.go b/rfc4849/generated.go index ac1c54b..87afe9b 100644 --- a/rfc4849/generated.go +++ b/rfc4849/generated.go @@ -10,6 +10,10 @@ const ( NASFilterRule_Type radius.Type = 92 ) +func init() { + radius.AddType(NASFilterRule_Type, "NASFilterRule") +} + func NASFilterRule_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc5090/generated.go b/rfc5090/generated.go index d7fd9c8..5306f3a 100644 --- a/rfc5090/generated.go +++ b/rfc5090/generated.go @@ -29,6 +29,29 @@ const ( SIPAOR_Type radius.Type = 122 ) +func init() { + radius.AddType(DigestResponse_Type, "DigestResponse") + radius.AddType(DigestRealm_Type, "DigestRealm") + radius.AddType(DigestNonce_Type, "DigestNonce") + radius.AddType(DigestResponseAuth_Type, "DigestResponseAuth") + radius.AddType(DigestNextnonce_Type, "DigestNextnonce") + radius.AddType(DigestMethod_Type, "DigestMethod") + radius.AddType(DigestURI_Type, "DigestURI") + radius.AddType(DigestQop_Type, "DigestQop") + radius.AddType(DigestAlgorithm_Type, "DigestAlgorithm") + radius.AddType(DigestEntityBodyHash_Type, "DigestEntityBodyHash") + radius.AddType(DigestCNonce_Type, "DigestCNonce") + radius.AddType(DigestNonceCount_Type, "DigestNonceCount") + radius.AddType(DigestUsername_Type, "DigestUsername") + radius.AddType(DigestOpaque_Type, "DigestOpaque") + radius.AddType(DigestAuthParam_Type, "DigestAuthParam") + radius.AddType(DigestAKAAuts_Type, "DigestAKAAuts") + radius.AddType(DigestDomain_Type, "DigestDomain") + radius.AddType(DigestStale_Type, "DigestStale") + radius.AddType(DigestHA1_Type, "DigestHA1") + radius.AddType(SIPAOR_Type, "SIPAOR") +} + func DigestResponse_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc5176/generated.go b/rfc5176/generated.go index 9d15aa7..40da1fe 100644 --- a/rfc5176/generated.go +++ b/rfc5176/generated.go @@ -6,6 +6,9 @@ import ( . "layeh.com/radius/rfc3576" ) +func init() { +} + func init() { ErrorCause_Strings[ErrorCause_Value_InvalidAttributeValue] = "Invalid-Attribute-Value" ErrorCause_Strings[ErrorCause_Value_MultipleSessionSelectionUnsupported] = "Multiple-Session-Selection-Unsupported" diff --git a/rfc5447/generated.go b/rfc5447/generated.go index 30ac5f3..31d28cc 100644 --- a/rfc5447/generated.go +++ b/rfc5447/generated.go @@ -13,6 +13,11 @@ const ( MIP6HomeLinkPrefix_Type radius.Type = 125 ) +func init() { + radius.AddType(MIP6FeatureVector_Type, "MIP6FeatureVector") + radius.AddType(MIP6HomeLinkPrefix_Type, "MIP6HomeLinkPrefix") +} + type MIP6FeatureVector uint64 var MIP6FeatureVector_Strings = map[MIP6FeatureVector]string{} diff --git a/rfc5580/generated.go b/rfc5580/generated.go index d11a5ff..856f5ad 100644 --- a/rfc5580/generated.go +++ b/rfc5580/generated.go @@ -18,6 +18,16 @@ const ( RequestedLocationInfo_Type radius.Type = 132 ) +func init() { + radius.AddType(OperatorName_Type, "OperatorName") + radius.AddType(LocationInformation_Type, "LocationInformation") + radius.AddType(LocationData_Type, "LocationData") + radius.AddType(BasicLocationPolicyRules_Type, "BasicLocationPolicyRules") + radius.AddType(ExtendedLocationPolicyRules_Type, "ExtendedLocationPolicyRules") + radius.AddType(LocationCapable_Type, "LocationCapable") + radius.AddType(RequestedLocationInfo_Type, "RequestedLocationInfo") +} + func OperatorName_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc5607/generated.go b/rfc5607/generated.go index 28474db..d8063c0 100644 --- a/rfc5607/generated.go +++ b/rfc5607/generated.go @@ -17,6 +17,13 @@ const ( ManagementPrivilegeLevel_Type radius.Type = 136 ) +func init() { + radius.AddType(FramedManagement_Type, "FramedManagement") + radius.AddType(ManagementTransportProtection_Type, "ManagementTransportProtection") + radius.AddType(ManagementPolicyID_Type, "ManagementPolicyID") + radius.AddType(ManagementPrivilegeLevel_Type, "ManagementPrivilegeLevel") +} + func init() { ServiceType_Strings[ServiceType_Value_FramedManagement] = "Framed-Management" } diff --git a/rfc5904/generated.go b/rfc5904/generated.go index 1adbcc9..08308e6 100644 --- a/rfc5904/generated.go +++ b/rfc5904/generated.go @@ -18,6 +18,16 @@ const ( PKMAuthKey_Type radius.Type = 143 ) +func init() { + radius.AddType(PKMSSCert_Type, "PKMSSCert") + radius.AddType(PKMCACert_Type, "PKMCACert") + radius.AddType(PKMConfigSettings_Type, "PKMConfigSettings") + radius.AddType(PKMCryptosuiteList_Type, "PKMCryptosuiteList") + radius.AddType(PKMSAID_Type, "PKMSAID") + radius.AddType(PKMSADescriptor_Type, "PKMSADescriptor") + radius.AddType(PKMAuthKey_Type, "PKMAuthKey") +} + func PKMSSCert_Get(p *radius.Packet) (value []byte) { value, _ = PKMSSCert_Lookup(p) return diff --git a/rfc6519/generated.go b/rfc6519/generated.go index 7a85278..44f054f 100644 --- a/rfc6519/generated.go +++ b/rfc6519/generated.go @@ -10,6 +10,10 @@ const ( DSLiteTunnelName_Type radius.Type = 144 ) +func init() { + radius.AddType(DSLiteTunnelName_Type, "DSLiteTunnelName") +} + func DSLiteTunnelName_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc6572/generated.go b/rfc6572/generated.go index 308cb40..b0ae4bc 100644 --- a/rfc6572/generated.go +++ b/rfc6572/generated.go @@ -27,6 +27,25 @@ const ( PMIP6VisitedIPv4Gateway_Type radius.Type = 162 ) +func init() { + radius.AddType(MobileNodeIdentifier_Type, "MobileNodeIdentifier") + radius.AddType(ServiceSelection_Type, "ServiceSelection") + radius.AddType(PMIP6HomeLMAIPv6Address_Type, "PMIP6HomeLMAIPv6Address") + radius.AddType(PMIP6VisitedLMAIPv6Address_Type, "PMIP6VisitedLMAIPv6Address") + radius.AddType(PMIP6HomeLMAIPv4Address_Type, "PMIP6HomeLMAIPv4Address") + radius.AddType(PMIP6VisitedLMAIPv4Address_Type, "PMIP6VisitedLMAIPv4Address") + radius.AddType(PMIP6HomeHNPrefix_Type, "PMIP6HomeHNPrefix") + radius.AddType(PMIP6VisitedHNPrefix_Type, "PMIP6VisitedHNPrefix") + radius.AddType(PMIP6HomeInterfaceID_Type, "PMIP6HomeInterfaceID") + radius.AddType(PMIP6VisitedInterfaceID_Type, "PMIP6VisitedInterfaceID") + radius.AddType(PMIP6HomeDHCP4ServerAddress_Type, "PMIP6HomeDHCP4ServerAddress") + radius.AddType(PMIP6VisitedDHCP4ServerAddress_Type, "PMIP6VisitedDHCP4ServerAddress") + radius.AddType(PMIP6HomeDHCP6ServerAddress_Type, "PMIP6HomeDHCP6ServerAddress") + radius.AddType(PMIP6VisitedDHCP6ServerAddress_Type, "PMIP6VisitedDHCP6ServerAddress") + radius.AddType(PMIP6HomeIPv4Gateway_Type, "PMIP6HomeIPv4Gateway") + radius.AddType(PMIP6VisitedIPv4Gateway_Type, "PMIP6VisitedIPv4Gateway") +} + func MobileNodeIdentifier_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc6677/generated.go b/rfc6677/generated.go index 65be05c..4992557 100644 --- a/rfc6677/generated.go +++ b/rfc6677/generated.go @@ -12,6 +12,10 @@ const ( EAPLowerLayer_Type radius.Type = 163 ) +func init() { + radius.AddType(EAPLowerLayer_Type, "EAPLowerLayer") +} + type EAPLowerLayer uint32 const ( diff --git a/rfc6911/generated.go b/rfc6911/generated.go index a4133fa..423a2e2 100644 --- a/rfc6911/generated.go +++ b/rfc6911/generated.go @@ -16,6 +16,14 @@ const ( StatefulIPv6AddressPool_Type radius.Type = 172 ) +func init() { + radius.AddType(FramedIPv6Address_Type, "FramedIPv6Address") + radius.AddType(DNSServerIPv6Address_Type, "DNSServerIPv6Address") + radius.AddType(RouteIPv6Information_Type, "RouteIPv6Information") + radius.AddType(DelegatedIPv6PrefixPool_Type, "DelegatedIPv6PrefixPool") + radius.AddType(StatefulIPv6AddressPool_Type, "StatefulIPv6AddressPool") +} + func FramedIPv6Address_Add(p *radius.Packet, value net.IP) (err error) { var a radius.Attribute a, err = radius.NewIPv6Addr(value) diff --git a/rfc7055/generated.go b/rfc7055/generated.go index f4c5e52..ce577eb 100644 --- a/rfc7055/generated.go +++ b/rfc7055/generated.go @@ -13,6 +13,13 @@ const ( GSSAcceptorRealmName_Type radius.Type = 167 ) +func init() { + radius.AddType(GSSAcceptorServiceName_Type, "GSSAcceptorServiceName") + radius.AddType(GSSAcceptorHostName_Type, "GSSAcceptorHostName") + radius.AddType(GSSAcceptorServiceSpecifics_Type, "GSSAcceptorServiceSpecifics") + radius.AddType(GSSAcceptorRealmName_Type, "GSSAcceptorRealmName") +} + func GSSAcceptorServiceName_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/rfc7268/generated.go b/rfc7268/generated.go index 775bd57..b854963 100644 --- a/rfc7268/generated.go +++ b/rfc7268/generated.go @@ -29,6 +29,26 @@ const ( WLANRFBand_Type radius.Type = 190 ) +func init() { + radius.AddType(AllowedCalledStationID_Type, "AllowedCalledStationID") + radius.AddType(EAPPeerID_Type, "EAPPeerID") + radius.AddType(EAPServerID_Type, "EAPServerID") + radius.AddType(MobilityDomainID_Type, "MobilityDomainID") + radius.AddType(PreauthTimeout_Type, "PreauthTimeout") + radius.AddType(NetworkIDName_Type, "NetworkIDName") + radius.AddType(EAPoLAnnouncement_Type, "EAPoLAnnouncement") + radius.AddType(WLANHESSID_Type, "WLANHESSID") + radius.AddType(WLANVenueInfo_Type, "WLANVenueInfo") + radius.AddType(WLANVenueLanguage_Type, "WLANVenueLanguage") + radius.AddType(WLANVenueName_Type, "WLANVenueName") + radius.AddType(WLANReasonCode_Type, "WLANReasonCode") + radius.AddType(WLANPairwiseCipher_Type, "WLANPairwiseCipher") + radius.AddType(WLANGroupCipher_Type, "WLANGroupCipher") + radius.AddType(WLANAKMSuite_Type, "WLANAKMSuite") + radius.AddType(WLANGroupMgmtCipher_Type, "WLANGroupMgmtCipher") + radius.AddType(WLANRFBand_Type, "WLANRFBand") +} + func AllowedCalledStationID_Add(p *radius.Packet, value []byte) (err error) { var a radius.Attribute a, err = radius.NewBytes(value) diff --git a/vendors/huawei/dictionary.huawei b/vendors/huawei/dictionary.huawei new file mode 100644 index 0000000..5ac2e92 --- /dev/null +++ b/vendors/huawei/dictionary.huawei @@ -0,0 +1,235 @@ +# -*- text -*- +# Copyright (C) 2022 The FreeRADIUS Server project and contributors +# This work is licensed under CC-BY version 4.0 https://creativecommons.org/licenses/by/4.0 +# Version $Id: e991e6ec8b34cfb699fb15fe1697d788dfd8e034 $ +############################################################################## +# +# Dictionary for Huawei. See also dictionary.h3c +# +# $Id: e991e6ec8b34cfb699fb15fe1697d788dfd8e034 $ +# +############################################################################## + +VENDOR Huawei 2011 + +BEGIN-VENDOR Huawei + +ATTRIBUTE Input-Burst-Size 1 integer +ATTRIBUTE Input-Average-Rate 2 integer +ATTRIBUTE Input-Peak-Rate 3 integer +ATTRIBUTE Output-Burst-Size 4 integer +ATTRIBUTE Output-Average-Rate 5 integer +ATTRIBUTE Output-Peak-Rate 6 integer +ATTRIBUTE In-Kb-Before-T-Switch 7 integer +ATTRIBUTE Out-Kb-Before-T-Switch 8 integer +ATTRIBUTE In-Pkt-Before-T-Switch 9 integer +ATTRIBUTE Out-Pkt-Before-T-Switch 10 integer +ATTRIBUTE In-Kb-After-T-Switch 11 integer +ATTRIBUTE Out-Kb-After-T-Switch 12 integer +ATTRIBUTE In-Pkt-After-T-Switch 13 integer +ATTRIBUTE Out-Pkt-After-T-Switch 14 integer +ATTRIBUTE Remanent-Volume 15 integer +ATTRIBUTE Tariff-Switch-Interval 16 integer +ATTRIBUTE ISP-ID 17 string +ATTRIBUTE Max-Users-Per-Logic-Port 18 integer +ATTRIBUTE Command 20 integer +ATTRIBUTE Priority 22 integer +ATTRIBUTE Control-Identifier 24 integer + +ATTRIBUTE Result-Code 25 integer + +# > 0 indicates an error. +VALUE Result-Code Succeeded 0 + +ATTRIBUTE Connect-ID 26 integer +ATTRIBUTE PortalURL 27 string +ATTRIBUTE FTP-Directory 28 string +ATTRIBUTE Exec-Privilege 29 integer +ATTRIBUTE IP-Address 30 integer +ATTRIBUTE Qos-Profile-Name 31 string +ATTRIBUTE SIP-Server 32 string +ATTRIBUTE User-Password 33 string +ATTRIBUTE Command-Mode 34 string +ATTRIBUTE Renewal-Time 35 integer +ATTRIBUTE Rebinding-Time 36 integer +ATTRIBUTE IGMP-Enable 37 integer +ATTRIBUTE Destnation-IP-Addr 39 string +ATTRIBUTE Destnation-Volume 40 string +ATTRIBUTE Startup-Stamp 59 integer +ATTRIBUTE IPHost-Addr 60 string +ATTRIBUTE Up-Priority 61 integer +ATTRIBUTE Down-Priority 62 integer +ATTRIBUTE Tunnel-VPN-Instance 63 string +ATTRIBUTE VT-Name 64 integer +ATTRIBUTE User-Date 65 string +ATTRIBUTE User-Class 66 string +ATTRIBUTE PPP-NCP-Type 70 integer +ATTRIBUTE VSI-Name 71 string +ATTRIBUTE Subnet-Mask 72 ipaddr +ATTRIBUTE Gateway-Address 73 ipaddr +ATTRIBUTE Lease-Time 74 integer +ATTRIBUTE Primary-WINS 75 ipaddr +ATTRIBUTE Secondary-WINS 76 ipaddr +ATTRIBUTE Input-Peak-Burst-Size 77 integer +ATTRIBUTE Output-Peak-Burst-Size 78 integer +ATTRIBUTE Reduced-CIR 79 integer +ATTRIBUTE Tunnel-Session-Limit 80 integer +ATTRIBUTE Zone-Name 81 string +ATTRIBUTE Data-Filter 82 string +ATTRIBUTE Access-Service 83 string +ATTRIBUTE Accounting-Level 84 integer +ATTRIBUTE Portal-Mode 85 integer + +VALUE Portal-Mode PADM 0 +VALUE Portal-Mode Redirectional 1 +VALUE Portal-Mode Non-captive 2 + +ATTRIBUTE DPI-Policy-Name 86 string +ATTRIBUTE Policy-Route 87 ipaddr +ATTRIBUTE Framed-Pool 88 string +ATTRIBUTE L2TP-Terminate-Cause 89 string +ATTRIBUTE Multi-Account-Mode 90 integer +ATTRIBUTE Queue-Profile 91 string +ATTRIBUTE Layer4-Session-Limit 92 integer +ATTRIBUTE Multicast-Profile 93 string +ATTRIBUTE VPN-Instance 94 string +ATTRIBUTE Policy-Name 95 string +ATTRIBUTE Tunnel-Group-Name 96 string +ATTRIBUTE Multicast-Source-Group 97 string +ATTRIBUTE Multicast-Receive-Group 98 ipaddr +ATTRIBUTE User-Multicast-Type 99 integer +ATTRIBUTE Reduced-PIR 100 integer +ATTRIBUTE LI-ID 101 string +ATTRIBUTE LI-Md-Address 102 ipaddr +ATTRIBUTE LI-Md-Port 103 integer +ATTRIBUTE LI-Md-VpnInstance 104 string +ATTRIBUTE Service-Chg-Cmd 105 integer +ATTRIBUTE Acct-Packet-Type 106 integer +ATTRIBUTE Call-Reference 107 integer +ATTRIBUTE PSTN-Port 108 integer +ATTRIBUTE Voip-Service-Type 109 integer +ATTRIBUTE Acct-Connection-Time 110 integer +ATTRIBUTE Error-Reason 112 integer +ATTRIBUTE Remain-Monney 113 integer +ATTRIBUTE Org-GK-ipaddr 123 ipaddr +ATTRIBUTE Org-GW-ipaddr 124 ipaddr +ATTRIBUTE Dst-GK-ipaddr 125 ipaddr +ATTRIBUTE Dst-GW-ipaddr 126 ipaddr +ATTRIBUTE Access-Num 127 string +ATTRIBUTE Remain-Time 128 integer +ATTRIBUTE Codec-Type 131 integer +ATTRIBUTE Transfer-Num 132 string +ATTRIBUTE New-User-Name 133 string +ATTRIBUTE Transfer-Station-Id 134 string +ATTRIBUTE Primary-DNS 135 ipaddr +ATTRIBUTE Secondary-DNS 136 ipaddr +ATTRIBUTE ONLY-Account-Type 137 integer +ATTRIBUTE Domain-Name 138 string +ATTRIBUTE ANCP-Profile 139 string +ATTRIBUTE HTTP-Redirect-URL 140 string +ATTRIBUTE Loopback-Address 141 string +ATTRIBUTE QoS-Profile-Type 142 integer + +VALUE QoS-Profile-Type Original 0 +VALUE QoS-Profile-Type L2TP-Inbound 1 +VALUE QoS-Profile-Type L2TP-Outbound 2 +VALUE QoS-Profile-Type L2TP 3 + +ATTRIBUTE Max-List-Num 143 integer +ATTRIBUTE Acct-IPv6-Input-Octets 144 integer +ATTRIBUTE Acct-IPv6-Output-Octets 145 integer +ATTRIBUTE Acct-IPv6-Input-Packets 146 integer +ATTRIBUTE Acct-IPv6-Output-Packets 147 integer +ATTRIBUTE Acct-IPv6-Input-Gigawords 148 integer +ATTRIBUTE Acct-IPv6-Output-Gigawords 149 integer +ATTRIBUTE DHCPv6-Option37 150 string +ATTRIBUTE DHCPv6-Option38 151 string +ATTRIBUTE User-Mac 153 string +ATTRIBUTE DNS-Server-IPv6-address 154 ipv6addr +ATTRIBUTE DHCPv4-Option121 155 string +ATTRIBUTE DHCPv4-Option43 156 string +ATTRIBUTE Framed-Pool-Group 157 string +ATTRIBUTE Framed-IPv6-Address 158 ipv6addr +ATTRIBUTE Acct-Update-Address 159 integer +ATTRIBUTE NAT-Policy-Name 160 string +ATTRIBUTE NAT-Public-Address 161 string +ATTRIBUTE NAT-Start-Port 162 string +ATTRIBUTE NAT-End-Port 163 string +ATTRIBUTE NAT-Port-Forwarding 164 string +ATTRIBUTE NAT-Port-Range-Update 165 integer +ATTRIBUTE DS-Lite-Tunnel-Name 166 string +ATTRIBUTE PCP-Server-Name 167 string # manual says text? +ATTRIBUTE Public-IP-Addr-State 168 integer + +VALUE Public-IP-Addr-State Safe 0 +VALUE Public-IP-Addr-State Warning 1 +VALUE Public-IP-Addr-State Danger 2 + +ATTRIBUTE Auth-Type 180 integer + +VALUE Auth-Type PPP 1 +VALUE Auth-Type Web 2 +VALUE Auth-Type Dot1x 3 +VALUE Auth-Type Fast 4 +VALUE Auth-Type Bind 5 +VALUE Auth-Type WLAN 6 +VALUE Auth-Type Administrative 7 +VALUE Auth-Type Tunnel 8 +VALUE Auth-Type MIP 9 +VALUE Auth-Type None 10 + +ATTRIBUTE Acct-Terminate-Subcause 181 string +ATTRIBUTE Down-QOS-Profile-Name 182 string +ATTRIBUTE Port-Mirror 183 integer + +VALUE Port-Mirror Disable 0 +VALUE Port-Mirror Uplink-Enable 1 +VALUE Port-Mirror Downlink-Enable 2 +VALUE Port-Mirror Enable 3 + +ATTRIBUTE Account-Info 184 string +ATTRIBUTE Service-Info 185 string +ATTRIBUTE DHCP-Option 187 octets +ATTRIBUTE AVpair 188 string +ATTRIBUTE Delegated-IPv6-Prefix-Pool 191 string +ATTRIBUTE IPv6-Prefix-Lease 192 octets +ATTRIBUTE IPv6-Address-Lease 193 octets +ATTRIBUTE IPv6-Policy-Route 194 ipv6prefix # manual says string? +ATTRIBUTE MNG-IPv6 196 integer + +VALUE MNG-IPv6 Unsupported 0 +VALUE MNG-IPv6 Supported 1 + +ATTRIBUTE DPSK-Info 206 string +ATTRIBUTE Flow-Info 211 string +ATTRIBUTE Flow-Id 212 integer +ATTRIBUTE DHCP-Server-IP 214 ipaddr +ATTRIBUTE Application-Type 215 integer + +VALUE Application-Type Fixed 1 +VALUE Application-Type Nomadic 2 +VALUE Application-Type Portable 3 +VALUE Application-Type Simple-Mobile 4 +VALUE Application-Type Full-Mobile 5 + +ATTRIBUTE Indication-Flag 216 octets # integer?? +ATTRIBUTE Original_NAS-IP_Address 217 ipaddr +ATTRIBUTE User-Priority 218 integer + +VALUE User-Priority Common 0 +VALUE User-Priority Copper 1 +VALUE User-Priority Silver 2 +VALUE User-Priority Gold 3 + +ATTRIBUTE ACS-Url 219 string +ATTRIBUTE Provision-Code 220 string +ATTRIBUTE Application-Scene 221 octets +ATTRIBUTE MS-Maximum-MAC-Study-Number 222 octets # ether?? +ATTRIBUTE GGSN-Vendor 232 string +ATTRIBUTE GGSN-Version 233 string +ATTRIBUTE Ext-Specific 238 string +ATTRIBUTE Web-URL 253 string +ATTRIBUTE Version 254 string +ATTRIBUTE Product-ID 255 string + +END-VENDOR Huawei diff --git a/vendors/huawei/generate.go b/vendors/huawei/generate.go new file mode 100644 index 0000000..8681e83 --- /dev/null +++ b/vendors/huawei/generate.go @@ -0,0 +1,2 @@ +//go:generate go run ../../cmd/radius-dict-gen/main.go -package huawei -output generated.go dictionary.huawei +package huawei diff --git a/vendors/huawei/generated.go b/vendors/huawei/generated.go new file mode 100644 index 0000000..fdbc1c4 --- /dev/null +++ b/vendors/huawei/generated.go @@ -0,0 +1,11913 @@ +// Code generated by radius-dict-gen. DO NOT EDIT. + +package huawei + +import ( + "net" + "strconv" + + "layeh.com/radius" + "layeh.com/radius/rfc2865" +) + +const ( + _Huawei_VendorID = 2011 +) + +func _Huawei_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(_Huawei_VendorID, vendor) + if err != nil { + return + } + p.Add(rfc2865.VendorSpecific_Type, vsa) + return +} + +func _Huawei_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 != _Huawei_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 _Huawei_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 != _Huawei_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 _Huawei_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 != _Huawei_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 _Huawei_AddVendor(p, typ, attr) +} + +func _Huawei_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 != _Huawei_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 InputBurstSize uint32 + +var InputBurstSize_Strings = map[InputBurstSize]string{} + +func (a InputBurstSize) String() string { + if str, ok := InputBurstSize_Strings[a]; ok { + return str + } + return "InputBurstSize(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InputBurstSize_Add(p *radius.Packet, value InputBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 1, a) +} + +func InputBurstSize_Get(p *radius.Packet) (value InputBurstSize) { + value, _ = InputBurstSize_Lookup(p) + return +} + +func InputBurstSize_Gets(p *radius.Packet) (values []InputBurstSize, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 1) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InputBurstSize(i)) + } + return +} + +func InputBurstSize_Lookup(p *radius.Packet) (value InputBurstSize, err error) { + a, ok := _Huawei_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InputBurstSize(i) + return +} + +func InputBurstSize_Set(p *radius.Packet, value InputBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 1, a) +} + +func InputBurstSize_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 1) +} + +type InputAverageRate uint32 + +var InputAverageRate_Strings = map[InputAverageRate]string{} + +func (a InputAverageRate) String() string { + if str, ok := InputAverageRate_Strings[a]; ok { + return str + } + return "InputAverageRate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InputAverageRate_Add(p *radius.Packet, value InputAverageRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 2, a) +} + +func InputAverageRate_Get(p *radius.Packet) (value InputAverageRate) { + value, _ = InputAverageRate_Lookup(p) + return +} + +func InputAverageRate_Gets(p *radius.Packet) (values []InputAverageRate, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 2) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InputAverageRate(i)) + } + return +} + +func InputAverageRate_Lookup(p *radius.Packet) (value InputAverageRate, err error) { + a, ok := _Huawei_LookupVendor(p, 2) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InputAverageRate(i) + return +} + +func InputAverageRate_Set(p *radius.Packet, value InputAverageRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 2, a) +} + +func InputAverageRate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 2) +} + +type InputPeakRate uint32 + +var InputPeakRate_Strings = map[InputPeakRate]string{} + +func (a InputPeakRate) String() string { + if str, ok := InputPeakRate_Strings[a]; ok { + return str + } + return "InputPeakRate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InputPeakRate_Add(p *radius.Packet, value InputPeakRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 3, a) +} + +func InputPeakRate_Get(p *radius.Packet) (value InputPeakRate) { + value, _ = InputPeakRate_Lookup(p) + return +} + +func InputPeakRate_Gets(p *radius.Packet) (values []InputPeakRate, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 3) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InputPeakRate(i)) + } + return +} + +func InputPeakRate_Lookup(p *radius.Packet) (value InputPeakRate, err error) { + a, ok := _Huawei_LookupVendor(p, 3) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InputPeakRate(i) + return +} + +func InputPeakRate_Set(p *radius.Packet, value InputPeakRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 3, a) +} + +func InputPeakRate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 3) +} + +type OutputBurstSize uint32 + +var OutputBurstSize_Strings = map[OutputBurstSize]string{} + +func (a OutputBurstSize) String() string { + if str, ok := OutputBurstSize_Strings[a]; ok { + return str + } + return "OutputBurstSize(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutputBurstSize_Add(p *radius.Packet, value OutputBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 4, a) +} + +func OutputBurstSize_Get(p *radius.Packet) (value OutputBurstSize) { + value, _ = OutputBurstSize_Lookup(p) + return +} + +func OutputBurstSize_Gets(p *radius.Packet) (values []OutputBurstSize, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 4) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutputBurstSize(i)) + } + return +} + +func OutputBurstSize_Lookup(p *radius.Packet) (value OutputBurstSize, err error) { + a, ok := _Huawei_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutputBurstSize(i) + return +} + +func OutputBurstSize_Set(p *radius.Packet, value OutputBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 4, a) +} + +func OutputBurstSize_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 4) +} + +type OutputAverageRate uint32 + +var OutputAverageRate_Strings = map[OutputAverageRate]string{} + +func (a OutputAverageRate) String() string { + if str, ok := OutputAverageRate_Strings[a]; ok { + return str + } + return "OutputAverageRate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutputAverageRate_Add(p *radius.Packet, value OutputAverageRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 5, a) +} + +func OutputAverageRate_Get(p *radius.Packet) (value OutputAverageRate) { + value, _ = OutputAverageRate_Lookup(p) + return +} + +func OutputAverageRate_Gets(p *radius.Packet) (values []OutputAverageRate, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 5) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutputAverageRate(i)) + } + return +} + +func OutputAverageRate_Lookup(p *radius.Packet) (value OutputAverageRate, err error) { + a, ok := _Huawei_LookupVendor(p, 5) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutputAverageRate(i) + return +} + +func OutputAverageRate_Set(p *radius.Packet, value OutputAverageRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 5, a) +} + +func OutputAverageRate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 5) +} + +type OutputPeakRate uint32 + +var OutputPeakRate_Strings = map[OutputPeakRate]string{} + +func (a OutputPeakRate) String() string { + if str, ok := OutputPeakRate_Strings[a]; ok { + return str + } + return "OutputPeakRate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutputPeakRate_Add(p *radius.Packet, value OutputPeakRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 6, a) +} + +func OutputPeakRate_Get(p *radius.Packet) (value OutputPeakRate) { + value, _ = OutputPeakRate_Lookup(p) + return +} + +func OutputPeakRate_Gets(p *radius.Packet) (values []OutputPeakRate, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 6) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutputPeakRate(i)) + } + return +} + +func OutputPeakRate_Lookup(p *radius.Packet) (value OutputPeakRate, err error) { + a, ok := _Huawei_LookupVendor(p, 6) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutputPeakRate(i) + return +} + +func OutputPeakRate_Set(p *radius.Packet, value OutputPeakRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 6, a) +} + +func OutputPeakRate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 6) +} + +type InKbBeforeTSwitch uint32 + +var InKbBeforeTSwitch_Strings = map[InKbBeforeTSwitch]string{} + +func (a InKbBeforeTSwitch) String() string { + if str, ok := InKbBeforeTSwitch_Strings[a]; ok { + return str + } + return "InKbBeforeTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InKbBeforeTSwitch_Add(p *radius.Packet, value InKbBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 7, a) +} + +func InKbBeforeTSwitch_Get(p *radius.Packet) (value InKbBeforeTSwitch) { + value, _ = InKbBeforeTSwitch_Lookup(p) + return +} + +func InKbBeforeTSwitch_Gets(p *radius.Packet) (values []InKbBeforeTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 7) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InKbBeforeTSwitch(i)) + } + return +} + +func InKbBeforeTSwitch_Lookup(p *radius.Packet) (value InKbBeforeTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 7) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InKbBeforeTSwitch(i) + return +} + +func InKbBeforeTSwitch_Set(p *radius.Packet, value InKbBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 7, a) +} + +func InKbBeforeTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 7) +} + +type OutKbBeforeTSwitch uint32 + +var OutKbBeforeTSwitch_Strings = map[OutKbBeforeTSwitch]string{} + +func (a OutKbBeforeTSwitch) String() string { + if str, ok := OutKbBeforeTSwitch_Strings[a]; ok { + return str + } + return "OutKbBeforeTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutKbBeforeTSwitch_Add(p *radius.Packet, value OutKbBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 8, a) +} + +func OutKbBeforeTSwitch_Get(p *radius.Packet) (value OutKbBeforeTSwitch) { + value, _ = OutKbBeforeTSwitch_Lookup(p) + return +} + +func OutKbBeforeTSwitch_Gets(p *radius.Packet) (values []OutKbBeforeTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 8) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutKbBeforeTSwitch(i)) + } + return +} + +func OutKbBeforeTSwitch_Lookup(p *radius.Packet) (value OutKbBeforeTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 8) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutKbBeforeTSwitch(i) + return +} + +func OutKbBeforeTSwitch_Set(p *radius.Packet, value OutKbBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 8, a) +} + +func OutKbBeforeTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 8) +} + +type InPktBeforeTSwitch uint32 + +var InPktBeforeTSwitch_Strings = map[InPktBeforeTSwitch]string{} + +func (a InPktBeforeTSwitch) String() string { + if str, ok := InPktBeforeTSwitch_Strings[a]; ok { + return str + } + return "InPktBeforeTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InPktBeforeTSwitch_Add(p *radius.Packet, value InPktBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 9, a) +} + +func InPktBeforeTSwitch_Get(p *radius.Packet) (value InPktBeforeTSwitch) { + value, _ = InPktBeforeTSwitch_Lookup(p) + return +} + +func InPktBeforeTSwitch_Gets(p *radius.Packet) (values []InPktBeforeTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 9) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InPktBeforeTSwitch(i)) + } + return +} + +func InPktBeforeTSwitch_Lookup(p *radius.Packet) (value InPktBeforeTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 9) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InPktBeforeTSwitch(i) + return +} + +func InPktBeforeTSwitch_Set(p *radius.Packet, value InPktBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 9, a) +} + +func InPktBeforeTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 9) +} + +type OutPktBeforeTSwitch uint32 + +var OutPktBeforeTSwitch_Strings = map[OutPktBeforeTSwitch]string{} + +func (a OutPktBeforeTSwitch) String() string { + if str, ok := OutPktBeforeTSwitch_Strings[a]; ok { + return str + } + return "OutPktBeforeTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutPktBeforeTSwitch_Add(p *radius.Packet, value OutPktBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 10, a) +} + +func OutPktBeforeTSwitch_Get(p *radius.Packet) (value OutPktBeforeTSwitch) { + value, _ = OutPktBeforeTSwitch_Lookup(p) + return +} + +func OutPktBeforeTSwitch_Gets(p *radius.Packet) (values []OutPktBeforeTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 10) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutPktBeforeTSwitch(i)) + } + return +} + +func OutPktBeforeTSwitch_Lookup(p *radius.Packet) (value OutPktBeforeTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 10) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutPktBeforeTSwitch(i) + return +} + +func OutPktBeforeTSwitch_Set(p *radius.Packet, value OutPktBeforeTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 10, a) +} + +func OutPktBeforeTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 10) +} + +type InKbAfterTSwitch uint32 + +var InKbAfterTSwitch_Strings = map[InKbAfterTSwitch]string{} + +func (a InKbAfterTSwitch) String() string { + if str, ok := InKbAfterTSwitch_Strings[a]; ok { + return str + } + return "InKbAfterTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InKbAfterTSwitch_Add(p *radius.Packet, value InKbAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 11, a) +} + +func InKbAfterTSwitch_Get(p *radius.Packet) (value InKbAfterTSwitch) { + value, _ = InKbAfterTSwitch_Lookup(p) + return +} + +func InKbAfterTSwitch_Gets(p *radius.Packet) (values []InKbAfterTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 11) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InKbAfterTSwitch(i)) + } + return +} + +func InKbAfterTSwitch_Lookup(p *radius.Packet) (value InKbAfterTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 11) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InKbAfterTSwitch(i) + return +} + +func InKbAfterTSwitch_Set(p *radius.Packet, value InKbAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 11, a) +} + +func InKbAfterTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 11) +} + +type OutKbAfterTSwitch uint32 + +var OutKbAfterTSwitch_Strings = map[OutKbAfterTSwitch]string{} + +func (a OutKbAfterTSwitch) String() string { + if str, ok := OutKbAfterTSwitch_Strings[a]; ok { + return str + } + return "OutKbAfterTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutKbAfterTSwitch_Add(p *radius.Packet, value OutKbAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 12, a) +} + +func OutKbAfterTSwitch_Get(p *radius.Packet) (value OutKbAfterTSwitch) { + value, _ = OutKbAfterTSwitch_Lookup(p) + return +} + +func OutKbAfterTSwitch_Gets(p *radius.Packet) (values []OutKbAfterTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 12) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutKbAfterTSwitch(i)) + } + return +} + +func OutKbAfterTSwitch_Lookup(p *radius.Packet) (value OutKbAfterTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 12) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutKbAfterTSwitch(i) + return +} + +func OutKbAfterTSwitch_Set(p *radius.Packet, value OutKbAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 12, a) +} + +func OutKbAfterTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 12) +} + +type InPktAfterTSwitch uint32 + +var InPktAfterTSwitch_Strings = map[InPktAfterTSwitch]string{} + +func (a InPktAfterTSwitch) String() string { + if str, ok := InPktAfterTSwitch_Strings[a]; ok { + return str + } + return "InPktAfterTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InPktAfterTSwitch_Add(p *radius.Packet, value InPktAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 13, a) +} + +func InPktAfterTSwitch_Get(p *radius.Packet) (value InPktAfterTSwitch) { + value, _ = InPktAfterTSwitch_Lookup(p) + return +} + +func InPktAfterTSwitch_Gets(p *radius.Packet) (values []InPktAfterTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 13) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InPktAfterTSwitch(i)) + } + return +} + +func InPktAfterTSwitch_Lookup(p *radius.Packet) (value InPktAfterTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 13) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InPktAfterTSwitch(i) + return +} + +func InPktAfterTSwitch_Set(p *radius.Packet, value InPktAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 13, a) +} + +func InPktAfterTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 13) +} + +type OutPktAfterTSwitch uint32 + +var OutPktAfterTSwitch_Strings = map[OutPktAfterTSwitch]string{} + +func (a OutPktAfterTSwitch) String() string { + if str, ok := OutPktAfterTSwitch_Strings[a]; ok { + return str + } + return "OutPktAfterTSwitch(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutPktAfterTSwitch_Add(p *radius.Packet, value OutPktAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 14, a) +} + +func OutPktAfterTSwitch_Get(p *radius.Packet) (value OutPktAfterTSwitch) { + value, _ = OutPktAfterTSwitch_Lookup(p) + return +} + +func OutPktAfterTSwitch_Gets(p *radius.Packet) (values []OutPktAfterTSwitch, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 14) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutPktAfterTSwitch(i)) + } + return +} + +func OutPktAfterTSwitch_Lookup(p *radius.Packet) (value OutPktAfterTSwitch, err error) { + a, ok := _Huawei_LookupVendor(p, 14) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutPktAfterTSwitch(i) + return +} + +func OutPktAfterTSwitch_Set(p *radius.Packet, value OutPktAfterTSwitch) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 14, a) +} + +func OutPktAfterTSwitch_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 14) +} + +type RemanentVolume uint32 + +var RemanentVolume_Strings = map[RemanentVolume]string{} + +func (a RemanentVolume) String() string { + if str, ok := RemanentVolume_Strings[a]; ok { + return str + } + return "RemanentVolume(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RemanentVolume_Add(p *radius.Packet, value RemanentVolume) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 15, a) +} + +func RemanentVolume_Get(p *radius.Packet) (value RemanentVolume) { + value, _ = RemanentVolume_Lookup(p) + return +} + +func RemanentVolume_Gets(p *radius.Packet) (values []RemanentVolume, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 15) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RemanentVolume(i)) + } + return +} + +func RemanentVolume_Lookup(p *radius.Packet) (value RemanentVolume, err error) { + a, ok := _Huawei_LookupVendor(p, 15) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RemanentVolume(i) + return +} + +func RemanentVolume_Set(p *radius.Packet, value RemanentVolume) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 15, a) +} + +func RemanentVolume_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 15) +} + +type TariffSwitchInterval uint32 + +var TariffSwitchInterval_Strings = map[TariffSwitchInterval]string{} + +func (a TariffSwitchInterval) String() string { + if str, ok := TariffSwitchInterval_Strings[a]; ok { + return str + } + return "TariffSwitchInterval(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TariffSwitchInterval_Add(p *radius.Packet, value TariffSwitchInterval) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 16, a) +} + +func TariffSwitchInterval_Get(p *radius.Packet) (value TariffSwitchInterval) { + value, _ = TariffSwitchInterval_Lookup(p) + return +} + +func TariffSwitchInterval_Gets(p *radius.Packet) (values []TariffSwitchInterval, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 16) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TariffSwitchInterval(i)) + } + return +} + +func TariffSwitchInterval_Lookup(p *radius.Packet) (value TariffSwitchInterval, err error) { + a, ok := _Huawei_LookupVendor(p, 16) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TariffSwitchInterval(i) + return +} + +func TariffSwitchInterval_Set(p *radius.Packet, value TariffSwitchInterval) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 16, a) +} + +func TariffSwitchInterval_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 16) +} + +func ISPID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 17, a) +} + +func ISPID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 17, a) +} + +func ISPID_Get(p *radius.Packet) (value []byte) { + value, _ = ISPID_Lookup(p) + return +} + +func ISPID_GetString(p *radius.Packet) (value string) { + value, _ = ISPID_LookupString(p) + return +} + +func ISPID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 17) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ISPID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 17) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ISPID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 17) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ISPID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 17) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ISPID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 17, a) +} + +func ISPID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 17, a) +} + +func ISPID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 17) +} + +type MaxUsersPerLogicPort uint32 + +var MaxUsersPerLogicPort_Strings = map[MaxUsersPerLogicPort]string{} + +func (a MaxUsersPerLogicPort) String() string { + if str, ok := MaxUsersPerLogicPort_Strings[a]; ok { + return str + } + return "MaxUsersPerLogicPort(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func MaxUsersPerLogicPort_Add(p *radius.Packet, value MaxUsersPerLogicPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 18, a) +} + +func MaxUsersPerLogicPort_Get(p *radius.Packet) (value MaxUsersPerLogicPort) { + value, _ = MaxUsersPerLogicPort_Lookup(p) + return +} + +func MaxUsersPerLogicPort_Gets(p *radius.Packet) (values []MaxUsersPerLogicPort, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 18) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, MaxUsersPerLogicPort(i)) + } + return +} + +func MaxUsersPerLogicPort_Lookup(p *radius.Packet) (value MaxUsersPerLogicPort, err error) { + a, ok := _Huawei_LookupVendor(p, 18) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = MaxUsersPerLogicPort(i) + return +} + +func MaxUsersPerLogicPort_Set(p *radius.Packet, value MaxUsersPerLogicPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 18, a) +} + +func MaxUsersPerLogicPort_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 18) +} + +type Command uint32 + +var Command_Strings = map[Command]string{} + +func (a Command) String() string { + if str, ok := Command_Strings[a]; ok { + return str + } + return "Command(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func Command_Add(p *radius.Packet, value Command) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 20, a) +} + +func Command_Get(p *radius.Packet) (value Command) { + value, _ = Command_Lookup(p) + return +} + +func Command_Gets(p *radius.Packet) (values []Command, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 20) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, Command(i)) + } + return +} + +func Command_Lookup(p *radius.Packet) (value Command, err error) { + a, ok := _Huawei_LookupVendor(p, 20) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = Command(i) + return +} + +func Command_Set(p *radius.Packet, value Command) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 20, a) +} + +func Command_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 20) +} + +type Priority uint32 + +var Priority_Strings = map[Priority]string{} + +func (a Priority) String() string { + if str, ok := Priority_Strings[a]; ok { + return str + } + return "Priority(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func Priority_Add(p *radius.Packet, value Priority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 22, a) +} + +func Priority_Get(p *radius.Packet) (value Priority) { + value, _ = Priority_Lookup(p) + return +} + +func Priority_Gets(p *radius.Packet) (values []Priority, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 22) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, Priority(i)) + } + return +} + +func Priority_Lookup(p *radius.Packet) (value Priority, err error) { + a, ok := _Huawei_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = Priority(i) + return +} + +func Priority_Set(p *radius.Packet, value Priority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 22, a) +} + +func Priority_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 22) +} + +type ControlIdentifier uint32 + +var ControlIdentifier_Strings = map[ControlIdentifier]string{} + +func (a ControlIdentifier) String() string { + if str, ok := ControlIdentifier_Strings[a]; ok { + return str + } + return "ControlIdentifier(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ControlIdentifier_Add(p *radius.Packet, value ControlIdentifier) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 24, a) +} + +func ControlIdentifier_Get(p *radius.Packet) (value ControlIdentifier) { + value, _ = ControlIdentifier_Lookup(p) + return +} + +func ControlIdentifier_Gets(p *radius.Packet) (values []ControlIdentifier, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 24) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ControlIdentifier(i)) + } + return +} + +func ControlIdentifier_Lookup(p *radius.Packet) (value ControlIdentifier, err error) { + a, ok := _Huawei_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ControlIdentifier(i) + return +} + +func ControlIdentifier_Set(p *radius.Packet, value ControlIdentifier) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 24, a) +} + +func ControlIdentifier_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 24) +} + +type ResultCode uint32 + +const ( + ResultCode_Value_Succeeded ResultCode = 0 +) + +var ResultCode_Strings = map[ResultCode]string{ + ResultCode_Value_Succeeded: "Succeeded", +} + +func (a ResultCode) String() string { + if str, ok := ResultCode_Strings[a]; ok { + return str + } + return "ResultCode(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ResultCode_Add(p *radius.Packet, value ResultCode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 25, a) +} + +func ResultCode_Get(p *radius.Packet) (value ResultCode) { + value, _ = ResultCode_Lookup(p) + return +} + +func ResultCode_Gets(p *radius.Packet) (values []ResultCode, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 25) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ResultCode(i)) + } + return +} + +func ResultCode_Lookup(p *radius.Packet) (value ResultCode, err error) { + a, ok := _Huawei_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ResultCode(i) + return +} + +func ResultCode_Set(p *radius.Packet, value ResultCode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 25, a) +} + +func ResultCode_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 25) +} + +type ConnectID uint32 + +var ConnectID_Strings = map[ConnectID]string{} + +func (a ConnectID) String() string { + if str, ok := ConnectID_Strings[a]; ok { + return str + } + return "ConnectID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ConnectID_Add(p *radius.Packet, value ConnectID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 26, a) +} + +func ConnectID_Get(p *radius.Packet) (value ConnectID) { + value, _ = ConnectID_Lookup(p) + return +} + +func ConnectID_Gets(p *radius.Packet) (values []ConnectID, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 26) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ConnectID(i)) + } + return +} + +func ConnectID_Lookup(p *radius.Packet) (value ConnectID, err error) { + a, ok := _Huawei_LookupVendor(p, 26) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ConnectID(i) + return +} + +func ConnectID_Set(p *radius.Packet, value ConnectID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 26, a) +} + +func ConnectID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 26) +} + +func PortalURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 27, a) +} + +func PortalURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 27, a) +} + +func PortalURL_Get(p *radius.Packet) (value []byte) { + value, _ = PortalURL_Lookup(p) + return +} + +func PortalURL_GetString(p *radius.Packet) (value string) { + value, _ = PortalURL_LookupString(p) + return +} + +func PortalURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 27) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PortalURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 27) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PortalURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func PortalURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func PortalURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 27, a) +} + +func PortalURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 27, a) +} + +func PortalURL_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 27) +} + +func FTPDirectory_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 28, a) +} + +func FTPDirectory_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 28, a) +} + +func FTPDirectory_Get(p *radius.Packet) (value []byte) { + value, _ = FTPDirectory_Lookup(p) + return +} + +func FTPDirectory_GetString(p *radius.Packet) (value string) { + value, _ = FTPDirectory_LookupString(p) + return +} + +func FTPDirectory_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 28) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FTPDirectory_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 28) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FTPDirectory_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FTPDirectory_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FTPDirectory_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 28, a) +} + +func FTPDirectory_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 28, a) +} + +func FTPDirectory_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 28) +} + +type ExecPrivilege uint32 + +var ExecPrivilege_Strings = map[ExecPrivilege]string{} + +func (a ExecPrivilege) String() string { + if str, ok := ExecPrivilege_Strings[a]; ok { + return str + } + return "ExecPrivilege(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ExecPrivilege_Add(p *radius.Packet, value ExecPrivilege) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 29, a) +} + +func ExecPrivilege_Get(p *radius.Packet) (value ExecPrivilege) { + value, _ = ExecPrivilege_Lookup(p) + return +} + +func ExecPrivilege_Gets(p *radius.Packet) (values []ExecPrivilege, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 29) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ExecPrivilege(i)) + } + return +} + +func ExecPrivilege_Lookup(p *radius.Packet) (value ExecPrivilege, err error) { + a, ok := _Huawei_LookupVendor(p, 29) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ExecPrivilege(i) + return +} + +func ExecPrivilege_Set(p *radius.Packet, value ExecPrivilege) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 29, a) +} + +func ExecPrivilege_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 29) +} + +type IPAddress uint32 + +var IPAddress_Strings = map[IPAddress]string{} + +func (a IPAddress) String() string { + if str, ok := IPAddress_Strings[a]; ok { + return str + } + return "IPAddress(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func IPAddress_Add(p *radius.Packet, value IPAddress) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 30, a) +} + +func IPAddress_Get(p *radius.Packet) (value IPAddress) { + value, _ = IPAddress_Lookup(p) + return +} + +func IPAddress_Gets(p *radius.Packet) (values []IPAddress, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 30) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, IPAddress(i)) + } + return +} + +func IPAddress_Lookup(p *radius.Packet) (value IPAddress, err error) { + a, ok := _Huawei_LookupVendor(p, 30) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = IPAddress(i) + return +} + +func IPAddress_Set(p *radius.Packet, value IPAddress) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 30, a) +} + +func IPAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 30) +} + +func QosProfileName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 31, a) +} + +func QosProfileName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 31, a) +} + +func QosProfileName_Get(p *radius.Packet) (value []byte) { + value, _ = QosProfileName_Lookup(p) + return +} + +func QosProfileName_GetString(p *radius.Packet) (value string) { + value, _ = QosProfileName_LookupString(p) + return +} + +func QosProfileName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 31) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QosProfileName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 31) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QosProfileName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QosProfileName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QosProfileName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 31, a) +} + +func QosProfileName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 31, a) +} + +func QosProfileName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 31) +} + +func SIPServer_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 32, a) +} + +func SIPServer_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 32, a) +} + +func SIPServer_Get(p *radius.Packet) (value []byte) { + value, _ = SIPServer_Lookup(p) + return +} + +func SIPServer_GetString(p *radius.Packet) (value string) { + value, _ = SIPServer_LookupString(p) + return +} + +func SIPServer_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 32) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SIPServer_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 32) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SIPServer_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func SIPServer_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func SIPServer_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 32, a) +} + +func SIPServer_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 32, a) +} + +func SIPServer_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 32) +} + +func UserPassword_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 33, a) +} + +func UserPassword_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 33, a) +} + +func UserPassword_Get(p *radius.Packet) (value []byte) { + value, _ = UserPassword_Lookup(p) + return +} + +func UserPassword_GetString(p *radius.Packet) (value string) { + value, _ = UserPassword_LookupString(p) + return +} + +func UserPassword_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 33) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserPassword_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 33) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserPassword_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 33) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func UserPassword_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 33) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func UserPassword_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 33, a) +} + +func UserPassword_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 33, a) +} + +func UserPassword_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 33) +} + +func CommandMode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 34, a) +} + +func CommandMode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 34, a) +} + +func CommandMode_Get(p *radius.Packet) (value []byte) { + value, _ = CommandMode_Lookup(p) + return +} + +func CommandMode_GetString(p *radius.Packet) (value string) { + value, _ = CommandMode_LookupString(p) + return +} + +func CommandMode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 34) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CommandMode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 34) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func CommandMode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 34) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func CommandMode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 34) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func CommandMode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 34, a) +} + +func CommandMode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 34, a) +} + +func CommandMode_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 34) +} + +type RenewalTime uint32 + +var RenewalTime_Strings = map[RenewalTime]string{} + +func (a RenewalTime) String() string { + if str, ok := RenewalTime_Strings[a]; ok { + return str + } + return "RenewalTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RenewalTime_Add(p *radius.Packet, value RenewalTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 35, a) +} + +func RenewalTime_Get(p *radius.Packet) (value RenewalTime) { + value, _ = RenewalTime_Lookup(p) + return +} + +func RenewalTime_Gets(p *radius.Packet) (values []RenewalTime, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 35) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RenewalTime(i)) + } + return +} + +func RenewalTime_Lookup(p *radius.Packet) (value RenewalTime, err error) { + a, ok := _Huawei_LookupVendor(p, 35) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RenewalTime(i) + return +} + +func RenewalTime_Set(p *radius.Packet, value RenewalTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 35, a) +} + +func RenewalTime_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 35) +} + +type RebindingTime uint32 + +var RebindingTime_Strings = map[RebindingTime]string{} + +func (a RebindingTime) String() string { + if str, ok := RebindingTime_Strings[a]; ok { + return str + } + return "RebindingTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RebindingTime_Add(p *radius.Packet, value RebindingTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 36, a) +} + +func RebindingTime_Get(p *radius.Packet) (value RebindingTime) { + value, _ = RebindingTime_Lookup(p) + return +} + +func RebindingTime_Gets(p *radius.Packet) (values []RebindingTime, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 36) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RebindingTime(i)) + } + return +} + +func RebindingTime_Lookup(p *radius.Packet) (value RebindingTime, err error) { + a, ok := _Huawei_LookupVendor(p, 36) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RebindingTime(i) + return +} + +func RebindingTime_Set(p *radius.Packet, value RebindingTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 36, a) +} + +func RebindingTime_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 36) +} + +type IGMPEnable uint32 + +var IGMPEnable_Strings = map[IGMPEnable]string{} + +func (a IGMPEnable) String() string { + if str, ok := IGMPEnable_Strings[a]; ok { + return str + } + return "IGMPEnable(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func IGMPEnable_Add(p *radius.Packet, value IGMPEnable) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 37, a) +} + +func IGMPEnable_Get(p *radius.Packet) (value IGMPEnable) { + value, _ = IGMPEnable_Lookup(p) + return +} + +func IGMPEnable_Gets(p *radius.Packet) (values []IGMPEnable, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 37) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, IGMPEnable(i)) + } + return +} + +func IGMPEnable_Lookup(p *radius.Packet) (value IGMPEnable, err error) { + a, ok := _Huawei_LookupVendor(p, 37) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = IGMPEnable(i) + return +} + +func IGMPEnable_Set(p *radius.Packet, value IGMPEnable) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 37, a) +} + +func IGMPEnable_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 37) +} + +func DestnationIPAddr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 39, a) +} + +func DestnationIPAddr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 39, a) +} + +func DestnationIPAddr_Get(p *radius.Packet) (value []byte) { + value, _ = DestnationIPAddr_Lookup(p) + return +} + +func DestnationIPAddr_GetString(p *radius.Packet) (value string) { + value, _ = DestnationIPAddr_LookupString(p) + return +} + +func DestnationIPAddr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 39) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DestnationIPAddr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 39) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DestnationIPAddr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DestnationIPAddr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 39) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DestnationIPAddr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 39, a) +} + +func DestnationIPAddr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 39, a) +} + +func DestnationIPAddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 39) +} + +func DestnationVolume_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 40, a) +} + +func DestnationVolume_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 40, a) +} + +func DestnationVolume_Get(p *radius.Packet) (value []byte) { + value, _ = DestnationVolume_Lookup(p) + return +} + +func DestnationVolume_GetString(p *radius.Packet) (value string) { + value, _ = DestnationVolume_LookupString(p) + return +} + +func DestnationVolume_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 40) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DestnationVolume_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 40) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DestnationVolume_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DestnationVolume_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 40) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DestnationVolume_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 40, a) +} + +func DestnationVolume_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 40, a) +} + +func DestnationVolume_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 40) +} + +type StartupStamp uint32 + +var StartupStamp_Strings = map[StartupStamp]string{} + +func (a StartupStamp) String() string { + if str, ok := StartupStamp_Strings[a]; ok { + return str + } + return "StartupStamp(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func StartupStamp_Add(p *radius.Packet, value StartupStamp) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 59, a) +} + +func StartupStamp_Get(p *radius.Packet) (value StartupStamp) { + value, _ = StartupStamp_Lookup(p) + return +} + +func StartupStamp_Gets(p *radius.Packet) (values []StartupStamp, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 59) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, StartupStamp(i)) + } + return +} + +func StartupStamp_Lookup(p *radius.Packet) (value StartupStamp, err error) { + a, ok := _Huawei_LookupVendor(p, 59) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = StartupStamp(i) + return +} + +func StartupStamp_Set(p *radius.Packet, value StartupStamp) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 59, a) +} + +func StartupStamp_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 59) +} + +func IPHostAddr_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 60, a) +} + +func IPHostAddr_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 60, a) +} + +func IPHostAddr_Get(p *radius.Packet) (value []byte) { + value, _ = IPHostAddr_Lookup(p) + return +} + +func IPHostAddr_GetString(p *radius.Packet) (value string) { + value, _ = IPHostAddr_LookupString(p) + return +} + +func IPHostAddr_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 60) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPHostAddr_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 60) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPHostAddr_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 60) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func IPHostAddr_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 60) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func IPHostAddr_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 60, a) +} + +func IPHostAddr_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 60, a) +} + +func IPHostAddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 60) +} + +type UpPriority uint32 + +var UpPriority_Strings = map[UpPriority]string{} + +func (a UpPriority) String() string { + if str, ok := UpPriority_Strings[a]; ok { + return str + } + return "UpPriority(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func UpPriority_Add(p *radius.Packet, value UpPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 61, a) +} + +func UpPriority_Get(p *radius.Packet) (value UpPriority) { + value, _ = UpPriority_Lookup(p) + return +} + +func UpPriority_Gets(p *radius.Packet) (values []UpPriority, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 61) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, UpPriority(i)) + } + return +} + +func UpPriority_Lookup(p *radius.Packet) (value UpPriority, err error) { + a, ok := _Huawei_LookupVendor(p, 61) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = UpPriority(i) + return +} + +func UpPriority_Set(p *radius.Packet, value UpPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 61, a) +} + +func UpPriority_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 61) +} + +type DownPriority uint32 + +var DownPriority_Strings = map[DownPriority]string{} + +func (a DownPriority) String() string { + if str, ok := DownPriority_Strings[a]; ok { + return str + } + return "DownPriority(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func DownPriority_Add(p *radius.Packet, value DownPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 62, a) +} + +func DownPriority_Get(p *radius.Packet) (value DownPriority) { + value, _ = DownPriority_Lookup(p) + return +} + +func DownPriority_Gets(p *radius.Packet) (values []DownPriority, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 62) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, DownPriority(i)) + } + return +} + +func DownPriority_Lookup(p *radius.Packet) (value DownPriority, err error) { + a, ok := _Huawei_LookupVendor(p, 62) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = DownPriority(i) + return +} + +func DownPriority_Set(p *radius.Packet, value DownPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 62, a) +} + +func DownPriority_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 62) +} + +func TunnelVPNInstance_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 63, a) +} + +func TunnelVPNInstance_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 63, a) +} + +func TunnelVPNInstance_Get(p *radius.Packet) (value []byte) { + value, _ = TunnelVPNInstance_Lookup(p) + return +} + +func TunnelVPNInstance_GetString(p *radius.Packet) (value string) { + value, _ = TunnelVPNInstance_LookupString(p) + return +} + +func TunnelVPNInstance_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 63) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TunnelVPNInstance_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 63) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TunnelVPNInstance_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 63) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TunnelVPNInstance_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 63) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TunnelVPNInstance_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 63, a) +} + +func TunnelVPNInstance_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 63, a) +} + +func TunnelVPNInstance_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 63) +} + +type VTName uint32 + +var VTName_Strings = map[VTName]string{} + +func (a VTName) String() string { + if str, ok := VTName_Strings[a]; ok { + return str + } + return "VTName(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func VTName_Add(p *radius.Packet, value VTName) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 64, a) +} + +func VTName_Get(p *radius.Packet) (value VTName) { + value, _ = VTName_Lookup(p) + return +} + +func VTName_Gets(p *radius.Packet) (values []VTName, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 64) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, VTName(i)) + } + return +} + +func VTName_Lookup(p *radius.Packet) (value VTName, err error) { + a, ok := _Huawei_LookupVendor(p, 64) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = VTName(i) + return +} + +func VTName_Set(p *radius.Packet, value VTName) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 64, a) +} + +func VTName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 64) +} + +func UserDate_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 65, a) +} + +func UserDate_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 65, a) +} + +func UserDate_Get(p *radius.Packet) (value []byte) { + value, _ = UserDate_Lookup(p) + return +} + +func UserDate_GetString(p *radius.Packet) (value string) { + value, _ = UserDate_LookupString(p) + return +} + +func UserDate_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 65) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserDate_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 65) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserDate_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 65) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func UserDate_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 65) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func UserDate_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 65, a) +} + +func UserDate_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 65, a) +} + +func UserDate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 65) +} + +func UserClass_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 66, a) +} + +func UserClass_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 66, a) +} + +func UserClass_Get(p *radius.Packet) (value []byte) { + value, _ = UserClass_Lookup(p) + return +} + +func UserClass_GetString(p *radius.Packet) (value string) { + value, _ = UserClass_LookupString(p) + return +} + +func UserClass_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 66) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserClass_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 66) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserClass_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 66) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func UserClass_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 66) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func UserClass_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 66, a) +} + +func UserClass_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 66, a) +} + +func UserClass_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 66) +} + +type PPPNCPType uint32 + +var PPPNCPType_Strings = map[PPPNCPType]string{} + +func (a PPPNCPType) String() string { + if str, ok := PPPNCPType_Strings[a]; ok { + return str + } + return "PPPNCPType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PPPNCPType_Add(p *radius.Packet, value PPPNCPType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 70, a) +} + +func PPPNCPType_Get(p *radius.Packet) (value PPPNCPType) { + value, _ = PPPNCPType_Lookup(p) + return +} + +func PPPNCPType_Gets(p *radius.Packet) (values []PPPNCPType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 70) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PPPNCPType(i)) + } + return +} + +func PPPNCPType_Lookup(p *radius.Packet) (value PPPNCPType, err error) { + a, ok := _Huawei_LookupVendor(p, 70) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PPPNCPType(i) + return +} + +func PPPNCPType_Set(p *radius.Packet, value PPPNCPType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 70, a) +} + +func PPPNCPType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 70) +} + +func VSIName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 71, a) +} + +func VSIName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 71, a) +} + +func VSIName_Get(p *radius.Packet) (value []byte) { + value, _ = VSIName_Lookup(p) + return +} + +func VSIName_GetString(p *radius.Packet) (value string) { + value, _ = VSIName_LookupString(p) + return +} + +func VSIName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 71) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VSIName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 71) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VSIName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 71) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func VSIName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 71) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func VSIName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 71, a) +} + +func VSIName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 71, a) +} + +func VSIName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 71) +} + +func SubnetMask_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 72, a) +} + +func SubnetMask_Get(p *radius.Packet) (value net.IP) { + value, _ = SubnetMask_Lookup(p) + return +} + +func SubnetMask_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 72) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SubnetMask_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 72) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func SubnetMask_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 72, a) +} + +func SubnetMask_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 72) +} + +func GatewayAddress_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 73, a) +} + +func GatewayAddress_Get(p *radius.Packet) (value net.IP) { + value, _ = GatewayAddress_Lookup(p) + return +} + +func GatewayAddress_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 73) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func GatewayAddress_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 73) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func GatewayAddress_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 73, a) +} + +func GatewayAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 73) +} + +type LeaseTime uint32 + +var LeaseTime_Strings = map[LeaseTime]string{} + +func (a LeaseTime) String() string { + if str, ok := LeaseTime_Strings[a]; ok { + return str + } + return "LeaseTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func LeaseTime_Add(p *radius.Packet, value LeaseTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 74, a) +} + +func LeaseTime_Get(p *radius.Packet) (value LeaseTime) { + value, _ = LeaseTime_Lookup(p) + return +} + +func LeaseTime_Gets(p *radius.Packet) (values []LeaseTime, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 74) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, LeaseTime(i)) + } + return +} + +func LeaseTime_Lookup(p *radius.Packet) (value LeaseTime, err error) { + a, ok := _Huawei_LookupVendor(p, 74) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = LeaseTime(i) + return +} + +func LeaseTime_Set(p *radius.Packet, value LeaseTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 74, a) +} + +func LeaseTime_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 74) +} + +func PrimaryWINS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 75, a) +} + +func PrimaryWINS_Get(p *radius.Packet) (value net.IP) { + value, _ = PrimaryWINS_Lookup(p) + return +} + +func PrimaryWINS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 75) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PrimaryWINS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 75) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func PrimaryWINS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 75, a) +} + +func PrimaryWINS_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 75) +} + +func SecondaryWINS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 76, a) +} + +func SecondaryWINS_Get(p *radius.Packet) (value net.IP) { + value, _ = SecondaryWINS_Lookup(p) + return +} + +func SecondaryWINS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 76) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SecondaryWINS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 76) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func SecondaryWINS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 76, a) +} + +func SecondaryWINS_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 76) +} + +type InputPeakBurstSize uint32 + +var InputPeakBurstSize_Strings = map[InputPeakBurstSize]string{} + +func (a InputPeakBurstSize) String() string { + if str, ok := InputPeakBurstSize_Strings[a]; ok { + return str + } + return "InputPeakBurstSize(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func InputPeakBurstSize_Add(p *radius.Packet, value InputPeakBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 77, a) +} + +func InputPeakBurstSize_Get(p *radius.Packet) (value InputPeakBurstSize) { + value, _ = InputPeakBurstSize_Lookup(p) + return +} + +func InputPeakBurstSize_Gets(p *radius.Packet) (values []InputPeakBurstSize, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 77) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, InputPeakBurstSize(i)) + } + return +} + +func InputPeakBurstSize_Lookup(p *radius.Packet) (value InputPeakBurstSize, err error) { + a, ok := _Huawei_LookupVendor(p, 77) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = InputPeakBurstSize(i) + return +} + +func InputPeakBurstSize_Set(p *radius.Packet, value InputPeakBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 77, a) +} + +func InputPeakBurstSize_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 77) +} + +type OutputPeakBurstSize uint32 + +var OutputPeakBurstSize_Strings = map[OutputPeakBurstSize]string{} + +func (a OutputPeakBurstSize) String() string { + if str, ok := OutputPeakBurstSize_Strings[a]; ok { + return str + } + return "OutputPeakBurstSize(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func OutputPeakBurstSize_Add(p *radius.Packet, value OutputPeakBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 78, a) +} + +func OutputPeakBurstSize_Get(p *radius.Packet) (value OutputPeakBurstSize) { + value, _ = OutputPeakBurstSize_Lookup(p) + return +} + +func OutputPeakBurstSize_Gets(p *radius.Packet) (values []OutputPeakBurstSize, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 78) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, OutputPeakBurstSize(i)) + } + return +} + +func OutputPeakBurstSize_Lookup(p *radius.Packet) (value OutputPeakBurstSize, err error) { + a, ok := _Huawei_LookupVendor(p, 78) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = OutputPeakBurstSize(i) + return +} + +func OutputPeakBurstSize_Set(p *radius.Packet, value OutputPeakBurstSize) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 78, a) +} + +func OutputPeakBurstSize_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 78) +} + +type ReducedCIR uint32 + +var ReducedCIR_Strings = map[ReducedCIR]string{} + +func (a ReducedCIR) String() string { + if str, ok := ReducedCIR_Strings[a]; ok { + return str + } + return "ReducedCIR(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ReducedCIR_Add(p *radius.Packet, value ReducedCIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 79, a) +} + +func ReducedCIR_Get(p *radius.Packet) (value ReducedCIR) { + value, _ = ReducedCIR_Lookup(p) + return +} + +func ReducedCIR_Gets(p *radius.Packet) (values []ReducedCIR, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 79) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ReducedCIR(i)) + } + return +} + +func ReducedCIR_Lookup(p *radius.Packet) (value ReducedCIR, err error) { + a, ok := _Huawei_LookupVendor(p, 79) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ReducedCIR(i) + return +} + +func ReducedCIR_Set(p *radius.Packet, value ReducedCIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 79, a) +} + +func ReducedCIR_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 79) +} + +type TunnelSessionLimit uint32 + +var TunnelSessionLimit_Strings = map[TunnelSessionLimit]string{} + +func (a TunnelSessionLimit) String() string { + if str, ok := TunnelSessionLimit_Strings[a]; ok { + return str + } + return "TunnelSessionLimit(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelSessionLimit_Add(p *radius.Packet, value TunnelSessionLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 80, a) +} + +func TunnelSessionLimit_Get(p *radius.Packet) (value TunnelSessionLimit) { + value, _ = TunnelSessionLimit_Lookup(p) + return +} + +func TunnelSessionLimit_Gets(p *radius.Packet) (values []TunnelSessionLimit, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 80) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelSessionLimit(i)) + } + return +} + +func TunnelSessionLimit_Lookup(p *radius.Packet) (value TunnelSessionLimit, err error) { + a, ok := _Huawei_LookupVendor(p, 80) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelSessionLimit(i) + return +} + +func TunnelSessionLimit_Set(p *radius.Packet, value TunnelSessionLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 80, a) +} + +func TunnelSessionLimit_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 80) +} + +func ZoneName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 81, a) +} + +func ZoneName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 81, a) +} + +func ZoneName_Get(p *radius.Packet) (value []byte) { + value, _ = ZoneName_Lookup(p) + return +} + +func ZoneName_GetString(p *radius.Packet) (value string) { + value, _ = ZoneName_LookupString(p) + return +} + +func ZoneName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 81) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ZoneName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 81) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ZoneName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ZoneName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ZoneName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 81, a) +} + +func ZoneName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 81, a) +} + +func ZoneName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 81) +} + +func DataFilter_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 82, a) +} + +func DataFilter_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 82, a) +} + +func DataFilter_Get(p *radius.Packet) (value []byte) { + value, _ = DataFilter_Lookup(p) + return +} + +func DataFilter_GetString(p *radius.Packet) (value string) { + value, _ = DataFilter_LookupString(p) + return +} + +func DataFilter_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 82) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DataFilter_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 82) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DataFilter_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DataFilter_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DataFilter_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 82, a) +} + +func DataFilter_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 82, a) +} + +func DataFilter_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 82) +} + +func AccessService_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 83, a) +} + +func AccessService_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 83, a) +} + +func AccessService_Get(p *radius.Packet) (value []byte) { + value, _ = AccessService_Lookup(p) + return +} + +func AccessService_GetString(p *radius.Packet) (value string) { + value, _ = AccessService_LookupString(p) + return +} + +func AccessService_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 83) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessService_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 83) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessService_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 83) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AccessService_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 83) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AccessService_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 83, a) +} + +func AccessService_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 83, a) +} + +func AccessService_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 83) +} + +type AccountingLevel uint32 + +var AccountingLevel_Strings = map[AccountingLevel]string{} + +func (a AccountingLevel) String() string { + if str, ok := AccountingLevel_Strings[a]; ok { + return str + } + return "AccountingLevel(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AccountingLevel_Add(p *radius.Packet, value AccountingLevel) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 84, a) +} + +func AccountingLevel_Get(p *radius.Packet) (value AccountingLevel) { + value, _ = AccountingLevel_Lookup(p) + return +} + +func AccountingLevel_Gets(p *radius.Packet) (values []AccountingLevel, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 84) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AccountingLevel(i)) + } + return +} + +func AccountingLevel_Lookup(p *radius.Packet) (value AccountingLevel, err error) { + a, ok := _Huawei_LookupVendor(p, 84) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AccountingLevel(i) + return +} + +func AccountingLevel_Set(p *radius.Packet, value AccountingLevel) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 84, a) +} + +func AccountingLevel_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 84) +} + +type PortalMode uint32 + +const ( + PortalMode_Value_PADM PortalMode = 0 + PortalMode_Value_Redirectional PortalMode = 1 + PortalMode_Value_NonCaptive PortalMode = 2 +) + +var PortalMode_Strings = map[PortalMode]string{ + PortalMode_Value_PADM: "PADM", + PortalMode_Value_Redirectional: "Redirectional", + PortalMode_Value_NonCaptive: "Non-captive", +} + +func (a PortalMode) String() string { + if str, ok := PortalMode_Strings[a]; ok { + return str + } + return "PortalMode(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PortalMode_Add(p *radius.Packet, value PortalMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 85, a) +} + +func PortalMode_Get(p *radius.Packet) (value PortalMode) { + value, _ = PortalMode_Lookup(p) + return +} + +func PortalMode_Gets(p *radius.Packet) (values []PortalMode, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 85) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PortalMode(i)) + } + return +} + +func PortalMode_Lookup(p *radius.Packet) (value PortalMode, err error) { + a, ok := _Huawei_LookupVendor(p, 85) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PortalMode(i) + return +} + +func PortalMode_Set(p *radius.Packet, value PortalMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 85, a) +} + +func PortalMode_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 85) +} + +func DPIPolicyName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 86, a) +} + +func DPIPolicyName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 86, a) +} + +func DPIPolicyName_Get(p *radius.Packet) (value []byte) { + value, _ = DPIPolicyName_Lookup(p) + return +} + +func DPIPolicyName_GetString(p *radius.Packet) (value string) { + value, _ = DPIPolicyName_LookupString(p) + return +} + +func DPIPolicyName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 86) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DPIPolicyName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 86) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DPIPolicyName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 86) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DPIPolicyName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 86) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DPIPolicyName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 86, a) +} + +func DPIPolicyName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 86, a) +} + +func DPIPolicyName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 86) +} + +func PolicyRoute_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 87, a) +} + +func PolicyRoute_Get(p *radius.Packet) (value net.IP) { + value, _ = PolicyRoute_Lookup(p) + return +} + +func PolicyRoute_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 87) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PolicyRoute_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 87) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func PolicyRoute_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 87, a) +} + +func PolicyRoute_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 87) +} + +func FramedPool_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 88, a) +} + +func FramedPool_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 88, a) +} + +func FramedPool_Get(p *radius.Packet) (value []byte) { + value, _ = FramedPool_Lookup(p) + return +} + +func FramedPool_GetString(p *radius.Packet) (value string) { + value, _ = FramedPool_LookupString(p) + return +} + +func FramedPool_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 88) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FramedPool_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 88) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FramedPool_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 88) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FramedPool_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 88) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FramedPool_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 88, a) +} + +func FramedPool_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 88, a) +} + +func FramedPool_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 88) +} + +func L2TPTerminateCause_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 89, a) +} + +func L2TPTerminateCause_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 89, a) +} + +func L2TPTerminateCause_Get(p *radius.Packet) (value []byte) { + value, _ = L2TPTerminateCause_Lookup(p) + return +} + +func L2TPTerminateCause_GetString(p *radius.Packet) (value string) { + value, _ = L2TPTerminateCause_LookupString(p) + return +} + +func L2TPTerminateCause_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 89) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func L2TPTerminateCause_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 89) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func L2TPTerminateCause_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 89) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func L2TPTerminateCause_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 89) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func L2TPTerminateCause_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 89, a) +} + +func L2TPTerminateCause_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 89, a) +} + +func L2TPTerminateCause_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 89) +} + +type MultiAccountMode uint32 + +var MultiAccountMode_Strings = map[MultiAccountMode]string{} + +func (a MultiAccountMode) String() string { + if str, ok := MultiAccountMode_Strings[a]; ok { + return str + } + return "MultiAccountMode(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func MultiAccountMode_Add(p *radius.Packet, value MultiAccountMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 90, a) +} + +func MultiAccountMode_Get(p *radius.Packet) (value MultiAccountMode) { + value, _ = MultiAccountMode_Lookup(p) + return +} + +func MultiAccountMode_Gets(p *radius.Packet) (values []MultiAccountMode, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 90) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, MultiAccountMode(i)) + } + return +} + +func MultiAccountMode_Lookup(p *radius.Packet) (value MultiAccountMode, err error) { + a, ok := _Huawei_LookupVendor(p, 90) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = MultiAccountMode(i) + return +} + +func MultiAccountMode_Set(p *radius.Packet, value MultiAccountMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 90, a) +} + +func MultiAccountMode_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 90) +} + +func QueueProfile_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 91, a) +} + +func QueueProfile_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 91, a) +} + +func QueueProfile_Get(p *radius.Packet) (value []byte) { + value, _ = QueueProfile_Lookup(p) + return +} + +func QueueProfile_GetString(p *radius.Packet) (value string) { + value, _ = QueueProfile_LookupString(p) + return +} + +func QueueProfile_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 91) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QueueProfile_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 91) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QueueProfile_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 91) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QueueProfile_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 91) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QueueProfile_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 91, a) +} + +func QueueProfile_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 91, a) +} + +func QueueProfile_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 91) +} + +type Layer4SessionLimit uint32 + +var Layer4SessionLimit_Strings = map[Layer4SessionLimit]string{} + +func (a Layer4SessionLimit) String() string { + if str, ok := Layer4SessionLimit_Strings[a]; ok { + return str + } + return "Layer4SessionLimit(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func Layer4SessionLimit_Add(p *radius.Packet, value Layer4SessionLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 92, a) +} + +func Layer4SessionLimit_Get(p *radius.Packet) (value Layer4SessionLimit) { + value, _ = Layer4SessionLimit_Lookup(p) + return +} + +func Layer4SessionLimit_Gets(p *radius.Packet) (values []Layer4SessionLimit, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 92) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, Layer4SessionLimit(i)) + } + return +} + +func Layer4SessionLimit_Lookup(p *radius.Packet) (value Layer4SessionLimit, err error) { + a, ok := _Huawei_LookupVendor(p, 92) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = Layer4SessionLimit(i) + return +} + +func Layer4SessionLimit_Set(p *radius.Packet, value Layer4SessionLimit) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 92, a) +} + +func Layer4SessionLimit_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 92) +} + +func MulticastProfile_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 93, a) +} + +func MulticastProfile_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 93, a) +} + +func MulticastProfile_Get(p *radius.Packet) (value []byte) { + value, _ = MulticastProfile_Lookup(p) + return +} + +func MulticastProfile_GetString(p *radius.Packet) (value string) { + value, _ = MulticastProfile_LookupString(p) + return +} + +func MulticastProfile_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 93) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MulticastProfile_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 93) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MulticastProfile_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 93) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func MulticastProfile_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 93) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func MulticastProfile_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 93, a) +} + +func MulticastProfile_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 93, a) +} + +func MulticastProfile_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 93) +} + +func VPNInstance_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 94, a) +} + +func VPNInstance_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 94, a) +} + +func VPNInstance_Get(p *radius.Packet) (value []byte) { + value, _ = VPNInstance_Lookup(p) + return +} + +func VPNInstance_GetString(p *radius.Packet) (value string) { + value, _ = VPNInstance_LookupString(p) + return +} + +func VPNInstance_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 94) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VPNInstance_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 94) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VPNInstance_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func VPNInstance_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func VPNInstance_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 94, a) +} + +func VPNInstance_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 94, a) +} + +func VPNInstance_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 94) +} + +func PolicyName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 95, a) +} + +func PolicyName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 95, a) +} + +func PolicyName_Get(p *radius.Packet) (value []byte) { + value, _ = PolicyName_Lookup(p) + return +} + +func PolicyName_GetString(p *radius.Packet) (value string) { + value, _ = PolicyName_LookupString(p) + return +} + +func PolicyName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 95) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PolicyName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 95) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PolicyName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 95) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func PolicyName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 95) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func PolicyName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 95, a) +} + +func PolicyName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 95, a) +} + +func PolicyName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 95) +} + +func TunnelGroupName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 96, a) +} + +func TunnelGroupName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 96, a) +} + +func TunnelGroupName_Get(p *radius.Packet) (value []byte) { + value, _ = TunnelGroupName_Lookup(p) + return +} + +func TunnelGroupName_GetString(p *radius.Packet) (value string) { + value, _ = TunnelGroupName_LookupString(p) + return +} + +func TunnelGroupName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 96) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TunnelGroupName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 96) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TunnelGroupName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 96) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TunnelGroupName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 96) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TunnelGroupName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 96, a) +} + +func TunnelGroupName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 96, a) +} + +func TunnelGroupName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 96) +} + +func MulticastSourceGroup_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 97, a) +} + +func MulticastSourceGroup_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 97, a) +} + +func MulticastSourceGroup_Get(p *radius.Packet) (value []byte) { + value, _ = MulticastSourceGroup_Lookup(p) + return +} + +func MulticastSourceGroup_GetString(p *radius.Packet) (value string) { + value, _ = MulticastSourceGroup_LookupString(p) + return +} + +func MulticastSourceGroup_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 97) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MulticastSourceGroup_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 97) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MulticastSourceGroup_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 97) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func MulticastSourceGroup_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 97) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func MulticastSourceGroup_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 97, a) +} + +func MulticastSourceGroup_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 97, a) +} + +func MulticastSourceGroup_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 97) +} + +func MulticastReceiveGroup_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 98, a) +} + +func MulticastReceiveGroup_Get(p *radius.Packet) (value net.IP) { + value, _ = MulticastReceiveGroup_Lookup(p) + return +} + +func MulticastReceiveGroup_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 98) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MulticastReceiveGroup_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 98) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func MulticastReceiveGroup_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 98, a) +} + +func MulticastReceiveGroup_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 98) +} + +type UserMulticastType uint32 + +var UserMulticastType_Strings = map[UserMulticastType]string{} + +func (a UserMulticastType) String() string { + if str, ok := UserMulticastType_Strings[a]; ok { + return str + } + return "UserMulticastType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func UserMulticastType_Add(p *radius.Packet, value UserMulticastType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 99, a) +} + +func UserMulticastType_Get(p *radius.Packet) (value UserMulticastType) { + value, _ = UserMulticastType_Lookup(p) + return +} + +func UserMulticastType_Gets(p *radius.Packet) (values []UserMulticastType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 99) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, UserMulticastType(i)) + } + return +} + +func UserMulticastType_Lookup(p *radius.Packet) (value UserMulticastType, err error) { + a, ok := _Huawei_LookupVendor(p, 99) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = UserMulticastType(i) + return +} + +func UserMulticastType_Set(p *radius.Packet, value UserMulticastType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 99, a) +} + +func UserMulticastType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 99) +} + +type ReducedPIR uint32 + +var ReducedPIR_Strings = map[ReducedPIR]string{} + +func (a ReducedPIR) String() string { + if str, ok := ReducedPIR_Strings[a]; ok { + return str + } + return "ReducedPIR(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ReducedPIR_Add(p *radius.Packet, value ReducedPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 100, a) +} + +func ReducedPIR_Get(p *radius.Packet) (value ReducedPIR) { + value, _ = ReducedPIR_Lookup(p) + return +} + +func ReducedPIR_Gets(p *radius.Packet) (values []ReducedPIR, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 100) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ReducedPIR(i)) + } + return +} + +func ReducedPIR_Lookup(p *radius.Packet) (value ReducedPIR, err error) { + a, ok := _Huawei_LookupVendor(p, 100) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ReducedPIR(i) + return +} + +func ReducedPIR_Set(p *radius.Packet, value ReducedPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 100, a) +} + +func ReducedPIR_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 100) +} + +func LIID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 101, a) +} + +func LIID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 101, a) +} + +func LIID_Get(p *radius.Packet) (value []byte) { + value, _ = LIID_Lookup(p) + return +} + +func LIID_GetString(p *radius.Packet) (value string) { + value, _ = LIID_LookupString(p) + return +} + +func LIID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 101) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LIID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 101) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LIID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 101) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func LIID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 101) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func LIID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 101, a) +} + +func LIID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 101, a) +} + +func LIID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 101) +} + +func LIMdAddress_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 102, a) +} + +func LIMdAddress_Get(p *radius.Packet) (value net.IP) { + value, _ = LIMdAddress_Lookup(p) + return +} + +func LIMdAddress_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 102) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LIMdAddress_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 102) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func LIMdAddress_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 102, a) +} + +func LIMdAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 102) +} + +type LIMdPort uint32 + +var LIMdPort_Strings = map[LIMdPort]string{} + +func (a LIMdPort) String() string { + if str, ok := LIMdPort_Strings[a]; ok { + return str + } + return "LIMdPort(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func LIMdPort_Add(p *radius.Packet, value LIMdPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 103, a) +} + +func LIMdPort_Get(p *radius.Packet) (value LIMdPort) { + value, _ = LIMdPort_Lookup(p) + return +} + +func LIMdPort_Gets(p *radius.Packet) (values []LIMdPort, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 103) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, LIMdPort(i)) + } + return +} + +func LIMdPort_Lookup(p *radius.Packet) (value LIMdPort, err error) { + a, ok := _Huawei_LookupVendor(p, 103) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = LIMdPort(i) + return +} + +func LIMdPort_Set(p *radius.Packet, value LIMdPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 103, a) +} + +func LIMdPort_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 103) +} + +func LIMdVpnInstance_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 104, a) +} + +func LIMdVpnInstance_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 104, a) +} + +func LIMdVpnInstance_Get(p *radius.Packet) (value []byte) { + value, _ = LIMdVpnInstance_Lookup(p) + return +} + +func LIMdVpnInstance_GetString(p *radius.Packet) (value string) { + value, _ = LIMdVpnInstance_LookupString(p) + return +} + +func LIMdVpnInstance_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 104) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LIMdVpnInstance_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 104) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LIMdVpnInstance_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 104) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func LIMdVpnInstance_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 104) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func LIMdVpnInstance_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 104, a) +} + +func LIMdVpnInstance_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 104, a) +} + +func LIMdVpnInstance_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 104) +} + +type ServiceChgCmd uint32 + +var ServiceChgCmd_Strings = map[ServiceChgCmd]string{} + +func (a ServiceChgCmd) String() string { + if str, ok := ServiceChgCmd_Strings[a]; ok { + return str + } + return "ServiceChgCmd(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ServiceChgCmd_Add(p *radius.Packet, value ServiceChgCmd) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 105, a) +} + +func ServiceChgCmd_Get(p *radius.Packet) (value ServiceChgCmd) { + value, _ = ServiceChgCmd_Lookup(p) + return +} + +func ServiceChgCmd_Gets(p *radius.Packet) (values []ServiceChgCmd, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 105) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ServiceChgCmd(i)) + } + return +} + +func ServiceChgCmd_Lookup(p *radius.Packet) (value ServiceChgCmd, err error) { + a, ok := _Huawei_LookupVendor(p, 105) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ServiceChgCmd(i) + return +} + +func ServiceChgCmd_Set(p *radius.Packet, value ServiceChgCmd) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 105, a) +} + +func ServiceChgCmd_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 105) +} + +type AcctPacketType uint32 + +var AcctPacketType_Strings = map[AcctPacketType]string{} + +func (a AcctPacketType) String() string { + if str, ok := AcctPacketType_Strings[a]; ok { + return str + } + return "AcctPacketType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctPacketType_Add(p *radius.Packet, value AcctPacketType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 106, a) +} + +func AcctPacketType_Get(p *radius.Packet) (value AcctPacketType) { + value, _ = AcctPacketType_Lookup(p) + return +} + +func AcctPacketType_Gets(p *radius.Packet) (values []AcctPacketType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 106) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctPacketType(i)) + } + return +} + +func AcctPacketType_Lookup(p *radius.Packet) (value AcctPacketType, err error) { + a, ok := _Huawei_LookupVendor(p, 106) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctPacketType(i) + return +} + +func AcctPacketType_Set(p *radius.Packet, value AcctPacketType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 106, a) +} + +func AcctPacketType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 106) +} + +type CallReference uint32 + +var CallReference_Strings = map[CallReference]string{} + +func (a CallReference) String() string { + if str, ok := CallReference_Strings[a]; ok { + return str + } + return "CallReference(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func CallReference_Add(p *radius.Packet, value CallReference) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 107, a) +} + +func CallReference_Get(p *radius.Packet) (value CallReference) { + value, _ = CallReference_Lookup(p) + return +} + +func CallReference_Gets(p *radius.Packet) (values []CallReference, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 107) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, CallReference(i)) + } + return +} + +func CallReference_Lookup(p *radius.Packet) (value CallReference, err error) { + a, ok := _Huawei_LookupVendor(p, 107) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = CallReference(i) + return +} + +func CallReference_Set(p *radius.Packet, value CallReference) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 107, a) +} + +func CallReference_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 107) +} + +type PSTNPort uint32 + +var PSTNPort_Strings = map[PSTNPort]string{} + +func (a PSTNPort) String() string { + if str, ok := PSTNPort_Strings[a]; ok { + return str + } + return "PSTNPort(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PSTNPort_Add(p *radius.Packet, value PSTNPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 108, a) +} + +func PSTNPort_Get(p *radius.Packet) (value PSTNPort) { + value, _ = PSTNPort_Lookup(p) + return +} + +func PSTNPort_Gets(p *radius.Packet) (values []PSTNPort, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 108) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PSTNPort(i)) + } + return +} + +func PSTNPort_Lookup(p *radius.Packet) (value PSTNPort, err error) { + a, ok := _Huawei_LookupVendor(p, 108) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PSTNPort(i) + return +} + +func PSTNPort_Set(p *radius.Packet, value PSTNPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 108, a) +} + +func PSTNPort_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 108) +} + +type VoipServiceType uint32 + +var VoipServiceType_Strings = map[VoipServiceType]string{} + +func (a VoipServiceType) String() string { + if str, ok := VoipServiceType_Strings[a]; ok { + return str + } + return "VoipServiceType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func VoipServiceType_Add(p *radius.Packet, value VoipServiceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 109, a) +} + +func VoipServiceType_Get(p *radius.Packet) (value VoipServiceType) { + value, _ = VoipServiceType_Lookup(p) + return +} + +func VoipServiceType_Gets(p *radius.Packet) (values []VoipServiceType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 109) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, VoipServiceType(i)) + } + return +} + +func VoipServiceType_Lookup(p *radius.Packet) (value VoipServiceType, err error) { + a, ok := _Huawei_LookupVendor(p, 109) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = VoipServiceType(i) + return +} + +func VoipServiceType_Set(p *radius.Packet, value VoipServiceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 109, a) +} + +func VoipServiceType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 109) +} + +type AcctConnectionTime uint32 + +var AcctConnectionTime_Strings = map[AcctConnectionTime]string{} + +func (a AcctConnectionTime) String() string { + if str, ok := AcctConnectionTime_Strings[a]; ok { + return str + } + return "AcctConnectionTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctConnectionTime_Add(p *radius.Packet, value AcctConnectionTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 110, a) +} + +func AcctConnectionTime_Get(p *radius.Packet) (value AcctConnectionTime) { + value, _ = AcctConnectionTime_Lookup(p) + return +} + +func AcctConnectionTime_Gets(p *radius.Packet) (values []AcctConnectionTime, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 110) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctConnectionTime(i)) + } + return +} + +func AcctConnectionTime_Lookup(p *radius.Packet) (value AcctConnectionTime, err error) { + a, ok := _Huawei_LookupVendor(p, 110) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctConnectionTime(i) + return +} + +func AcctConnectionTime_Set(p *radius.Packet, value AcctConnectionTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 110, a) +} + +func AcctConnectionTime_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 110) +} + +type ErrorReason uint32 + +var ErrorReason_Strings = map[ErrorReason]string{} + +func (a ErrorReason) String() string { + if str, ok := ErrorReason_Strings[a]; ok { + return str + } + return "ErrorReason(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ErrorReason_Add(p *radius.Packet, value ErrorReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 112, a) +} + +func ErrorReason_Get(p *radius.Packet) (value ErrorReason) { + value, _ = ErrorReason_Lookup(p) + return +} + +func ErrorReason_Gets(p *radius.Packet) (values []ErrorReason, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 112) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ErrorReason(i)) + } + return +} + +func ErrorReason_Lookup(p *radius.Packet) (value ErrorReason, err error) { + a, ok := _Huawei_LookupVendor(p, 112) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ErrorReason(i) + return +} + +func ErrorReason_Set(p *radius.Packet, value ErrorReason) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 112, a) +} + +func ErrorReason_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 112) +} + +type RemainMonney uint32 + +var RemainMonney_Strings = map[RemainMonney]string{} + +func (a RemainMonney) String() string { + if str, ok := RemainMonney_Strings[a]; ok { + return str + } + return "RemainMonney(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RemainMonney_Add(p *radius.Packet, value RemainMonney) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 113, a) +} + +func RemainMonney_Get(p *radius.Packet) (value RemainMonney) { + value, _ = RemainMonney_Lookup(p) + return +} + +func RemainMonney_Gets(p *radius.Packet) (values []RemainMonney, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 113) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RemainMonney(i)) + } + return +} + +func RemainMonney_Lookup(p *radius.Packet) (value RemainMonney, err error) { + a, ok := _Huawei_LookupVendor(p, 113) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RemainMonney(i) + return +} + +func RemainMonney_Set(p *radius.Packet, value RemainMonney) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 113, a) +} + +func RemainMonney_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 113) +} + +func OrgGKIpaddr_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 123, a) +} + +func OrgGKIpaddr_Get(p *radius.Packet) (value net.IP) { + value, _ = OrgGKIpaddr_Lookup(p) + return +} + +func OrgGKIpaddr_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 123) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func OrgGKIpaddr_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 123) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func OrgGKIpaddr_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 123, a) +} + +func OrgGKIpaddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 123) +} + +func OrgGWIpaddr_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 124, a) +} + +func OrgGWIpaddr_Get(p *radius.Packet) (value net.IP) { + value, _ = OrgGWIpaddr_Lookup(p) + return +} + +func OrgGWIpaddr_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 124) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func OrgGWIpaddr_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 124) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func OrgGWIpaddr_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 124, a) +} + +func OrgGWIpaddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 124) +} + +func DstGKIpaddr_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 125, a) +} + +func DstGKIpaddr_Get(p *radius.Packet) (value net.IP) { + value, _ = DstGKIpaddr_Lookup(p) + return +} + +func DstGKIpaddr_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 125) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DstGKIpaddr_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 125) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func DstGKIpaddr_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 125, a) +} + +func DstGKIpaddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 125) +} + +func DstGWIpaddr_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 126, a) +} + +func DstGWIpaddr_Get(p *radius.Packet) (value net.IP) { + value, _ = DstGWIpaddr_Lookup(p) + return +} + +func DstGWIpaddr_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 126) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DstGWIpaddr_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 126) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func DstGWIpaddr_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 126, a) +} + +func DstGWIpaddr_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 126) +} + +func AccessNum_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 127, a) +} + +func AccessNum_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 127, a) +} + +func AccessNum_Get(p *radius.Packet) (value []byte) { + value, _ = AccessNum_Lookup(p) + return +} + +func AccessNum_GetString(p *radius.Packet) (value string) { + value, _ = AccessNum_LookupString(p) + return +} + +func AccessNum_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 127) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessNum_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 127) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessNum_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 127) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AccessNum_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 127) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AccessNum_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 127, a) +} + +func AccessNum_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 127, a) +} + +func AccessNum_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 127) +} + +type RemainTime uint32 + +var RemainTime_Strings = map[RemainTime]string{} + +func (a RemainTime) String() string { + if str, ok := RemainTime_Strings[a]; ok { + return str + } + return "RemainTime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RemainTime_Add(p *radius.Packet, value RemainTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 128, a) +} + +func RemainTime_Get(p *radius.Packet) (value RemainTime) { + value, _ = RemainTime_Lookup(p) + return +} + +func RemainTime_Gets(p *radius.Packet) (values []RemainTime, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 128) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RemainTime(i)) + } + return +} + +func RemainTime_Lookup(p *radius.Packet) (value RemainTime, err error) { + a, ok := _Huawei_LookupVendor(p, 128) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RemainTime(i) + return +} + +func RemainTime_Set(p *radius.Packet, value RemainTime) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 128, a) +} + +func RemainTime_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 128) +} + +type CodecType uint32 + +var CodecType_Strings = map[CodecType]string{} + +func (a CodecType) String() string { + if str, ok := CodecType_Strings[a]; ok { + return str + } + return "CodecType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func CodecType_Add(p *radius.Packet, value CodecType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 131, a) +} + +func CodecType_Get(p *radius.Packet) (value CodecType) { + value, _ = CodecType_Lookup(p) + return +} + +func CodecType_Gets(p *radius.Packet) (values []CodecType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 131) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, CodecType(i)) + } + return +} + +func CodecType_Lookup(p *radius.Packet) (value CodecType, err error) { + a, ok := _Huawei_LookupVendor(p, 131) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = CodecType(i) + return +} + +func CodecType_Set(p *radius.Packet, value CodecType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 131, a) +} + +func CodecType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 131) +} + +func TransferNum_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 132, a) +} + +func TransferNum_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 132, a) +} + +func TransferNum_Get(p *radius.Packet) (value []byte) { + value, _ = TransferNum_Lookup(p) + return +} + +func TransferNum_GetString(p *radius.Packet) (value string) { + value, _ = TransferNum_LookupString(p) + return +} + +func TransferNum_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 132) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TransferNum_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 132) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TransferNum_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 132) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TransferNum_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 132) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TransferNum_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 132, a) +} + +func TransferNum_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 132, a) +} + +func TransferNum_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 132) +} + +func NewUserName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 133, a) +} + +func NewUserName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 133, a) +} + +func NewUserName_Get(p *radius.Packet) (value []byte) { + value, _ = NewUserName_Lookup(p) + return +} + +func NewUserName_GetString(p *radius.Packet) (value string) { + value, _ = NewUserName_LookupString(p) + return +} + +func NewUserName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 133) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NewUserName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 133) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NewUserName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 133) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NewUserName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 133) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NewUserName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 133, a) +} + +func NewUserName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 133, a) +} + +func NewUserName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 133) +} + +func TransferStationID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 134, a) +} + +func TransferStationID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 134, a) +} + +func TransferStationID_Get(p *radius.Packet) (value []byte) { + value, _ = TransferStationID_Lookup(p) + return +} + +func TransferStationID_GetString(p *radius.Packet) (value string) { + value, _ = TransferStationID_LookupString(p) + return +} + +func TransferStationID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 134) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TransferStationID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 134) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func TransferStationID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 134) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func TransferStationID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 134) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func TransferStationID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 134, a) +} + +func TransferStationID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 134, a) +} + +func TransferStationID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 134) +} + +func PrimaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 135, a) +} + +func PrimaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = PrimaryDNS_Lookup(p) + return +} + +func PrimaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 135) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PrimaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 135) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func PrimaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 135, a) +} + +func PrimaryDNS_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 135) +} + +func SecondaryDNS_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 136, a) +} + +func SecondaryDNS_Get(p *radius.Packet) (value net.IP) { + value, _ = SecondaryDNS_Lookup(p) + return +} + +func SecondaryDNS_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 136) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func SecondaryDNS_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 136) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func SecondaryDNS_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 136, a) +} + +func SecondaryDNS_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 136) +} + +type ONLYAccountType uint32 + +var ONLYAccountType_Strings = map[ONLYAccountType]string{} + +func (a ONLYAccountType) String() string { + if str, ok := ONLYAccountType_Strings[a]; ok { + return str + } + return "ONLYAccountType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ONLYAccountType_Add(p *radius.Packet, value ONLYAccountType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 137, a) +} + +func ONLYAccountType_Get(p *radius.Packet) (value ONLYAccountType) { + value, _ = ONLYAccountType_Lookup(p) + return +} + +func ONLYAccountType_Gets(p *radius.Packet) (values []ONLYAccountType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 137) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ONLYAccountType(i)) + } + return +} + +func ONLYAccountType_Lookup(p *radius.Packet) (value ONLYAccountType, err error) { + a, ok := _Huawei_LookupVendor(p, 137) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ONLYAccountType(i) + return +} + +func ONLYAccountType_Set(p *radius.Packet, value ONLYAccountType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 137, a) +} + +func ONLYAccountType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 137) +} + +func DomainName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 138, a) +} + +func DomainName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 138, a) +} + +func DomainName_Get(p *radius.Packet) (value []byte) { + value, _ = DomainName_Lookup(p) + return +} + +func DomainName_GetString(p *radius.Packet) (value string) { + value, _ = DomainName_LookupString(p) + return +} + +func DomainName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 138) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DomainName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 138) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DomainName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 138) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DomainName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 138) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DomainName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 138, a) +} + +func DomainName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 138, a) +} + +func DomainName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 138) +} + +func ANCPProfile_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 139, a) +} + +func ANCPProfile_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 139, a) +} + +func ANCPProfile_Get(p *radius.Packet) (value []byte) { + value, _ = ANCPProfile_Lookup(p) + return +} + +func ANCPProfile_GetString(p *radius.Packet) (value string) { + value, _ = ANCPProfile_LookupString(p) + return +} + +func ANCPProfile_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 139) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ANCPProfile_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 139) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ANCPProfile_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 139) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ANCPProfile_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 139) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ANCPProfile_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 139, a) +} + +func ANCPProfile_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 139, a) +} + +func ANCPProfile_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 139) +} + +func HTTPRedirectURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 140, a) +} + +func HTTPRedirectURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 140, a) +} + +func HTTPRedirectURL_Get(p *radius.Packet) (value []byte) { + value, _ = HTTPRedirectURL_Lookup(p) + return +} + +func HTTPRedirectURL_GetString(p *radius.Packet) (value string) { + value, _ = HTTPRedirectURL_LookupString(p) + return +} + +func HTTPRedirectURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 140) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func HTTPRedirectURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 140) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func HTTPRedirectURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 140) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func HTTPRedirectURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 140) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func HTTPRedirectURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 140, a) +} + +func HTTPRedirectURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 140, a) +} + +func HTTPRedirectURL_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 140) +} + +func LoopbackAddress_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 141, a) +} + +func LoopbackAddress_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 141, a) +} + +func LoopbackAddress_Get(p *radius.Packet) (value []byte) { + value, _ = LoopbackAddress_Lookup(p) + return +} + +func LoopbackAddress_GetString(p *radius.Packet) (value string) { + value, _ = LoopbackAddress_LookupString(p) + return +} + +func LoopbackAddress_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 141) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LoopbackAddress_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 141) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func LoopbackAddress_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 141) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func LoopbackAddress_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 141) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func LoopbackAddress_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 141, a) +} + +func LoopbackAddress_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 141, a) +} + +func LoopbackAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 141) +} + +type QoSProfileType uint32 + +const ( + QoSProfileType_Value_Original QoSProfileType = 0 + QoSProfileType_Value_L2TPInbound QoSProfileType = 1 + QoSProfileType_Value_L2TPOutbound QoSProfileType = 2 + QoSProfileType_Value_L2TP QoSProfileType = 3 +) + +var QoSProfileType_Strings = map[QoSProfileType]string{ + QoSProfileType_Value_Original: "Original", + QoSProfileType_Value_L2TPInbound: "L2TP-Inbound", + QoSProfileType_Value_L2TPOutbound: "L2TP-Outbound", + QoSProfileType_Value_L2TP: "L2TP", +} + +func (a QoSProfileType) String() string { + if str, ok := QoSProfileType_Strings[a]; ok { + return str + } + return "QoSProfileType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QoSProfileType_Add(p *radius.Packet, value QoSProfileType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 142, a) +} + +func QoSProfileType_Get(p *radius.Packet) (value QoSProfileType) { + value, _ = QoSProfileType_Lookup(p) + return +} + +func QoSProfileType_Gets(p *radius.Packet) (values []QoSProfileType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 142) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QoSProfileType(i)) + } + return +} + +func QoSProfileType_Lookup(p *radius.Packet) (value QoSProfileType, err error) { + a, ok := _Huawei_LookupVendor(p, 142) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QoSProfileType(i) + return +} + +func QoSProfileType_Set(p *radius.Packet, value QoSProfileType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 142, a) +} + +func QoSProfileType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 142) +} + +type MaxListNum uint32 + +var MaxListNum_Strings = map[MaxListNum]string{} + +func (a MaxListNum) String() string { + if str, ok := MaxListNum_Strings[a]; ok { + return str + } + return "MaxListNum(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func MaxListNum_Add(p *radius.Packet, value MaxListNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 143, a) +} + +func MaxListNum_Get(p *radius.Packet) (value MaxListNum) { + value, _ = MaxListNum_Lookup(p) + return +} + +func MaxListNum_Gets(p *radius.Packet) (values []MaxListNum, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 143) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, MaxListNum(i)) + } + return +} + +func MaxListNum_Lookup(p *radius.Packet) (value MaxListNum, err error) { + a, ok := _Huawei_LookupVendor(p, 143) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = MaxListNum(i) + return +} + +func MaxListNum_Set(p *radius.Packet, value MaxListNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 143, a) +} + +func MaxListNum_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 143) +} + +type AcctIPv6InputOctets uint32 + +var AcctIPv6InputOctets_Strings = map[AcctIPv6InputOctets]string{} + +func (a AcctIPv6InputOctets) String() string { + if str, ok := AcctIPv6InputOctets_Strings[a]; ok { + return str + } + return "AcctIPv6InputOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6InputOctets_Add(p *radius.Packet, value AcctIPv6InputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 144, a) +} + +func AcctIPv6InputOctets_Get(p *radius.Packet) (value AcctIPv6InputOctets) { + value, _ = AcctIPv6InputOctets_Lookup(p) + return +} + +func AcctIPv6InputOctets_Gets(p *radius.Packet) (values []AcctIPv6InputOctets, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 144) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6InputOctets(i)) + } + return +} + +func AcctIPv6InputOctets_Lookup(p *radius.Packet) (value AcctIPv6InputOctets, err error) { + a, ok := _Huawei_LookupVendor(p, 144) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6InputOctets(i) + return +} + +func AcctIPv6InputOctets_Set(p *radius.Packet, value AcctIPv6InputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 144, a) +} + +func AcctIPv6InputOctets_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 144) +} + +type AcctIPv6OutputOctets uint32 + +var AcctIPv6OutputOctets_Strings = map[AcctIPv6OutputOctets]string{} + +func (a AcctIPv6OutputOctets) String() string { + if str, ok := AcctIPv6OutputOctets_Strings[a]; ok { + return str + } + return "AcctIPv6OutputOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6OutputOctets_Add(p *radius.Packet, value AcctIPv6OutputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 145, a) +} + +func AcctIPv6OutputOctets_Get(p *radius.Packet) (value AcctIPv6OutputOctets) { + value, _ = AcctIPv6OutputOctets_Lookup(p) + return +} + +func AcctIPv6OutputOctets_Gets(p *radius.Packet) (values []AcctIPv6OutputOctets, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 145) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6OutputOctets(i)) + } + return +} + +func AcctIPv6OutputOctets_Lookup(p *radius.Packet) (value AcctIPv6OutputOctets, err error) { + a, ok := _Huawei_LookupVendor(p, 145) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6OutputOctets(i) + return +} + +func AcctIPv6OutputOctets_Set(p *radius.Packet, value AcctIPv6OutputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 145, a) +} + +func AcctIPv6OutputOctets_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 145) +} + +type AcctIPv6InputPackets uint32 + +var AcctIPv6InputPackets_Strings = map[AcctIPv6InputPackets]string{} + +func (a AcctIPv6InputPackets) String() string { + if str, ok := AcctIPv6InputPackets_Strings[a]; ok { + return str + } + return "AcctIPv6InputPackets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6InputPackets_Add(p *radius.Packet, value AcctIPv6InputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 146, a) +} + +func AcctIPv6InputPackets_Get(p *radius.Packet) (value AcctIPv6InputPackets) { + value, _ = AcctIPv6InputPackets_Lookup(p) + return +} + +func AcctIPv6InputPackets_Gets(p *radius.Packet) (values []AcctIPv6InputPackets, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 146) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6InputPackets(i)) + } + return +} + +func AcctIPv6InputPackets_Lookup(p *radius.Packet) (value AcctIPv6InputPackets, err error) { + a, ok := _Huawei_LookupVendor(p, 146) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6InputPackets(i) + return +} + +func AcctIPv6InputPackets_Set(p *radius.Packet, value AcctIPv6InputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 146, a) +} + +func AcctIPv6InputPackets_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 146) +} + +type AcctIPv6OutputPackets uint32 + +var AcctIPv6OutputPackets_Strings = map[AcctIPv6OutputPackets]string{} + +func (a AcctIPv6OutputPackets) String() string { + if str, ok := AcctIPv6OutputPackets_Strings[a]; ok { + return str + } + return "AcctIPv6OutputPackets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6OutputPackets_Add(p *radius.Packet, value AcctIPv6OutputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 147, a) +} + +func AcctIPv6OutputPackets_Get(p *radius.Packet) (value AcctIPv6OutputPackets) { + value, _ = AcctIPv6OutputPackets_Lookup(p) + return +} + +func AcctIPv6OutputPackets_Gets(p *radius.Packet) (values []AcctIPv6OutputPackets, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 147) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6OutputPackets(i)) + } + return +} + +func AcctIPv6OutputPackets_Lookup(p *radius.Packet) (value AcctIPv6OutputPackets, err error) { + a, ok := _Huawei_LookupVendor(p, 147) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6OutputPackets(i) + return +} + +func AcctIPv6OutputPackets_Set(p *radius.Packet, value AcctIPv6OutputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 147, a) +} + +func AcctIPv6OutputPackets_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 147) +} + +type AcctIPv6InputGigawords uint32 + +var AcctIPv6InputGigawords_Strings = map[AcctIPv6InputGigawords]string{} + +func (a AcctIPv6InputGigawords) String() string { + if str, ok := AcctIPv6InputGigawords_Strings[a]; ok { + return str + } + return "AcctIPv6InputGigawords(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6InputGigawords_Add(p *radius.Packet, value AcctIPv6InputGigawords) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 148, a) +} + +func AcctIPv6InputGigawords_Get(p *radius.Packet) (value AcctIPv6InputGigawords) { + value, _ = AcctIPv6InputGigawords_Lookup(p) + return +} + +func AcctIPv6InputGigawords_Gets(p *radius.Packet) (values []AcctIPv6InputGigawords, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 148) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6InputGigawords(i)) + } + return +} + +func AcctIPv6InputGigawords_Lookup(p *radius.Packet) (value AcctIPv6InputGigawords, err error) { + a, ok := _Huawei_LookupVendor(p, 148) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6InputGigawords(i) + return +} + +func AcctIPv6InputGigawords_Set(p *radius.Packet, value AcctIPv6InputGigawords) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 148, a) +} + +func AcctIPv6InputGigawords_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 148) +} + +type AcctIPv6OutputGigawords uint32 + +var AcctIPv6OutputGigawords_Strings = map[AcctIPv6OutputGigawords]string{} + +func (a AcctIPv6OutputGigawords) String() string { + if str, ok := AcctIPv6OutputGigawords_Strings[a]; ok { + return str + } + return "AcctIPv6OutputGigawords(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctIPv6OutputGigawords_Add(p *radius.Packet, value AcctIPv6OutputGigawords) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 149, a) +} + +func AcctIPv6OutputGigawords_Get(p *radius.Packet) (value AcctIPv6OutputGigawords) { + value, _ = AcctIPv6OutputGigawords_Lookup(p) + return +} + +func AcctIPv6OutputGigawords_Gets(p *radius.Packet) (values []AcctIPv6OutputGigawords, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 149) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctIPv6OutputGigawords(i)) + } + return +} + +func AcctIPv6OutputGigawords_Lookup(p *radius.Packet) (value AcctIPv6OutputGigawords, err error) { + a, ok := _Huawei_LookupVendor(p, 149) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctIPv6OutputGigawords(i) + return +} + +func AcctIPv6OutputGigawords_Set(p *radius.Packet, value AcctIPv6OutputGigawords) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 149, a) +} + +func AcctIPv6OutputGigawords_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 149) +} + +func DHCPv6Option37_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 150, a) +} + +func DHCPv6Option37_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 150, a) +} + +func DHCPv6Option37_Get(p *radius.Packet) (value []byte) { + value, _ = DHCPv6Option37_Lookup(p) + return +} + +func DHCPv6Option37_GetString(p *radius.Packet) (value string) { + value, _ = DHCPv6Option37_LookupString(p) + return +} + +func DHCPv6Option37_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 150) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv6Option37_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 150) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv6Option37_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 150) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DHCPv6Option37_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 150) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DHCPv6Option37_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 150, a) +} + +func DHCPv6Option37_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 150, a) +} + +func DHCPv6Option37_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 150) +} + +func DHCPv6Option38_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 151, a) +} + +func DHCPv6Option38_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 151, a) +} + +func DHCPv6Option38_Get(p *radius.Packet) (value []byte) { + value, _ = DHCPv6Option38_Lookup(p) + return +} + +func DHCPv6Option38_GetString(p *radius.Packet) (value string) { + value, _ = DHCPv6Option38_LookupString(p) + return +} + +func DHCPv6Option38_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 151) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv6Option38_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 151) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv6Option38_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 151) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DHCPv6Option38_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 151) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DHCPv6Option38_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 151, a) +} + +func DHCPv6Option38_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 151, a) +} + +func DHCPv6Option38_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 151) +} + +func UserMac_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 153, a) +} + +func UserMac_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 153, a) +} + +func UserMac_Get(p *radius.Packet) (value []byte) { + value, _ = UserMac_Lookup(p) + return +} + +func UserMac_GetString(p *radius.Packet) (value string) { + value, _ = UserMac_LookupString(p) + return +} + +func UserMac_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 153) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserMac_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 153) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func UserMac_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 153) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func UserMac_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 153) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func UserMac_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 153, a) +} + +func UserMac_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 153, a) +} + +func UserMac_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 153) +} + +func DNSServerIPv6Address_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 154, a) +} + +func DNSServerIPv6Address_Get(p *radius.Packet) (value net.IP) { + value, _ = DNSServerIPv6Address_Lookup(p) + return +} + +func DNSServerIPv6Address_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 154) { + i, err = radius.IPv6Addr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DNSServerIPv6Address_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 154) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Addr(a) + return +} + +func DNSServerIPv6Address_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 154, a) +} + +func DNSServerIPv6Address_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 154) +} + +func DHCPv4Option121_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 155, a) +} + +func DHCPv4Option121_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 155, a) +} + +func DHCPv4Option121_Get(p *radius.Packet) (value []byte) { + value, _ = DHCPv4Option121_Lookup(p) + return +} + +func DHCPv4Option121_GetString(p *radius.Packet) (value string) { + value, _ = DHCPv4Option121_LookupString(p) + return +} + +func DHCPv4Option121_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 155) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv4Option121_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 155) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv4Option121_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 155) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DHCPv4Option121_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 155) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DHCPv4Option121_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 155, a) +} + +func DHCPv4Option121_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 155, a) +} + +func DHCPv4Option121_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 155) +} + +func DHCPv4Option43_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 156, a) +} + +func DHCPv4Option43_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 156, a) +} + +func DHCPv4Option43_Get(p *radius.Packet) (value []byte) { + value, _ = DHCPv4Option43_Lookup(p) + return +} + +func DHCPv4Option43_GetString(p *radius.Packet) (value string) { + value, _ = DHCPv4Option43_LookupString(p) + return +} + +func DHCPv4Option43_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 156) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv4Option43_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 156) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPv4Option43_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 156) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DHCPv4Option43_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 156) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DHCPv4Option43_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 156, a) +} + +func DHCPv4Option43_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 156, a) +} + +func DHCPv4Option43_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 156) +} + +func FramedPoolGroup_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 157, a) +} + +func FramedPoolGroup_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 157, a) +} + +func FramedPoolGroup_Get(p *radius.Packet) (value []byte) { + value, _ = FramedPoolGroup_Lookup(p) + return +} + +func FramedPoolGroup_GetString(p *radius.Packet) (value string) { + value, _ = FramedPoolGroup_LookupString(p) + return +} + +func FramedPoolGroup_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 157) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FramedPoolGroup_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 157) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FramedPoolGroup_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 157) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FramedPoolGroup_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 157) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FramedPoolGroup_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 157, a) +} + +func FramedPoolGroup_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 157, a) +} + +func FramedPoolGroup_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 157) +} + +func FramedIPv6Address_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 158, a) +} + +func FramedIPv6Address_Get(p *radius.Packet) (value net.IP) { + value, _ = FramedIPv6Address_Lookup(p) + return +} + +func FramedIPv6Address_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 158) { + i, err = radius.IPv6Addr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FramedIPv6Address_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 158) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Addr(a) + return +} + +func FramedIPv6Address_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Addr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 158, a) +} + +func FramedIPv6Address_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 158) +} + +type AcctUpdateAddress uint32 + +var AcctUpdateAddress_Strings = map[AcctUpdateAddress]string{} + +func (a AcctUpdateAddress) String() string { + if str, ok := AcctUpdateAddress_Strings[a]; ok { + return str + } + return "AcctUpdateAddress(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctUpdateAddress_Add(p *radius.Packet, value AcctUpdateAddress) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 159, a) +} + +func AcctUpdateAddress_Get(p *radius.Packet) (value AcctUpdateAddress) { + value, _ = AcctUpdateAddress_Lookup(p) + return +} + +func AcctUpdateAddress_Gets(p *radius.Packet) (values []AcctUpdateAddress, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 159) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctUpdateAddress(i)) + } + return +} + +func AcctUpdateAddress_Lookup(p *radius.Packet) (value AcctUpdateAddress, err error) { + a, ok := _Huawei_LookupVendor(p, 159) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctUpdateAddress(i) + return +} + +func AcctUpdateAddress_Set(p *radius.Packet, value AcctUpdateAddress) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 159, a) +} + +func AcctUpdateAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 159) +} + +func NATPolicyName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 160, a) +} + +func NATPolicyName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 160, a) +} + +func NATPolicyName_Get(p *radius.Packet) (value []byte) { + value, _ = NATPolicyName_Lookup(p) + return +} + +func NATPolicyName_GetString(p *radius.Packet) (value string) { + value, _ = NATPolicyName_LookupString(p) + return +} + +func NATPolicyName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 160) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPolicyName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 160) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPolicyName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 160) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NATPolicyName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 160) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NATPolicyName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 160, a) +} + +func NATPolicyName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 160, a) +} + +func NATPolicyName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 160) +} + +func NATPublicAddress_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 161, a) +} + +func NATPublicAddress_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 161, a) +} + +func NATPublicAddress_Get(p *radius.Packet) (value []byte) { + value, _ = NATPublicAddress_Lookup(p) + return +} + +func NATPublicAddress_GetString(p *radius.Packet) (value string) { + value, _ = NATPublicAddress_LookupString(p) + return +} + +func NATPublicAddress_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 161) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPublicAddress_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 161) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPublicAddress_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 161) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NATPublicAddress_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 161) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NATPublicAddress_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 161, a) +} + +func NATPublicAddress_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 161, a) +} + +func NATPublicAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 161) +} + +func NATStartPort_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 162, a) +} + +func NATStartPort_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 162, a) +} + +func NATStartPort_Get(p *radius.Packet) (value []byte) { + value, _ = NATStartPort_Lookup(p) + return +} + +func NATStartPort_GetString(p *radius.Packet) (value string) { + value, _ = NATStartPort_LookupString(p) + return +} + +func NATStartPort_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 162) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATStartPort_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 162) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATStartPort_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 162) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NATStartPort_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 162) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NATStartPort_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 162, a) +} + +func NATStartPort_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 162, a) +} + +func NATStartPort_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 162) +} + +func NATEndPort_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 163, a) +} + +func NATEndPort_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 163, a) +} + +func NATEndPort_Get(p *radius.Packet) (value []byte) { + value, _ = NATEndPort_Lookup(p) + return +} + +func NATEndPort_GetString(p *radius.Packet) (value string) { + value, _ = NATEndPort_LookupString(p) + return +} + +func NATEndPort_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 163) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATEndPort_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 163) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATEndPort_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 163) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NATEndPort_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 163) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NATEndPort_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 163, a) +} + +func NATEndPort_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 163, a) +} + +func NATEndPort_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 163) +} + +func NATPortForwarding_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 164, a) +} + +func NATPortForwarding_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 164, a) +} + +func NATPortForwarding_Get(p *radius.Packet) (value []byte) { + value, _ = NATPortForwarding_Lookup(p) + return +} + +func NATPortForwarding_GetString(p *radius.Packet) (value string) { + value, _ = NATPortForwarding_LookupString(p) + return +} + +func NATPortForwarding_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 164) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPortForwarding_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 164) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATPortForwarding_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 164) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func NATPortForwarding_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 164) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func NATPortForwarding_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 164, a) +} + +func NATPortForwarding_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 164, a) +} + +func NATPortForwarding_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 164) +} + +type NATPortRangeUpdate uint32 + +var NATPortRangeUpdate_Strings = map[NATPortRangeUpdate]string{} + +func (a NATPortRangeUpdate) String() string { + if str, ok := NATPortRangeUpdate_Strings[a]; ok { + return str + } + return "NATPortRangeUpdate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func NATPortRangeUpdate_Add(p *radius.Packet, value NATPortRangeUpdate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 165, a) +} + +func NATPortRangeUpdate_Get(p *radius.Packet) (value NATPortRangeUpdate) { + value, _ = NATPortRangeUpdate_Lookup(p) + return +} + +func NATPortRangeUpdate_Gets(p *radius.Packet) (values []NATPortRangeUpdate, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 165) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, NATPortRangeUpdate(i)) + } + return +} + +func NATPortRangeUpdate_Lookup(p *radius.Packet) (value NATPortRangeUpdate, err error) { + a, ok := _Huawei_LookupVendor(p, 165) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = NATPortRangeUpdate(i) + return +} + +func NATPortRangeUpdate_Set(p *radius.Packet, value NATPortRangeUpdate) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 165, a) +} + +func NATPortRangeUpdate_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 165) +} + +func DSLiteTunnelName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 166, a) +} + +func DSLiteTunnelName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 166, a) +} + +func DSLiteTunnelName_Get(p *radius.Packet) (value []byte) { + value, _ = DSLiteTunnelName_Lookup(p) + return +} + +func DSLiteTunnelName_GetString(p *radius.Packet) (value string) { + value, _ = DSLiteTunnelName_LookupString(p) + return +} + +func DSLiteTunnelName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 166) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DSLiteTunnelName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 166) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DSLiteTunnelName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 166) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DSLiteTunnelName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 166) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DSLiteTunnelName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 166, a) +} + +func DSLiteTunnelName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 166, a) +} + +func DSLiteTunnelName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 166) +} + +func PCPServerName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 167, a) +} + +func PCPServerName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 167, a) +} + +func PCPServerName_Get(p *radius.Packet) (value []byte) { + value, _ = PCPServerName_Lookup(p) + return +} + +func PCPServerName_GetString(p *radius.Packet) (value string) { + value, _ = PCPServerName_LookupString(p) + return +} + +func PCPServerName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 167) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PCPServerName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 167) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PCPServerName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 167) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func PCPServerName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 167) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func PCPServerName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 167, a) +} + +func PCPServerName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 167, a) +} + +func PCPServerName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 167) +} + +type PublicIPAddrState uint32 + +const ( + PublicIPAddrState_Value_Safe PublicIPAddrState = 0 + PublicIPAddrState_Value_Warning PublicIPAddrState = 1 + PublicIPAddrState_Value_Danger PublicIPAddrState = 2 +) + +var PublicIPAddrState_Strings = map[PublicIPAddrState]string{ + PublicIPAddrState_Value_Safe: "Safe", + PublicIPAddrState_Value_Warning: "Warning", + PublicIPAddrState_Value_Danger: "Danger", +} + +func (a PublicIPAddrState) String() string { + if str, ok := PublicIPAddrState_Strings[a]; ok { + return str + } + return "PublicIPAddrState(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PublicIPAddrState_Add(p *radius.Packet, value PublicIPAddrState) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 168, a) +} + +func PublicIPAddrState_Get(p *radius.Packet) (value PublicIPAddrState) { + value, _ = PublicIPAddrState_Lookup(p) + return +} + +func PublicIPAddrState_Gets(p *radius.Packet) (values []PublicIPAddrState, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 168) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PublicIPAddrState(i)) + } + return +} + +func PublicIPAddrState_Lookup(p *radius.Packet) (value PublicIPAddrState, err error) { + a, ok := _Huawei_LookupVendor(p, 168) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PublicIPAddrState(i) + return +} + +func PublicIPAddrState_Set(p *radius.Packet, value PublicIPAddrState) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 168, a) +} + +func PublicIPAddrState_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 168) +} + +type AuthType uint32 + +const ( + AuthType_Value_PPP AuthType = 1 + AuthType_Value_Web AuthType = 2 + AuthType_Value_Dot1x AuthType = 3 + AuthType_Value_Fast AuthType = 4 + AuthType_Value_Bind AuthType = 5 + AuthType_Value_WLAN AuthType = 6 + AuthType_Value_Administrative AuthType = 7 + AuthType_Value_Tunnel AuthType = 8 + AuthType_Value_MIP AuthType = 9 + AuthType_Value_None AuthType = 10 +) + +var AuthType_Strings = map[AuthType]string{ + AuthType_Value_PPP: "PPP", + AuthType_Value_Web: "Web", + AuthType_Value_Dot1x: "Dot1x", + AuthType_Value_Fast: "Fast", + AuthType_Value_Bind: "Bind", + AuthType_Value_WLAN: "WLAN", + AuthType_Value_Administrative: "Administrative", + AuthType_Value_Tunnel: "Tunnel", + AuthType_Value_MIP: "MIP", + AuthType_Value_None: "None", +} + +func (a AuthType) String() string { + if str, ok := AuthType_Strings[a]; ok { + return str + } + return "AuthType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AuthType_Add(p *radius.Packet, value AuthType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 180, a) +} + +func AuthType_Get(p *radius.Packet) (value AuthType) { + value, _ = AuthType_Lookup(p) + return +} + +func AuthType_Gets(p *radius.Packet) (values []AuthType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 180) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AuthType(i)) + } + return +} + +func AuthType_Lookup(p *radius.Packet) (value AuthType, err error) { + a, ok := _Huawei_LookupVendor(p, 180) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AuthType(i) + return +} + +func AuthType_Set(p *radius.Packet, value AuthType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 180, a) +} + +func AuthType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 180) +} + +func AcctTerminateSubcause_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 181, a) +} + +func AcctTerminateSubcause_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 181, a) +} + +func AcctTerminateSubcause_Get(p *radius.Packet) (value []byte) { + value, _ = AcctTerminateSubcause_Lookup(p) + return +} + +func AcctTerminateSubcause_GetString(p *radius.Packet) (value string) { + value, _ = AcctTerminateSubcause_LookupString(p) + return +} + +func AcctTerminateSubcause_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 181) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AcctTerminateSubcause_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 181) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AcctTerminateSubcause_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 181) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AcctTerminateSubcause_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 181) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AcctTerminateSubcause_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 181, a) +} + +func AcctTerminateSubcause_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 181, a) +} + +func AcctTerminateSubcause_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 181) +} + +func DownQOSProfileName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 182, a) +} + +func DownQOSProfileName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 182, a) +} + +func DownQOSProfileName_Get(p *radius.Packet) (value []byte) { + value, _ = DownQOSProfileName_Lookup(p) + return +} + +func DownQOSProfileName_GetString(p *radius.Packet) (value string) { + value, _ = DownQOSProfileName_LookupString(p) + return +} + +func DownQOSProfileName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 182) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DownQOSProfileName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 182) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DownQOSProfileName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 182) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DownQOSProfileName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 182) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DownQOSProfileName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 182, a) +} + +func DownQOSProfileName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 182, a) +} + +func DownQOSProfileName_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 182) +} + +type PortMirror uint32 + +const ( + PortMirror_Value_Disable PortMirror = 0 + PortMirror_Value_UplinkEnable PortMirror = 1 + PortMirror_Value_DownlinkEnable PortMirror = 2 + PortMirror_Value_Enable PortMirror = 3 +) + +var PortMirror_Strings = map[PortMirror]string{ + PortMirror_Value_Disable: "Disable", + PortMirror_Value_UplinkEnable: "Uplink-Enable", + PortMirror_Value_DownlinkEnable: "Downlink-Enable", + PortMirror_Value_Enable: "Enable", +} + +func (a PortMirror) String() string { + if str, ok := PortMirror_Strings[a]; ok { + return str + } + return "PortMirror(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PortMirror_Add(p *radius.Packet, value PortMirror) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 183, a) +} + +func PortMirror_Get(p *radius.Packet) (value PortMirror) { + value, _ = PortMirror_Lookup(p) + return +} + +func PortMirror_Gets(p *radius.Packet) (values []PortMirror, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 183) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PortMirror(i)) + } + return +} + +func PortMirror_Lookup(p *radius.Packet) (value PortMirror, err error) { + a, ok := _Huawei_LookupVendor(p, 183) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PortMirror(i) + return +} + +func PortMirror_Set(p *radius.Packet, value PortMirror) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 183, a) +} + +func PortMirror_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 183) +} + +func AccountInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 184, a) +} + +func AccountInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 184, a) +} + +func AccountInfo_Get(p *radius.Packet) (value []byte) { + value, _ = AccountInfo_Lookup(p) + return +} + +func AccountInfo_GetString(p *radius.Packet) (value string) { + value, _ = AccountInfo_LookupString(p) + return +} + +func AccountInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 184) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccountInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 184) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccountInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 184) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AccountInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 184) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AccountInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 184, a) +} + +func AccountInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 184, a) +} + +func AccountInfo_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 184) +} + +func ServiceInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 185, a) +} + +func ServiceInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 185, a) +} + +func ServiceInfo_Get(p *radius.Packet) (value []byte) { + value, _ = ServiceInfo_Lookup(p) + return +} + +func ServiceInfo_GetString(p *radius.Packet) (value string) { + value, _ = ServiceInfo_LookupString(p) + return +} + +func ServiceInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 185) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ServiceInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 185) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ServiceInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 185) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ServiceInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 185) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ServiceInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 185, a) +} + +func ServiceInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 185, a) +} + +func ServiceInfo_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 185) +} + +func DHCPOption_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 187, a) +} + +func DHCPOption_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 187, a) +} + +func DHCPOption_Get(p *radius.Packet) (value []byte) { + value, _ = DHCPOption_Lookup(p) + return +} + +func DHCPOption_GetString(p *radius.Packet) (value string) { + value, _ = DHCPOption_LookupString(p) + return +} + +func DHCPOption_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 187) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPOption_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 187) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPOption_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 187) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DHCPOption_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 187) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DHCPOption_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 187, a) +} + +func DHCPOption_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 187, a) +} + +func DHCPOption_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 187) +} + +func AVpair_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 188, a) +} + +func AVpair_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 188, a) +} + +func AVpair_Get(p *radius.Packet) (value []byte) { + value, _ = AVpair_Lookup(p) + return +} + +func AVpair_GetString(p *radius.Packet) (value string) { + value, _ = AVpair_LookupString(p) + return +} + +func AVpair_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 188) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AVpair_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 188) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AVpair_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 188) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AVpair_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 188) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AVpair_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 188, a) +} + +func AVpair_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 188, a) +} + +func AVpair_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 188) +} + +func DelegatedIPv6PrefixPool_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 191, a) +} + +func DelegatedIPv6PrefixPool_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 191, a) +} + +func DelegatedIPv6PrefixPool_Get(p *radius.Packet) (value []byte) { + value, _ = DelegatedIPv6PrefixPool_Lookup(p) + return +} + +func DelegatedIPv6PrefixPool_GetString(p *radius.Packet) (value string) { + value, _ = DelegatedIPv6PrefixPool_LookupString(p) + return +} + +func DelegatedIPv6PrefixPool_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 191) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DelegatedIPv6PrefixPool_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 191) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DelegatedIPv6PrefixPool_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 191) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DelegatedIPv6PrefixPool_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 191) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DelegatedIPv6PrefixPool_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 191, a) +} + +func DelegatedIPv6PrefixPool_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 191, a) +} + +func DelegatedIPv6PrefixPool_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 191) +} + +func IPv6PrefixLease_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 192, a) +} + +func IPv6PrefixLease_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 192, a) +} + +func IPv6PrefixLease_Get(p *radius.Packet) (value []byte) { + value, _ = IPv6PrefixLease_Lookup(p) + return +} + +func IPv6PrefixLease_GetString(p *radius.Packet) (value string) { + value, _ = IPv6PrefixLease_LookupString(p) + return +} + +func IPv6PrefixLease_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 192) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPv6PrefixLease_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 192) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPv6PrefixLease_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 192) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func IPv6PrefixLease_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 192) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func IPv6PrefixLease_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 192, a) +} + +func IPv6PrefixLease_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 192, a) +} + +func IPv6PrefixLease_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 192) +} + +func IPv6AddressLease_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 193, a) +} + +func IPv6AddressLease_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 193, a) +} + +func IPv6AddressLease_Get(p *radius.Packet) (value []byte) { + value, _ = IPv6AddressLease_Lookup(p) + return +} + +func IPv6AddressLease_GetString(p *radius.Packet) (value string) { + value, _ = IPv6AddressLease_LookupString(p) + return +} + +func IPv6AddressLease_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 193) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPv6AddressLease_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 193) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPv6AddressLease_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 193) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func IPv6AddressLease_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 193) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func IPv6AddressLease_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 193, a) +} + +func IPv6AddressLease_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 193, a) +} + +func IPv6AddressLease_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 193) +} + +func IPv6PolicyRoute_Add(p *radius.Packet, value *net.IPNet) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Prefix(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 194, a) +} + +func IPv6PolicyRoute_Get(p *radius.Packet) (value *net.IPNet) { + value, _ = IPv6PolicyRoute_Lookup(p) + return +} + +func IPv6PolicyRoute_Gets(p *radius.Packet) (values []*net.IPNet, err error) { + var i *net.IPNet + for _, attr := range _Huawei_GetsVendor(p, 194) { + i, err = radius.IPv6Prefix(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IPv6PolicyRoute_Lookup(p *radius.Packet) (value *net.IPNet, err error) { + a, ok := _Huawei_LookupVendor(p, 194) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPv6Prefix(a) + return +} + +func IPv6PolicyRoute_Set(p *radius.Packet, value *net.IPNet) (err error) { + var a radius.Attribute + a, err = radius.NewIPv6Prefix(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 194, a) +} + +func IPv6PolicyRoute_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 194) +} + +type MNGIPv6 uint32 + +const ( + MNGIPv6_Value_Unsupported MNGIPv6 = 0 + MNGIPv6_Value_Supported MNGIPv6 = 1 +) + +var MNGIPv6_Strings = map[MNGIPv6]string{ + MNGIPv6_Value_Unsupported: "Unsupported", + MNGIPv6_Value_Supported: "Supported", +} + +func (a MNGIPv6) String() string { + if str, ok := MNGIPv6_Strings[a]; ok { + return str + } + return "MNGIPv6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func MNGIPv6_Add(p *radius.Packet, value MNGIPv6) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 196, a) +} + +func MNGIPv6_Get(p *radius.Packet) (value MNGIPv6) { + value, _ = MNGIPv6_Lookup(p) + return +} + +func MNGIPv6_Gets(p *radius.Packet) (values []MNGIPv6, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 196) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, MNGIPv6(i)) + } + return +} + +func MNGIPv6_Lookup(p *radius.Packet) (value MNGIPv6, err error) { + a, ok := _Huawei_LookupVendor(p, 196) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = MNGIPv6(i) + return +} + +func MNGIPv6_Set(p *radius.Packet, value MNGIPv6) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 196, a) +} + +func MNGIPv6_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 196) +} + +func DPSKInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 206, a) +} + +func DPSKInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 206, a) +} + +func DPSKInfo_Get(p *radius.Packet) (value []byte) { + value, _ = DPSKInfo_Lookup(p) + return +} + +func DPSKInfo_GetString(p *radius.Packet) (value string) { + value, _ = DPSKInfo_LookupString(p) + return +} + +func DPSKInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 206) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DPSKInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 206) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DPSKInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 206) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func DPSKInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 206) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func DPSKInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 206, a) +} + +func DPSKInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 206, a) +} + +func DPSKInfo_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 206) +} + +func FlowInfo_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 211, a) +} + +func FlowInfo_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 211, a) +} + +func FlowInfo_Get(p *radius.Packet) (value []byte) { + value, _ = FlowInfo_Lookup(p) + return +} + +func FlowInfo_GetString(p *radius.Packet) (value string) { + value, _ = FlowInfo_LookupString(p) + return +} + +func FlowInfo_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 211) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FlowInfo_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 211) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func FlowInfo_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 211) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func FlowInfo_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 211) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func FlowInfo_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 211, a) +} + +func FlowInfo_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 211, a) +} + +func FlowInfo_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 211) +} + +type FlowID uint32 + +var FlowID_Strings = map[FlowID]string{} + +func (a FlowID) String() string { + if str, ok := FlowID_Strings[a]; ok { + return str + } + return "FlowID(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func FlowID_Add(p *radius.Packet, value FlowID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 212, a) +} + +func FlowID_Get(p *radius.Packet) (value FlowID) { + value, _ = FlowID_Lookup(p) + return +} + +func FlowID_Gets(p *radius.Packet) (values []FlowID, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 212) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, FlowID(i)) + } + return +} + +func FlowID_Lookup(p *radius.Packet) (value FlowID, err error) { + a, ok := _Huawei_LookupVendor(p, 212) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = FlowID(i) + return +} + +func FlowID_Set(p *radius.Packet, value FlowID) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 212, a) +} + +func FlowID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 212) +} + +func DHCPServerIP_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 214, a) +} + +func DHCPServerIP_Get(p *radius.Packet) (value net.IP) { + value, _ = DHCPServerIP_Lookup(p) + return +} + +func DHCPServerIP_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 214) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func DHCPServerIP_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 214) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func DHCPServerIP_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 214, a) +} + +func DHCPServerIP_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 214) +} + +type ApplicationType uint32 + +const ( + ApplicationType_Value_Fixed ApplicationType = 1 + ApplicationType_Value_Nomadic ApplicationType = 2 + ApplicationType_Value_Portable ApplicationType = 3 + ApplicationType_Value_SimpleMobile ApplicationType = 4 + ApplicationType_Value_FullMobile ApplicationType = 5 +) + +var ApplicationType_Strings = map[ApplicationType]string{ + ApplicationType_Value_Fixed: "Fixed", + ApplicationType_Value_Nomadic: "Nomadic", + ApplicationType_Value_Portable: "Portable", + ApplicationType_Value_SimpleMobile: "Simple-Mobile", + ApplicationType_Value_FullMobile: "Full-Mobile", +} + +func (a ApplicationType) String() string { + if str, ok := ApplicationType_Strings[a]; ok { + return str + } + return "ApplicationType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func ApplicationType_Add(p *radius.Packet, value ApplicationType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 215, a) +} + +func ApplicationType_Get(p *radius.Packet) (value ApplicationType) { + value, _ = ApplicationType_Lookup(p) + return +} + +func ApplicationType_Gets(p *radius.Packet) (values []ApplicationType, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 215) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, ApplicationType(i)) + } + return +} + +func ApplicationType_Lookup(p *radius.Packet) (value ApplicationType, err error) { + a, ok := _Huawei_LookupVendor(p, 215) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = ApplicationType(i) + return +} + +func ApplicationType_Set(p *radius.Packet, value ApplicationType) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 215, a) +} + +func ApplicationType_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 215) +} + +func IndicationFlag_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 216, a) +} + +func IndicationFlag_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 216, a) +} + +func IndicationFlag_Get(p *radius.Packet) (value []byte) { + value, _ = IndicationFlag_Lookup(p) + return +} + +func IndicationFlag_GetString(p *radius.Packet) (value string) { + value, _ = IndicationFlag_LookupString(p) + return +} + +func IndicationFlag_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 216) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IndicationFlag_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 216) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func IndicationFlag_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 216) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func IndicationFlag_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 216) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func IndicationFlag_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 216, a) +} + +func IndicationFlag_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 216, a) +} + +func IndicationFlag_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 216) +} + +func OriginalNASIPAddress_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 217, a) +} + +func OriginalNASIPAddress_Get(p *radius.Packet) (value net.IP) { + value, _ = OriginalNASIPAddress_Lookup(p) + return +} + +func OriginalNASIPAddress_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _Huawei_GetsVendor(p, 217) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func OriginalNASIPAddress_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _Huawei_LookupVendor(p, 217) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func OriginalNASIPAddress_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 217, a) +} + +func OriginalNASIPAddress_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 217) +} + +type UserPriority uint32 + +const ( + UserPriority_Value_Common UserPriority = 0 + UserPriority_Value_Copper UserPriority = 1 + UserPriority_Value_Silver UserPriority = 2 + UserPriority_Value_Gold UserPriority = 3 +) + +var UserPriority_Strings = map[UserPriority]string{ + UserPriority_Value_Common: "Common", + UserPriority_Value_Copper: "Copper", + UserPriority_Value_Silver: "Silver", + UserPriority_Value_Gold: "Gold", +} + +func (a UserPriority) String() string { + if str, ok := UserPriority_Strings[a]; ok { + return str + } + return "UserPriority(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func UserPriority_Add(p *radius.Packet, value UserPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_AddVendor(p, 218, a) +} + +func UserPriority_Get(p *radius.Packet) (value UserPriority) { + value, _ = UserPriority_Lookup(p) + return +} + +func UserPriority_Gets(p *radius.Packet) (values []UserPriority, err error) { + var i uint32 + for _, attr := range _Huawei_GetsVendor(p, 218) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, UserPriority(i)) + } + return +} + +func UserPriority_Lookup(p *radius.Packet) (value UserPriority, err error) { + a, ok := _Huawei_LookupVendor(p, 218) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = UserPriority(i) + return +} + +func UserPriority_Set(p *radius.Packet, value UserPriority) (err error) { + a := radius.NewInteger(uint32(value)) + return _Huawei_SetVendor(p, 218, a) +} + +func UserPriority_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 218) +} + +func ACSURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 219, a) +} + +func ACSURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 219, a) +} + +func ACSURL_Get(p *radius.Packet) (value []byte) { + value, _ = ACSURL_Lookup(p) + return +} + +func ACSURL_GetString(p *radius.Packet) (value string) { + value, _ = ACSURL_LookupString(p) + return +} + +func ACSURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 219) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ACSURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 219) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ACSURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 219) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ACSURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 219) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ACSURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 219, a) +} + +func ACSURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 219, a) +} + +func ACSURL_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 219) +} + +func ProvisionCode_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 220, a) +} + +func ProvisionCode_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 220, a) +} + +func ProvisionCode_Get(p *radius.Packet) (value []byte) { + value, _ = ProvisionCode_Lookup(p) + return +} + +func ProvisionCode_GetString(p *radius.Packet) (value string) { + value, _ = ProvisionCode_LookupString(p) + return +} + +func ProvisionCode_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 220) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ProvisionCode_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 220) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ProvisionCode_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 220) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ProvisionCode_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 220) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ProvisionCode_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 220, a) +} + +func ProvisionCode_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 220, a) +} + +func ProvisionCode_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 220) +} + +func ApplicationScene_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 221, a) +} + +func ApplicationScene_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 221, a) +} + +func ApplicationScene_Get(p *radius.Packet) (value []byte) { + value, _ = ApplicationScene_Lookup(p) + return +} + +func ApplicationScene_GetString(p *radius.Packet) (value string) { + value, _ = ApplicationScene_LookupString(p) + return +} + +func ApplicationScene_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 221) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ApplicationScene_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 221) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ApplicationScene_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 221) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ApplicationScene_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 221) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ApplicationScene_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 221, a) +} + +func ApplicationScene_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 221, a) +} + +func ApplicationScene_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 221) +} + +func MSMaximumMACStudyNumber_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 222, a) +} + +func MSMaximumMACStudyNumber_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 222, a) +} + +func MSMaximumMACStudyNumber_Get(p *radius.Packet) (value []byte) { + value, _ = MSMaximumMACStudyNumber_Lookup(p) + return +} + +func MSMaximumMACStudyNumber_GetString(p *radius.Packet) (value string) { + value, _ = MSMaximumMACStudyNumber_LookupString(p) + return +} + +func MSMaximumMACStudyNumber_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 222) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MSMaximumMACStudyNumber_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 222) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func MSMaximumMACStudyNumber_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 222) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func MSMaximumMACStudyNumber_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 222) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func MSMaximumMACStudyNumber_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 222, a) +} + +func MSMaximumMACStudyNumber_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 222, a) +} + +func MSMaximumMACStudyNumber_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 222) +} + +func GGSNVendor_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 232, a) +} + +func GGSNVendor_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 232, a) +} + +func GGSNVendor_Get(p *radius.Packet) (value []byte) { + value, _ = GGSNVendor_Lookup(p) + return +} + +func GGSNVendor_GetString(p *radius.Packet) (value string) { + value, _ = GGSNVendor_LookupString(p) + return +} + +func GGSNVendor_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 232) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func GGSNVendor_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 232) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func GGSNVendor_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 232) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func GGSNVendor_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 232) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func GGSNVendor_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 232, a) +} + +func GGSNVendor_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 232, a) +} + +func GGSNVendor_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 232) +} + +func GGSNVersion_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 233, a) +} + +func GGSNVersion_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 233, a) +} + +func GGSNVersion_Get(p *radius.Packet) (value []byte) { + value, _ = GGSNVersion_Lookup(p) + return +} + +func GGSNVersion_GetString(p *radius.Packet) (value string) { + value, _ = GGSNVersion_LookupString(p) + return +} + +func GGSNVersion_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 233) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func GGSNVersion_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 233) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func GGSNVersion_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 233) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func GGSNVersion_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 233) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func GGSNVersion_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 233, a) +} + +func GGSNVersion_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 233, a) +} + +func GGSNVersion_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 233) +} + +func ExtSpecific_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 238, a) +} + +func ExtSpecific_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 238, a) +} + +func ExtSpecific_Get(p *radius.Packet) (value []byte) { + value, _ = ExtSpecific_Lookup(p) + return +} + +func ExtSpecific_GetString(p *radius.Packet) (value string) { + value, _ = ExtSpecific_LookupString(p) + return +} + +func ExtSpecific_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 238) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ExtSpecific_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 238) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ExtSpecific_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 238) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ExtSpecific_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 238) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ExtSpecific_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 238, a) +} + +func ExtSpecific_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 238, a) +} + +func ExtSpecific_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 238) +} + +func WebURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 253, a) +} + +func WebURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 253, a) +} + +func WebURL_Get(p *radius.Packet) (value []byte) { + value, _ = WebURL_Lookup(p) + return +} + +func WebURL_GetString(p *radius.Packet) (value string) { + value, _ = WebURL_LookupString(p) + return +} + +func WebURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 253) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func WebURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 253) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func WebURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 253) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func WebURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 253) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func WebURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 253, a) +} + +func WebURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 253, a) +} + +func WebURL_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 253) +} + +func Version_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 254, a) +} + +func Version_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 254, a) +} + +func Version_Get(p *radius.Packet) (value []byte) { + value, _ = Version_Lookup(p) + return +} + +func Version_GetString(p *radius.Packet) (value string) { + value, _ = Version_LookupString(p) + return +} + +func Version_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 254) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func Version_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 254) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func Version_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 254) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func Version_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 254) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func Version_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 254, a) +} + +func Version_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 254, a) +} + +func Version_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 254) +} + +func ProductID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 255, a) +} + +func ProductID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_AddVendor(p, 255, a) +} + +func ProductID_Get(p *radius.Packet) (value []byte) { + value, _ = ProductID_Lookup(p) + return +} + +func ProductID_GetString(p *radius.Packet) (value string) { + value, _ = ProductID_LookupString(p) + return +} + +func ProductID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _Huawei_GetsVendor(p, 255) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ProductID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _Huawei_GetsVendor(p, 255) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ProductID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _Huawei_LookupVendor(p, 255) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ProductID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _Huawei_LookupVendor(p, 255) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ProductID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 255, a) +} + +func ProductID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _Huawei_SetVendor(p, 255, a) +} + +func ProductID_Del(p *radius.Packet) { + _Huawei_DelVendor(p, 255) +} diff --git a/vendors/zte/dictionary.zte b/vendors/zte/dictionary.zte new file mode 100644 index 0000000..5d87d92 --- /dev/null +++ b/vendors/zte/dictionary.zte @@ -0,0 +1,88 @@ +# -*- text -*- +# Copyright (C) 2022 The FreeRADIUS Server project and contributors +# This work is licensed under CC-BY version 4.0 https://creativecommons.org/licenses/by/4.0 +# Version $Id: b630330d5aa3163377ca05279988ce6e082622bf $ +# +# For ZTE. +# +# $Id: b630330d5aa3163377ca05279988ce6e082622bf $ +# +# QoS attributes Mostly derived from: +# http://wwwen.zte.com.cn/en/products/bearer/201308/P020130828522349526032.pdf +# +VENDOR ZTE 3902 +BEGIN-VENDOR ZTE + +ATTRIBUTE Client-DNS-Pri 1 string +ATTRIBUTE Client-DNS-Sec 2 string +ATTRIBUTE Context-Name 4 string +ATTRIBUTE Tunnel-Max-Sessions 21 integer +ATTRIBUTE Tunnel-Max-Tunnels 22 integer +ATTRIBUTE Tunnel-Window 24 integer +ATTRIBUTE Tunnel-Retransmit 25 integer +ATTRIBUTE Tunnel-Cmd-Timeout 26 integer +ATTRIBUTE PPPOE-URL 27 string +ATTRIBUTE PPPOE-MOTM 28 string +ATTRIBUTE Tunnel-Algorithm 31 integer +ATTRIBUTE Tunnel-Deadtime 32 integer +ATTRIBUTE Mcast-Send 33 integer +ATTRIBUTE Mcast-Receive 34 integer +ATTRIBUTE Mcast-MaxGroups 35 integer +ATTRIBUTE Access-Type 74 integer + +ATTRIBUTE QoS-Type 81 integer +ATTRIBUTE QoS-Profile-Down 82 string +ATTRIBUTE Rate-Ctrl-SCR-Down 83 integer +ATTRIBUTE Rate-Ctrl-Burst-Down 84 integer +ATTRIBUTE Rate-Ctrl-PCR 86 integer +ATTRIBUTE TCP-Syn-Rate 88 integer +ATTRIBUTE Rate-Ctrl-SCR-Up 89 integer +ATTRIBUTE Priority-Level 90 integer +ATTRIBUTE Rate-Ctrl-Burst-Up 91 integer +ATTRIBUTE Rate-Ctrl-Burst-Max-Down 92 integer +ATTRIBUTE Rate-Ctrl-Burst-Max-Up 93 integer +ATTRIBUTE QOS-Profile-Up 94 string + +ATTRIBUTE TCP-Limit-Num 95 integer +ATTRIBUTE TCP-Limit-Mode 96 integer +ATTRIBUTE IGMP-Service-Profile-Num 97 integer +ATTRIBUTE NAT-IP-Address 98 ipaddr +ATTRIBUTE NAT-start-Port 99 integer +ATTRIBUTE NAT-end-Port 100 integer +ATTRIBUTE PPP-Sservice-Type 101 integer +ATTRIBUTE SW-Privilege 104 integer +ATTRIBUTE QOS-Subcar-Cir-Up-User 127 integer +ATTRIBUTE QOS-Subcar-Pir-Up-User 128 integer +ATTRIBUTE QOS-Subcar-Cir-Down-User 131 integer +ATTRIBUTE QOS-Subcar-Pir-Down-User 132 integer +ATTRIBUTE Access-Domain 151 string +ATTRIBUTE VPN-ID 190 string + +# 0 (lowest) - 15 (highest) privilege level +#ATTRIBUTE SW-Privilege 191 integer + +ATTRIBUTE Rate-Bust-DPIR 191 integer +ATTRIBUTE Rate-Bust-UPIR 192 integer + +ATTRIBUTE Rate-Ctrl-PBS-Down 202 integer +ATTRIBUTE Rate-Ctrl-PBS-Up 203 integer +ATTRIBUTE Rate-Ctrl-SCR-Up-v6 228 integer +ATTRIBUTE Rate-Ctrl-Burst-Up-v6 229 integer +ATTRIBUTE Rate-Ctrl-Burst-Max-Up-v6 230 integer +ATTRIBUTE Rate-Ctrl-PBS-Up-v6 231 integer +ATTRIBUTE QoS-Profile-Up-v6 232 string + +ATTRIBUTE Rate-Ctrl-SCR-Down-v6 233 integer +ATTRIBUTE Rate-Ctrl-Burst-Down-v6 234 integer +ATTRIBUTE Rate-Ctrl-Burst-Max-Down-v6 235 integer +ATTRIBUTE Rate-Ctrl-PBS-Down-v6 236 integer +ATTRIBUTE QoS-Profile-Down-v6 237 string +ATTRIBUTE v6-Input-Octets 245 integer +ATTRIBUTE v6-Input-Giga-Octets 246 integer +ATTRIBUTE v6-Output-Octets 247 integer +ATTRIBUTE v6-Outut-Giga-Octets 248 integer +ATTRIBUTE v6-Input-Packets 249 integer +ATTRIBUTE v6-Output-Packets 250 integer +ATTRIBUTE Acct-Address-Change 251 integer +END-VENDOR ZTE + diff --git a/vendors/zte/generate.go b/vendors/zte/generate.go new file mode 100644 index 0000000..34e047a --- /dev/null +++ b/vendors/zte/generate.go @@ -0,0 +1,2 @@ +//go:generate go run ../../cmd/radius-dict-gen/main.go -package zte -output generated.go dictionary.zte +package zte diff --git a/vendors/zte/generated.go b/vendors/zte/generated.go new file mode 100644 index 0000000..98ad6e9 --- /dev/null +++ b/vendors/zte/generated.go @@ -0,0 +1,4135 @@ +// Code generated by radius-dict-gen. DO NOT EDIT. + +package zte + +import ( + "net" + "strconv" + + "layeh.com/radius" + "layeh.com/radius/rfc2865" +) + +const ( + _ZTE_VendorID = 3902 +) + +func _ZTE_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(_ZTE_VendorID, vendor) + if err != nil { + return + } + p.Add(rfc2865.VendorSpecific_Type, vsa) + return +} + +func _ZTE_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 != _ZTE_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 _ZTE_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 != _ZTE_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 _ZTE_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 != _ZTE_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 _ZTE_AddVendor(p, typ, attr) +} + +func _ZTE_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 != _ZTE_VendorID { + i++ + continue + } + offset := 0 + for len(vsa[offset:]) >= 3 { + vsaTyp, vsaLen := vsa[offset], vsa[offset+1] + if int(vsaLen) > len(vsa) || vsaLen < 3 { + continue vsaLoop + } + if vsaTyp == typ { + copy(vsa[offset:], vsa[offset+int(vsaLen):]) + vsa = vsa[:len(vsa)-int(vsaLen)] + } else { + offset += int(vsaLen) + } + } + if offset == 0 { + p.Attributes = append(p.Attributes[:i], p.Attributes[i+1:]...) + } else { + i++ + } + } + return +} + +func ClientDNSPri_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 1, a) +} + +func ClientDNSPri_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 1, a) +} + +func ClientDNSPri_Get(p *radius.Packet) (value []byte) { + value, _ = ClientDNSPri_Lookup(p) + return +} + +func ClientDNSPri_GetString(p *radius.Packet) (value string) { + value, _ = ClientDNSPri_LookupString(p) + return +} + +func ClientDNSPri_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 1) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ClientDNSPri_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 1) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ClientDNSPri_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ClientDNSPri_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 1) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ClientDNSPri_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 1, a) +} + +func ClientDNSPri_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 1, a) +} + +func ClientDNSPri_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 1) +} + +func ClientDNSSec_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 2, a) +} + +func ClientDNSSec_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 2, a) +} + +func ClientDNSSec_Get(p *radius.Packet) (value []byte) { + value, _ = ClientDNSSec_Lookup(p) + return +} + +func ClientDNSSec_GetString(p *radius.Packet) (value string) { + value, _ = ClientDNSSec_LookupString(p) + return +} + +func ClientDNSSec_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 2) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ClientDNSSec_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 2) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ClientDNSSec_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 2) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ClientDNSSec_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 2) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ClientDNSSec_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 2, a) +} + +func ClientDNSSec_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 2, a) +} + +func ClientDNSSec_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 2) +} + +func ContextName_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 4, a) +} + +func ContextName_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 4, a) +} + +func ContextName_Get(p *radius.Packet) (value []byte) { + value, _ = ContextName_Lookup(p) + return +} + +func ContextName_GetString(p *radius.Packet) (value string) { + value, _ = ContextName_LookupString(p) + return +} + +func ContextName_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 4) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ContextName_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 4) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func ContextName_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func ContextName_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 4) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func ContextName_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 4, a) +} + +func ContextName_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 4, a) +} + +func ContextName_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 4) +} + +type TunnelMaxSessions uint32 + +var TunnelMaxSessions_Strings = map[TunnelMaxSessions]string{} + +func (a TunnelMaxSessions) String() string { + if str, ok := TunnelMaxSessions_Strings[a]; ok { + return str + } + return "TunnelMaxSessions(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelMaxSessions_Add(p *radius.Packet, value TunnelMaxSessions) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 21, a) +} + +func TunnelMaxSessions_Get(p *radius.Packet) (value TunnelMaxSessions) { + value, _ = TunnelMaxSessions_Lookup(p) + return +} + +func TunnelMaxSessions_Gets(p *radius.Packet) (values []TunnelMaxSessions, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 21) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelMaxSessions(i)) + } + return +} + +func TunnelMaxSessions_Lookup(p *radius.Packet) (value TunnelMaxSessions, err error) { + a, ok := _ZTE_LookupVendor(p, 21) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelMaxSessions(i) + return +} + +func TunnelMaxSessions_Set(p *radius.Packet, value TunnelMaxSessions) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 21, a) +} + +func TunnelMaxSessions_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 21) +} + +type TunnelMaxTunnels uint32 + +var TunnelMaxTunnels_Strings = map[TunnelMaxTunnels]string{} + +func (a TunnelMaxTunnels) String() string { + if str, ok := TunnelMaxTunnels_Strings[a]; ok { + return str + } + return "TunnelMaxTunnels(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelMaxTunnels_Add(p *radius.Packet, value TunnelMaxTunnels) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 22, a) +} + +func TunnelMaxTunnels_Get(p *radius.Packet) (value TunnelMaxTunnels) { + value, _ = TunnelMaxTunnels_Lookup(p) + return +} + +func TunnelMaxTunnels_Gets(p *radius.Packet) (values []TunnelMaxTunnels, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 22) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelMaxTunnels(i)) + } + return +} + +func TunnelMaxTunnels_Lookup(p *radius.Packet) (value TunnelMaxTunnels, err error) { + a, ok := _ZTE_LookupVendor(p, 22) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelMaxTunnels(i) + return +} + +func TunnelMaxTunnels_Set(p *radius.Packet, value TunnelMaxTunnels) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 22, a) +} + +func TunnelMaxTunnels_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 22) +} + +type TunnelWindow uint32 + +var TunnelWindow_Strings = map[TunnelWindow]string{} + +func (a TunnelWindow) String() string { + if str, ok := TunnelWindow_Strings[a]; ok { + return str + } + return "TunnelWindow(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelWindow_Add(p *radius.Packet, value TunnelWindow) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 24, a) +} + +func TunnelWindow_Get(p *radius.Packet) (value TunnelWindow) { + value, _ = TunnelWindow_Lookup(p) + return +} + +func TunnelWindow_Gets(p *radius.Packet) (values []TunnelWindow, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 24) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelWindow(i)) + } + return +} + +func TunnelWindow_Lookup(p *radius.Packet) (value TunnelWindow, err error) { + a, ok := _ZTE_LookupVendor(p, 24) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelWindow(i) + return +} + +func TunnelWindow_Set(p *radius.Packet, value TunnelWindow) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 24, a) +} + +func TunnelWindow_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 24) +} + +type TunnelRetransmit uint32 + +var TunnelRetransmit_Strings = map[TunnelRetransmit]string{} + +func (a TunnelRetransmit) String() string { + if str, ok := TunnelRetransmit_Strings[a]; ok { + return str + } + return "TunnelRetransmit(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelRetransmit_Add(p *radius.Packet, value TunnelRetransmit) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 25, a) +} + +func TunnelRetransmit_Get(p *radius.Packet) (value TunnelRetransmit) { + value, _ = TunnelRetransmit_Lookup(p) + return +} + +func TunnelRetransmit_Gets(p *radius.Packet) (values []TunnelRetransmit, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 25) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelRetransmit(i)) + } + return +} + +func TunnelRetransmit_Lookup(p *radius.Packet) (value TunnelRetransmit, err error) { + a, ok := _ZTE_LookupVendor(p, 25) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelRetransmit(i) + return +} + +func TunnelRetransmit_Set(p *radius.Packet, value TunnelRetransmit) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 25, a) +} + +func TunnelRetransmit_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 25) +} + +type TunnelCmdTimeout uint32 + +var TunnelCmdTimeout_Strings = map[TunnelCmdTimeout]string{} + +func (a TunnelCmdTimeout) String() string { + if str, ok := TunnelCmdTimeout_Strings[a]; ok { + return str + } + return "TunnelCmdTimeout(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelCmdTimeout_Add(p *radius.Packet, value TunnelCmdTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 26, a) +} + +func TunnelCmdTimeout_Get(p *radius.Packet) (value TunnelCmdTimeout) { + value, _ = TunnelCmdTimeout_Lookup(p) + return +} + +func TunnelCmdTimeout_Gets(p *radius.Packet) (values []TunnelCmdTimeout, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 26) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelCmdTimeout(i)) + } + return +} + +func TunnelCmdTimeout_Lookup(p *radius.Packet) (value TunnelCmdTimeout, err error) { + a, ok := _ZTE_LookupVendor(p, 26) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelCmdTimeout(i) + return +} + +func TunnelCmdTimeout_Set(p *radius.Packet, value TunnelCmdTimeout) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 26, a) +} + +func TunnelCmdTimeout_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 26) +} + +func PPPOEURL_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 27, a) +} + +func PPPOEURL_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 27, a) +} + +func PPPOEURL_Get(p *radius.Packet) (value []byte) { + value, _ = PPPOEURL_Lookup(p) + return +} + +func PPPOEURL_GetString(p *radius.Packet) (value string) { + value, _ = PPPOEURL_LookupString(p) + return +} + +func PPPOEURL_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 27) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PPPOEURL_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 27) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PPPOEURL_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func PPPOEURL_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 27) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func PPPOEURL_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 27, a) +} + +func PPPOEURL_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 27, a) +} + +func PPPOEURL_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 27) +} + +func PPPOEMOTM_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 28, a) +} + +func PPPOEMOTM_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 28, a) +} + +func PPPOEMOTM_Get(p *radius.Packet) (value []byte) { + value, _ = PPPOEMOTM_Lookup(p) + return +} + +func PPPOEMOTM_GetString(p *radius.Packet) (value string) { + value, _ = PPPOEMOTM_LookupString(p) + return +} + +func PPPOEMOTM_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 28) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PPPOEMOTM_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 28) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func PPPOEMOTM_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func PPPOEMOTM_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 28) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func PPPOEMOTM_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 28, a) +} + +func PPPOEMOTM_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 28, a) +} + +func PPPOEMOTM_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 28) +} + +type TunnelAlgorithm uint32 + +var TunnelAlgorithm_Strings = map[TunnelAlgorithm]string{} + +func (a TunnelAlgorithm) String() string { + if str, ok := TunnelAlgorithm_Strings[a]; ok { + return str + } + return "TunnelAlgorithm(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelAlgorithm_Add(p *radius.Packet, value TunnelAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 31, a) +} + +func TunnelAlgorithm_Get(p *radius.Packet) (value TunnelAlgorithm) { + value, _ = TunnelAlgorithm_Lookup(p) + return +} + +func TunnelAlgorithm_Gets(p *radius.Packet) (values []TunnelAlgorithm, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 31) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelAlgorithm(i)) + } + return +} + +func TunnelAlgorithm_Lookup(p *radius.Packet) (value TunnelAlgorithm, err error) { + a, ok := _ZTE_LookupVendor(p, 31) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelAlgorithm(i) + return +} + +func TunnelAlgorithm_Set(p *radius.Packet, value TunnelAlgorithm) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 31, a) +} + +func TunnelAlgorithm_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 31) +} + +type TunnelDeadtime uint32 + +var TunnelDeadtime_Strings = map[TunnelDeadtime]string{} + +func (a TunnelDeadtime) String() string { + if str, ok := TunnelDeadtime_Strings[a]; ok { + return str + } + return "TunnelDeadtime(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TunnelDeadtime_Add(p *radius.Packet, value TunnelDeadtime) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 32, a) +} + +func TunnelDeadtime_Get(p *radius.Packet) (value TunnelDeadtime) { + value, _ = TunnelDeadtime_Lookup(p) + return +} + +func TunnelDeadtime_Gets(p *radius.Packet) (values []TunnelDeadtime, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 32) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TunnelDeadtime(i)) + } + return +} + +func TunnelDeadtime_Lookup(p *radius.Packet) (value TunnelDeadtime, err error) { + a, ok := _ZTE_LookupVendor(p, 32) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TunnelDeadtime(i) + return +} + +func TunnelDeadtime_Set(p *radius.Packet, value TunnelDeadtime) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 32, a) +} + +func TunnelDeadtime_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 32) +} + +type McastSend uint32 + +var McastSend_Strings = map[McastSend]string{} + +func (a McastSend) String() string { + if str, ok := McastSend_Strings[a]; ok { + return str + } + return "McastSend(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func McastSend_Add(p *radius.Packet, value McastSend) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 33, a) +} + +func McastSend_Get(p *radius.Packet) (value McastSend) { + value, _ = McastSend_Lookup(p) + return +} + +func McastSend_Gets(p *radius.Packet) (values []McastSend, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 33) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, McastSend(i)) + } + return +} + +func McastSend_Lookup(p *radius.Packet) (value McastSend, err error) { + a, ok := _ZTE_LookupVendor(p, 33) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = McastSend(i) + return +} + +func McastSend_Set(p *radius.Packet, value McastSend) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 33, a) +} + +func McastSend_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 33) +} + +type McastReceive uint32 + +var McastReceive_Strings = map[McastReceive]string{} + +func (a McastReceive) String() string { + if str, ok := McastReceive_Strings[a]; ok { + return str + } + return "McastReceive(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func McastReceive_Add(p *radius.Packet, value McastReceive) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 34, a) +} + +func McastReceive_Get(p *radius.Packet) (value McastReceive) { + value, _ = McastReceive_Lookup(p) + return +} + +func McastReceive_Gets(p *radius.Packet) (values []McastReceive, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 34) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, McastReceive(i)) + } + return +} + +func McastReceive_Lookup(p *radius.Packet) (value McastReceive, err error) { + a, ok := _ZTE_LookupVendor(p, 34) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = McastReceive(i) + return +} + +func McastReceive_Set(p *radius.Packet, value McastReceive) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 34, a) +} + +func McastReceive_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 34) +} + +type McastMaxGroups uint32 + +var McastMaxGroups_Strings = map[McastMaxGroups]string{} + +func (a McastMaxGroups) String() string { + if str, ok := McastMaxGroups_Strings[a]; ok { + return str + } + return "McastMaxGroups(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func McastMaxGroups_Add(p *radius.Packet, value McastMaxGroups) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 35, a) +} + +func McastMaxGroups_Get(p *radius.Packet) (value McastMaxGroups) { + value, _ = McastMaxGroups_Lookup(p) + return +} + +func McastMaxGroups_Gets(p *radius.Packet) (values []McastMaxGroups, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 35) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, McastMaxGroups(i)) + } + return +} + +func McastMaxGroups_Lookup(p *radius.Packet) (value McastMaxGroups, err error) { + a, ok := _ZTE_LookupVendor(p, 35) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = McastMaxGroups(i) + return +} + +func McastMaxGroups_Set(p *radius.Packet, value McastMaxGroups) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 35, a) +} + +func McastMaxGroups_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 35) +} + +type AccessType uint32 + +var AccessType_Strings = map[AccessType]string{} + +func (a AccessType) String() string { + if str, ok := AccessType_Strings[a]; ok { + return str + } + return "AccessType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AccessType_Add(p *radius.Packet, value AccessType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 74, a) +} + +func AccessType_Get(p *radius.Packet) (value AccessType) { + value, _ = AccessType_Lookup(p) + return +} + +func AccessType_Gets(p *radius.Packet) (values []AccessType, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 74) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AccessType(i)) + } + return +} + +func AccessType_Lookup(p *radius.Packet) (value AccessType, err error) { + a, ok := _ZTE_LookupVendor(p, 74) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AccessType(i) + return +} + +func AccessType_Set(p *radius.Packet, value AccessType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 74, a) +} + +func AccessType_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 74) +} + +type QoSType uint32 + +var QoSType_Strings = map[QoSType]string{} + +func (a QoSType) String() string { + if str, ok := QoSType_Strings[a]; ok { + return str + } + return "QoSType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QoSType_Add(p *radius.Packet, value QoSType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 81, a) +} + +func QoSType_Get(p *radius.Packet) (value QoSType) { + value, _ = QoSType_Lookup(p) + return +} + +func QoSType_Gets(p *radius.Packet) (values []QoSType, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 81) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QoSType(i)) + } + return +} + +func QoSType_Lookup(p *radius.Packet) (value QoSType, err error) { + a, ok := _ZTE_LookupVendor(p, 81) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QoSType(i) + return +} + +func QoSType_Set(p *radius.Packet, value QoSType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 81, a) +} + +func QoSType_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 81) +} + +func QoSProfileDown_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 82, a) +} + +func QoSProfileDown_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 82, a) +} + +func QoSProfileDown_Get(p *radius.Packet) (value []byte) { + value, _ = QoSProfileDown_Lookup(p) + return +} + +func QoSProfileDown_GetString(p *radius.Packet) (value string) { + value, _ = QoSProfileDown_LookupString(p) + return +} + +func QoSProfileDown_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 82) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileDown_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 82) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileDown_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QoSProfileDown_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 82) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QoSProfileDown_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 82, a) +} + +func QoSProfileDown_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 82, a) +} + +func QoSProfileDown_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 82) +} + +type RateCtrlSCRDown uint32 + +var RateCtrlSCRDown_Strings = map[RateCtrlSCRDown]string{} + +func (a RateCtrlSCRDown) String() string { + if str, ok := RateCtrlSCRDown_Strings[a]; ok { + return str + } + return "RateCtrlSCRDown(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlSCRDown_Add(p *radius.Packet, value RateCtrlSCRDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 83, a) +} + +func RateCtrlSCRDown_Get(p *radius.Packet) (value RateCtrlSCRDown) { + value, _ = RateCtrlSCRDown_Lookup(p) + return +} + +func RateCtrlSCRDown_Gets(p *radius.Packet) (values []RateCtrlSCRDown, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 83) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlSCRDown(i)) + } + return +} + +func RateCtrlSCRDown_Lookup(p *radius.Packet) (value RateCtrlSCRDown, err error) { + a, ok := _ZTE_LookupVendor(p, 83) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlSCRDown(i) + return +} + +func RateCtrlSCRDown_Set(p *radius.Packet, value RateCtrlSCRDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 83, a) +} + +func RateCtrlSCRDown_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 83) +} + +type RateCtrlBurstDown uint32 + +var RateCtrlBurstDown_Strings = map[RateCtrlBurstDown]string{} + +func (a RateCtrlBurstDown) String() string { + if str, ok := RateCtrlBurstDown_Strings[a]; ok { + return str + } + return "RateCtrlBurstDown(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstDown_Add(p *radius.Packet, value RateCtrlBurstDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 84, a) +} + +func RateCtrlBurstDown_Get(p *radius.Packet) (value RateCtrlBurstDown) { + value, _ = RateCtrlBurstDown_Lookup(p) + return +} + +func RateCtrlBurstDown_Gets(p *radius.Packet) (values []RateCtrlBurstDown, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 84) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstDown(i)) + } + return +} + +func RateCtrlBurstDown_Lookup(p *radius.Packet) (value RateCtrlBurstDown, err error) { + a, ok := _ZTE_LookupVendor(p, 84) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstDown(i) + return +} + +func RateCtrlBurstDown_Set(p *radius.Packet, value RateCtrlBurstDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 84, a) +} + +func RateCtrlBurstDown_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 84) +} + +type RateCtrlPCR uint32 + +var RateCtrlPCR_Strings = map[RateCtrlPCR]string{} + +func (a RateCtrlPCR) String() string { + if str, ok := RateCtrlPCR_Strings[a]; ok { + return str + } + return "RateCtrlPCR(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlPCR_Add(p *radius.Packet, value RateCtrlPCR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 86, a) +} + +func RateCtrlPCR_Get(p *radius.Packet) (value RateCtrlPCR) { + value, _ = RateCtrlPCR_Lookup(p) + return +} + +func RateCtrlPCR_Gets(p *radius.Packet) (values []RateCtrlPCR, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 86) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlPCR(i)) + } + return +} + +func RateCtrlPCR_Lookup(p *radius.Packet) (value RateCtrlPCR, err error) { + a, ok := _ZTE_LookupVendor(p, 86) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlPCR(i) + return +} + +func RateCtrlPCR_Set(p *radius.Packet, value RateCtrlPCR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 86, a) +} + +func RateCtrlPCR_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 86) +} + +type TCPSynRate uint32 + +var TCPSynRate_Strings = map[TCPSynRate]string{} + +func (a TCPSynRate) String() string { + if str, ok := TCPSynRate_Strings[a]; ok { + return str + } + return "TCPSynRate(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TCPSynRate_Add(p *radius.Packet, value TCPSynRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 88, a) +} + +func TCPSynRate_Get(p *radius.Packet) (value TCPSynRate) { + value, _ = TCPSynRate_Lookup(p) + return +} + +func TCPSynRate_Gets(p *radius.Packet) (values []TCPSynRate, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 88) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TCPSynRate(i)) + } + return +} + +func TCPSynRate_Lookup(p *radius.Packet) (value TCPSynRate, err error) { + a, ok := _ZTE_LookupVendor(p, 88) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TCPSynRate(i) + return +} + +func TCPSynRate_Set(p *radius.Packet, value TCPSynRate) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 88, a) +} + +func TCPSynRate_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 88) +} + +type RateCtrlSCRUp uint32 + +var RateCtrlSCRUp_Strings = map[RateCtrlSCRUp]string{} + +func (a RateCtrlSCRUp) String() string { + if str, ok := RateCtrlSCRUp_Strings[a]; ok { + return str + } + return "RateCtrlSCRUp(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlSCRUp_Add(p *radius.Packet, value RateCtrlSCRUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 89, a) +} + +func RateCtrlSCRUp_Get(p *radius.Packet) (value RateCtrlSCRUp) { + value, _ = RateCtrlSCRUp_Lookup(p) + return +} + +func RateCtrlSCRUp_Gets(p *radius.Packet) (values []RateCtrlSCRUp, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 89) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlSCRUp(i)) + } + return +} + +func RateCtrlSCRUp_Lookup(p *radius.Packet) (value RateCtrlSCRUp, err error) { + a, ok := _ZTE_LookupVendor(p, 89) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlSCRUp(i) + return +} + +func RateCtrlSCRUp_Set(p *radius.Packet, value RateCtrlSCRUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 89, a) +} + +func RateCtrlSCRUp_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 89) +} + +type PriorityLevel uint32 + +var PriorityLevel_Strings = map[PriorityLevel]string{} + +func (a PriorityLevel) String() string { + if str, ok := PriorityLevel_Strings[a]; ok { + return str + } + return "PriorityLevel(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PriorityLevel_Add(p *radius.Packet, value PriorityLevel) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 90, a) +} + +func PriorityLevel_Get(p *radius.Packet) (value PriorityLevel) { + value, _ = PriorityLevel_Lookup(p) + return +} + +func PriorityLevel_Gets(p *radius.Packet) (values []PriorityLevel, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 90) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PriorityLevel(i)) + } + return +} + +func PriorityLevel_Lookup(p *radius.Packet) (value PriorityLevel, err error) { + a, ok := _ZTE_LookupVendor(p, 90) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PriorityLevel(i) + return +} + +func PriorityLevel_Set(p *radius.Packet, value PriorityLevel) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 90, a) +} + +func PriorityLevel_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 90) +} + +type RateCtrlBurstUp uint32 + +var RateCtrlBurstUp_Strings = map[RateCtrlBurstUp]string{} + +func (a RateCtrlBurstUp) String() string { + if str, ok := RateCtrlBurstUp_Strings[a]; ok { + return str + } + return "RateCtrlBurstUp(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstUp_Add(p *radius.Packet, value RateCtrlBurstUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 91, a) +} + +func RateCtrlBurstUp_Get(p *radius.Packet) (value RateCtrlBurstUp) { + value, _ = RateCtrlBurstUp_Lookup(p) + return +} + +func RateCtrlBurstUp_Gets(p *radius.Packet) (values []RateCtrlBurstUp, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 91) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstUp(i)) + } + return +} + +func RateCtrlBurstUp_Lookup(p *radius.Packet) (value RateCtrlBurstUp, err error) { + a, ok := _ZTE_LookupVendor(p, 91) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstUp(i) + return +} + +func RateCtrlBurstUp_Set(p *radius.Packet, value RateCtrlBurstUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 91, a) +} + +func RateCtrlBurstUp_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 91) +} + +type RateCtrlBurstMaxDown uint32 + +var RateCtrlBurstMaxDown_Strings = map[RateCtrlBurstMaxDown]string{} + +func (a RateCtrlBurstMaxDown) String() string { + if str, ok := RateCtrlBurstMaxDown_Strings[a]; ok { + return str + } + return "RateCtrlBurstMaxDown(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstMaxDown_Add(p *radius.Packet, value RateCtrlBurstMaxDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 92, a) +} + +func RateCtrlBurstMaxDown_Get(p *radius.Packet) (value RateCtrlBurstMaxDown) { + value, _ = RateCtrlBurstMaxDown_Lookup(p) + return +} + +func RateCtrlBurstMaxDown_Gets(p *radius.Packet) (values []RateCtrlBurstMaxDown, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 92) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstMaxDown(i)) + } + return +} + +func RateCtrlBurstMaxDown_Lookup(p *radius.Packet) (value RateCtrlBurstMaxDown, err error) { + a, ok := _ZTE_LookupVendor(p, 92) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstMaxDown(i) + return +} + +func RateCtrlBurstMaxDown_Set(p *radius.Packet, value RateCtrlBurstMaxDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 92, a) +} + +func RateCtrlBurstMaxDown_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 92) +} + +type RateCtrlBurstMaxUp uint32 + +var RateCtrlBurstMaxUp_Strings = map[RateCtrlBurstMaxUp]string{} + +func (a RateCtrlBurstMaxUp) String() string { + if str, ok := RateCtrlBurstMaxUp_Strings[a]; ok { + return str + } + return "RateCtrlBurstMaxUp(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstMaxUp_Add(p *radius.Packet, value RateCtrlBurstMaxUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 93, a) +} + +func RateCtrlBurstMaxUp_Get(p *radius.Packet) (value RateCtrlBurstMaxUp) { + value, _ = RateCtrlBurstMaxUp_Lookup(p) + return +} + +func RateCtrlBurstMaxUp_Gets(p *radius.Packet) (values []RateCtrlBurstMaxUp, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 93) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstMaxUp(i)) + } + return +} + +func RateCtrlBurstMaxUp_Lookup(p *radius.Packet) (value RateCtrlBurstMaxUp, err error) { + a, ok := _ZTE_LookupVendor(p, 93) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstMaxUp(i) + return +} + +func RateCtrlBurstMaxUp_Set(p *radius.Packet, value RateCtrlBurstMaxUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 93, a) +} + +func RateCtrlBurstMaxUp_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 93) +} + +func QOSProfileUp_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 94, a) +} + +func QOSProfileUp_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 94, a) +} + +func QOSProfileUp_Get(p *radius.Packet) (value []byte) { + value, _ = QOSProfileUp_Lookup(p) + return +} + +func QOSProfileUp_GetString(p *radius.Packet) (value string) { + value, _ = QOSProfileUp_LookupString(p) + return +} + +func QOSProfileUp_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 94) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QOSProfileUp_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 94) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QOSProfileUp_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QOSProfileUp_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 94) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QOSProfileUp_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 94, a) +} + +func QOSProfileUp_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 94, a) +} + +func QOSProfileUp_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 94) +} + +type TCPLimitNum uint32 + +var TCPLimitNum_Strings = map[TCPLimitNum]string{} + +func (a TCPLimitNum) String() string { + if str, ok := TCPLimitNum_Strings[a]; ok { + return str + } + return "TCPLimitNum(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TCPLimitNum_Add(p *radius.Packet, value TCPLimitNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 95, a) +} + +func TCPLimitNum_Get(p *radius.Packet) (value TCPLimitNum) { + value, _ = TCPLimitNum_Lookup(p) + return +} + +func TCPLimitNum_Gets(p *radius.Packet) (values []TCPLimitNum, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 95) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TCPLimitNum(i)) + } + return +} + +func TCPLimitNum_Lookup(p *radius.Packet) (value TCPLimitNum, err error) { + a, ok := _ZTE_LookupVendor(p, 95) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TCPLimitNum(i) + return +} + +func TCPLimitNum_Set(p *radius.Packet, value TCPLimitNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 95, a) +} + +func TCPLimitNum_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 95) +} + +type TCPLimitMode uint32 + +var TCPLimitMode_Strings = map[TCPLimitMode]string{} + +func (a TCPLimitMode) String() string { + if str, ok := TCPLimitMode_Strings[a]; ok { + return str + } + return "TCPLimitMode(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func TCPLimitMode_Add(p *radius.Packet, value TCPLimitMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 96, a) +} + +func TCPLimitMode_Get(p *radius.Packet) (value TCPLimitMode) { + value, _ = TCPLimitMode_Lookup(p) + return +} + +func TCPLimitMode_Gets(p *radius.Packet) (values []TCPLimitMode, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 96) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, TCPLimitMode(i)) + } + return +} + +func TCPLimitMode_Lookup(p *radius.Packet) (value TCPLimitMode, err error) { + a, ok := _ZTE_LookupVendor(p, 96) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = TCPLimitMode(i) + return +} + +func TCPLimitMode_Set(p *radius.Packet, value TCPLimitMode) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 96, a) +} + +func TCPLimitMode_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 96) +} + +type IGMPServiceProfileNum uint32 + +var IGMPServiceProfileNum_Strings = map[IGMPServiceProfileNum]string{} + +func (a IGMPServiceProfileNum) String() string { + if str, ok := IGMPServiceProfileNum_Strings[a]; ok { + return str + } + return "IGMPServiceProfileNum(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func IGMPServiceProfileNum_Add(p *radius.Packet, value IGMPServiceProfileNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 97, a) +} + +func IGMPServiceProfileNum_Get(p *radius.Packet) (value IGMPServiceProfileNum) { + value, _ = IGMPServiceProfileNum_Lookup(p) + return +} + +func IGMPServiceProfileNum_Gets(p *radius.Packet) (values []IGMPServiceProfileNum, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 97) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, IGMPServiceProfileNum(i)) + } + return +} + +func IGMPServiceProfileNum_Lookup(p *radius.Packet) (value IGMPServiceProfileNum, err error) { + a, ok := _ZTE_LookupVendor(p, 97) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = IGMPServiceProfileNum(i) + return +} + +func IGMPServiceProfileNum_Set(p *radius.Packet, value IGMPServiceProfileNum) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 97, a) +} + +func IGMPServiceProfileNum_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 97) +} + +func NATIPAddress_Add(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 98, a) +} + +func NATIPAddress_Get(p *radius.Packet) (value net.IP) { + value, _ = NATIPAddress_Lookup(p) + return +} + +func NATIPAddress_Gets(p *radius.Packet) (values []net.IP, err error) { + var i net.IP + for _, attr := range _ZTE_GetsVendor(p, 98) { + i, err = radius.IPAddr(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func NATIPAddress_Lookup(p *radius.Packet) (value net.IP, err error) { + a, ok := _ZTE_LookupVendor(p, 98) + if !ok { + err = radius.ErrNoAttribute + return + } + value, err = radius.IPAddr(a) + return +} + +func NATIPAddress_Set(p *radius.Packet, value net.IP) (err error) { + var a radius.Attribute + a, err = radius.NewIPAddr(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 98, a) +} + +func NATIPAddress_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 98) +} + +type NATStartPort uint32 + +var NATStartPort_Strings = map[NATStartPort]string{} + +func (a NATStartPort) String() string { + if str, ok := NATStartPort_Strings[a]; ok { + return str + } + return "NATStartPort(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func NATStartPort_Add(p *radius.Packet, value NATStartPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 99, a) +} + +func NATStartPort_Get(p *radius.Packet) (value NATStartPort) { + value, _ = NATStartPort_Lookup(p) + return +} + +func NATStartPort_Gets(p *radius.Packet) (values []NATStartPort, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 99) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, NATStartPort(i)) + } + return +} + +func NATStartPort_Lookup(p *radius.Packet) (value NATStartPort, err error) { + a, ok := _ZTE_LookupVendor(p, 99) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = NATStartPort(i) + return +} + +func NATStartPort_Set(p *radius.Packet, value NATStartPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 99, a) +} + +func NATStartPort_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 99) +} + +type NATEndPort uint32 + +var NATEndPort_Strings = map[NATEndPort]string{} + +func (a NATEndPort) String() string { + if str, ok := NATEndPort_Strings[a]; ok { + return str + } + return "NATEndPort(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func NATEndPort_Add(p *radius.Packet, value NATEndPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 100, a) +} + +func NATEndPort_Get(p *radius.Packet) (value NATEndPort) { + value, _ = NATEndPort_Lookup(p) + return +} + +func NATEndPort_Gets(p *radius.Packet) (values []NATEndPort, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 100) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, NATEndPort(i)) + } + return +} + +func NATEndPort_Lookup(p *radius.Packet) (value NATEndPort, err error) { + a, ok := _ZTE_LookupVendor(p, 100) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = NATEndPort(i) + return +} + +func NATEndPort_Set(p *radius.Packet, value NATEndPort) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 100, a) +} + +func NATEndPort_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 100) +} + +type PPPSserviceType uint32 + +var PPPSserviceType_Strings = map[PPPSserviceType]string{} + +func (a PPPSserviceType) String() string { + if str, ok := PPPSserviceType_Strings[a]; ok { + return str + } + return "PPPSserviceType(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func PPPSserviceType_Add(p *radius.Packet, value PPPSserviceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 101, a) +} + +func PPPSserviceType_Get(p *radius.Packet) (value PPPSserviceType) { + value, _ = PPPSserviceType_Lookup(p) + return +} + +func PPPSserviceType_Gets(p *radius.Packet) (values []PPPSserviceType, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 101) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, PPPSserviceType(i)) + } + return +} + +func PPPSserviceType_Lookup(p *radius.Packet) (value PPPSserviceType, err error) { + a, ok := _ZTE_LookupVendor(p, 101) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = PPPSserviceType(i) + return +} + +func PPPSserviceType_Set(p *radius.Packet, value PPPSserviceType) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 101, a) +} + +func PPPSserviceType_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 101) +} + +type SWPrivilege uint32 + +var SWPrivilege_Strings = map[SWPrivilege]string{} + +func (a SWPrivilege) String() string { + if str, ok := SWPrivilege_Strings[a]; ok { + return str + } + return "SWPrivilege(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func SWPrivilege_Add(p *radius.Packet, value SWPrivilege) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 104, a) +} + +func SWPrivilege_Get(p *radius.Packet) (value SWPrivilege) { + value, _ = SWPrivilege_Lookup(p) + return +} + +func SWPrivilege_Gets(p *radius.Packet) (values []SWPrivilege, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 104) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, SWPrivilege(i)) + } + return +} + +func SWPrivilege_Lookup(p *radius.Packet) (value SWPrivilege, err error) { + a, ok := _ZTE_LookupVendor(p, 104) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = SWPrivilege(i) + return +} + +func SWPrivilege_Set(p *radius.Packet, value SWPrivilege) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 104, a) +} + +func SWPrivilege_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 104) +} + +type QOSSubcarCirUpUser uint32 + +var QOSSubcarCirUpUser_Strings = map[QOSSubcarCirUpUser]string{} + +func (a QOSSubcarCirUpUser) String() string { + if str, ok := QOSSubcarCirUpUser_Strings[a]; ok { + return str + } + return "QOSSubcarCirUpUser(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QOSSubcarCirUpUser_Add(p *radius.Packet, value QOSSubcarCirUpUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 127, a) +} + +func QOSSubcarCirUpUser_Get(p *radius.Packet) (value QOSSubcarCirUpUser) { + value, _ = QOSSubcarCirUpUser_Lookup(p) + return +} + +func QOSSubcarCirUpUser_Gets(p *radius.Packet) (values []QOSSubcarCirUpUser, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 127) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QOSSubcarCirUpUser(i)) + } + return +} + +func QOSSubcarCirUpUser_Lookup(p *radius.Packet) (value QOSSubcarCirUpUser, err error) { + a, ok := _ZTE_LookupVendor(p, 127) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QOSSubcarCirUpUser(i) + return +} + +func QOSSubcarCirUpUser_Set(p *radius.Packet, value QOSSubcarCirUpUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 127, a) +} + +func QOSSubcarCirUpUser_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 127) +} + +type QOSSubcarPirUpUser uint32 + +var QOSSubcarPirUpUser_Strings = map[QOSSubcarPirUpUser]string{} + +func (a QOSSubcarPirUpUser) String() string { + if str, ok := QOSSubcarPirUpUser_Strings[a]; ok { + return str + } + return "QOSSubcarPirUpUser(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QOSSubcarPirUpUser_Add(p *radius.Packet, value QOSSubcarPirUpUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 128, a) +} + +func QOSSubcarPirUpUser_Get(p *radius.Packet) (value QOSSubcarPirUpUser) { + value, _ = QOSSubcarPirUpUser_Lookup(p) + return +} + +func QOSSubcarPirUpUser_Gets(p *radius.Packet) (values []QOSSubcarPirUpUser, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 128) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QOSSubcarPirUpUser(i)) + } + return +} + +func QOSSubcarPirUpUser_Lookup(p *radius.Packet) (value QOSSubcarPirUpUser, err error) { + a, ok := _ZTE_LookupVendor(p, 128) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QOSSubcarPirUpUser(i) + return +} + +func QOSSubcarPirUpUser_Set(p *radius.Packet, value QOSSubcarPirUpUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 128, a) +} + +func QOSSubcarPirUpUser_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 128) +} + +type QOSSubcarCirDownUser uint32 + +var QOSSubcarCirDownUser_Strings = map[QOSSubcarCirDownUser]string{} + +func (a QOSSubcarCirDownUser) String() string { + if str, ok := QOSSubcarCirDownUser_Strings[a]; ok { + return str + } + return "QOSSubcarCirDownUser(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QOSSubcarCirDownUser_Add(p *radius.Packet, value QOSSubcarCirDownUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 131, a) +} + +func QOSSubcarCirDownUser_Get(p *radius.Packet) (value QOSSubcarCirDownUser) { + value, _ = QOSSubcarCirDownUser_Lookup(p) + return +} + +func QOSSubcarCirDownUser_Gets(p *radius.Packet) (values []QOSSubcarCirDownUser, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 131) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QOSSubcarCirDownUser(i)) + } + return +} + +func QOSSubcarCirDownUser_Lookup(p *radius.Packet) (value QOSSubcarCirDownUser, err error) { + a, ok := _ZTE_LookupVendor(p, 131) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QOSSubcarCirDownUser(i) + return +} + +func QOSSubcarCirDownUser_Set(p *radius.Packet, value QOSSubcarCirDownUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 131, a) +} + +func QOSSubcarCirDownUser_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 131) +} + +type QOSSubcarPirDownUser uint32 + +var QOSSubcarPirDownUser_Strings = map[QOSSubcarPirDownUser]string{} + +func (a QOSSubcarPirDownUser) String() string { + if str, ok := QOSSubcarPirDownUser_Strings[a]; ok { + return str + } + return "QOSSubcarPirDownUser(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func QOSSubcarPirDownUser_Add(p *radius.Packet, value QOSSubcarPirDownUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 132, a) +} + +func QOSSubcarPirDownUser_Get(p *radius.Packet) (value QOSSubcarPirDownUser) { + value, _ = QOSSubcarPirDownUser_Lookup(p) + return +} + +func QOSSubcarPirDownUser_Gets(p *radius.Packet) (values []QOSSubcarPirDownUser, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 132) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, QOSSubcarPirDownUser(i)) + } + return +} + +func QOSSubcarPirDownUser_Lookup(p *radius.Packet) (value QOSSubcarPirDownUser, err error) { + a, ok := _ZTE_LookupVendor(p, 132) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = QOSSubcarPirDownUser(i) + return +} + +func QOSSubcarPirDownUser_Set(p *radius.Packet, value QOSSubcarPirDownUser) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 132, a) +} + +func QOSSubcarPirDownUser_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 132) +} + +func AccessDomain_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 151, a) +} + +func AccessDomain_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 151, a) +} + +func AccessDomain_Get(p *radius.Packet) (value []byte) { + value, _ = AccessDomain_Lookup(p) + return +} + +func AccessDomain_GetString(p *radius.Packet) (value string) { + value, _ = AccessDomain_LookupString(p) + return +} + +func AccessDomain_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 151) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessDomain_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 151) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func AccessDomain_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 151) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func AccessDomain_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 151) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func AccessDomain_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 151, a) +} + +func AccessDomain_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 151, a) +} + +func AccessDomain_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 151) +} + +func VPNID_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 190, a) +} + +func VPNID_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 190, a) +} + +func VPNID_Get(p *radius.Packet) (value []byte) { + value, _ = VPNID_Lookup(p) + return +} + +func VPNID_GetString(p *radius.Packet) (value string) { + value, _ = VPNID_LookupString(p) + return +} + +func VPNID_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 190) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VPNID_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 190) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func VPNID_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 190) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func VPNID_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 190) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func VPNID_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 190, a) +} + +func VPNID_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 190, a) +} + +func VPNID_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 190) +} + +type RateBustDPIR uint32 + +var RateBustDPIR_Strings = map[RateBustDPIR]string{} + +func (a RateBustDPIR) String() string { + if str, ok := RateBustDPIR_Strings[a]; ok { + return str + } + return "RateBustDPIR(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateBustDPIR_Add(p *radius.Packet, value RateBustDPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 191, a) +} + +func RateBustDPIR_Get(p *radius.Packet) (value RateBustDPIR) { + value, _ = RateBustDPIR_Lookup(p) + return +} + +func RateBustDPIR_Gets(p *radius.Packet) (values []RateBustDPIR, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 191) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateBustDPIR(i)) + } + return +} + +func RateBustDPIR_Lookup(p *radius.Packet) (value RateBustDPIR, err error) { + a, ok := _ZTE_LookupVendor(p, 191) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateBustDPIR(i) + return +} + +func RateBustDPIR_Set(p *radius.Packet, value RateBustDPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 191, a) +} + +func RateBustDPIR_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 191) +} + +type RateBustUPIR uint32 + +var RateBustUPIR_Strings = map[RateBustUPIR]string{} + +func (a RateBustUPIR) String() string { + if str, ok := RateBustUPIR_Strings[a]; ok { + return str + } + return "RateBustUPIR(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateBustUPIR_Add(p *radius.Packet, value RateBustUPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 192, a) +} + +func RateBustUPIR_Get(p *radius.Packet) (value RateBustUPIR) { + value, _ = RateBustUPIR_Lookup(p) + return +} + +func RateBustUPIR_Gets(p *radius.Packet) (values []RateBustUPIR, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 192) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateBustUPIR(i)) + } + return +} + +func RateBustUPIR_Lookup(p *radius.Packet) (value RateBustUPIR, err error) { + a, ok := _ZTE_LookupVendor(p, 192) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateBustUPIR(i) + return +} + +func RateBustUPIR_Set(p *radius.Packet, value RateBustUPIR) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 192, a) +} + +func RateBustUPIR_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 192) +} + +type RateCtrlPBSDown uint32 + +var RateCtrlPBSDown_Strings = map[RateCtrlPBSDown]string{} + +func (a RateCtrlPBSDown) String() string { + if str, ok := RateCtrlPBSDown_Strings[a]; ok { + return str + } + return "RateCtrlPBSDown(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlPBSDown_Add(p *radius.Packet, value RateCtrlPBSDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 202, a) +} + +func RateCtrlPBSDown_Get(p *radius.Packet) (value RateCtrlPBSDown) { + value, _ = RateCtrlPBSDown_Lookup(p) + return +} + +func RateCtrlPBSDown_Gets(p *radius.Packet) (values []RateCtrlPBSDown, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 202) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlPBSDown(i)) + } + return +} + +func RateCtrlPBSDown_Lookup(p *radius.Packet) (value RateCtrlPBSDown, err error) { + a, ok := _ZTE_LookupVendor(p, 202) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlPBSDown(i) + return +} + +func RateCtrlPBSDown_Set(p *radius.Packet, value RateCtrlPBSDown) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 202, a) +} + +func RateCtrlPBSDown_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 202) +} + +type RateCtrlPBSUp uint32 + +var RateCtrlPBSUp_Strings = map[RateCtrlPBSUp]string{} + +func (a RateCtrlPBSUp) String() string { + if str, ok := RateCtrlPBSUp_Strings[a]; ok { + return str + } + return "RateCtrlPBSUp(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlPBSUp_Add(p *radius.Packet, value RateCtrlPBSUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 203, a) +} + +func RateCtrlPBSUp_Get(p *radius.Packet) (value RateCtrlPBSUp) { + value, _ = RateCtrlPBSUp_Lookup(p) + return +} + +func RateCtrlPBSUp_Gets(p *radius.Packet) (values []RateCtrlPBSUp, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 203) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlPBSUp(i)) + } + return +} + +func RateCtrlPBSUp_Lookup(p *radius.Packet) (value RateCtrlPBSUp, err error) { + a, ok := _ZTE_LookupVendor(p, 203) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlPBSUp(i) + return +} + +func RateCtrlPBSUp_Set(p *radius.Packet, value RateCtrlPBSUp) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 203, a) +} + +func RateCtrlPBSUp_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 203) +} + +type RateCtrlSCRUpV6 uint32 + +var RateCtrlSCRUpV6_Strings = map[RateCtrlSCRUpV6]string{} + +func (a RateCtrlSCRUpV6) String() string { + if str, ok := RateCtrlSCRUpV6_Strings[a]; ok { + return str + } + return "RateCtrlSCRUpV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlSCRUpV6_Add(p *radius.Packet, value RateCtrlSCRUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 228, a) +} + +func RateCtrlSCRUpV6_Get(p *radius.Packet) (value RateCtrlSCRUpV6) { + value, _ = RateCtrlSCRUpV6_Lookup(p) + return +} + +func RateCtrlSCRUpV6_Gets(p *radius.Packet) (values []RateCtrlSCRUpV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 228) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlSCRUpV6(i)) + } + return +} + +func RateCtrlSCRUpV6_Lookup(p *radius.Packet) (value RateCtrlSCRUpV6, err error) { + a, ok := _ZTE_LookupVendor(p, 228) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlSCRUpV6(i) + return +} + +func RateCtrlSCRUpV6_Set(p *radius.Packet, value RateCtrlSCRUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 228, a) +} + +func RateCtrlSCRUpV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 228) +} + +type RateCtrlBurstUpV6 uint32 + +var RateCtrlBurstUpV6_Strings = map[RateCtrlBurstUpV6]string{} + +func (a RateCtrlBurstUpV6) String() string { + if str, ok := RateCtrlBurstUpV6_Strings[a]; ok { + return str + } + return "RateCtrlBurstUpV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstUpV6_Add(p *radius.Packet, value RateCtrlBurstUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 229, a) +} + +func RateCtrlBurstUpV6_Get(p *radius.Packet) (value RateCtrlBurstUpV6) { + value, _ = RateCtrlBurstUpV6_Lookup(p) + return +} + +func RateCtrlBurstUpV6_Gets(p *radius.Packet) (values []RateCtrlBurstUpV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 229) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstUpV6(i)) + } + return +} + +func RateCtrlBurstUpV6_Lookup(p *radius.Packet) (value RateCtrlBurstUpV6, err error) { + a, ok := _ZTE_LookupVendor(p, 229) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstUpV6(i) + return +} + +func RateCtrlBurstUpV6_Set(p *radius.Packet, value RateCtrlBurstUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 229, a) +} + +func RateCtrlBurstUpV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 229) +} + +type RateCtrlBurstMaxUpV6 uint32 + +var RateCtrlBurstMaxUpV6_Strings = map[RateCtrlBurstMaxUpV6]string{} + +func (a RateCtrlBurstMaxUpV6) String() string { + if str, ok := RateCtrlBurstMaxUpV6_Strings[a]; ok { + return str + } + return "RateCtrlBurstMaxUpV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstMaxUpV6_Add(p *radius.Packet, value RateCtrlBurstMaxUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 230, a) +} + +func RateCtrlBurstMaxUpV6_Get(p *radius.Packet) (value RateCtrlBurstMaxUpV6) { + value, _ = RateCtrlBurstMaxUpV6_Lookup(p) + return +} + +func RateCtrlBurstMaxUpV6_Gets(p *radius.Packet) (values []RateCtrlBurstMaxUpV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 230) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstMaxUpV6(i)) + } + return +} + +func RateCtrlBurstMaxUpV6_Lookup(p *radius.Packet) (value RateCtrlBurstMaxUpV6, err error) { + a, ok := _ZTE_LookupVendor(p, 230) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstMaxUpV6(i) + return +} + +func RateCtrlBurstMaxUpV6_Set(p *radius.Packet, value RateCtrlBurstMaxUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 230, a) +} + +func RateCtrlBurstMaxUpV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 230) +} + +type RateCtrlPBSUpV6 uint32 + +var RateCtrlPBSUpV6_Strings = map[RateCtrlPBSUpV6]string{} + +func (a RateCtrlPBSUpV6) String() string { + if str, ok := RateCtrlPBSUpV6_Strings[a]; ok { + return str + } + return "RateCtrlPBSUpV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlPBSUpV6_Add(p *radius.Packet, value RateCtrlPBSUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 231, a) +} + +func RateCtrlPBSUpV6_Get(p *radius.Packet) (value RateCtrlPBSUpV6) { + value, _ = RateCtrlPBSUpV6_Lookup(p) + return +} + +func RateCtrlPBSUpV6_Gets(p *radius.Packet) (values []RateCtrlPBSUpV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 231) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlPBSUpV6(i)) + } + return +} + +func RateCtrlPBSUpV6_Lookup(p *radius.Packet) (value RateCtrlPBSUpV6, err error) { + a, ok := _ZTE_LookupVendor(p, 231) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlPBSUpV6(i) + return +} + +func RateCtrlPBSUpV6_Set(p *radius.Packet, value RateCtrlPBSUpV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 231, a) +} + +func RateCtrlPBSUpV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 231) +} + +func QoSProfileUpV6_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 232, a) +} + +func QoSProfileUpV6_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 232, a) +} + +func QoSProfileUpV6_Get(p *radius.Packet) (value []byte) { + value, _ = QoSProfileUpV6_Lookup(p) + return +} + +func QoSProfileUpV6_GetString(p *radius.Packet) (value string) { + value, _ = QoSProfileUpV6_LookupString(p) + return +} + +func QoSProfileUpV6_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 232) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileUpV6_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 232) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileUpV6_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 232) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QoSProfileUpV6_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 232) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QoSProfileUpV6_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 232, a) +} + +func QoSProfileUpV6_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 232, a) +} + +func QoSProfileUpV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 232) +} + +type RateCtrlSCRDownV6 uint32 + +var RateCtrlSCRDownV6_Strings = map[RateCtrlSCRDownV6]string{} + +func (a RateCtrlSCRDownV6) String() string { + if str, ok := RateCtrlSCRDownV6_Strings[a]; ok { + return str + } + return "RateCtrlSCRDownV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlSCRDownV6_Add(p *radius.Packet, value RateCtrlSCRDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 233, a) +} + +func RateCtrlSCRDownV6_Get(p *radius.Packet) (value RateCtrlSCRDownV6) { + value, _ = RateCtrlSCRDownV6_Lookup(p) + return +} + +func RateCtrlSCRDownV6_Gets(p *radius.Packet) (values []RateCtrlSCRDownV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 233) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlSCRDownV6(i)) + } + return +} + +func RateCtrlSCRDownV6_Lookup(p *radius.Packet) (value RateCtrlSCRDownV6, err error) { + a, ok := _ZTE_LookupVendor(p, 233) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlSCRDownV6(i) + return +} + +func RateCtrlSCRDownV6_Set(p *radius.Packet, value RateCtrlSCRDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 233, a) +} + +func RateCtrlSCRDownV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 233) +} + +type RateCtrlBurstDownV6 uint32 + +var RateCtrlBurstDownV6_Strings = map[RateCtrlBurstDownV6]string{} + +func (a RateCtrlBurstDownV6) String() string { + if str, ok := RateCtrlBurstDownV6_Strings[a]; ok { + return str + } + return "RateCtrlBurstDownV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstDownV6_Add(p *radius.Packet, value RateCtrlBurstDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 234, a) +} + +func RateCtrlBurstDownV6_Get(p *radius.Packet) (value RateCtrlBurstDownV6) { + value, _ = RateCtrlBurstDownV6_Lookup(p) + return +} + +func RateCtrlBurstDownV6_Gets(p *radius.Packet) (values []RateCtrlBurstDownV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 234) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstDownV6(i)) + } + return +} + +func RateCtrlBurstDownV6_Lookup(p *radius.Packet) (value RateCtrlBurstDownV6, err error) { + a, ok := _ZTE_LookupVendor(p, 234) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstDownV6(i) + return +} + +func RateCtrlBurstDownV6_Set(p *radius.Packet, value RateCtrlBurstDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 234, a) +} + +func RateCtrlBurstDownV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 234) +} + +type RateCtrlBurstMaxDownV6 uint32 + +var RateCtrlBurstMaxDownV6_Strings = map[RateCtrlBurstMaxDownV6]string{} + +func (a RateCtrlBurstMaxDownV6) String() string { + if str, ok := RateCtrlBurstMaxDownV6_Strings[a]; ok { + return str + } + return "RateCtrlBurstMaxDownV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlBurstMaxDownV6_Add(p *radius.Packet, value RateCtrlBurstMaxDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 235, a) +} + +func RateCtrlBurstMaxDownV6_Get(p *radius.Packet) (value RateCtrlBurstMaxDownV6) { + value, _ = RateCtrlBurstMaxDownV6_Lookup(p) + return +} + +func RateCtrlBurstMaxDownV6_Gets(p *radius.Packet) (values []RateCtrlBurstMaxDownV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 235) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlBurstMaxDownV6(i)) + } + return +} + +func RateCtrlBurstMaxDownV6_Lookup(p *radius.Packet) (value RateCtrlBurstMaxDownV6, err error) { + a, ok := _ZTE_LookupVendor(p, 235) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlBurstMaxDownV6(i) + return +} + +func RateCtrlBurstMaxDownV6_Set(p *radius.Packet, value RateCtrlBurstMaxDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 235, a) +} + +func RateCtrlBurstMaxDownV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 235) +} + +type RateCtrlPBSDownV6 uint32 + +var RateCtrlPBSDownV6_Strings = map[RateCtrlPBSDownV6]string{} + +func (a RateCtrlPBSDownV6) String() string { + if str, ok := RateCtrlPBSDownV6_Strings[a]; ok { + return str + } + return "RateCtrlPBSDownV6(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func RateCtrlPBSDownV6_Add(p *radius.Packet, value RateCtrlPBSDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 236, a) +} + +func RateCtrlPBSDownV6_Get(p *radius.Packet) (value RateCtrlPBSDownV6) { + value, _ = RateCtrlPBSDownV6_Lookup(p) + return +} + +func RateCtrlPBSDownV6_Gets(p *radius.Packet) (values []RateCtrlPBSDownV6, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 236) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, RateCtrlPBSDownV6(i)) + } + return +} + +func RateCtrlPBSDownV6_Lookup(p *radius.Packet) (value RateCtrlPBSDownV6, err error) { + a, ok := _ZTE_LookupVendor(p, 236) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = RateCtrlPBSDownV6(i) + return +} + +func RateCtrlPBSDownV6_Set(p *radius.Packet, value RateCtrlPBSDownV6) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 236, a) +} + +func RateCtrlPBSDownV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 236) +} + +func QoSProfileDownV6_Add(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 237, a) +} + +func QoSProfileDownV6_AddString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_AddVendor(p, 237, a) +} + +func QoSProfileDownV6_Get(p *radius.Packet) (value []byte) { + value, _ = QoSProfileDownV6_Lookup(p) + return +} + +func QoSProfileDownV6_GetString(p *radius.Packet) (value string) { + value, _ = QoSProfileDownV6_LookupString(p) + return +} + +func QoSProfileDownV6_Gets(p *radius.Packet) (values [][]byte, err error) { + var i []byte + for _, attr := range _ZTE_GetsVendor(p, 237) { + i = radius.Bytes(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileDownV6_GetStrings(p *radius.Packet) (values []string, err error) { + var i string + for _, attr := range _ZTE_GetsVendor(p, 237) { + i = radius.String(attr) + if err != nil { + return + } + values = append(values, i) + } + return +} + +func QoSProfileDownV6_Lookup(p *radius.Packet) (value []byte, err error) { + a, ok := _ZTE_LookupVendor(p, 237) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.Bytes(a) + return +} + +func QoSProfileDownV6_LookupString(p *radius.Packet) (value string, err error) { + a, ok := _ZTE_LookupVendor(p, 237) + if !ok { + err = radius.ErrNoAttribute + return + } + value = radius.String(a) + return +} + +func QoSProfileDownV6_Set(p *radius.Packet, value []byte) (err error) { + var a radius.Attribute + a, err = radius.NewBytes(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 237, a) +} + +func QoSProfileDownV6_SetString(p *radius.Packet, value string) (err error) { + var a radius.Attribute + a, err = radius.NewString(value) + if err != nil { + return + } + return _ZTE_SetVendor(p, 237, a) +} + +func QoSProfileDownV6_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 237) +} + +type V6InputOctets uint32 + +var V6InputOctets_Strings = map[V6InputOctets]string{} + +func (a V6InputOctets) String() string { + if str, ok := V6InputOctets_Strings[a]; ok { + return str + } + return "V6InputOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6InputOctets_Add(p *radius.Packet, value V6InputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 245, a) +} + +func V6InputOctets_Get(p *radius.Packet) (value V6InputOctets) { + value, _ = V6InputOctets_Lookup(p) + return +} + +func V6InputOctets_Gets(p *radius.Packet) (values []V6InputOctets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 245) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6InputOctets(i)) + } + return +} + +func V6InputOctets_Lookup(p *radius.Packet) (value V6InputOctets, err error) { + a, ok := _ZTE_LookupVendor(p, 245) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6InputOctets(i) + return +} + +func V6InputOctets_Set(p *radius.Packet, value V6InputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 245, a) +} + +func V6InputOctets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 245) +} + +type V6InputGigaOctets uint32 + +var V6InputGigaOctets_Strings = map[V6InputGigaOctets]string{} + +func (a V6InputGigaOctets) String() string { + if str, ok := V6InputGigaOctets_Strings[a]; ok { + return str + } + return "V6InputGigaOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6InputGigaOctets_Add(p *radius.Packet, value V6InputGigaOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 246, a) +} + +func V6InputGigaOctets_Get(p *radius.Packet) (value V6InputGigaOctets) { + value, _ = V6InputGigaOctets_Lookup(p) + return +} + +func V6InputGigaOctets_Gets(p *radius.Packet) (values []V6InputGigaOctets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 246) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6InputGigaOctets(i)) + } + return +} + +func V6InputGigaOctets_Lookup(p *radius.Packet) (value V6InputGigaOctets, err error) { + a, ok := _ZTE_LookupVendor(p, 246) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6InputGigaOctets(i) + return +} + +func V6InputGigaOctets_Set(p *radius.Packet, value V6InputGigaOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 246, a) +} + +func V6InputGigaOctets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 246) +} + +type V6OutputOctets uint32 + +var V6OutputOctets_Strings = map[V6OutputOctets]string{} + +func (a V6OutputOctets) String() string { + if str, ok := V6OutputOctets_Strings[a]; ok { + return str + } + return "V6OutputOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6OutputOctets_Add(p *radius.Packet, value V6OutputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 247, a) +} + +func V6OutputOctets_Get(p *radius.Packet) (value V6OutputOctets) { + value, _ = V6OutputOctets_Lookup(p) + return +} + +func V6OutputOctets_Gets(p *radius.Packet) (values []V6OutputOctets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 247) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6OutputOctets(i)) + } + return +} + +func V6OutputOctets_Lookup(p *radius.Packet) (value V6OutputOctets, err error) { + a, ok := _ZTE_LookupVendor(p, 247) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6OutputOctets(i) + return +} + +func V6OutputOctets_Set(p *radius.Packet, value V6OutputOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 247, a) +} + +func V6OutputOctets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 247) +} + +type V6OututGigaOctets uint32 + +var V6OututGigaOctets_Strings = map[V6OututGigaOctets]string{} + +func (a V6OututGigaOctets) String() string { + if str, ok := V6OututGigaOctets_Strings[a]; ok { + return str + } + return "V6OututGigaOctets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6OututGigaOctets_Add(p *radius.Packet, value V6OututGigaOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 248, a) +} + +func V6OututGigaOctets_Get(p *radius.Packet) (value V6OututGigaOctets) { + value, _ = V6OututGigaOctets_Lookup(p) + return +} + +func V6OututGigaOctets_Gets(p *radius.Packet) (values []V6OututGigaOctets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 248) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6OututGigaOctets(i)) + } + return +} + +func V6OututGigaOctets_Lookup(p *radius.Packet) (value V6OututGigaOctets, err error) { + a, ok := _ZTE_LookupVendor(p, 248) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6OututGigaOctets(i) + return +} + +func V6OututGigaOctets_Set(p *radius.Packet, value V6OututGigaOctets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 248, a) +} + +func V6OututGigaOctets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 248) +} + +type V6InputPackets uint32 + +var V6InputPackets_Strings = map[V6InputPackets]string{} + +func (a V6InputPackets) String() string { + if str, ok := V6InputPackets_Strings[a]; ok { + return str + } + return "V6InputPackets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6InputPackets_Add(p *radius.Packet, value V6InputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 249, a) +} + +func V6InputPackets_Get(p *radius.Packet) (value V6InputPackets) { + value, _ = V6InputPackets_Lookup(p) + return +} + +func V6InputPackets_Gets(p *radius.Packet) (values []V6InputPackets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 249) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6InputPackets(i)) + } + return +} + +func V6InputPackets_Lookup(p *radius.Packet) (value V6InputPackets, err error) { + a, ok := _ZTE_LookupVendor(p, 249) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6InputPackets(i) + return +} + +func V6InputPackets_Set(p *radius.Packet, value V6InputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 249, a) +} + +func V6InputPackets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 249) +} + +type V6OutputPackets uint32 + +var V6OutputPackets_Strings = map[V6OutputPackets]string{} + +func (a V6OutputPackets) String() string { + if str, ok := V6OutputPackets_Strings[a]; ok { + return str + } + return "V6OutputPackets(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func V6OutputPackets_Add(p *radius.Packet, value V6OutputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 250, a) +} + +func V6OutputPackets_Get(p *radius.Packet) (value V6OutputPackets) { + value, _ = V6OutputPackets_Lookup(p) + return +} + +func V6OutputPackets_Gets(p *radius.Packet) (values []V6OutputPackets, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 250) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, V6OutputPackets(i)) + } + return +} + +func V6OutputPackets_Lookup(p *radius.Packet) (value V6OutputPackets, err error) { + a, ok := _ZTE_LookupVendor(p, 250) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = V6OutputPackets(i) + return +} + +func V6OutputPackets_Set(p *radius.Packet, value V6OutputPackets) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 250, a) +} + +func V6OutputPackets_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 250) +} + +type AcctAddressChange uint32 + +var AcctAddressChange_Strings = map[AcctAddressChange]string{} + +func (a AcctAddressChange) String() string { + if str, ok := AcctAddressChange_Strings[a]; ok { + return str + } + return "AcctAddressChange(" + strconv.FormatUint(uint64(a), 10) + ")" +} + +func AcctAddressChange_Add(p *radius.Packet, value AcctAddressChange) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_AddVendor(p, 251, a) +} + +func AcctAddressChange_Get(p *radius.Packet) (value AcctAddressChange) { + value, _ = AcctAddressChange_Lookup(p) + return +} + +func AcctAddressChange_Gets(p *radius.Packet) (values []AcctAddressChange, err error) { + var i uint32 + for _, attr := range _ZTE_GetsVendor(p, 251) { + i, err = radius.Integer(attr) + if err != nil { + return + } + values = append(values, AcctAddressChange(i)) + } + return +} + +func AcctAddressChange_Lookup(p *radius.Packet) (value AcctAddressChange, err error) { + a, ok := _ZTE_LookupVendor(p, 251) + if !ok { + err = radius.ErrNoAttribute + return + } + var i uint32 + i, err = radius.Integer(a) + if err != nil { + return + } + value = AcctAddressChange(i) + return +} + +func AcctAddressChange_Set(p *radius.Packet, value AcctAddressChange) (err error) { + a := radius.NewInteger(uint32(value)) + return _ZTE_SetVendor(p, 251, a) +} + +func AcctAddressChange_Del(p *radius.Packet) { + _ZTE_DelVendor(p, 251) +}