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.kdcReqBody; 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.kdcReqBody.actions.AddEType; 030import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.AddTicket; 031import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.ETypeSequence; 032import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.KdcReqBodyInit; 033import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreAddresses; 034import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreCName; 035import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreEncAuthorizationData; 036import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreFrom; 037import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreKdcOptions; 038import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreNonce; 039import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreRTime; 040import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreRealm; 041import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreSName; 042import org.apache.directory.shared.kerberos.codec.kdcReqBody.actions.StoreTill; 043import org.slf4j.Logger; 044import org.slf4j.LoggerFactory; 045 046 047/** 048 * This class implements the KdcReqBody structure. All the actions are declared 049 * in this class. As it is a singleton, these declaration are only done once. If 050 * an action is to be added or modified, this is where the work is to be done ! 051 * 052 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 053 */ 054public final class KdcReqBodyGrammar extends AbstractGrammar<KdcReqBodyContainer> 055{ 056 /** The logger */ 057 static final Logger LOG = LoggerFactory.getLogger( KdcReqBodyGrammar.class ); 058 059 /** A speedup for logger */ 060 static final boolean IS_DEBUG = LOG.isDebugEnabled(); 061 062 /** The instance of grammar. KdcReqBodyGrammar is a singleton */ 063 private static Grammar<KdcReqBodyContainer> instance = new KdcReqBodyGrammar(); 064 065 066 /** 067 * Creates a new KdcReqBodyGrammar object. 068 */ 069 @SuppressWarnings("unchecked") 070 private KdcReqBodyGrammar() 071 { 072 setName( KdcReqBodyGrammar.class.getName() ); 073 074 // Create the transitions table 075 super.transitions = 076 new GrammarTransition[KdcReqBodyStatesEnum.LAST_KDC_REQ_BODY_STATE.ordinal()][256]; 077 078 // ============================================================================================ 079 // KdcReqBody 080 // ============================================================================================ 081 // -------------------------------------------------------------------------------------------- 082 // Transition from KdcReqBody init to KdcReqBody SEQ 083 // -------------------------------------------------------------------------------------------- 084 // KDC-REQ-BODY ::= SEQUENCE { 085 super.transitions[KdcReqBodyStatesEnum.START_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = 086 new GrammarTransition<KdcReqBodyContainer>( 087 KdcReqBodyStatesEnum.START_STATE, 088 KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_TAG_STATE, 089 UniversalTag.SEQUENCE, 090 new KdcReqBodyInit() ); 091 092 // -------------------------------------------------------------------------------------------- 093 // Transition from KdcReqBody SEQ to kdc-options tag 094 // -------------------------------------------------------------------------------------------- 095 // KDC-REQ-BODY ::= SEQUENCE { 096 // kdc-options [0] 097 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_KDC_OPTIONS_TAG] = 098 new GrammarTransition<KdcReqBodyContainer>( 099 KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_TAG_STATE, 100 KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_STATE, 101 KerberosConstants.KDC_REQ_BODY_KDC_OPTIONS_TAG, 102 new CheckNotNullLength<KdcReqBodyContainer>() ); 103 104 // -------------------------------------------------------------------------------------------- 105 // Transition from kdc-options tag to kdc-options value 106 // -------------------------------------------------------------------------------------------- 107 // KDC-REQ-BODY ::= SEQUENCE { 108 // kdc-options [0] KDCOptions 109 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_STATE.ordinal()][UniversalTag.BIT_STRING 110 .getValue()] = 111 new GrammarTransition<KdcReqBodyContainer>( 112 KdcReqBodyStatesEnum.KDC_REQ_BODY_KDC_OPTIONS_STATE, 113 KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_OR_REALM_TAG_STATE, 114 UniversalTag.BIT_STRING, 115 new StoreKdcOptions() ); 116 117 // -------------------------------------------------------------------------------------------- 118 // Transition from kdc-options value to cname tag 119 // -------------------------------------------------------------------------------------------- 120 // KDC-REQ-BODY ::= SEQUENCE { 121 // ... 122 // cname [1] 123 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_OR_REALM_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_CNAME_TAG] = 124 new GrammarTransition<KdcReqBodyContainer>( 125 KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_OR_REALM_TAG_STATE, 126 KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_STATE, 127 KerberosConstants.KDC_REQ_BODY_CNAME_TAG, 128 new StoreCName() ); 129 130 // -------------------------------------------------------------------------------------------- 131 // Transition from kdc-options value to realm tag (cname is empty) 132 // -------------------------------------------------------------------------------------------- 133 // KDC-REQ-BODY ::= SEQUENCE { 134 // ... 135 // realm [2] 136 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_OR_REALM_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_REALM_TAG] = 137 new GrammarTransition<KdcReqBodyContainer>( 138 KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_OR_REALM_TAG_STATE, 139 KdcReqBodyStatesEnum.KDC_REQ_BODY_REALM_TAG_STATE, 140 KerberosConstants.KDC_REQ_BODY_REALM_TAG, 141 new CheckNotNullLength<KdcReqBodyContainer>() ); 142 143 // -------------------------------------------------------------------------------------------- 144 // Transition from cname tag to realm tag 145 // -------------------------------------------------------------------------------------------- 146 // KDC-REQ-BODY ::= SEQUENCE { 147 // ... 148 // realm [2] 149 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_REALM_TAG] = 150 new GrammarTransition<KdcReqBodyContainer>( 151 KdcReqBodyStatesEnum.KDC_REQ_BODY_CNAME_STATE, 152 KdcReqBodyStatesEnum.KDC_REQ_BODY_REALM_TAG_STATE, 153 KerberosConstants.KDC_REQ_BODY_REALM_TAG, 154 new CheckNotNullLength<KdcReqBodyContainer>() ); 155 156 // -------------------------------------------------------------------------------------------- 157 // Transition from realm tag to realm value 158 // -------------------------------------------------------------------------------------------- 159 // KDC-REQ-BODY ::= SEQUENCE { 160 // ... 161 // realm [2] Realm 162 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_REALM_TAG_STATE.ordinal()][UniversalTag.GENERAL_STRING 163 .getValue()] = 164 new GrammarTransition<KdcReqBodyContainer>( 165 KdcReqBodyStatesEnum.KDC_REQ_BODY_REALM_TAG_STATE, 166 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE, 167 UniversalTag.GENERAL_STRING, 168 new StoreRealm() ); 169 170 // -------------------------------------------------------------------------------------------- 171 // Transition from realm value to sname tag 172 // -------------------------------------------------------------------------------------------- 173 // KDC-REQ-BODY ::= SEQUENCE { 174 // ... 175 // sname [3] 176 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_SNAME_TAG] = 177 new GrammarTransition<KdcReqBodyContainer>( 178 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE, 179 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_STATE, 180 KerberosConstants.KDC_REQ_BODY_SNAME_TAG, 181 new StoreSName() ); 182 183 // -------------------------------------------------------------------------------------------- 184 // Transition from realm value to from tag (sname is empty) 185 // -------------------------------------------------------------------------------------------- 186 // KDC-REQ-BODY ::= SEQUENCE { 187 // ... 188 // from [4] 189 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_FROM_TAG] = 190 new GrammarTransition<KdcReqBodyContainer>( 191 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE, 192 KdcReqBodyStatesEnum.KDC_REQ_BODY_FROM_STATE, 193 KerberosConstants.KDC_REQ_BODY_FROM_TAG, 194 new CheckNotNullLength<KdcReqBodyContainer>() ); 195 196 // -------------------------------------------------------------------------------------------- 197 // Transition from realm value to till tag (sname and from are empty) 198 // -------------------------------------------------------------------------------------------- 199 // KDC-REQ-BODY ::= SEQUENCE { 200 // ... 201 // till [5] 202 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_TILL_TAG] = 203 new GrammarTransition<KdcReqBodyContainer>( 204 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_OR_FROM_OR_TILL_TAG_STATE, 205 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_STATE, 206 KerberosConstants.KDC_REQ_BODY_TILL_TAG, 207 new CheckNotNullLength<KdcReqBodyContainer>() ); 208 209 // -------------------------------------------------------------------------------------------- 210 // Transition from sname tag to from tag 211 // -------------------------------------------------------------------------------------------- 212 // KDC-REQ-BODY ::= SEQUENCE { 213 // ... 214 // from [4] 215 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_FROM_TAG] = 216 new GrammarTransition<KdcReqBodyContainer>( 217 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_STATE, 218 KdcReqBodyStatesEnum.KDC_REQ_BODY_FROM_STATE, 219 KerberosConstants.KDC_REQ_BODY_FROM_TAG, 220 new CheckNotNullLength<KdcReqBodyContainer>() ); 221 222 // -------------------------------------------------------------------------------------------- 223 // Transition from sname tag to till tag (from is empty) 224 // -------------------------------------------------------------------------------------------- 225 // KDC-REQ-BODY ::= SEQUENCE { 226 // ... 227 // till [5] 228 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_TILL_TAG] = 229 new GrammarTransition<KdcReqBodyContainer>( 230 KdcReqBodyStatesEnum.KDC_REQ_BODY_SNAME_STATE, 231 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_STATE, 232 KerberosConstants.KDC_REQ_BODY_TILL_TAG, 233 new CheckNotNullLength<KdcReqBodyContainer>() ); 234 235 // -------------------------------------------------------------------------------------------- 236 // Transition from from tag to from value 237 // -------------------------------------------------------------------------------------------- 238 // KDC-REQ-BODY ::= SEQUENCE { 239 // ... 240 // from [4] KerberosTime 241 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_FROM_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 242 .getValue()] = 243 new GrammarTransition<KdcReqBodyContainer>( 244 KdcReqBodyStatesEnum.KDC_REQ_BODY_FROM_STATE, 245 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_TAG_STATE, 246 UniversalTag.GENERALIZED_TIME, 247 new StoreFrom() ); 248 249 // -------------------------------------------------------------------------------------------- 250 // Transition from till tag to till value 251 // -------------------------------------------------------------------------------------------- 252 // KDC-REQ-BODY ::= SEQUENCE { 253 // ... 254 // till [5] 255 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_TILL_TAG] = 256 new GrammarTransition<KdcReqBodyContainer>( 257 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_TAG_STATE, 258 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_STATE, 259 KerberosConstants.KDC_REQ_BODY_TILL_TAG, 260 new CheckNotNullLength<KdcReqBodyContainer>() ); 261 262 // -------------------------------------------------------------------------------------------- 263 // Transition from till tag to till value 264 // -------------------------------------------------------------------------------------------- 265 // KDC-REQ-BODY ::= SEQUENCE { 266 // ... 267 // till [5] KerberosTime 268 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 269 .getValue()] = 270 new GrammarTransition<KdcReqBodyContainer>( 271 KdcReqBodyStatesEnum.KDC_REQ_BODY_TILL_STATE, 272 KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_OR_NONCE_TAG_STATE, 273 UniversalTag.GENERALIZED_TIME, 274 new StoreTill() ); 275 276 // -------------------------------------------------------------------------------------------- 277 // Transition from till value to rtime 278 // -------------------------------------------------------------------------------------------- 279 // KDC-REQ-BODY ::= SEQUENCE { 280 // ... 281 // rtime [6] 282 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_OR_NONCE_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_RTIME_TAG] = 283 new GrammarTransition<KdcReqBodyContainer>( 284 KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_OR_NONCE_TAG_STATE, 285 KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_STATE, 286 KerberosConstants.KDC_REQ_BODY_RTIME_TAG, 287 new CheckNotNullLength<KdcReqBodyContainer>() ); 288 289 // -------------------------------------------------------------------------------------------- 290 // Transition from till value to nonce 291 // -------------------------------------------------------------------------------------------- 292 // KDC-REQ-BODY ::= SEQUENCE { 293 // ... 294 // nonce [7] 295 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_OR_NONCE_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_NONCE_TAG] = 296 new GrammarTransition<KdcReqBodyContainer>( 297 KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_OR_NONCE_TAG_STATE, 298 KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_STATE, 299 KerberosConstants.KDC_REQ_BODY_NONCE_TAG, 300 new CheckNotNullLength<KdcReqBodyContainer>() ); 301 302 // -------------------------------------------------------------------------------------------- 303 // Transition from rtime to nonce tag 304 // -------------------------------------------------------------------------------------------- 305 // KDC-REQ-BODY ::= SEQUENCE { 306 // ... 307 // rtime [6] KerberosTime 308 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 309 .getValue()] = 310 new GrammarTransition<KdcReqBodyContainer>( 311 KdcReqBodyStatesEnum.KDC_REQ_BODY_RTIME_STATE, 312 KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_TAG_STATE, 313 UniversalTag.GENERALIZED_TIME, 314 new StoreRTime() ); 315 316 // -------------------------------------------------------------------------------------------- 317 // Transition from nonce tag to nonce value 318 // -------------------------------------------------------------------------------------------- 319 // KDC-REQ-BODY ::= SEQUENCE { 320 // ... 321 // nonce [7] UInt32 322 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_NONCE_TAG] = 323 new GrammarTransition<KdcReqBodyContainer>( 324 KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_TAG_STATE, 325 KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_STATE, 326 KerberosConstants.KDC_REQ_BODY_NONCE_TAG, 327 new CheckNotNullLength<KdcReqBodyContainer>() ); 328 329 // -------------------------------------------------------------------------------------------- 330 // Transition from nonce value to etype Tag 331 // -------------------------------------------------------------------------------------------- 332 // KDC-REQ-BODY ::= SEQUENCE { 333 // ... 334 // etype [8] 335 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_STATE.ordinal()][UniversalTag.INTEGER.getValue()] = 336 new GrammarTransition<KdcReqBodyContainer>( 337 KdcReqBodyStatesEnum.KDC_REQ_BODY_NONCE_TAG_STATE, 338 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_TAG_STATE, 339 UniversalTag.INTEGER, 340 new StoreNonce() ); 341 342 // -------------------------------------------------------------------------------------------- 343 // Transition from etype Tag to etype Tag 344 // -------------------------------------------------------------------------------------------- 345 // KDC-REQ-BODY ::= SEQUENCE { 346 // ... 347 // etype [8] 348 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_TAG_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ETYPE_TAG] = 349 new GrammarTransition<KdcReqBodyContainer>( 350 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_TAG_STATE, 351 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_SEQ_STATE, 352 KerberosConstants.KDC_REQ_BODY_ETYPE_TAG, 353 new CheckNotNullLength<KdcReqBodyContainer>() ); 354 355 // -------------------------------------------------------------------------------------------- 356 // Transition from etype Tag to etype SEQ 357 // -------------------------------------------------------------------------------------------- 358 // KDC-REQ-BODY ::= SEQUENCE { 359 // ... 360 // etype [8] SEQUENCE OF 361 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_SEQ_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = 362 new GrammarTransition<KdcReqBodyContainer>( 363 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_SEQ_STATE, 364 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 365 UniversalTag.SEQUENCE, 366 new ETypeSequence() ); 367 368 // -------------------------------------------------------------------------------------------- 369 // Transition from etype SEQ to EType values 370 // -------------------------------------------------------------------------------------------- 371 // KDC-REQ-BODY ::= SEQUENCE { 372 // ... 373 // etype [8] SEQUENCE OF Int32 374 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE.ordinal()][UniversalTag.INTEGER.getValue()] = 375 new GrammarTransition<KdcReqBodyContainer>( 376 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 377 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 378 UniversalTag.INTEGER, 379 new AddEType() ); 380 381 // -------------------------------------------------------------------------------------------- 382 // Transition from EType values to addresses 383 // -------------------------------------------------------------------------------------------- 384 // KDC-REQ-BODY ::= SEQUENCE { 385 // ... 386 // addresses [9] 387 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ADDRESSES_TAG] = 388 new GrammarTransition<KdcReqBodyContainer>( 389 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 390 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDRESSES_STATE, 391 KerberosConstants.KDC_REQ_BODY_ADDRESSES_TAG, 392 new StoreAddresses() ); 393 394 // -------------------------------------------------------------------------------------------- 395 // Transition from EType values to encAuthorizationData (addresses is empty) 396 // -------------------------------------------------------------------------------------------- 397 // KDC-REQ-BODY ::= SEQUENCE { 398 // ... 399 // enc-authorization-data [10] 400 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ENC_AUTHZ_DATA_TAG] = 401 new GrammarTransition<KdcReqBodyContainer>( 402 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 403 KdcReqBodyStatesEnum.KDC_REQ_BODY_ENC_AUTH_DATA_STATE, 404 KerberosConstants.KDC_REQ_BODY_ENC_AUTHZ_DATA_TAG, 405 new StoreEncAuthorizationData() ); 406 407 // -------------------------------------------------------------------------------------------- 408 // Transition from EType values to additionalTickets tag (addresses and enc-authorization data 409 // are empty) 410 // -------------------------------------------------------------------------------------------- 411 // KDC-REQ-BODY ::= SEQUENCE { 412 // ... 413 // additional-tickets [11] 414 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG] = 415 new GrammarTransition<KdcReqBodyContainer>( 416 KdcReqBodyStatesEnum.KDC_REQ_BODY_ETYPE_STATE, 417 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG_STATE, 418 KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG, 419 new CheckNotNullLength<KdcReqBodyContainer>() ); 420 421 // -------------------------------------------------------------------------------------------- 422 // Transition from addresses values to encAuthorizationData 423 // -------------------------------------------------------------------------------------------- 424 // KDC-REQ-BODY ::= SEQUENCE { 425 // ... 426 // enc-authorization-data [10] 427 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDRESSES_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ENC_AUTHZ_DATA_TAG] = 428 new GrammarTransition<KdcReqBodyContainer>( 429 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDRESSES_STATE, 430 KdcReqBodyStatesEnum.KDC_REQ_BODY_ENC_AUTH_DATA_STATE, 431 KerberosConstants.KDC_REQ_BODY_ENC_AUTHZ_DATA_TAG, 432 new StoreEncAuthorizationData() ); 433 434 // -------------------------------------------------------------------------------------------- 435 // Transition from addresses values to additional-tickets tag 436 // -------------------------------------------------------------------------------------------- 437 // KDC-REQ-BODY ::= SEQUENCE { 438 // ... 439 // additional-tickets [11] 440 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDRESSES_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG] = 441 new GrammarTransition<KdcReqBodyContainer>( 442 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDRESSES_STATE, 443 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG_STATE, 444 KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG, 445 new CheckNotNullLength<KdcReqBodyContainer>() ); 446 447 // -------------------------------------------------------------------------------------------- 448 // Transition from encAuthorizationData to additional-tickets tag 449 // -------------------------------------------------------------------------------------------- 450 // KDC-REQ-BODY ::= SEQUENCE { 451 // ... 452 // additional-tickets [11] 453 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ENC_AUTH_DATA_STATE.ordinal()][KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG] = 454 new GrammarTransition<KdcReqBodyContainer>( 455 KdcReqBodyStatesEnum.KDC_REQ_BODY_ENC_AUTH_DATA_STATE, 456 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG_STATE, 457 KerberosConstants.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG, 458 new CheckNotNullLength<KdcReqBodyContainer>() ); 459 460 // -------------------------------------------------------------------------------------------- 461 // Transition from additional-tickets tag to Ticket SEQUENCE 462 // -------------------------------------------------------------------------------------------- 463 // KDC-REQ-BODY ::= SEQUENCE { 464 // ... 465 // additional-tickets [11] SEQUENCE OF 466 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG_STATE.ordinal()][UniversalTag.SEQUENCE 467 .getValue()] = 468 new GrammarTransition<KdcReqBodyContainer>( 469 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_TAG_STATE, 470 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_SEQ_STATE, 471 UniversalTag.SEQUENCE, 472 new CheckNotNullLength<KdcReqBodyContainer>() ); 473 474 // -------------------------------------------------------------------------------------------- 475 // Transition from Ticket SEQUENCE to Ticket 476 // -------------------------------------------------------------------------------------------- 477 // KDC-REQ-BODY ::= SEQUENCE { 478 // ... 479 // additional-tickets [11] SEQUENCE OF Ticket 480 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_SEQ_STATE.ordinal()][KerberosConstants.TICKET_TAG] = 481 new GrammarTransition<KdcReqBodyContainer>( 482 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_SEQ_STATE, 483 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_STATE, 484 KerberosConstants.TICKET_TAG, 485 new AddTicket() ); 486 487 // -------------------------------------------------------------------------------------------- 488 // Transition from Ticket to Ticket 489 // -------------------------------------------------------------------------------------------- 490 // KDC-REQ-BODY ::= SEQUENCE { 491 // ... 492 // additional-tickets [11] SEQUENCE OF Ticket 493 super.transitions[KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_STATE.ordinal()][KerberosConstants.TICKET_TAG] = 494 new GrammarTransition<KdcReqBodyContainer>( 495 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_STATE, 496 KdcReqBodyStatesEnum.KDC_REQ_BODY_ADDITIONAL_TICKETS_STATE, 497 KerberosConstants.TICKET_TAG, 498 new AddTicket() ); 499 } 500 501 502 /** 503 * Get the instance of this grammar 504 * 505 * @return An instance on the KDC-REQ-BODY Grammar 506 */ 507 public static Grammar<KdcReqBodyContainer> getInstance() 508 { 509 return instance; 510 } 511}