directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From elecha...@apache.org
Subject svn commit: r161400 [2/2] - in directory/sandbox/trunk/asn1-new-codec/src/java/org/apache/asn1/ldap/codec/grammars: ./ BindRequestGrammar.java BindResponseGrammar.java LdapControlGrammar.java LdapMessageGrammar.java LdapResultGrammar.java
Date Fri, 15 Apr 2005 05:42:24 GMT
Added: directory/sandbox/trunk/asn1-new-codec/src/java/org/apache/asn1/ldap/codec/grammars/LdapResultGrammar.java
URL: http://svn.apache.org/viewcvs/directory/sandbox/trunk/asn1-new-codec/src/java/org/apache/asn1/ldap/codec/grammars/LdapResultGrammar.java?view=auto&rev=161400
==============================================================================
--- directory/sandbox/trunk/asn1-new-codec/src/java/org/apache/asn1/ldap/codec/grammars/LdapResultGrammar.java
(added)
+++ directory/sandbox/trunk/asn1-new-codec/src/java/org/apache/asn1/ldap/codec/grammars/LdapResultGrammar.java
Thu Apr 14 22:42:23 2005
@@ -0,0 +1,585 @@
+/*
+ *   Copyright 2005 The Apache Software Foundation
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+package org.apache.asn1.ldap.codec.grammars;
+
+import org.apache.asn1.ber.containers.IAsn1Container;
+import org.apache.asn1.ber.grammar.AbstractGrammar;
+import org.apache.asn1.ber.grammar.GrammarAction;
+import org.apache.asn1.ber.grammar.GrammarTransition;
+import org.apache.asn1.ber.grammar.IGrammar;
+import org.apache.asn1.ber.grammar.StatesEnum;
+import org.apache.asn1.ber.tlv.TLV;
+import org.apache.asn1.ber.tlv.Value;
+import org.apache.asn1.ldap.codec.DecoderException;
+import org.apache.asn1.ldap.codec.LdapMessageContainer;
+import org.apache.asn1.ldap.codec.primitives.LdapDN;
+import org.apache.asn1.ldap.codec.primitives.LdapString;
+import org.apache.asn1.ldap.codec.utils.IntegerDecoder;
+import org.apache.asn1.ldap.codec.utils.LdapResultEnum;
+import org.apache.asn1.ldap.pojo.BindResponsePOJO;
+import org.apache.asn1.ldap.pojo.LdapMessagePOJO;
+import org.apache.asn1.ldap.pojo.LdapResultPOJO;
+import org.apache.asn1.util.MutableString;
+import org.apache.asn1.util.pools.PoolEnum;
+import org.apache.asn1.util.pools.PoolException;
+
+import org.apache.log4j.Logger;
+
+
+/**
+ * This class implements the LdapMessage. All the actions are declared in this
+ * class. As it is a singleton, these declaration are only done once.
+ * 
+ * If an action is to be added or modified, this is where the work is to be done !
+ * 
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+public class LdapResultGrammar extends AbstractGrammar implements IGrammar
+{
+    //~ Static fields/initializers -----------------------------------------------------------------
+
+    /** The logger */
+    private static final Logger log = Logger.getLogger( LdapResultGrammar.class );
+
+    /** Logging speed up  */
+    private static final boolean DEBUG = log.isDebugEnabled();
+
+    /** The instance of grammar. LdapMessage is a singleton */
+    private static IGrammar instance = new LdapResultGrammar();
+
+    //~ Constructors -------------------------------------------------------------------------------
+
+    /**
+     * Creates a new LdapMessageGrammar object.
+     */
+    private LdapResultGrammar()
+    {
+        name              = LdapResultGrammar.class.getName();
+
+        super.transitions = new GrammarTransition[StatesEnum.LDAP_RESULT_LAST_STATE][256];
+
+        //============================================================================================
+        // LdapResult
+        //============================================================================================
+        // LDAPResult --> SEQUENCE {
+        //    resultCode    ENUMERATED { ... (Tag)
+        // We have a LDAPResult, and the tag may be 0x0A
+        // Nothing to do
+        super.transitions[StatesEnum.LDAP_RESULT_CODE_TAG][0x0A] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_CODE_TAG, StatesEnum.LDAP_RESULT_CODE_LENGTH, null
);
+
+        // LDAPResult --> SEQUENCE {
+        //    resultCode    ENUMERATED { ... (Length)
+        //   let's check the length
+        super.transitions[StatesEnum.LDAP_RESULT_CODE_LENGTH][0x0A] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_CODE_LENGTH, StatesEnum.LDAP_RESULT_CODE_VALUE,
+                new GrammarAction( "LdapResult Length" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        // We have to store the expected Length of the PDU
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+
+                        // We have to allocate a LdapResultPOJO now
+                        LdapResultPOJO ldapResult = null;
+
+                        try
+                        {
+                            ldapResult = ( LdapResultPOJO ) ( ldapMessageContainer.getPoolManager()
+                                    .allocate( PoolEnum.LDAP_RESULT_POJO_POOL ) );
+                            bindResponse.setLdapResult( ldapResult );
+                        }
+                        catch ( PoolException pe )
+                        {
+                            throw new DecoderException(
+                                "Cannot allocate a LdapResult Pojo : " + pe.getMessage()
);
+                        }
+
+                        TLV tlv = ldapMessageContainer.getCurrentTLV();
+
+                        ldapResult.setExpectedLength( tlv.getLength().getLength() );
+                        ldapResult.setCurrentLength( 0 );
+                        ldapResult.setFather( bindResponse );
+
+                        checkLength( bindResponse, tlv );
+
+                        return;
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    resultCode    ENUMERATED { ... (Value)
+        // The result code. The different values are :
+        //  success                      (0),
+        //  operationsError              (1),
+        //  protocolError                (2),
+        //  timeLimitExceeded            (3),
+        //  sizeLimitExceeded            (4),
+        //  compareFalse                 (5),
+        //  compareTrue                  (6),
+        //  authMethodNotSupported       (7),
+        //  strongAuthRequired           (8),
+        //  -- 9 reserved --
+        //  referral                     (10),  -- new
+        //  adminLimitExceeded           (11),  -- new
+        //  unavailableCriticalExtension (12),  -- new
+        //  confidentialityRequired      (13),  -- new
+        //  saslBindInProgress           (14),  -- new
+        //  noSuchAttribute              (16),
+        //  undefinedAttributeType       (17),
+        //  inappropriateMatching        (18),
+        //  constraintViolation          (19),
+        //  attributeOrValueExists       (20),
+        //  invalidAttributeSyntax       (21),
+        //  -- 22-31 unused --
+        //  noSuchObject                 (32),
+        //  aliasProblem                 (33),
+        //  invalidDNSyntax              (34),
+        //  -- 35 reserved for undefined isLeaf --
+        //  aliasDereferencingProblem    (36),
+        //  -- 37-47 unused --
+        //  inappropriateAuthentication  (48),
+        //  invalidCredentials           (49),
+        //  insufficientAccessRights     (50),
+        //  busy                         (51),
+        //  unavailable                  (52),
+        //  unwillingToPerform           (53),
+        //  loopDetect                   (54),
+        //  -- 55-63 unused --
+        //  namingViolation              (64),
+        //  objectClassViolation         (65),
+        //  notAllowedOnNonLeaf          (66),
+        //  notAllowedOnRDN              (67),
+        //  entryAlreadyExists           (68),
+        //  objectClassModsProhibited    (69),
+        //  -- 70 reserved for CLDAP --
+        //  affectsMultipleDSAs          (71), -- new
+        //  -- 72-79 unused --
+        //  other                        (80) },
+        //  -- 81-90 reserved for APIs --
+        //
+        super.transitions[StatesEnum.LDAP_RESULT_CODE_VALUE][0x0A] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_CODE_VALUE, StatesEnum.LDAP_RESULT_MATCHED_DN_TAG,
+                new GrammarAction( "Store resultCode" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          =
+                            ldapMessageContainer.getLdapMessage();
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        // We don't have to allocate a LdapResultPOJO first.
+
+                        // The current TLV should be a integer
+                        // We get it and store it in MessageId
+                        TLV   tlv        = ldapMessageContainer.getCurrentTLV();
+
+                        Value value      = tlv.getValue();
+
+                        int   resultCode = IntegerDecoder.parse( value, 0, 90 );
+
+                        // Treat the 'normal' cases !
+                        switch ( resultCode )
+                        {
+
+                            case LdapResultEnum.SUCCESS :
+                            case LdapResultEnum.OPERATIONS_ERROR :
+                            case LdapResultEnum.PROTOCOL_ERROR :
+                            case LdapResultEnum.TIME_LIMIT_EXCEEDED :
+                            case LdapResultEnum.SIZE_LIMIT_EXCEEDED :
+                            case LdapResultEnum.COMPARE_FALSE :
+                            case LdapResultEnum.COMPARE_TRUE :
+                            case LdapResultEnum.AUTH_METHOD_NOT_SUPPORTED :
+                            case LdapResultEnum.STRONG_AUTH_REQUIRED :
+                            case LdapResultEnum.REFERRAL :
+                            case LdapResultEnum.ADMIN_LIMIT_EXCEEDED :
+                            case LdapResultEnum.UNAVAILABLE_CRITICAL_EXTENSION :
+                            case LdapResultEnum.CONFIDENTIALITY_REQUIRED :
+                            case LdapResultEnum.SASL_BIND_IN_PROGRESS :
+                            case LdapResultEnum.NO_SUCH_ATTRIBUTE :
+                            case LdapResultEnum.UNDEFINED_ATTRIBUTE_TYPE :
+                            case LdapResultEnum.INAPPROPRIATE_MATCHING :
+                            case LdapResultEnum.CONSTRAINT_VIOLATION :
+                            case LdapResultEnum.ATTRIBUTE_OR_VALUE_EXISTS :
+                            case LdapResultEnum.INVALID_ATTRIBUTE_SYNTAX :
+                            case LdapResultEnum.NO_SUCH_OBJECT :
+                            case LdapResultEnum.ALIAS_PROBLEM :
+                            case LdapResultEnum.INVALID_DN_SYNTAX :
+                            case LdapResultEnum.ALIAS_DEREFERENCING_PROBLEM :
+                            case LdapResultEnum.INAPPROPRIATE_AUTHENTICATION :
+                            case LdapResultEnum.INVALID_CREDENTIALS :
+                            case LdapResultEnum.INSUFFICIENT_ACCESS_RIGHTS :
+                            case LdapResultEnum.BUSY :
+                            case LdapResultEnum.UNAVAILABLE :
+                            case LdapResultEnum.UNWILLING_TO_PERFORM :
+                            case LdapResultEnum.LOOP_DETECT :
+                            case LdapResultEnum.NAMING_VIOLATION :
+                            case LdapResultEnum.OBJECT_CLASS_VIOLATION :
+                            case LdapResultEnum.NOT_ALLOWED_ON_NON_LEAF :
+                            case LdapResultEnum.NOT_ALLOWED_ON_RDN :
+                            case LdapResultEnum.ENTRY_ALREADY_EXISTS :
+                            case LdapResultEnum.AFFECTS_MULTIPLE_DSAS :
+                                ldapResult.setResultCode( resultCode );
+                                break;
+
+                            default :
+                                throw new DecoderException(
+                                    "Error <" + LdapResultEnum.errorCode( resultCode )
+
+                                    "> not allowed" );
+                        }
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    matchedDN   LDAPDN, (Tag)
+        // The tag is 0x04. Nothing to do
+        super.transitions[StatesEnum.LDAP_RESULT_MATCHED_DN_TAG][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_MATCHED_DN_TAG, StatesEnum.LDAP_RESULT_MATCHED_DN_LENGTH,
+                null );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    matchedDN   LDAPDN, (Length)
+        // The tag is 0x04. We have to check the Length
+        super.transitions[StatesEnum.LDAP_RESULT_MATCHED_DN_LENGTH][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_MATCHED_DN_LENGTH, StatesEnum.LDAP_RESULT_MATCHED_DN_VALUE,
+                new GrammarAction( "Ldap Result Matched DN lentgh control" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        TLV                  tlv                  =
+                            ldapMessageContainer.getCurrentTLV();
+
+                        checkLength( bindResponse, tlv );
+                        
+                        // We have to handle the special case of a 0 length matched DN
+                        if (tlv.getLength().getLength() == 0)
+                        {
+                            ldapResult.setMatchedDN( MutableString.EMPTY_STRING );
+                        }
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    matchedDN   LDAPDN, (Value)
+        // We store the LDAPDN after having checked that it is valid.
+        super.transitions[StatesEnum.LDAP_RESULT_MATCHED_DN_VALUE][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_MATCHED_DN_VALUE, StatesEnum.LDAP_RESULT_ERROR_MESSAGE_TAG,
+                new GrammarAction( "Store Ldap Result matched DN" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        // Get the Value and store it in the BindResponse
+                        TLV           tlv       = ldapMessageContainer.getCurrentTLV();
+
+                        MutableString matchedDN = LdapDN.parseDN(
+                                ldapMessageContainer.getPoolManager(), tlv.getValue().getData()
);
+                        ldapResult.setMatchedDN( matchedDN );
+                        return;
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    errorMessage   LDAPString, (Tag)
+        // The tag is 0x04. Nothing to do
+        super.transitions[StatesEnum.LDAP_RESULT_ERROR_MESSAGE_TAG][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_ERROR_MESSAGE_TAG,
+                StatesEnum.LDAP_RESULT_ERROR_MESSAGE_LENGTH, null );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    errorMessage   LDAPString, (Length)
+        // The tag is 0x04. We have to check the Length
+        super.transitions[StatesEnum.LDAP_RESULT_ERROR_MESSAGE_LENGTH][0x04] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_ERROR_MESSAGE_LENGTH,
+                StatesEnum.LDAP_RESULT_ERROR_MESSAGE_VALUE,
+                new GrammarAction( "Ldap Result error message length control" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        TLV                  tlv                  =
+                            ldapMessageContainer.getCurrentTLV();
+
+                        checkLength( bindResponse, tlv );
+                        
+                        // We have to handle the special case of a 0 length error message
+                        if (tlv.getLength().getLength() == 0)
+                        {
+                            ldapResult.setErrorMessage( MutableString.EMPTY_STRING );
+                        }
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    errorMessage   LDAPString, (Value)
+        // Stores the value.
+        super.transitions[StatesEnum.LDAP_RESULT_ERROR_MESSAGE_VALUE][0x04] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_ERROR_MESSAGE_VALUE,
+                StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
+                new GrammarAction( "Store Ldap Result error message" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        // Get the Value and store it in the BindResponse
+                        TLV           tlv          = ldapMessageContainer.getCurrentTLV();
+
+                        MutableString errorMessage = LdapString.parse(
+                                ldapMessageContainer.getPoolManager(), tlv.getValue().getData()
);
+                        ldapResult.setErrorMessage( errorMessage );
+                        return;
+                    }
+                } );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    referral   [3] Referral OPTIONAL } (Tag)
+        //
+        // The next state could be one of the following :
+        //  - 0x80 : a control, like in SearchResultDone, ModifyResponse, AddResponse, DelResponse,
ModifyDNResponse, CompareResponse
+        //  - 0x83 : a referral, in a LdapResult.
+        //  - 0x87 : a serverSaslCreds, in a BindResponse
+        //  - 0x8A : an extended response
+        //  - GRAMMAR_END : this is implicitly deducted by the fact that we don't have anymore
byte...
+        //
+        // We don't deal with all of this values, we just have to treat the 0x83, because
+        // referral is a part of the LdapResult grammar. In all other cases, we just quit
+        // the grammar.
+        //
+        // This is a control. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG][0x80] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+        // This is a referral.
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG][0x83] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
+                StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_LENGTH, null );
+
+        // This is a serverSaslCreds. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG][0x87] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+        // This is a extended response. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG][0x8A] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+        // LDAPResult --> SEQUENCE {
+        //    ...
+        //    referral   [3] Referral OPTIONAL } (Length)
+        // We just check the length, and store the new expected length. As this is a sequence,
we don't have any value, so we
+        // transit to the REFERRAL_TAG.
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_LENGTH][0x83] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_LENGTH,
+                StatesEnum.LDAP_RESULT_REFERRAL_TAG,
+                new GrammarAction( "Ldap Result referrals length control" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        TLV                  tlv                  =
+                            ldapMessageContainer.getCurrentTLV();
+
+                        checkLength( bindResponse, tlv );
+
+                        // We will use the LdapString POJO to check the expected length of
the following
+                        // referrals. This is quite a trick, but as this POJO's expected
length is never
+                        // used, it's just ok.
+                        ldapResult.setExpectedLength( ldapMessageContainer.getCurrentTLV()
+                            .getLength().getLength() );
+                        ldapResult.setCurrentLength( 0 );
+
+                    }
+                } );
+
+        // Referral ::= SEQUENCE OF LDAPURL (Tag)
+        // This is a SEQUENCE, we will have at least one referral, but may be many.
+        // As this is the tag, we don't have anything to do.
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_TAG][0x04]    = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_REFERRAL_TAG, StatesEnum.LDAP_RESULT_REFERRAL_LENGTH,
null );
+
+        // Referral ::= SEQUENCE OF LDAPURL (Length)
+        // This is a SEQUENCE, we will have at least one referral, but may be many.
+        // We will check the length.
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_LENGTH][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_REFERRAL_LENGTH, StatesEnum.LDAP_RESULT_REFERRAL_VALUE,
+                new GrammarAction( "Ldap Result referral length control" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        TLV                  tlv                  =
+                            ldapMessageContainer.getCurrentTLV();
+
+                        checkLength( ldapResult, tlv );
+
+                        // We have to handle the special case of a 0 length referral
+                        if (tlv.getLength().getLength() == 0)
+                        {
+                            ldapResult.addReferral( MutableString.EMPTY_STRING );
+                        }
+                    }
+                } );
+        
+        // Referral ::= SEQUENCE OF LDAPURL (Length)
+        // We may have other referrals, but wa may also have finished to read the LdapResult.
+        // To handle those different cases, we have to transit to a special state, which
+        // will do this brancing.
+        // Here, we store the referral in the ldapResult.
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_VALUE][0x04] = new GrammarTransition(
+                StatesEnum.LDAP_RESULT_REFERRAL_LENGTH, StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG,
+                new GrammarAction( "Store Ldap Result referral" )
+                {
+                    public void action( IAsn1Container container ) throws DecoderException
+                    {
+
+                        LdapMessageContainer ldapMessageContainer = ( LdapMessageContainer
)
+                            container;
+                        LdapMessagePOJO      ldapMessage          = ( LdapMessagePOJO )
+                            ( ldapMessageContainer.getLdapMessage() );
+                        BindResponsePOJO     bindResponse         = ( BindResponsePOJO )
+                            ( ldapMessage.getProtocolOp() );
+                        LdapResultPOJO       ldapResult           = ( LdapResultPOJO )
+                            ( bindResponse.getLdapResult() );
+
+                        TLV                  tlv                  =
+                            ldapMessageContainer.getCurrentTLV();
+
+                        MutableString referral = LdapString.parse(
+                                ldapMessageContainer.getPoolManager(), tlv.getValue().getData()
);
+                        ldapResult.addReferral( referral );
+                    }
+                } );
+
+        // Referral ::= SEQUENCE OF LDAPURL (Tag)
+        // We may have another referral, but we could also have something else : 
+        //  - 0x04 : a referral, in a LdapResult.
+        //  - 0x80 : a control, like in SearchResultDone, ModifyResponse, AddResponse, DelResponse,
ModifyDNResponse, CompareResponse
+        //  - 0x87 : a serverSaslCreds, in a BindResponse
+        //  - 0x8A : an extended response
+        //  - GRAMMAR_END : this is implicitly deducted by the fact that we don't have anymore
byte...
+        // Those different cases are handled here.
+        
+        // This is a referral. We have to transit to its Length state
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG][0x04] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG,
+                StatesEnum.LDAP_RESULT_REFERRAL_SEQUENCE_LENGTH, null );
+
+        // This is a control. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG][0x80] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+        // This is a serverSaslCreds. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG][0x87] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+        // This is a extended response. We have to quit the LdapResult grammar
+        super.transitions[StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG][0x8A] =
+            new GrammarTransition( StatesEnum.LDAP_RESULT_REFERRAL_LOOP_TAG,
+                StatesEnum.GRAMMAR_END, null );
+
+    }
+
+    //~ Methods ------------------------------------------------------------------------------------
+
+    /**
+     * This class is a singleton.
+     *
+     * @return An instance on this grammar
+     */
+    public static IGrammar getInstance()
+    {
+        return instance;
+    }
+}



Mime
View raw message