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.krbSafeBody; 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.krbSafeBody.actions.KrbSafeBodyInit; 030import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreRecipientAddress; 031import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreSenderAddress; 032import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreSeqNumber; 033import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreTimestamp; 034import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreUsec; 035import org.apache.directory.shared.kerberos.codec.krbSafeBody.actions.StoreUserData; 036import org.slf4j.Logger; 037import org.slf4j.LoggerFactory; 038 039 040/** 041 * This class implements the KRB-SAFE-BODY structure. All the actions are declared 042 * in this class. As it is a singleton, these declaration are only done once. If 043 * an action is to be added or modified, this is where the work is to be done ! 044 * 045 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> 046 */ 047public final class KrbSafeBodyGrammar extends AbstractGrammar<KrbSafeBodyContainer> 048{ 049 /** The logger */ 050 static final Logger LOG = LoggerFactory.getLogger( KrbSafeBodyGrammar.class ); 051 052 /** A speedup for logger */ 053 static final boolean IS_DEBUG = LOG.isDebugEnabled(); 054 055 /** The instance of grammar. KrbSafeBodyGrammar is a singleton */ 056 private static Grammar<KrbSafeBodyContainer> instance = new KrbSafeBodyGrammar(); 057 058 059 /** 060 * Creates a new KrbSafeBodyGrammar object. 061 */ 062 @SuppressWarnings("unchecked") 063 private KrbSafeBodyGrammar() 064 { 065 setName( KrbSafeBodyGrammar.class.getName() ); 066 067 // Create the transitions table 068 super.transitions = new GrammarTransition[KrbSafeBodyStatesEnum.LAST_KRB_SAFE_BODY_STATE.ordinal()][256]; 069 070 // ============================================================================================ 071 // KrbSafeBody 072 // ============================================================================================ 073 // -------------------------------------------------------------------------------------------- 074 // Transition from KrbSafeBody init to KrbSafeBody seq 075 // -------------------------------------------------------------------------------------------- 076 // KRB-SAFE-BODY ::= SEQUENCE { 077 super.transitions[KrbSafeBodyStatesEnum.START_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = 078 new GrammarTransition<KrbSafeBodyContainer>( 079 KrbSafeBodyStatesEnum.START_STATE, 080 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_TAG_STATE, 081 UniversalTag.SEQUENCE, 082 new KrbSafeBodyInit() ); 083 084 // -------------------------------------------------------------------------------------------- 085 // Transition from KrbSafeBody seq to user-data tag 086 // -------------------------------------------------------------------------------------------- 087 // KRB-SAFE-BODY ::= SEQUENCE { 088 // user-data [0] 089 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_TAG_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_USER_DATA_TAG] = 090 new GrammarTransition<KrbSafeBodyContainer>( 091 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_TAG_STATE, 092 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_TAG_STATE, 093 KerberosConstants.KRB_SAFE_BODY_USER_DATA_TAG, 094 new CheckNotNullLength<KrbSafeBodyContainer>() ); 095 096 // -------------------------------------------------------------------------------------------- 097 // Transition from user-data tag to user-data value 098 // -------------------------------------------------------------------------------------------- 099 // KRB-SAFE-BODY ::= SEQUENCE { 100 // user-data [0] OCTET STRING 101 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_TAG_STATE.ordinal()][UniversalTag.OCTET_STRING 102 .getValue()] = 103 new GrammarTransition<KrbSafeBodyContainer>( 104 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_TAG_STATE, 105 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE, 106 UniversalTag.OCTET_STRING, 107 new StoreUserData() ); 108 109 // -------------------------------------------------------------------------------------------- 110 // Transition from user-data value to timestamp tag 111 // -------------------------------------------------------------------------------------------- 112 // KRB-SAFE-BODY ::= SEQUENCE { 113 // timestamp [1] 114 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_TIMESTAMP_TAG] = 115 new GrammarTransition<KrbSafeBodyContainer>( 116 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE, 117 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_TAG_STATE, 118 KerberosConstants.KRB_SAFE_BODY_TIMESTAMP_TAG, 119 new CheckNotNullLength<KrbSafeBodyContainer>() ); 120 121 // -------------------------------------------------------------------------------------------- 122 // Transition from timestamp tag to timestamp value 123 // -------------------------------------------------------------------------------------------- 124 // KRB-SAFE-BODY ::= SEQUENCE { 125 // timestamp [1] KerberosTime OPTIONAL 126 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_TAG_STATE.ordinal()][UniversalTag.GENERALIZED_TIME 127 .getValue()] = 128 new GrammarTransition<KrbSafeBodyContainer>( 129 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_TAG_STATE, 130 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_STATE, 131 UniversalTag.GENERALIZED_TIME, 132 new StoreTimestamp() ); 133 134 // -------------------------------------------------------------------------------------------- 135 // Transition from timestamp value to usec tag 136 // -------------------------------------------------------------------------------------------- 137 // KRB-SAFE-BODY ::= SEQUENCE { 138 // usec [2] 139 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_USEC_TAG] = 140 new GrammarTransition<KrbSafeBodyContainer>( 141 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_TIMESTAMP_STATE, 142 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_TAG_STATE, 143 KerberosConstants.KRB_SAFE_BODY_USEC_TAG, 144 new CheckNotNullLength<KrbSafeBodyContainer>() ); 145 146 // -------------------------------------------------------------------------------------------- 147 // Transition from usec tag to usec value 148 // -------------------------------------------------------------------------------------------- 149 // KRB-SAFE-BODY ::= SEQUENCE { 150 // usec [2] Microseconds OPTIONAL 151 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_TAG_STATE.ordinal()][UniversalTag.INTEGER.getValue()] = 152 new GrammarTransition<KrbSafeBodyContainer>( 153 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_TAG_STATE, 154 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_STATE, 155 UniversalTag.INTEGER, 156 new StoreUsec() ); 157 158 // -------------------------------------------------------------------------------------------- 159 // Transition from usec value to seq-number tag 160 // -------------------------------------------------------------------------------------------- 161 // KRB-SAFE-BODY ::= SEQUENCE { 162 // seq-number [3] 163 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_SEQ_NUMBER_TAG] = 164 new GrammarTransition<KrbSafeBodyContainer>( 165 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_STATE, 166 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_TAG_STATE, 167 KerberosConstants.KRB_SAFE_BODY_SEQ_NUMBER_TAG, 168 new CheckNotNullLength<KrbSafeBodyContainer>() ); 169 170 // -------------------------------------------------------------------------------------------- 171 // Transition from seq-number tag to seq-number value 172 // -------------------------------------------------------------------------------------------- 173 // KRB-SAFE-BODY ::= SEQUENCE { 174 // seq-number [3] UInt32 OPTIONAL 175 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_TAG_STATE.ordinal()][UniversalTag.INTEGER 176 .getValue()] = 177 new GrammarTransition<KrbSafeBodyContainer>( 178 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_TAG_STATE, 179 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_STATE, 180 UniversalTag.INTEGER, 181 new StoreSeqNumber() ); 182 183 // -------------------------------------------------------------------------------------------- 184 // Transition from seq-number to s-address tag 185 // -------------------------------------------------------------------------------------------- 186 // KRB-SAFE-BODY ::= SEQUENCE { 187 // s-address [4] HostAddress 188 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG] = 189 new GrammarTransition<KrbSafeBodyContainer>( 190 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_STATE, 191 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SENDER_ADDRESS_TAG_STATE, 192 KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG, 193 new StoreSenderAddress() ); 194 195 // -------------------------------------------------------------------------------------------- 196 // Transition from s-address tag to r-address tag 197 // -------------------------------------------------------------------------------------------- 198 // KRB-SAFE-BODY ::= SEQUENCE { 199 // r-address [5] HostAddress 200 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SENDER_ADDRESS_TAG_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_RECIPIENT_ADDRESS_TAG] = 201 new GrammarTransition<KrbSafeBodyContainer>( 202 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SENDER_ADDRESS_TAG_STATE, 203 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_RECIPIENT_ADDRESS_TAG_STATE, 204 KerberosConstants.KRB_SAFE_BODY_RECIPIENT_ADDRESS_TAG, 205 new StoreRecipientAddress() ); 206 207 //----------------------------- OPTIONAL transitions --------------------------- 208 209 // -------------------------------------------------------------------------------------------- 210 // Transition from user-data value to usec tag 211 // -------------------------------------------------------------------------------------------- 212 // KRB-SAFE-BODY ::= SEQUENCE { 213 // usec [2] 214 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_USEC_TAG] = 215 new GrammarTransition<KrbSafeBodyContainer>( 216 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE, 217 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_TAG_STATE, 218 KerberosConstants.KRB_SAFE_BODY_USEC_TAG, 219 new CheckNotNullLength<KrbSafeBodyContainer>() ); 220 221 // -------------------------------------------------------------------------------------------- 222 // Transition from user-data value to seq-number tag 223 // -------------------------------------------------------------------------------------------- 224 // KRB-SAFE-BODY ::= SEQUENCE { 225 // seq-number [3] 226 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_SEQ_NUMBER_TAG] = 227 new GrammarTransition<KrbSafeBodyContainer>( 228 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE, 229 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SEQ_NUMBER_TAG_STATE, 230 KerberosConstants.KRB_SAFE_BODY_SEQ_NUMBER_TAG, 231 new CheckNotNullLength<KrbSafeBodyContainer>() ); 232 233 // -------------------------------------------------------------------------------------------- 234 // Transition from user-data value to s-address tag 235 // -------------------------------------------------------------------------------------------- 236 // KRB-SAFE-BODY ::= SEQUENCE { 237 // s-address [4] 238 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG] = 239 new GrammarTransition<KrbSafeBodyContainer>( 240 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USER_DATA_STATE, 241 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SENDER_ADDRESS_TAG_STATE, 242 KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG, 243 new StoreSenderAddress() ); 244 245 // -------------------------------------------------------------------------------------------- 246 // Transition from usec value to s-address tag 247 // -------------------------------------------------------------------------------------------- 248 // KRB-SAFE-BODY ::= SEQUENCE { 249 // s-address [4] 250 super.transitions[KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_STATE.ordinal()][KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG] = 251 new GrammarTransition<KrbSafeBodyContainer>( 252 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_USEC_STATE, 253 KrbSafeBodyStatesEnum.KRB_SAFE_BODY_SENDER_ADDRESS_TAG_STATE, 254 KerberosConstants.KRB_SAFE_BODY_SENDER_ADDRESS_TAG, 255 new StoreSenderAddress() ); 256 } 257 258 259 /** 260 * Get the instance of this grammar 261 * 262 * @return An instance on the KRB-SAFE-BODY Grammar 263 */ 264 public static Grammar<KrbSafeBodyContainer> getInstance() 265 { 266 return instance; 267 } 268}