// ...
//
// Stores the matched Dn
super.transitions[LdapStatesEnum.RESULT_CODE_BR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.RESULT_CODE_BR_STATE, LdapStatesEnum.MATCHED_DN_BR_STATE, UniversalTag.OCTET_STRING.getValue(),
new MatchedDNAction() );
// --------------------------------------------------------------------------------------------
// Transition from Matched Dn BR to Error Message BR
// --------------------------------------------------------------------------------------------
// LDAPResult ::= SEQUENCE {
// ...
// errorMessage LDAPString,
// ...
//
// Stores the error message
super.transitions[LdapStatesEnum.MATCHED_DN_BR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MATCHED_DN_BR_STATE, LdapStatesEnum.ERROR_MESSAGE_BR_STATE, UniversalTag.OCTET_STRING.getValue(),
new ErrorMessageAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message BR to Server SASL credentials
// --------------------------------------------------------------------------------------------
// BindResponse ::= APPLICATION 1] SEQUENCE {
// ...
// serverSaslCreds [7] OCTET STRING OPTIONAL }
//
// Stores the sasl credentials
super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.SERVER_SASL_CREDENTIAL_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_BR_STATE, LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE,
LdapConstants.SERVER_SASL_CREDENTIAL_TAG, new ServerSASLCredsAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message BR to Referrals BR
// --------------------------------------------------------------------------------------------
// LDAPResult ::= SEQUENCE {
// ...
// referral [3] Referral OPTIONNAL }
//
// Initialiaze the referrals list
super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_BR_STATE, LdapStatesEnum.REFERRALS_BR_STATE,
LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG, new InitReferralsAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referrals BR to Referral BR
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Add a first Referral
super.transitions[LdapStatesEnum.REFERRALS_BR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRALS_BR_STATE, LdapStatesEnum.REFERRAL_BR_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral BR to Referral BR
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRAL_BR_STATE, LdapStatesEnum.REFERRAL_BR_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral BR to Server SASL Credentials
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][LdapConstants.SERVER_SASL_CREDENTIAL_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_BR_STATE, LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE,
LdapConstants.SERVER_SASL_CREDENTIAL_TAG, new ServerSASLCredsAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral BR to Controls
// --------------------------------------------------------------------------------------------
// bindResponse BindResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_BR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_BR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message BR to controls
// --------------------------------------------------------------------------------------------
// bindResponse BindResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
//
super.transitions[LdapStatesEnum.ERROR_MESSAGE_BR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_BR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Server SASL credentials to Controls
// --------------------------------------------------------------------------------------------
// bindResponse BindResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
super.transitions[LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.SERVER_SASL_CREDENTIALS_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Result Code to Matched Dn
// --------------------------------------------------------------------------------------------
// LDAPResult ::= SEQUENCE {
// ...
// matchedDN LDAPDN,
// ...
//
// Stores the matched Dn
super.transitions[LdapStatesEnum.RESULT_CODE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.RESULT_CODE_STATE, LdapStatesEnum.MATCHED_DN_STATE, UniversalTag.OCTET_STRING.getValue(),
new MatchedDNAction() );
// --------------------------------------------------------------------------------------------
// Transition from Matched Dn to Error Message
// --------------------------------------------------------------------------------------------
// LDAPResult ::= SEQUENCE {
// ...
// errorMessage LDAPString,
// ...
//
// Stores the error message
super.transitions[LdapStatesEnum.MATCHED_DN_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MATCHED_DN_STATE, LdapStatesEnum.ERROR_MESSAGE_STATE, UniversalTag.OCTET_STRING.getValue(),
new ErrorMessageAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message to Referrals
// --------------------------------------------------------------------------------------------
// LDAPResult ::= SEQUENCE {
// ...
// referral [3] Referral OPTIONNAL }
//
// Initialize the referrals list
super.transitions[LdapStatesEnum.ERROR_MESSAGE_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_STATE, LdapStatesEnum.REFERRALS_STATE,
LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG, new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Init referrals list" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
TLV tlv = container.getCurrentTLV();
// If we have a Referrals sequence, then it should not be empty
// sasl credentials
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04080 );
LOG.error( msg );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
Message response = container.getMessage();
LdapResult ldapResult = ( ( ResultResponse ) response ).getLdapResult();
Referral referral = new ReferralImpl();
ldapResult.setReferral( referral );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from Referrals to Referral
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Add a first Referral
super.transitions[LdapStatesEnum.REFERRALS_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRALS_STATE, LdapStatesEnum.REFERRAL_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral to Referral
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRAL_STATE, LdapStatesEnum.REFERRAL_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral to Controls
// --------------------------------------------------------------------------------------------
// xxxResponse xxxResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message to controls
// --------------------------------------------------------------------------------------------
// xxxResponse xxxResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
//
super.transitions[LdapStatesEnum.ERROR_MESSAGE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from MessageId to SearchResultEntry Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultEntry ...
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
//
// Initialize the searchResultEntry object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_ENTRY_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE,
LdapConstants.SEARCH_RESULT_ENTRY_TAG, new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Init SearchResultEntry" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container )
{
// Now, we can allocate the SearchResultEntry Object
SearchResultEntryDecorator searchResultEntry = new SearchResultEntryDecorator(
container.getLdapCodecService(), new SearchResultEntryImpl( container.getMessageId() ) );
container.setMessage( searchResultEntry );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from SearchResultEntry Message to ObjectName
// --------------------------------------------------------------------------------------------
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
// objectName LDAPDN,
// ...
//
// Store the object name.
super.transitions[LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.SEARCH_RESULT_ENTRY_STATE, LdapStatesEnum.OBJECT_NAME_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<SearchResultEntryDecorator>>( "Store search result entry object name Value" )
{
public void action( LdapMessageContainer<SearchResultEntryDecorator> container ) throws DecoderException
{
SearchResultEntryDecorator searchResultEntry = container.getMessage();
TLV tlv = container.getCurrentTLV();
Dn objectName = Dn.EMPTY_DN;
// Store the value.
if ( tlv.getLength() == 0 )
{
searchResultEntry.setObjectName( objectName );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
objectName = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
// This is for the client side. We will never decode LdapResult on the server
String msg = "The Dn " + Strings.dumpBytes(dnBytes) + "is invalid : "
+ ine.getMessage();
LOG.error( "{} : {}", msg, ine.getMessage() );
throw new DecoderException( msg, ine );
}
searchResultEntry.setObjectName( objectName );
}
if ( IS_DEBUG )
{
LOG.debug( "Search Result Entry Dn found : {}", searchResultEntry.getObjectName() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ObjectName to AttributesSR
// --------------------------------------------------------------------------------------------
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
// ...
// attributes PartialAttributeList }
//
// PartialAttributeList ::= *SEQUENCE* OF SEQUENCE {
// ...
//
// We may have no attributes. Just allows the grammar to end
super.transitions[LdapStatesEnum.OBJECT_NAME_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.OBJECT_NAME_STATE, LdapStatesEnum.ATTRIBUTES_SR_STATE, UniversalTag.SEQUENCE.getValue(),
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Pop and end allowed" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
container.setGrammarEndAllowed( true );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from AttributesSR to PartialAttributesList
// --------------------------------------------------------------------------------------------
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
// ...
// attributes PartialAttributeList }
//
// PartialAttributeList ::= SEQUENCE OF *SEQUENCE* {
// ...
//
// nothing to do
super.transitions[LdapStatesEnum.ATTRIBUTES_SR_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTES_SR_STATE, LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from AttributesSR to Controls
// --------------------------------------------------------------------------------------------
// searchResultEntry SearchResultEntry,
// ... },
// controls [0] Controls OPTIONAL }
//
// Initialize the controls
super.transitions[LdapStatesEnum.ATTRIBUTES_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTES_SR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from PartialAttributesList to typeSR
// --------------------------------------------------------------------------------------------
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
// ...
// attributes PartialAttributeList }
//
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// type AttributeDescription,
// ...
//
// Store the attribute's name.
super.transitions[LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE, LdapStatesEnum.TYPE_SR_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<SearchResultEntryDecorator>>( "Store search result entry object name Value" )
{
public void action( LdapMessageContainer<SearchResultEntryDecorator> container ) throws DecoderException
{
SearchResultEntryDecorator searchResultEntry = container.getMessage();
TLV tlv = container.getCurrentTLV();
String type = "";
// Store the name
if ( tlv.getLength() == 0 )
{
// The type can't be null
String msg = I18n.err( I18n.ERR_04081 );
LOG.error( msg );
throw new DecoderException( msg );
}
else
{
type = getType(tlv.getValue().getData());
try
{
searchResultEntry.addAttribute( type );
}
catch ( LdapException ine )
{
// This is for the client side. We will never decode LdapResult on the server
String msg = "The Attribute type " + type + "is invalid : " + ine.getMessage();
LOG.error( "{} : {}", msg, ine.getMessage() );
throw new DecoderException( msg, ine );
}
}
if ( IS_DEBUG )
{
LOG.debug( "Attribute type : {}", type );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from typeSR to ValsSR
// --------------------------------------------------------------------------------------------
// SearchResultEntry ::= [APPLICATION 4] SEQUENCE { ...
// ...
// attributes PartialAttributeList }
//
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// We may have no value. Just allows the grammar to end
super.transitions[LdapStatesEnum.TYPE_SR_STATE.ordinal()][UniversalTag.SET.getValue()] = new GrammarTransition(
LdapStatesEnum.TYPE_SR_STATE, LdapStatesEnum.VALS_SR_STATE, UniversalTag.SET.getValue(),
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Grammar end allowed" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
container.setGrammarEndAllowed( true );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ValsSR to AttributeValueSR
// --------------------------------------------------------------------------------------------
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Store the attribute value
super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.VALS_SR_STATE, LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE, UniversalTag.OCTET_STRING.getValue(),
new SearchResultAttributeValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from ValsSR to PartialAttributesList
// --------------------------------------------------------------------------------------------
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// Loop when we don't have any attribute value. Nothing to do
super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.VALS_SR_STATE, LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from ValsSR to Controls
// --------------------------------------------------------------------------------------------
// searchResultEntry SearchResultEntry,
// ... },
// controls [0] Controls OPTIONAL }
//
// Initialize the controls
super.transitions[LdapStatesEnum.VALS_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.VALS_SR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from AttributeValueSR to AttributeValueSR
// --------------------------------------------------------------------------------------------
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Store the attribute value
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE, LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE,
UniversalTag.OCTET_STRING.getValue(), new SearchResultAttributeValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from AttributeValueSR to PartialAttributesList
// --------------------------------------------------------------------------------------------
// PartialAttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// Loop when we don't have any attribute value. Nothing to do
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE, LdapStatesEnum.PARTIAL_ATTRIBUTES_LIST_STATE,
UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from AttributeValueSR to Controls
// --------------------------------------------------------------------------------------------
// searchResultEntry SearchResultEntry,
// ... },
// controls [0] Controls OPTIONAL }
//
// Initialize the controls
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_SR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// SearchResultDone Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultDone ...
// SearchResultDone ::= [APPLICATION 5] SEQUENCE { ...
//
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_DONE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.SEARCH_RESULT_DONE_STATE,
LdapConstants.SEARCH_RESULT_DONE_TAG, new GrammarAction<LdapMessageContainer<SearchResultDoneDecorator>>( "Init search Result Done" )
{
public void action( LdapMessageContainer<SearchResultDoneDecorator> container )
{
// Now, we can allocate the SearchResultDone Object
SearchResultDoneDecorator searchResultDone = new SearchResultDoneDecorator(
container.getLdapCodecService(), new SearchResultDoneImpl( container.getMessageId() ) );
container.setMessage( searchResultDone );
LOG.debug( "Search Result Done found" );
}
} );
// --------------------------------------------------------------------------------------------
// SearchResultDone Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultDone ...
// SearchResultDone ::= [APPLICATION 5] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.SEARCH_RESULT_DONE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.SEARCH_RESULT_DONE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// Transition from Message ID to ModifyRequest Message
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ModifyRequest ...
// ModifyRequest ::= [APPLICATION 6] SEQUENCE { ...
//
// Creates the Modify Request object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.MODIFY_REQUEST_STATE, LdapConstants.MODIFY_REQUEST_TAG,
new GrammarAction<LdapMessageContainer<ModifyRequestDecorator>>( "Init ModifyRequest" )
{
public void action( LdapMessageContainer<ModifyRequestDecorator> container )
{
// Now, we can allocate the ModifyRequest Object
ModifyRequest modifyRequest = new ModifyRequestImpl( container.getMessageId() );
ModifyRequestDecorator modifyRequestDecorator = new ModifyRequestDecorator(
container.getLdapCodecService(), modifyRequest );
container.setMessage( modifyRequestDecorator );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ModifyRequest Message to Object
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// object LDAPDN,
// ...
//
// Stores the object Dn
super.transitions[LdapStatesEnum.MODIFY_REQUEST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFY_REQUEST_STATE, LdapStatesEnum.OBJECT_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<ModifyRequestDecorator>>( "Store Modify request object Value" )
{
public void action( LdapMessageContainer<ModifyRequestDecorator> container ) throws DecoderException
{
ModifyRequestDecorator modifyRequestDecorator = container.getMessage();
ModifyRequest modifyRequest = modifyRequestDecorator.getDecorated();
TLV tlv = container.getCurrentTLV();
Dn object = Dn.EMPTY_DN;
// Store the value.
if ( tlv.getLength() == 0 )
{
((ModifyRequest)modifyRequestDecorator.getDecorated()).setName( object );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
object = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid Dn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
ModifyResponseImpl response = new ModifyResponseImpl( modifyRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
Dn.EMPTY_DN, ine );
}
modifyRequest.setName( object );
}
if ( IS_DEBUG )
{
LOG.debug( "Modification of Dn {}", modifyRequest.getName() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from Object to modifications
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification *SEQUENCE OF* SEQUENCE {
// ...
//
// Initialize the modifications list
super.transitions[LdapStatesEnum.OBJECT_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.OBJECT_STATE, LdapStatesEnum.MODIFICATIONS_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from modifications to modification sequence
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF *SEQUENCE* {
// ...
//
// Nothing to do
super.transitions[LdapStatesEnum.MODIFICATIONS_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFICATIONS_STATE, LdapStatesEnum.MODIFICATIONS_SEQ_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from modification sequence to operation
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// operation ENUMERATED {
// ...
//
// Store operation type
super.transitions[LdapStatesEnum.MODIFICATIONS_SEQ_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFICATIONS_SEQ_STATE, LdapStatesEnum.OPERATION_STATE, UniversalTag.ENUMERATED.getValue(),
new GrammarAction<LdapMessageContainer<ModifyRequestDecorator>>( "Store operation type" )
{
public void action( LdapMessageContainer<ModifyRequestDecorator> container ) throws DecoderException
{
ModifyRequestDecorator modifyRequestDecorator = container.getMessage();
TLV tlv = container.getCurrentTLV();
// Decode the operation type
int operation = 0;
try
{
operation = IntegerDecoder.parse( tlv.getValue(), 0, 2 );
}
catch ( IntegerDecoderException ide )
{
String msg = I18n.err( I18n.ERR_04082, Strings.dumpBytes(tlv.getValue().getData()) );
LOG.error( msg );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
// Store the current operation.
modifyRequestDecorator.setCurrentOperation( operation );
if ( IS_DEBUG )
{
switch ( operation )
{
case LdapConstants.OPERATION_ADD:
LOG.debug( "Modification operation : ADD" );
break;
case LdapConstants.OPERATION_DELETE:
LOG.debug( "Modification operation : DELETE" );
break;
case LdapConstants.OPERATION_REPLACE:
LOG.debug( "Modification operation : REPLACE" );
break;
}
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from operation to modification
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
//
// Nothing to do
super.transitions[LdapStatesEnum.OPERATION_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.OPERATION_STATE, LdapStatesEnum.MODIFICATION_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from modification to TypeMod
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// type AttributeDescription,
// ...
//
// Stores the type
super.transitions[LdapStatesEnum.MODIFICATION_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFICATION_STATE, LdapStatesEnum.TYPE_MOD_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<ModifyRequestDecorator>>( "Store type" )
{
public void action( LdapMessageContainer<ModifyRequestDecorator> container ) throws DecoderException
{
ModifyRequestDecorator modifyRequestDecorator = container.getMessage();
ModifyRequest modifyRequest = modifyRequestDecorator.getDecorated();
TLV tlv = container.getCurrentTLV();
// Store the value. It can't be null
String type = null;
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04083 );
LOG.error( msg );
ModifyResponseImpl response = new ModifyResponseImpl( modifyRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX,
modifyRequest.getName(), null );
}
else
{
type = getType(tlv.getValue().getData());
modifyRequestDecorator.addAttributeTypeAndValues( type );
}
if ( IS_DEBUG )
{
LOG.debug( "Modifying type : {}", type );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from TypeMod to vals
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// Initialize the list of values
super.transitions[LdapStatesEnum.TYPE_MOD_STATE.ordinal()][UniversalTag.SET.getValue()] = new GrammarTransition(
LdapStatesEnum.TYPE_MOD_STATE, LdapStatesEnum.VALS_STATE, UniversalTag.SET.getValue(),
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Init Attribute vals" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container )
{
TLV tlv = container.getCurrentTLV();
// If the length is null, we store an empty value
if ( tlv.getLength() == 0 )
{
LOG.debug( "No vals for this attribute" );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
LOG.debug( "Some vals are to be decoded" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from vals to Attribute Value
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Stores a value
super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.VALS_STATE, LdapStatesEnum.ATTRIBUTE_VALUE_STATE, UniversalTag.OCTET_STRING.getValue(),
new ModifyAttributeValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from vals to ModificationsSeq
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF *SEQUENCE* {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Nothing to do
super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.VALS_STATE, LdapStatesEnum.MODIFICATIONS_SEQ_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from vals to Controls
// --------------------------------------------------------------------------------------------
// modifyRequest ModifyRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Nothing to do
super.transitions[LdapStatesEnum.VALS_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.VALS_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Attribute Value to Attribute Value
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF SEQUENCE {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Stores a value
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_STATE, LdapStatesEnum.ATTRIBUTE_VALUE_STATE, UniversalTag.OCTET_STRING.getValue(),
new ModifyAttributeValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from Attribute Value to ModificationsSeq
// --------------------------------------------------------------------------------------------
// ModifyRequest ::= [APPLICATION 6] SEQUENCE {
// ...
// modification SEQUENCE OF *SEQUENCE* {
// ...
// modification AttributeTypeAndValues }
//
// AttributeTypeAndValues ::= SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue ::= OCTET STRING
//
// Nothing to do
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_STATE, LdapStatesEnum.MODIFICATIONS_SEQ_STATE, UniversalTag.SEQUENCE.getValue(),
null );
// --------------------------------------------------------------------------------------------
// Transition from Attribute Value to Controls
// --------------------------------------------------------------------------------------------
// modifyRequest ModifyRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Nothing to do
super.transitions[LdapStatesEnum.ATTRIBUTE_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_VALUE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// ModifyResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ModifyResponse ...
// ModifyResponse ::= [APPLICATION 7] SEQUENCE { ...
// We have to switch to the ModifyResponse grammar
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.MODIFY_RESPONSE_STATE, LdapConstants.MODIFY_RESPONSE_TAG,
new GrammarAction<LdapMessageContainer<ModifyResponseDecorator>>( "Init ModifyResponse" )
{
public void action( LdapMessageContainer<ModifyResponseDecorator> container )
{
// Now, we can allocate the ModifyResponse Object
ModifyResponseDecorator modifyResponse = new ModifyResponseDecorator(
container.getLdapCodecService(), new ModifyResponseImpl( container.getMessageId() ) );
container.setMessage( modifyResponse );
LOG.debug( "Modify response" );
}
} );
// --------------------------------------------------------------------------------------------
// ModifyResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ModifyResponse ...
// ModifyResponse ::= [APPLICATION 7] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.MODIFY_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFY_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// AddRequest Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... AddRequest ...
// AddRequest ::= [APPLICATION 8] SEQUENCE { ...
//
// Initialize the AddRequest object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.ADD_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.ADD_REQUEST_STATE, LdapConstants.ADD_REQUEST_TAG,
new GrammarAction<LdapMessageContainer<AddRequestDecorator>>( "Init addRequest" )
{
public void action( LdapMessageContainer<AddRequestDecorator> container ) throws DecoderException
{
// Now, we can allocate the AddRequest Object
int messageId = container.getMessageId();
AddRequestDecorator addRequest = new AddRequestDecorator(
container.getLdapCodecService(), new AddRequestImpl( messageId ) );
container.setMessage( addRequest );
// We will check that the request is not null
TLV tlv = container.getCurrentTLV();
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04084 );
LOG.error( msg );
// Will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from Add Request to Entry
// --------------------------------------------------------------------------------------------
// AddRequest ::= [APPLICATION 8] SEQUENCE {
// entry LDAPDN,
// ...
//
// Stores the Dn
super.transitions[LdapStatesEnum.ADD_REQUEST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ADD_REQUEST_STATE, LdapStatesEnum.ENTRY_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<AddRequestDecorator>>( "Store add request object Value" )
{
public void action( LdapMessageContainer<AddRequestDecorator> container ) throws DecoderException
{
AddRequestDecorator addRequest = container.getMessage();
TLV tlv = container.getCurrentTLV();
// Store the entry. It can't be null
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04085 );
LOG.error( msg );
AddResponseImpl response = new AddResponseImpl( addRequest.getMessageId() );
// I guess that trying to add an entry which Dn is empty is a naming violation...
// Not 100% sure though ...
throw new ResponseCarryingException( msg, response, ResultCodeEnum.NAMING_VIOLATION,
Dn.EMPTY_DN, null );
}
else
{
Dn entryDn = null;
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
entryDn = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid Dn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
AddResponseImpl response = new AddResponseImpl( addRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
Dn.EMPTY_DN, ine );
}
addRequest.setEntryDn( entryDn );
}
LOG.debug( "Adding an entry with Dn : {}", addRequest.getEntry() );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from Entry to Attributes
// --------------------------------------------------------------------------------------------
// AddRequest ::= [APPLICATION 8] SEQUENCE {
// ...
// attributes AttributeList }
//
// AttributeList ::= SEQUENCE OF ...
//
// Initialize the attribute list
super.transitions[LdapStatesEnum.ENTRY_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ENTRY_STATE, LdapStatesEnum.ATTRIBUTES_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from Attributes to Attribute
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
//
// We don't do anything in this transition. The attribute will be created when we met the type
super.transitions[LdapStatesEnum.ATTRIBUTES_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTES_STATE, LdapStatesEnum.ATTRIBUTE_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from Attribute to type
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
// type AttributeDescription,
// ...
//
// AttributeDescription LDAPString
//
// We store the type in the current attribute
super.transitions[LdapStatesEnum.ATTRIBUTE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_STATE, LdapStatesEnum.TYPE_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<AddRequestDecorator>>( "Store attribute type" )
{
public void action( LdapMessageContainer<AddRequestDecorator> container ) throws DecoderException
{
AddRequestDecorator addRequest = container.getMessage();
TLV tlv = container.getCurrentTLV();
// Store the type. It can't be null.
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04086 );
LOG.error( msg );
AddResponseImpl response = new AddResponseImpl( addRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX,
addRequest.getEntry().getDn(), null );
}
String type = getType(tlv.getValue().getData());
try
{
addRequest.addAttributeType( type );
}
catch ( LdapException ne )
{
String msg = I18n.err( I18n.ERR_04087 );
LOG.error( msg );
AddResponseImpl response = new AddResponseImpl( addRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX,
addRequest.getEntry().getDn(), ne );
}
if ( IS_DEBUG )
{
LOG.debug( "Adding type {}", type );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from type to vals
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// Nothing to do here.
super.transitions[LdapStatesEnum.TYPE_STATE.ordinal()][UniversalTag.SET.getValue()] = new GrammarTransition(
LdapStatesEnum.TYPE_STATE, LdapStatesEnum.VALUES_STATE, UniversalTag.SET.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from vals to Value
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue OCTET STRING
//
// Store the value into the current attribute
super.transitions[LdapStatesEnum.VALUES_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.VALUES_STATE, LdapStatesEnum.VALUE_STATE, UniversalTag.OCTET_STRING.getValue(), new ValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from Value to Value
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
// ...
// vals SET OF AttributeValue }
//
// AttributeValue OCTET STRING
//
// Store the value into the current attribute
super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.VALUE_STATE, LdapStatesEnum.VALUE_STATE, UniversalTag.OCTET_STRING.getValue(), new ValueAction() );
// --------------------------------------------------------------------------------------------
// Transition from Value to Attribute
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
//
// Nothing to do here.
super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.VALUE_STATE, LdapStatesEnum.ATTRIBUTE_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from Value to Controls
// --------------------------------------------------------------------------------------------
// AttributeList ::= SEQUENCE OF SEQUENCE {
//
// Initialize the controls
super.transitions[LdapStatesEnum.VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.VALUE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// AddResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... AddResponse ...
// AddResponse ::= [APPLICATION 9] LDAPResult
//
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.ADD_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.ADD_RESPONSE_STATE, LdapConstants.ADD_RESPONSE_TAG,
new GrammarAction<LdapMessageContainer<AddResponseDecorator>>( "Init AddResponse" )
{
public void action( LdapMessageContainer<AddResponseDecorator> container ) throws DecoderException
{
// Now, we can allocate the AddResponse Object
AddResponseDecorator addResponse = new AddResponseDecorator(
container.getLdapCodecService(), new AddResponseImpl( container.getMessageId() ) );
container.setMessage( addResponse );
// We will check that the request is not null
TLV tlv = container.getCurrentTLV();
int expectedLength = tlv.getLength();
if ( expectedLength == 0 )
{
String msg = I18n.err( I18n.ERR_04088 );
LOG.error( msg );
throw new DecoderException( msg );
}
LOG.debug( "Add Response" );
}
} );
// --------------------------------------------------------------------------------------------
// AddResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... AddResponse ...
// AddResponse ::= [APPLICATION 9] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.ADD_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.ADD_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// DelResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... DelResponse ...
// DelResponse ::= [APPLICATION 11] LDAPResult
// We have to switch to the DelResponse grammar
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.DEL_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.DEL_RESPONSE_STATE, LdapConstants.DEL_RESPONSE_TAG,
new GrammarAction<LdapMessageContainer<DeleteResponseDecorator>>( "Init DelResponse" )
{
public void action( LdapMessageContainer<DeleteResponseDecorator> container )
{
// Now, we can allocate the DelResponse Object
DeleteResponseDecorator delResponse = new DeleteResponseDecorator(
container.getLdapCodecService(), new DeleteResponseImpl( container.getMessageId() ) );
container.setMessage( delResponse );
LOG.debug( "Del response " );
}
} );
// --------------------------------------------------------------------------------------------
// DelResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... DelResponse ...
// DelResponse ::= [APPLICATION 11] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.DEL_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.DEL_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// Transition from MessageID to ModifydDNRequest Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ModifyDNRequest ...
// ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
//
// Create the ModifyDNRequest Object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_DN_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.MODIFY_DN_REQUEST_STATE,
LdapConstants.MODIFY_DN_REQUEST_TAG, new GrammarAction<LdapMessageContainer<ModifyDnRequestDecorator>>( "Init Modify Dn Request" )
{
public void action( LdapMessageContainer<ModifyDnRequestDecorator> container )
{
// Now, we can allocate the ModifyDNRequest Object
ModifyDnRequestDecorator modifyDnRequest = new ModifyDnRequestDecorator(
container.getLdapCodecService(), new ModifyDnRequestImpl( container.getMessageId() ) );
container.setMessage( modifyDnRequest );
LOG.debug( "ModifyDn request" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ModifydDNRequest Message to EntryModDN
// --------------------------------------------------------------------------------------------
// ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
// entry LDAPDN,
// ...
//
// Stores the entry Dn
super.transitions[LdapStatesEnum.MODIFY_DN_REQUEST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFY_DN_REQUEST_STATE, LdapStatesEnum.ENTRY_MOD_DN_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<ModifyDnRequestDecorator>>( "Store entry" )
{
public void action( LdapMessageContainer<ModifyDnRequestDecorator> container ) throws DecoderException
{
ModifyDnRequest modifyDnRequest = container.getMessage();
// Get the Value and store it in the modifyDNRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// Dn
Dn entry = null;
if ( tlv.getLength() == 0 )
{
// This will generate a PROTOCOL_ERROR
throw new DecoderException( I18n.err( I18n.ERR_04089 ) );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
entry = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid Dn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
ModifyDnResponseImpl response = new ModifyDnResponseImpl( modifyDnRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
Dn.EMPTY_DN, ine );
}
modifyDnRequest.setName( entry );
}
if ( IS_DEBUG )
{
LOG.debug( "Modifying Dn {}", entry );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from EntryModDN to NewRDN
// --------------------------------------------------------------------------------------------
// ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
// ...
// newrdn RelativeRDN,
// ...
//
// RelativeRDN :: LDAPString
//
// Stores the new Rdn
super.transitions[LdapStatesEnum.ENTRY_MOD_DN_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ENTRY_MOD_DN_STATE, LdapStatesEnum.NEW_RDN_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<ModifyDnRequestDecorator>>( "Store new Rdn" )
{
public void action( LdapMessageContainer<ModifyDnRequestDecorator> container ) throws DecoderException
{
ModifyDnRequest modifyDnRequest = container.getMessage();
// Get the Value and store it in the modifyDNRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// newDN
Rdn newRdn = null;
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04090 );
LOG.error( msg );
ModifyDnResponseImpl response = new ModifyDnResponseImpl( modifyDnRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
modifyDnRequest.getName(), null );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
Dn dn = new Dn( dnStr );
newRdn = dn.getRdn( 0 );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid new Rdn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
ModifyDnResponseImpl response = new ModifyDnResponseImpl( modifyDnRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
modifyDnRequest.getName(), ine );
}
modifyDnRequest.setNewRdn( newRdn );
}
if ( IS_DEBUG )
{
LOG.debug( "Modifying with new Rdn {}", newRdn );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from NewRDN to DeleteOldRDN
// --------------------------------------------------------------------------------------------
// ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
// ...
// deleteoldrdn BOOLEAN,
// ...
//
// Stores the deleteOldRDN flag
super.transitions[LdapStatesEnum.NEW_RDN_STATE.ordinal()][UniversalTag.BOOLEAN.getValue()] = new GrammarTransition(
LdapStatesEnum.NEW_RDN_STATE, LdapStatesEnum.DELETE_OLD_RDN_STATE, UniversalTag.BOOLEAN.getValue(),
new GrammarAction<LdapMessageContainer<ModifyDnRequestDecorator>>( "Store matching dnAttributes Value" )
{
public void action( LdapMessageContainer<ModifyDnRequestDecorator> container ) throws DecoderException
{
ModifyDnRequest modifyDnRequest = container.getMessage();
TLV tlv = container.getCurrentTLV();
// We get the value. If it's a 0, it's a FALSE. If it's
// a FF, it's a TRUE. Any other value should be an error,
// but we could relax this constraint. So if we have
// something
// which is not 0, it will be interpreted as TRUE, but we
// will generate a warning.
Value value = tlv.getValue();
try
{
modifyDnRequest.setDeleteOldRdn( BooleanDecoder.parse( value ) );
}
catch ( BooleanDecoderException bde )
{
LOG.error( I18n
.err( I18n.ERR_04091, Strings.dumpBytes(value.getData()), bde.getMessage() ) );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( bde.getMessage() );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
if ( modifyDnRequest.getDeleteOldRdn() )
{
LOG.debug( " Old Rdn attributes will be deleted" );
}
else
{
LOG.debug( " Old Rdn attributes will be retained" );
}
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from DeleteOldRDN to NewSuperior
// --------------------------------------------------------------------------------------------
// ModifyDNRequest ::= [APPLICATION 12] SEQUENCE { ...
// ...
// newSuperior [0] LDAPDN OPTIONAL }
//
// Stores the new superior
super.transitions[LdapStatesEnum.DELETE_OLD_RDN_STATE.ordinal()][LdapConstants.MODIFY_DN_REQUEST_NEW_SUPERIOR_TAG] = new GrammarTransition(
LdapStatesEnum.DELETE_OLD_RDN_STATE, LdapStatesEnum.NEW_SUPERIOR_STATE,
LdapConstants.MODIFY_DN_REQUEST_NEW_SUPERIOR_TAG,
new GrammarAction<LdapMessageContainer<ModifyDnRequestDecorator>>( "Store new superior" )
{
public void action( LdapMessageContainer<ModifyDnRequestDecorator> container ) throws DecoderException
{
ModifyDnRequest modifyDnRequest = container.getMessage();
// Get the Value and store it in the modifyDNRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// Dn
Dn newSuperior = Dn.EMPTY_DN;
if ( tlv.getLength() == 0 )
{
if ( modifyDnRequest.getDeleteOldRdn() )
{
// This will generate a PROTOCOL_ERROR
throw new DecoderException( I18n.err( I18n.ERR_04092 ) );
}
else
{
LOG.warn( "The new superior is null, so we will change the entry" );
}
modifyDnRequest.setNewSuperior( newSuperior );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
newSuperior = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid new superior Dn given : " + dnStr + " ("
+ Strings.dumpBytes(dnBytes) + ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
ModifyDnResponseImpl response = new ModifyDnResponseImpl( modifyDnRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
modifyDnRequest.getName(), ine );
}
modifyDnRequest.setNewSuperior( newSuperior );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "New superior Dn {}", newSuperior );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from DeleteOldRDN to Controls
// --------------------------------------------------------------------------------------------
// modifyDNRequest ModifyDNRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the new superior
super.transitions[LdapStatesEnum.DELETE_OLD_RDN_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.DELETE_OLD_RDN_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from DeleteOldRDN to Controls
// --------------------------------------------------------------------------------------------
// modifyDNRequest ModifyDNRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the new superior
super.transitions[LdapStatesEnum.NEW_SUPERIOR_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.NEW_SUPERIOR_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from MessageID to ModifyDNResponse Message.
// --------------------------------------------------------------------------------------------
// ModifyDNResponse ::= [APPLICATION 13] SEQUENCE {
// ...
//
// Creates the ModifyDNResponse
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.MODIFY_DN_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.MODIFY_DN_RESPONSE_STATE,
LdapConstants.MODIFY_DN_RESPONSE_TAG, new GrammarAction<LdapMessageContainer<ModifyDnResponseDecorator>>( "Init ModifyDNResponse" )
{
public void action( LdapMessageContainer<ModifyDnResponseDecorator> container )
{
// Now, we can allocate the ModifyDnResponse Object
ModifyDnResponseDecorator modifyDnResponse = new ModifyDnResponseDecorator(
container.getLdapCodecService(), new ModifyDnResponseImpl( container.getMessageId() ) );
container.setMessage( modifyDnResponse );
LOG.debug( "Modify Dn response " );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ModifyDNResponse Message to Result Code
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ModifyDNResponse ...
// ModifyDNResponse ::= [APPLICATION 13] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result co // modifyDNRequest ModifyDNRequest,
// ... },
// controls [0] Controls OPTIONAL }
super.transitions[LdapStatesEnum.MODIFY_DN_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.MODIFY_DN_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// Transition from Message ID to CompareResquest
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... CompareRequest ...
//
// CompareRequest ::= [APPLICATION 14] SEQUENCE {
// ...
//
// Initialize the Compare Request object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.COMPARE_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.COMPARE_REQUEST_STATE, LdapConstants.COMPARE_REQUEST_TAG,
new GrammarAction<LdapMessageContainer<CompareRequestDecorator>>( "Init Compare Request" )
{
public void action( LdapMessageContainer<CompareRequestDecorator> container )
{
// Now, we can allocate the CompareRequest Object
CompareRequestDecorator compareRequest = new CompareRequestDecorator(
container.getLdapCodecService(), new CompareRequestImpl( container.getMessageId() ) );
container.setMessage( compareRequest );
LOG.debug( "Compare Request" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from CompareResquest to entryComp
// --------------------------------------------------------------------------------------------
// CompareRequest ::= [APPLICATION 14] SEQUENCE {
// entry LDAPDN,
// ...
//
// Stores the compared Dn
super.transitions[LdapStatesEnum.COMPARE_REQUEST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.COMPARE_REQUEST_STATE, LdapStatesEnum.ENTRY_COMP_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<CompareRequestDecorator>>( "Store entry" )
{
public void action( LdapMessageContainer<CompareRequestDecorator> container ) throws DecoderException
{
CompareRequest compareRequest = container.getMessage();
// Get the Value and store it in the CompareRequest
TLV tlv = container.getCurrentTLV();
Dn entry = null;
// We have to handle the special case of a 0 length matched
// Dn
if ( tlv.getLength() == 0 )
{
// This will generate a PROTOCOL_ERROR
throw new DecoderException( I18n.err( I18n.ERR_04089 ) );
}
else
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
entry = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid Dn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
CompareResponseImpl response = new CompareResponseImpl( compareRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
Dn.EMPTY_DN, ine );
}
compareRequest.setName( entry );
}
if ( IS_DEBUG )
{
LOG.debug( "Comparing Dn {}", entry );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from entryComp to ava
// --------------------------------------------------------------------------------------------
// CompareRequest ::= [APPLICATION 14] SEQUENCE {
// ...
// ava AttributeValueAssertion }
//
// AttributeValueAssertion ::= SEQUENCE {
//
// Nothing to do
super.transitions[LdapStatesEnum.ENTRY_COMP_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.ENTRY_COMP_STATE, LdapStatesEnum.AVA_STATE, UniversalTag.SEQUENCE.getValue(), null );
// --------------------------------------------------------------------------------------------
// Transition from ava to AttributeDesc
// --------------------------------------------------------------------------------------------
// AttributeValueAssertion ::= SEQUENCE {
// attributeDesc AttributeDescription,
// ...
//
// AttributeDescription LDAPString
//
// Stores the attribute description
super.transitions[LdapStatesEnum.AVA_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.AVA_STATE, LdapStatesEnum.ATTRIBUTE_DESC_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<CompareRequestDecorator>>( "Store attribute desc" )
{
public void action( LdapMessageContainer<CompareRequestDecorator> container ) throws DecoderException
{
// Get the CompareRequest Object
CompareRequest compareRequest = container.getMessage();
// Get the Value and store it in the CompareRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// Dn
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04093 );
LOG.error( msg );
CompareResponseImpl response = new CompareResponseImpl( compareRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_ATTRIBUTE_SYNTAX,
compareRequest.getName(), null );
}
String type = getType(tlv.getValue().getData());
compareRequest.setAttributeId( type );
if ( IS_DEBUG )
{
LOG.debug( "Comparing attribute description {}", compareRequest.getAttributeId() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from AttributeDesc to Assertion Value
// --------------------------------------------------------------------------------------------
// AttributeValueAssertion ::= SEQUENCE {
// ...
// assertionValue AssertionValue }
//
// AssertionValue OCTET STRING
//
// Stores the attribute value
super.transitions[LdapStatesEnum.ATTRIBUTE_DESC_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.ATTRIBUTE_DESC_STATE, LdapStatesEnum.ASSERTION_VALUE_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<CompareRequestDecorator>>( "Store assertion value" )
{
public void action( LdapMessageContainer<CompareRequestDecorator> container )
{
// Get the CompareRequest Object
CompareRequest compareRequest = container.getMessage();
// Get the Value and store it in the CompareRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length value
if ( tlv.getLength() == 0 )
{
compareRequest.setAssertionValue( "" );
}
else
{
if ( container.isBinary( compareRequest.getAttributeId() ) )
{
compareRequest.setAssertionValue( tlv.getValue().getData() );
if ( IS_DEBUG )
{
LOG.debug( "Comparing attribute value {}", Strings.dumpBytes(compareRequest
.getAssertionValue().getBytes()) );
}
}
else
{
compareRequest.setAssertionValue( Strings.utf8ToString(tlv.getValue().getData()) );
if ( LOG.isDebugEnabled() )
{
LOG.debug( "Comparing attribute value {}", compareRequest.getAssertionValue() );
}
}
}
// We can have an END transition
container.setGrammarEndAllowed( true );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from Assertion Value to Controls
// --------------------------------------------------------------------------------------------
// AttributeValueAssertion ::= SEQUENCE {
// ...
// assertionValue AssertionValue }
//
// AssertionValue OCTET STRING
//
// Stores the attribute value
super.transitions[LdapStatesEnum.ASSERTION_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ASSERTION_VALUE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// CompareResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... CompareResponse ...
// CompareResponse ::= [APPLICATION 15] LDAPResult
// We have to switch to the CompareResponse grammar
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.COMPARE_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.COMPARE_RESPONSE_STATE, LdapConstants.COMPARE_RESPONSE_TAG,
new GrammarAction<LdapMessageContainer<CompareResponseDecorator>>( "Init CompareResponse" )
{
public void action( LdapMessageContainer<CompareResponseDecorator> container ) throws DecoderException
{
// Now, we can allocate the CompareResponse Object
CompareResponseDecorator compareResponse = new CompareResponseDecorator(
container.getLdapCodecService(), new CompareResponseImpl( container.getMessageId() ) );
container.setMessage( compareResponse );
// We will check that the request is not null
TLV tlv = container.getCurrentTLV();
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04094 );
LOG.error( msg );
throw new DecoderException( msg );
}
LOG.debug( "Compare response " );
}
} );
// --------------------------------------------------------------------------------------------
// CompareResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... CompareResponse ...
// CompareResponse ::= [APPLICATION 15] LDAPResult
//
// LDAPResult ::= SEQUENCE {
// resultCode ENUMERATED {
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.COMPARE_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.COMPARE_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// Transition from MessageID to SearchResultReference Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultReference ...
// SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
//
// Initialization of SearchResultReference object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_RESULT_REFERENCE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE,
LdapConstants.SEARCH_RESULT_REFERENCE_TAG, new GrammarAction<LdapMessageContainer<SearchResultReferenceDecorator>>( "Init SearchResultReference" )
{
public void action( LdapMessageContainer<SearchResultReferenceDecorator> container ) throws DecoderException
{
// Now, we can allocate the SearchResultReference Object
SearchResultReferenceDecorator searchResultReference = new SearchResultReferenceDecorator(
container.getLdapCodecService(), new SearchResultReferenceImpl( container.getMessageId() ) );
container.setMessage( searchResultReference );
LOG.debug( "SearchResultReference response " );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from SearchResultReference Message to Reference
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultReference ...
// SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
//
// Initialization of SearchResultReference object
super.transitions[LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.SEARCH_RESULT_REFERENCE_STATE, LdapStatesEnum.REFERENCE_STATE, UniversalTag.OCTET_STRING.getValue(),
new StoreReferenceAction() );
// --------------------------------------------------------------------------------------------
// Transition from Reference to Reference
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchResultReference ...
// SearchResultReference ::= [APPLICATION 19] SEQUENCE OF LDAPURL
//
// Initialization of SearchResultReference object
super.transitions[LdapStatesEnum.REFERENCE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERENCE_STATE, LdapStatesEnum.REFERENCE_STATE, UniversalTag.OCTET_STRING.getValue(),
new StoreReferenceAction() );
// --------------------------------------------------------------------------------------------
// Transition from Reference to Controls
// --------------------------------------------------------------------------------------------
// searchResultReference SearchResultReference,
// ... },
// controls [0] Controls OPTIONAL }
//
// Initialization the controls
super.transitions[LdapStatesEnum.REFERENCE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REFERENCE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Message Id to ExtendedRequest Message
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedRequest ...
// ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
//
// Creates the ExtendedRequest object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.EXTENDED_REQUEST_STATE, LdapConstants.EXTENDED_REQUEST_TAG,
new GrammarAction<LdapMessageContainer<ExtendedRequestDecorator>>( "Init Extended Request" )
{
public void action( LdapMessageContainer<ExtendedRequestDecorator> container ) throws DecoderException
{
// Now, we can allocate the ExtendedRequest Object
ExtendedRequestDecorator extendedRequest = new ExtendedRequestDecorator(
container.getLdapCodecService(), new ExtendedRequestImpl( container.getMessageId() ) );
container.setMessage( extendedRequest );
LOG.debug( "Extended request" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ExtendedRequest Message to RequestName
// --------------------------------------------------------------------------------------------
// ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
// requestName [0] LDAPOID,
// ...
//
// Stores the name
super.transitions[LdapStatesEnum.EXTENDED_REQUEST_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_NAME_TAG] = new GrammarTransition(
LdapStatesEnum.EXTENDED_REQUEST_STATE, LdapStatesEnum.REQUEST_NAME_STATE,
LdapConstants.EXTENDED_REQUEST_NAME_TAG, new GrammarAction<LdapMessageContainer<ExtendedRequestDecorator>>( "Store name" )
{
public void action( LdapMessageContainer<ExtendedRequestDecorator> container ) throws DecoderException
{
// We can allocate the ExtendedRequest Object
ExtendedRequest extendedRequest = container.getMessage();
// Get the Value and store it in the ExtendedRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// OID
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04095 );
LOG.error( msg );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
else
{
byte[] requestNameBytes = tlv.getValue().getData();
try
{
String requestName = Strings.utf8ToString(requestNameBytes);
if ( !OID.isOID( requestName ) )
{
String msg = "The Request name is not a valid OID : "
+ Strings.utf8ToString(requestNameBytes) + " ("
+ Strings.dumpBytes(requestNameBytes) + ") is invalid";
LOG.error( msg );
// throw an exception, we will get a PROTOCOL_ERROR
throw new DecoderException( msg );
}
extendedRequest.setRequestName( requestName );
}
catch ( DecoderException de )
{
String msg = "The Request name is not a valid OID : "
+ Strings.utf8ToString(requestNameBytes) + " ("
+ Strings.dumpBytes(requestNameBytes) + ") is invalid";
LOG.error( "{} : {}", msg, de.getMessage() );
// Rethrow the exception, we will get a PROTOCOL_ERROR
throw de;
}
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "OID read : {}", extendedRequest.getRequestName() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from RequestName to RequestValue
// --------------------------------------------------------------------------------------------
// ExtendedRequest ::= [APPLICATION 23] SEQUENCE {
// ...
// requestValue [1] OCTET STRING OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.REQUEST_NAME_STATE.ordinal()][LdapConstants.EXTENDED_REQUEST_VALUE_TAG] = new GrammarTransition(
LdapStatesEnum.REQUEST_NAME_STATE, LdapStatesEnum.REQUEST_VALUE_STATE,
LdapConstants.EXTENDED_REQUEST_VALUE_TAG, new GrammarAction<LdapMessageContainer<ExtendedRequestDecorator>>( "Store value" )
{
public void action( LdapMessageContainer<ExtendedRequestDecorator> container ) throws DecoderException
{
// We can allocate the ExtendedRequest Object
ExtendedRequest extendedRequest = container.getMessage();
// Get the Value and store it in the ExtendedRequest
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// value
if ( tlv.getLength() == 0 )
{
extendedRequest.setRequestValue( StringConstants.EMPTY_BYTES );
}
else
{
extendedRequest.setRequestValue( tlv.getValue().getData() );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "Extended value : {}", extendedRequest.getRequestValue() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from RequestName to Controls
// --------------------------------------------------------------------------------------------
// extendedRequest EtendedRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.REQUEST_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REQUEST_NAME_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from RequestValue to Controls
// --------------------------------------------------------------------------------------------
// extendedRequest EtendedRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.REQUEST_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REQUEST_VALUE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from MessageId to ExtendedResponse Message.
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
//
// Creates the ExtendeResponse object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.EXTENDED_RESPONSE_STATE,
LdapConstants.EXTENDED_RESPONSE_TAG, new GrammarAction<LdapMessageContainer<ExtendedResponseDecorator>>( "Init Extended Reponse" )
{
public void action( LdapMessageContainer<ExtendedResponseDecorator> container ) throws DecoderException
{
// Now, we can allocate the ExtendedResponse Object
ExtendedResponseDecorator extendedResponse = new ExtendedResponseDecorator(
container.getLdapCodecService(), new ExtendedResponseImpl( container.getMessageId() ) );
container.setMessage( extendedResponse );
LOG.debug( "Extended Response" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ExtendedResponse Message to Result Code ER
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
//
// Stores the result code
super.transitions[LdapStatesEnum.EXTENDED_RESPONSE_STATE.ordinal()][UniversalTag.ENUMERATED.getValue()] = new GrammarTransition(
LdapStatesEnum.EXTENDED_RESPONSE_STATE, LdapStatesEnum.RESULT_CODE_ER_STATE, UniversalTag.ENUMERATED.getValue(),
new ResultCodeAction() );
// --------------------------------------------------------------------------------------------
// Transition from Result Code ER to Matched Dn ER
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
//
//
super.transitions[LdapStatesEnum.RESULT_CODE_ER_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.RESULT_CODE_ER_STATE, LdapStatesEnum.MATCHED_DN_ER_STATE, UniversalTag.OCTET_STRING.getValue(),
new MatchedDNAction() );
// --------------------------------------------------------------------------------------------
// Transition from Matched Dn ER to Error Message ER
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...