1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 *
19 */
20 package org.apache.directory.shared.kerberos.codec.EncKdcRepPart;
21
22
23 import org.apache.directory.api.asn1.actions.CheckNotNullLength;
24 import org.apache.directory.api.asn1.ber.grammar.AbstractGrammar;
25 import org.apache.directory.api.asn1.ber.grammar.Grammar;
26 import org.apache.directory.api.asn1.ber.grammar.GrammarTransition;
27 import org.apache.directory.api.asn1.ber.tlv.UniversalTag;
28 import org.apache.directory.shared.kerberos.KerberosConstants;
29 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.EncKdcRepPartInit;
30 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreAuthTime;
31 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreCAddr;
32 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreEndTime;
33 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreFlags;
34 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreKey;
35 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreKeyExpiration;
36 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreLastReq;
37 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreNonce;
38 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreRenewTill;
39 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreSName;
40 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreSRealm;
41 import org.apache.directory.shared.kerberos.codec.EncKdcRepPart.actions.StoreStartTime;
42 import org.slf4j.Logger;
43 import org.slf4j.LoggerFactory;
44
45
46 /**
47 * This class implements the EncKdcRepPart structure. All the actions are declared
48 * in this class. As it is a singleton, these declaration are only done once. If
49 * an action is to be added or modified, this is where the work is to be done !
50 *
51 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
52 */
53 public final class EncKdcRepPartGrammar extends AbstractGrammar<EncKdcRepPartContainer>
54 {
55 /** The logger */
56 static final Logger LOG = LoggerFactory.getLogger( EncKdcRepPartGrammar.class );
57
58 /** A speedup for logger */
59 static final boolean IS_DEBUG = LOG.isDebugEnabled();
60
61 /** The instance of grammar. EncKdcRepPartGrammar is a singleton */
62 private static Grammar<EncKdcRepPartContainer> instance = new EncKdcRepPartGrammar();
63
64
65 /**
66 * Creates a new EncKdcRepPartGrammar object.
67 */
68 @SuppressWarnings("unchecked")
69 private EncKdcRepPartGrammar()
70 {
71 setName( EncKdcRepPartGrammar.class.getName() );
72
73 // Create the transitions table
74 super.transitions = new GrammarTransition[EncKdcRepPartStatesEnum.LAST_ENC_KDC_REP_PART_STATE.ordinal()][256];
75
76 // ============================================================================================
77 // EncKdcRepPart
78 // ============================================================================================
79 // --------------------------------------------------------------------------------------------
80 // Transition from EncKdcRepPart init to EncKdcRepPart tag
81 // --------------------------------------------------------------------------------------------
82 // EncKDCRepPart ::= SEQUENCE {
83 super.transitions[EncKdcRepPartStatesEnum.START_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] =
84 new GrammarTransition<EncKdcRepPartContainer>(
85 EncKdcRepPartStatesEnum.START_STATE,
86 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE,
87 UniversalTag.SEQUENCE,
88 new EncKdcRepPartInit() );
89
90 // --------------------------------------------------------------------------------------------
91 // Transition from EncKdcRepPart tag to key
92 // --------------------------------------------------------------------------------------------
93 // EncKDCRepPart ::= SEQUENCE {
94 // key [0] EncryptionKey,
95 super.transitions[EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE.ordinal()][KerberosConstants.ENC_KDC_REP_PART_KEY_TAG] =
96 new GrammarTransition<EncKdcRepPartContainer>(
97 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_SEQ_TAG_STATE,
98 EncKdcRepPartStatesEnum.ENC_KDC_REP_PART_KEY_TAG_STATE,
99 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 }