{
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 ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
//
//
super.transitions[LdapStatesEnum.MATCHED_DN_ER_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.MATCHED_DN_ER_STATE, LdapStatesEnum.ERROR_MESSAGE_ER_STATE, UniversalTag.OCTET_STRING.getValue(),
new ErrorMessageAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message ER to Referrals ER
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
//
//
super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_ER_STATE, LdapStatesEnum.REFERRALS_ER_STATE,
LdapConstants.LDAP_RESULT_REFERRAL_SEQUENCE_TAG, new InitReferralsAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referrals ER to Referral ER
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Add a first Referral
super.transitions[LdapStatesEnum.REFERRALS_ER_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRALS_ER_STATE, LdapStatesEnum.REFERRAL_ER_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral ER to Referral ER
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.REFERRAL_ER_STATE, LdapStatesEnum.REFERRAL_ER_STATE, UniversalTag.OCTET_STRING.getValue(),
new ReferralAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral ER to ResponseName
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_ER_STATE, LdapStatesEnum.RESPONSE_NAME_STATE,
LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG, new ResponseNameAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral ER to Response
// --------------------------------------------------------------------------------------------
// Referral ::= SEQUENCE SIZE (1..MAX) OF uri URI (RFC 4511)
// URI ::= LDAPString
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_ER_STATE, LdapStatesEnum.RESPONSE_STATE,
LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG, new ResponseAction() );
// --------------------------------------------------------------------------------------------
// Transition from Referral ER to Controls
// --------------------------------------------------------------------------------------------
// extendedResponse ExtendedResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
// Adda new Referral
super.transitions[LdapStatesEnum.REFERRAL_ER_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.REFERRAL_ER_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message ER to Controls
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
//
//
super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_ER_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message ER to ResponseName
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// responseName [10] LDAPOID OPTIONAL,
// ...
//
// Stores the response name
super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_ER_STATE, LdapStatesEnum.RESPONSE_NAME_STATE,
LdapConstants.EXTENDED_RESPONSE_RESPONSE_NAME_TAG, new ResponseNameAction() );
// --------------------------------------------------------------------------------------------
// Transition from Response Name to Response
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// ...
// responseName [10] LDAPOID OPTIONAL,
// response [11] OCTET STRING OPTIONAL}
//
// Stores the response
super.transitions[LdapStatesEnum.RESPONSE_NAME_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.RESPONSE_NAME_STATE, LdapStatesEnum.RESPONSE_STATE,
LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG, new ResponseAction() );
// --------------------------------------------------------------------------------------------
// Transition from ResponseName to Controls
// --------------------------------------------------------------------------------------------
// extendedRequest EtendedRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Init the controls
super.transitions[LdapStatesEnum.RESPONSE_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.RESPONSE_NAME_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Error Message ER to Response
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... ExtendedResponse ...
// ExtendedResponse ::= [APPLICATION 24] SEQUENCE {
// COMPONENTS OF LDAPResult,
// ...
// response [11] OCTET STRING OPTIONAL}
//
// Stores the response
super.transitions[LdapStatesEnum.ERROR_MESSAGE_ER_STATE.ordinal()][LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.ERROR_MESSAGE_ER_STATE, LdapStatesEnum.RESPONSE_STATE,
LdapConstants.EXTENDED_RESPONSE_RESPONSE_TAG, new ResponseAction() );
// --------------------------------------------------------------------------------------------
// Transition from Response to Controls
// --------------------------------------------------------------------------------------------
// extendedRequest EtendedRequest,
// ... },
// controls [0] Controls OPTIONAL }
//
// Init the controls
super.transitions[LdapStatesEnum.RESPONSE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.RESPONSE_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from Message Id to IntermediateResponse Message
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... IntermediateResponse ...
// IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
//
// Creates the IntermediateResponse object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE,
LdapConstants.INTERMEDIATE_RESPONSE_TAG, new GrammarAction<LdapMessageContainer<IntermediateResponseDecorator>>( "Init Intermediate Response" )
{
public void action( LdapMessageContainer<IntermediateResponseDecorator> container ) throws DecoderException
{
// Now, we can allocate the IntermediateResponse Object
IntermediateResponseDecorator intermediateResponse =
new IntermediateResponseDecorator( container.getLdapCodecService(),
new IntermediateResponseImpl( container.getMessageId() ) );
container.setMessage( intermediateResponse );
LOG.debug( "Intermediate Response" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from IntermediateResponse Message to ResponseName
// --------------------------------------------------------------------------------------------
// IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
// responseName [0] LDAPOID OPTIONAL,
// ...
//
// Stores the name
super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_NAME_TAG] = new GrammarTransition(
LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE, LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE,
LdapConstants.INTERMEDIATE_RESPONSE_NAME_TAG, new GrammarAction<LdapMessageContainer<IntermediateResponseDecorator>>( "Store response name" )
{
public void action( LdapMessageContainer<IntermediateResponseDecorator> container ) throws DecoderException
{
// We can get the IntermediateResponse Object
IntermediateResponse intermediateResponse = container.getMessage();
// Get the Value and store it in the IntermediateResponse
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[] responseNameBytes = tlv.getValue().getData();
String oidStr = Strings.utf8ToString(responseNameBytes);
if ( OID.isOID( oidStr ) )
{
OID.isOID( oidStr );
intermediateResponse.setResponseName( oidStr );
}
else
{
String msg = "The Intermediate Response name is not a valid OID : "
+ Strings.utf8ToString(responseNameBytes) + " ("
+ Strings.dumpBytes(responseNameBytes) + ") is invalid";
LOG.error( "{} : {}", msg, oidStr );
// Rethrow the exception, we will get a PROTOCOL_ERROR
throw new DecoderException( msg );
}
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "OID read : {}", intermediateResponse.getResponseName() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from IntermediateResponse Message to ResponseValue (ResponseName is null)
// --------------------------------------------------------------------------------------------
// IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
// ...
// responseValue [1] OCTET STRING OPTIONAL
// }
//
// Stores the value
super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG] = new GrammarTransition(
LdapStatesEnum.INTERMEDIATE_RESPONSE_STATE, LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE,
LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG,
new GrammarAction<LdapMessageContainer<IntermediateResponseDecorator>>( "Store response value" )
{
public void action( LdapMessageContainer<IntermediateResponseDecorator> container ) throws DecoderException
{
// We can get the IntermediateResponse Object
IntermediateResponse intermediateResponse = container.getMessage();
// Get the Value and store it in the IntermediateResponse
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// value
if ( tlv.getLength() == 0 )
{
intermediateResponse.setResponseValue( StringConstants.EMPTY_BYTES );
}
else
{
intermediateResponse.setResponseValue( tlv.getValue().getData() );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "Value read : {}", Strings.dumpBytes(intermediateResponse.getResponseValue()) );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ResponseName to ResponseValue
// --------------------------------------------------------------------------------------------
// IntermediateResponse ::= [APPLICATION 25] SEQUENCE {
// ...
// responseValue [1] OCTET STRING OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE.ordinal()][LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG] = new GrammarTransition(
LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE, LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE,
LdapConstants.INTERMEDIATE_RESPONSE_VALUE_TAG,
new GrammarAction<LdapMessageContainer<IntermediateResponseDecorator>>( "Store value" )
{
public void action( LdapMessageContainer<IntermediateResponseDecorator> container ) throws DecoderException
{
// We can allocate the ExtendedRequest Object
IntermediateResponse intermediateResponse = container.getMessage();
// Get the Value and store it in the IntermediateResponse
TLV tlv = container.getCurrentTLV();
// We have to handle the special case of a 0 length matched
// value
if ( tlv.getLength() == 0 )
{
intermediateResponse.setResponseValue( StringConstants.EMPTY_BYTES );
}
else
{
intermediateResponse.setResponseValue( tlv.getValue().getData() );
}
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "Response value : {}", intermediateResponse.getResponseValue() );
}
}
} );
// --------------------------------------------------------------------------------------------
// Transition from ResponseName to Controls
// --------------------------------------------------------------------------------------------
// intermediateResponse IntermediateResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.INTERMEDIATE_RESPONSE_NAME_STATE, LdapStatesEnum.CONTROLS_STATE, LdapConstants.CONTROLS_TAG,
new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Transition from ResponseValue to Controls
// --------------------------------------------------------------------------------------------
// intermediateResponse IntermediateResponse,
// ... },
// controls [0] Controls OPTIONAL }
//
// Stores the value
super.transitions[LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE.ordinal()][LdapConstants.CONTROLS_TAG] = new GrammarTransition(
LdapStatesEnum.INTERMEDIATE_RESPONSE_VALUE_STATE, LdapStatesEnum.CONTROLS_STATE,
LdapConstants.CONTROLS_TAG, new ControlsInitAction() );
// --------------------------------------------------------------------------------------------
// Controls
// --------------------------------------------------------------------------------------------
Action<LdapMessageContainer<MessageDecorator<? extends Message>>> addControl =
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Add Control" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
TLV tlv = container.getCurrentTLV();
int expectedLength = tlv.getLength();
// The Length should be null
if ( expectedLength == 0 )
{
String msg = I18n.err( I18n.ERR_04096 );
LOG.error( msg );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
}
};
// ============================================================================================
// Transition from Controls to Control
// ============================================================================================
// ...
// Controls ::= SEQUENCE OF Control
// ...
//
// Initialize the controls
super.transitions[LdapStatesEnum.CONTROLS_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROLS_STATE, LdapStatesEnum.CONTROL_STATE, UniversalTag.SEQUENCE.getValue(), addControl );
// ============================================================================================
// Transition from Control to ControlType
// ============================================================================================
// Control ::= SEQUENCE {
// ...
//
// Create a new Control object, and store it in the message Container
super.transitions[LdapStatesEnum.CONTROL_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROL_STATE, LdapStatesEnum.CONTROL_TYPE_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Set Control Type" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
TLV tlv = container.getCurrentTLV();
// Store the type
// We have to handle the special case of a 0 length OID
if ( tlv.getLength() == 0 )
{
String msg = I18n.err( I18n.ERR_04097 );
LOG.error( msg );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( msg );
}
byte[] value = tlv.getValue().getData();
String oidValue = Strings.asciiBytesToString(value);
// The OID is encoded as a String, not an Object Id
if ( !OID.isOID(oidValue) )
{
LOG.error( I18n.err( I18n.ERR_04098, Strings.dumpBytes(value) ) );
// This will generate a PROTOCOL_ERROR
throw new DecoderException( I18n.err( I18n.ERR_04099, oidValue ) );
}
Message message = container.getMessage();
Control control = container.getLdapCodecService().newControl( oidValue );
message.addControl( control );
// We can have an END transition
container.setGrammarEndAllowed( true );
if ( IS_DEBUG )
{
LOG.debug( "Control OID : " + oidValue );
}
}
} );
// ============================================================================================
// Transition from ControlType to Control Criticality
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// criticality BOOLEAN DEFAULT FALSE,
// ...
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][UniversalTag.BOOLEAN.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROL_TYPE_STATE, LdapStatesEnum.CRITICALITY_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<MessageDecorator<? extends Message>>>( "Set Criticality" )
{
public void action( LdapMessageContainer<MessageDecorator<? extends Message>> container ) throws DecoderException
{
TLV tlv = container.getCurrentTLV();
// Get the current control
Control control = null;
MessageDecorator<? extends Message> message = container.getMessage();
control = message.getCurrentControl();
// Store the criticality
// 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
{
control.setCritical( BooleanDecoder.parse( value ) );
}
catch ( BooleanDecoderException bde )
{
LOG.error( I18n
.err( I18n.ERR_04100, 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 )
{
LOG.debug( "Control criticality : " + control.isCritical() );
}
}
} );
// ============================================================================================
// Transition from Control Criticality to Control Value
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// controlValue OCTET STRING OPTIONAL }
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CRITICALITY_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.CRITICALITY_STATE, LdapStatesEnum.CONTROL_VALUE_STATE, UniversalTag.OCTET_STRING.getValue(),
new ControlValueAction() );
// ============================================================================================
// Transition from Control Type to Control Value
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// controlValue OCTET STRING OPTIONAL }
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROL_TYPE_STATE, LdapStatesEnum.CONTROL_VALUE_STATE, UniversalTag.OCTET_STRING.getValue(),
new ControlValueAction() );
// ============================================================================================
// Transition from Control Type to Control
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// controlValue OCTET STRING OPTIONAL }
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CONTROL_TYPE_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROL_TYPE_STATE, LdapStatesEnum.CONTROL_STATE, UniversalTag.SEQUENCE.getValue(), addControl );
// ============================================================================================
// Transition from Control Criticality to Control
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// controlValue OCTET STRING OPTIONAL }
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CRITICALITY_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.CRITICALITY_STATE, LdapStatesEnum.CONTROL_STATE, UniversalTag.SEQUENCE.getValue(), addControl );
// ============================================================================================
// Transition from Control Value to Control
// ============================================================================================
// Control ::= SEQUENCE {
// ...
// controlValue OCTET STRING OPTIONAL }
//
// Store the value in the control object created before
super.transitions[LdapStatesEnum.CONTROL_VALUE_STATE.ordinal()][UniversalTag.SEQUENCE.getValue()] = new GrammarTransition(
LdapStatesEnum.CONTROL_VALUE_STATE, LdapStatesEnum.CONTROL_STATE, UniversalTag.SEQUENCE.getValue(), addControl );
// --------------------------------------------------------------------------------------------
// Transition from message ID to SearchRequest Message
// --------------------------------------------------------------------------------------------
// LdapMessage ::= ... SearchRequest ...
// SearchRequest ::= [APPLICATION 3] SEQUENCE { ...
//
// Initialize the searchRequest object
super.transitions[LdapStatesEnum.MESSAGE_ID_STATE.ordinal()][LdapConstants.SEARCH_REQUEST_TAG] = new GrammarTransition(
LdapStatesEnum.MESSAGE_ID_STATE, LdapStatesEnum.SEARCH_REQUEST_STATE, LdapConstants.SEARCH_REQUEST_TAG,
new GrammarAction<LdapMessageContainer<SearchRequestDecorator>>( "Init SearchRequest" )
{
public void action( LdapMessageContainer<SearchRequestDecorator> container )
{
// Now, we can allocate the SearchRequest Object
TLV tlv = container.getCurrentTLV();
SearchRequestDecorator searchRequest = new SearchRequestDecorator(
container.getLdapCodecService(), new SearchRequestImpl( container.getMessageId() ) );
searchRequest.setTlvId( tlv.getId());
container.setMessage( searchRequest );
LOG.debug( "Search Request" );
}
} );
// --------------------------------------------------------------------------------------------
// Transition from SearchRequest Message to BaseObject
// --------------------------------------------------------------------------------------------
// SearchRequest ::= [APPLICATION 3] SEQUENCE {
// baseObject LDAPDN,
// ...
//
// We have a value for the base object, we will store it in the message
super.transitions[LdapStatesEnum.SEARCH_REQUEST_STATE.ordinal()][UniversalTag.OCTET_STRING.getValue()] = new GrammarTransition(
LdapStatesEnum.SEARCH_REQUEST_STATE, LdapStatesEnum.BASE_OBJECT_STATE, UniversalTag.OCTET_STRING.getValue(),
new GrammarAction<LdapMessageContainer<SearchRequestDecorator>>( "store base object value" )
{
public void action( LdapMessageContainer<SearchRequestDecorator> container ) throws DecoderException
{
SearchRequestDecorator searchRequestDecorator = container.getMessage();
SearchRequest searchRequest = searchRequestDecorator.getDecorated();
TLV tlv = container.getCurrentTLV();
// We have to check that this is a correct Dn
Dn baseObject = null;
// We have to handle the special case of a 0 length base
// object,
// which means that the search is done from the default
// root.
if ( tlv.getLength() != 0 )
{
byte[] dnBytes = tlv.getValue().getData();
String dnStr = Strings.utf8ToString(dnBytes);
try
{
baseObject = new Dn( dnStr );
}
catch ( LdapInvalidDnException ine )
{
String msg = "Invalid root Dn given : " + dnStr + " (" + Strings.dumpBytes(dnBytes)
+ ") is invalid";
LOG.error( "{} : {}", msg, ine.getMessage() );
SearchResultDoneImpl response = new SearchResultDoneImpl( searchRequest.getMessageId() );
throw new ResponseCarryingException( msg, response, ResultCodeEnum.INVALID_DN_SYNTAX,
Dn.EMPTY_DN, ine );
}
}
else