001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 * 019 */ 020package org.apache.directory.shared.kerberos.codec.EncKdcRepPart; 021 022 023import org.apache.directory.api.asn1.actions.CheckNotNullLength; 024import org.apache.directory.api.asn1.ber.grammar.AbstractGrammar; 025import org.apache.directory.api.asn1.ber.grammar.Grammar; 026import org.apache.directory.api.asn1.ber.grammar.GrammarTransition; 027import org.apache.directory.api.asn1.ber.tlv.UniversalTag; 028import org.apache.directory.shared.kerberos.KerberosConstants; 029import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.EncKdcRepPartInit; 030import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreAuthTime; 031import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreCAddr; 032import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreEndTime; 033import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreFlags; 034import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreKey; 035import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreKeyExpiration; 036import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreLastReq; 037import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreNonce; 038import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreRenewTill; 039import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreSName; 040import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreSRealm; 041import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreStartTime; 042import org.slf4j.Logger; 043import org.slf4j.LoggerFactory; 044 045 046/** 047 * This class implements the EncKdcRepPart structure. All the actions are declared 048 * in this class. As it is a singleton, these declaration are only done once. If 049 * an action is to be added or modified, this is where the work is to be done ! 050 * 051 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 052 */ 053public final class EncKdcRepPartGrammar extends AbstractGrammar<EncKdcRepPartContainer> 054{ 055 /** The logger */ 056 static final Logger LOG = LoggerFactory.getLogger( EncKdcRepPartGrammar.class ); 057 058 /** A speedup for logger */ 059 static final boolean IS_DEBUG = LOG.isDebugEnabled(); 060 061 /** The instance of grammar. EncKdcRepPartGrammar is a singleton */ 062 private static Grammar<EncKdcRepPartContainer> instance = new EncKdcRepPartGrammar(); 063 064 065 /** 066 * Creates a new EncKdcRepPartGrammar object. 067 */ 068 @SuppressWarnings("unchecked") 069 private EncKdcRepPartGrammar() 070 { 071 setName( EncKdcRepPartGrammar.class.getName() ); 072 073 // Create the transitions table 074 super.transitions = new GrammarTransition[EncKdcRepPartStatesEnum.LAST_ENC_KDC_REP_PART_STATE.ordinal()][256]; 075 076 // ============================================================================================ 077 // EncKdcRepPart 078 // ============================================================================================ 079 // -------------------------------------------------------------------------------------------- 080 // Transition from EncKdcRepPart init to EncKdcRepPart tag 081 // -------------------------------------------------------------------------------------------- 082 // EncKDCRepPart ::= SEQUENCE { 083 super.transitions[EncKdcRepPartStatesEnum.START_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = 084 new GrammarTransition<EncKdcRepPartContainer>( 085 EncKdcRepPartStatesEnum.START_STATE, 086 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE, 087 UniversalTag.SEQUENCE, 088 new EncKdcRepPartInit() ); 089 090 // -------------------------------------------------------------------------------------------- 091 // Transition from EncKdcRepPart tag to key 092 // -------------------------------------------------------------------------------------------- 093 // EncKDCRepPart ::= SEQUENCE { 094 // key [0] EncryptionKey, 095 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_KEY_TAG] = 096 new GrammarTransition<EncKdcRepPartContainer>( 097 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE, 098 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_TAG_STATE, 099 KerberosConstants.ENC_KDC_REP_PART_KEY_TAG, 100 new StoreKey() ); 101 102 // -------------------------------------------------------------------------------------------- 103 // Transition from key to last-req 104 // -------------------------------------------------------------------------------------------- 105 // EncKDCRepPart ::= SEQUENCE { 106 // ... 107 // last-req [1] LastReq, 108 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_TAG_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_LAST_REQ_TAG] = 109 new GrammarTransition<EncKdcRepPartContainer>( 110 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_TAG_STATE, 111 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_LAST_REQ_TAG_STATE, 112 KerberosConstants.ENC_KDC_REP_PART_LAST_REQ_TAG, 113 new StoreLastReq() ); 114 115 // -------------------------------------------------------------------------------------------- 116 // Transition from last-req to nonce tag 117 // -------------------------------------------------------------------------------------------- 118 // EncKDCRepPart ::= SEQUENCE { 119 // ... 120 // nonce [2] 121 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_LAST_REQ_TAG_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_NONCE_TAG] = 122 new GrammarTransition<EncKdcRepPartContainer>( 123 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_LAST_REQ_TAG_STATE, 124 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_TAG_STATE, 125 KerberosConstants.ENC_KDC_REP_PART_NONCE_TAG, 126 new CheckNotNullLength<EncKdcRepPartContainer>() ); 127 128 // -------------------------------------------------------------------------------------------- 129 // Transition from nonce tag to nonce value 130 // -------------------------------------------------------------------------------------------- 131 // EncKDCRepPart ::= SEQUENCE { 132 // ... 133 // nonce [2] UInt32, 134 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_TAG_STATE.ordinal()][UniversalTag.INTEGER 135 .getValue()] = 136 new GrammarTransition<EncKdcRepPartContainer>( 137 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_TAG_STATE, 138 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_STATE, 139 UniversalTag.INTEGER, 140 new StoreNonce() ); 141 142 // -------------------------------------------------------------------------------------------- 143 // Transition from nonce value to key-expiration tag 144 // -------------------------------------------------------------------------------------------- 145 // EncKDCRepPart ::= SEQUENCE { 146 // ... 147 // key-expiration [3] 148 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG] = 149 new GrammarTransition<EncKdcRepPartContainer>( 150 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_STATE, 151 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG_STATE, 152 KerberosConstants.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG, 153 new CheckNotNullLength<EncKdcRepPartContainer>() ); 154 155 // -------------------------------------------------------------------------------------------- 156 // Transition from nonce value to flags tag 157 // -------------------------------------------------------------------------------------------- 158 // EncKDCRepPart ::= SEQUENCE { 159 // ... 160 // flags [4] 161 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_FLAGS_TAG] = 162 new GrammarTransition<EncKdcRepPartContainer>( 163 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_NONCE_STATE, 164 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_TAG_STATE, 165 KerberosConstants.ENC_KDC_REP_PART_FLAGS_TAG, 166 new CheckNotNullLength<EncKdcRepPartContainer>() ); 167 168 // -------------------------------------------------------------------------------------------- 169 // Transition from key-expiration tag to key-expiration value 170 // -------------------------------------------------------------------------------------------- 171 // EncKDCRepPart ::= SEQUENCE { 172 // ... 173 // key-expiration [3] KerberosTime OPTIONAL, 174 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 175 .getValue()] = 176 new GrammarTransition<EncKdcRepPartContainer>( 177 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_TAG_STATE, 178 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_STATE, 179 UniversalTag.GENERALIZED_TIME, 180 new StoreKeyExpiration() ); 181 182 // -------------------------------------------------------------------------------------------- 183 // Transition from key-expiration value to flags tag 184 // -------------------------------------------------------------------------------------------- 185 // EncKDCRepPart ::= SEQUENCE { 186 // ... 187 // flags [4] 188 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_FLAGS_TAG] = 189 new GrammarTransition<EncKdcRepPartContainer>( 190 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_EXPIRATION_STATE, 191 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_TAG_STATE, 192 KerberosConstants.ENC_KDC_REP_PART_FLAGS_TAG, 193 new CheckNotNullLength<EncKdcRepPartContainer>() ); 194 195 // -------------------------------------------------------------------------------------------- 196 // Transition from flags tag to flags value 197 // -------------------------------------------------------------------------------------------- 198 // EncKDCRepPart ::= SEQUENCE { 199 // ... 200 // flags [4] TicketFlags, 201 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_TAG_STATE.ordinal()][UniversalTag.BIT_STRING 202 .getValue()] = 203 new GrammarTransition<EncKdcRepPartContainer>( 204 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_TAG_STATE, 205 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_STATE, 206 UniversalTag.BIT_STRING, 207 new StoreFlags() ); 208 209 // -------------------------------------------------------------------------------------------- 210 // Transition from flags value to authtime tag 211 // -------------------------------------------------------------------------------------------- 212 // EncKDCRepPart ::= SEQUENCE { 213 // ... 214 // authtime [5] 215 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_AUTH_TIME_TAG] = 216 new GrammarTransition<EncKdcRepPartContainer>( 217 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_FLAGS_STATE, 218 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_TAG_STATE, 219 KerberosConstants.ENC_KDC_REP_PART_AUTH_TIME_TAG, 220 new CheckNotNullLength<EncKdcRepPartContainer>() ); 221 222 // -------------------------------------------------------------------------------------------- 223 // Transition from authtime tag to authtime value 224 // -------------------------------------------------------------------------------------------- 225 // EncKDCRepPart ::= SEQUENCE { 226 // ... 227 // authtime [5] KerberosTime, 228 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 229 .getValue()] = 230 new GrammarTransition<EncKdcRepPartContainer>( 231 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_TAG_STATE, 232 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_STATE, 233 UniversalTag.GENERALIZED_TIME, 234 new StoreAuthTime() ); 235 236 // -------------------------------------------------------------------------------------------- 237 // Transition from authtime value to starttime tag 238 // -------------------------------------------------------------------------------------------- 239 // EncKDCRepPart ::= SEQUENCE { 240 // ... 241 // starttime [6] 242 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_START_TIME_TAG] = 243 new GrammarTransition<EncKdcRepPartContainer>( 244 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_STATE, 245 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_TAG_STATE, 246 KerberosConstants.ENC_KDC_REP_PART_START_TIME_TAG, 247 new CheckNotNullLength<EncKdcRepPartContainer>() ); 248 249 // -------------------------------------------------------------------------------------------- 250 // Transition from authtime value to endtime tag 251 // -------------------------------------------------------------------------------------------- 252 // EncKDCRepPart ::= SEQUENCE { 253 // ... 254 // endtime [7] 255 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_END_TIME_TAG] = 256 new GrammarTransition<EncKdcRepPartContainer>( 257 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_AUTH_TIME_STATE, 258 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_TAG_STATE, 259 KerberosConstants.ENC_KDC_REP_PART_END_TIME_TAG, 260 new CheckNotNullLength<EncKdcRepPartContainer>() ); 261 262 // -------------------------------------------------------------------------------------------- 263 // Transition from starttime tag to starttime value 264 // -------------------------------------------------------------------------------------------- 265 // EncKDCRepPart ::= SEQUENCE { 266 // ... 267 // starttime [6] KerberosTime OPTIONAL, 268 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 269 .getValue()] = 270 new GrammarTransition<EncKdcRepPartContainer>( 271 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_TAG_STATE, 272 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_STATE, 273 UniversalTag.GENERALIZED_TIME, 274 new StoreStartTime() ); 275 276 // -------------------------------------------------------------------------------------------- 277 // Transition from starttime value to endtime tag 278 // -------------------------------------------------------------------------------------------- 279 // EncKDCRepPart ::= SEQUENCE { 280 // ... 281 // endtime [7] 282 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_END_TIME_TAG] = 283 new GrammarTransition<EncKdcRepPartContainer>( 284 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_START_TIME_STATE, 285 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_TAG_STATE, 286 KerberosConstants.ENC_KDC_REP_PART_END_TIME_TAG, 287 new CheckNotNullLength<EncKdcRepPartContainer>() ); 288 289 // -------------------------------------------------------------------------------------------- 290 // Transition from endtime tag to endtime value 291 // -------------------------------------------------------------------------------------------- 292 // EncKDCRepPart ::= SEQUENCE { 293 // ... 294 // endtime [7] KerberosTime, 295 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 296 .getValue()] = 297 new GrammarTransition<EncKdcRepPartContainer>( 298 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_TAG_STATE, 299 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_STATE, 300 UniversalTag.GENERALIZED_TIME, 301 new StoreEndTime() ); 302 303 // -------------------------------------------------------------------------------------------- 304 // Transition from endtime value to renew-till tag 305 // -------------------------------------------------------------------------------------------- 306 // EncKDCRepPart ::= SEQUENCE { 307 // ... 308 // renew-till [8] 309 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_RENEW_TILL_TAG] = 310 new GrammarTransition<EncKdcRepPartContainer>( 311 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_STATE, 312 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_TAG_STATE, 313 KerberosConstants.ENC_KDC_REP_PART_RENEW_TILL_TAG, 314 new CheckNotNullLength<EncKdcRepPartContainer>() ); 315 316 // -------------------------------------------------------------------------------------------- 317 // Transition from endtime value to srealm tag 318 // -------------------------------------------------------------------------------------------- 319 // EncKDCRepPart ::= SEQUENCE { 320 // ... 321 // srealm [9] 322 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_SREALM_TAG] = 323 new GrammarTransition<EncKdcRepPartContainer>( 324 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_END_TIME_STATE, 325 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_TAG_STATE, 326 KerberosConstants.ENC_KDC_REP_PART_SREALM_TAG, 327 new CheckNotNullLength<EncKdcRepPartContainer>() ); 328 329 // -------------------------------------------------------------------------------------------- 330 // Transition from renew-till tag to renew-till value 331 // -------------------------------------------------------------------------------------------- 332 // EncKDCRepPart ::= SEQUENCE { 333 // ... 334 // renew-till [8] KerberosTime OPTIONAL, 335 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 336 .getValue()] = 337 new GrammarTransition<EncKdcRepPartContainer>( 338 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_TAG_STATE, 339 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_STATE, 340 UniversalTag.GENERALIZED_TIME, 341 new StoreRenewTill() ); 342 343 // -------------------------------------------------------------------------------------------- 344 // Transition from renew-till value to srealm tag 345 // -------------------------------------------------------------------------------------------- 346 // EncKDCRepPart ::= SEQUENCE { 347 // ... 348 // srealm [9] 349 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_SREALM_TAG] = 350 new GrammarTransition<EncKdcRepPartContainer>( 351 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_RENEW_TILL_STATE, 352 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_TAG_STATE, 353 KerberosConstants.ENC_KDC_REP_PART_SREALM_TAG, 354 new CheckNotNullLength<EncKdcRepPartContainer>() ); 355 356 // -------------------------------------------------------------------------------------------- 357 // Transition from srealm tag to srealm value 358 // -------------------------------------------------------------------------------------------- 359 // EncKDCRepPart ::= SEQUENCE { 360 // ... 361 // srealm [9] Realm, 362 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_TAG_STATE.ordinal()][UniversalTag.GENERAL_STRING 363 .getValue()] = 364 new GrammarTransition<EncKdcRepPartContainer>( 365 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_TAG_STATE, 366 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_STATE, 367 UniversalTag.GENERAL_STRING, 368 new StoreSRealm() ); 369 370 // -------------------------------------------------------------------------------------------- 371 // Transition from srealm value to sname 372 // -------------------------------------------------------------------------------------------- 373 // EncKDCRepPart ::= SEQUENCE { 374 // ... 375 // sname [10] PrincipalName, 376 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_SNAME_TAG] = 377 new GrammarTransition<EncKdcRepPartContainer>( 378 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SREALM_STATE, 379 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SNAME_TAG_STATE, 380 KerberosConstants.ENC_KDC_REP_PART_SNAME_TAG, 381 new StoreSName() ); 382 383 // -------------------------------------------------------------------------------------------- 384 // Transition from sname to caddr 385 // -------------------------------------------------------------------------------------------- 386 // EncKDCRepPart ::= SEQUENCE { 387 // ... 388 // caddr [11] <HostAddresses> OPTIONAL 389 // } 390 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SNAME_TAG_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_CADDR_TAG] = 391 new GrammarTransition<EncKdcRepPartContainer>( 392 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SNAME_TAG_STATE, 393 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_CADDR_TAG_STATE, 394 KerberosConstants.ENC_KDC_REP_PART_CADDR_TAG, 395 new StoreCAddr() ); 396 } 397 398 399 /** 400 * Get the instance of this grammar 401 * 402 * @return An instance on the EncKdcRepPart Grammar 403 */ 404 public static Grammar<EncKdcRepPartContainer> getInstance() 405 { 406 return instance; 407 } 408}