17 Configuring Synchronization with a Third-Party Directory

Customizing ACLs for Import Profiles

The import profile is the identity used by the Oracle Directory Integration Platform to access Oracle Internet Directory. ACLs must enable the import profile to add, modify, and delete objects in either the users and groups containers or the subtree where entries are accessed. By default, import profiles are part of the Realm Administrators group (cn=RealmAdministrators, cn=groups,cn=OracleContext,realm_DN) in the default realm. This group has privileges to perform all operations on any entry under the DN of the default realm.

You should not need to customize the ACLs for import synchronization with the default realm that is installed with Oracle Internet Directory Release 11g Release 1 (11.1.1). If you are upgrading from an earlier version of Oracle Internet Directory, or if the synchronization is with a nondefault Oracle Internet Directory realm, then be sure that the necessary privileges in the proper subtree or containers are granted to the import profiles handling the synchronization.

For an ACL template in LDIF format, see the file $ORACLE_HOME/ldap/schema/oid/oidRealmAdminACL.sbs. If you have not changed the ACLs on the default realm, then this template file can be applied directly after instantiating the substitution variables, replacing %s_SubscriberDN% with the default realm DN in Oracle Internet Directory and replacing %s_OracleContextDN% with cn=OracleContext,default_realm_DN respectively. For example, if realmacl.ldif is the instantiated file, then you can upload it by using the following ldapmodify command. After executing the command, you will be prompted for the password for privileged directory user.

$ORACLE_HOME/bin/ldapmodify -h OID host -p OID port 
-D binddn -q -v -f realmacl.ldif

Customizing ACLs for Export Profiles

To enable the Oracle Directory Integration Platform to access a third-party directory, you must create an identity in third-party directory. This identity is configured in each export profile.

ACLs for Other Oracle Components

Default ACLs enable you to create, modify, and delete users and groups, but only in the users and groups containers under the default realm. To synchronize objects in other containers, you must customize the ACLs.

There are sample ACL files that you can use to customize ACLs for Oracle Components. These sample files are installed in the $ORACLE_HOME/ldap/schema/oid directory. They are:

• oidUserAdminACL.sbs—Grants necessary rights to the subtree for Oracle components to manage and access users

• oidGroupAdminACL.sbs—Grants necessary rights to the subtree for Oracle components to manage and access groups

• oidUserAndGroupAdminACL.sbs—Grants the privileges for Oracle components to manage and access users and groups in the subtree.

You can customize your ACL policy to grant privileges on a container-by-container basis with the required rights.

Configuring External Authentication Against Multiple Domains

To set up an external authentication plug-in to work with multiple external authentication domains, you must perform some manual instructions after you run the external configuration tool. Proceed as follows:

1. Configure the external authentication plug-in as described in "Configuring External Authentication Plug-ins".

2. Search for the plug-in configuration entries created by the configuration tool in step 1, and redirect the search output to a file. Use an ldapsearch command similar to this:

   ldapsearch -p 3060 -D binddn -q -s sub -L \
       -b "cn=plugin,cn=subconfigsubentry" cn="oidexplg_*_ad" >> output.ldif
   

   Note:

   You will be prompted for the password.

   The example shows an Microsoft Active Directory cn. Use the correct plug-in cn for the type of plug-in you configured, as shown in Table 17-2. You can use * as a wildcard, as shown in the example.

   Table 17-2 Distinguished Names of External Authentication Plug-ins

   Plug-in Type	DN
   Microsoft Active Directory	cn=oidexplg_compare_ad, cn=plugin,cn=subconfigsubentry cn=oidexplg_bind_ad, cn=plugin,cn=subconfigsubentry
   Sun Java System Directory Server	cn=oidexplg_compare_iplanet, cn=plugin,cn=subconfigsubentry cn=oidexplg_bind_iplanet, cn=plugin,cn=subconfigsubentry
   Novell eDirectory	cn=oidexplg_compare_Novell eDirectory, cn=plugin,cn=subconfigsubentry cn=oidexplg_bind_Novell eDirectory, cn=plugin,cn=subconfigsubentry
   OpenLDAP	cn=oidexplg_compare_openldap, cn=plugin,cn=subconfigsubentry cn=oidexplg_bind_openldap, cn=plugin,cn=subconfigsubentry

   
   

3. Examine the output file. For an Microsoft Active Directory plug-in, the output file resembles the following:

   dn: cn=oidexplg_compare_ad,cn=plugin,cn=subconfigsubentry
   cn: oidexplg_compare_ad
   objectclass: orclPluginConfig
   objectclass: top
   orclpluginname: oidexplg.jar
   orclplugintype: operational
   orclpluginkind: Java
   orclplugintiming: when
   orclpluginldapoperation: ldapcompare
   orclpluginsecuredflexfield;walletpwd: password
   orclpluginsecuredflexfield;walletpwd2: password
   orclpluginversion: 1.0.1
   orclpluginisreplace: 1
   orclpluginattributelist: userpassword
   orclpluginentryproperties: (!(&(objectclass=orcladobject)(objectclass=orcluserv2)))
   orclpluginflexfield;host2: host.domain.com
   orclpluginflexfield;port2: 636
   orclpluginflexfield;isssl2: 1
   orclpluginflexfield;host: host.domain.com
   orclpluginflexfield;walletloc2: /location/wallet
   orclpluginflexfield;port: 389
   orclpluginflexfield;walletloc: /tmp
   orclpluginflexfield;isssl: 0
   orclpluginflexfield;isfailover: 0
   orclpluginclassreloadenabled: 0
   orclpluginenable: 0
   orclpluginsubscriberdnlist: cn=users,dc=us,dc=oracle,dc=com
   
   dn: cn=oidexplg_bind_ad,cn=plugin,cn=subconfigsubentry
   cn: oidexplg_bind_ad
   objectclass: orclPluginConfigobjectclass: top
   orclpluginname: oidexplg.jar
   orclplugintype: operational
   orclpluginkind: Java
   orclplugintiming: when
   orclpluginldapoperation: ldapbind
   orclpluginversion: 1.0.1
   orclpluginisreplace: 1
   orclpluginentryproperties: (!(&(objectclass=orcladobject)(objectclass=orcluserv2)))
   orclpluginclassreloadenabled: 0
   orclpluginflexfield;walletloc2: /location/wallet
   orclpluginflexfield;port: 389
   orclpluginflexfield;walletloc: /tmp
   orclpluginflexfield;isssl: 0
   orclpluginflexfield;isfailover: 0
   orclpluginflexfield;host2: host.domain.com
   orclpluginflexfield;port2: 636
   orclpluginflexfield;isssl2: 1
   orclpluginflexfield;host: host.domain.com
   orclpluginenable: 0
   orclpluginsecuredflexfield;walletpwd: password
   orclpluginsecuredflexfield;walletpwd2: password
   orclpluginsubscriberdnlist:
   cn=users,dc=us,dc=oracle,dc=com
   

4. Create a new LDIF file from the output file as follows:

   1. Change the entry names. In the example shown in the previous step, you would change cn=oidexplg_compare_ad,cn=plugin, cn=subconfigsubentry to cn=oidexplg_compare_ad1, cn=plugin,cn=subconfigsubentry and cn=oidexplg_bind_ad, cn=plugin,cn=subconfigsubentry to cn=oidexplg_bind_ad1, cn=plugin,cn=subconfigsubentry.

   2. Change the value for orclpluginenable. Use value 1 if you want to enable it, and use value 0 if you want to disable it.

   3. Change the values for orclpluginflexfield;host and orclpluginflexfield;port for the external directory host name and port number.

   4. Change the value for orclpluginflexfield;isssl. Use value 1 if you want to enable the SSL connection against the external directory, and use value 0 if you want to disable. If you use value 1, you will also need to change the value of orclpluginflexfield;walletloc and orclpluginsecuredflexfield;walletpwd for the wallet location and password.

   5. Change orclpluginflexfield;isfailover. Use value 1 if to set up the failover against a backup external directory. If you use value 1, then you must also change the value of orclpluginflexfield;host2, orclpluginflexfield;port2 for the host name and port number. To use an SSL connection against the backup directory server, you must to change the value for orclpluginflexfield;walletloc2 and orclpluginsecuredflexfield;walletpwd2.

   6. Modify orclpluginsubscriberdnlist for the plug-in invocation naming context.

   7. Modify orclPluginRequestGroup for the plug-in request group. If this attribute is missing in the search out put, then just add the attribute and value in the LDIF file.

5. Add the modified plug-in configuration entries to the Oracle Internet Directory server. Use a command similar to the following:

   $ORACLE_HOME/ldap/bin/ldapadd -h host -p port -D binddn -q \
         -v -f input.ldif
   

   Note:

   You will be prompted for the password.

Sample Reader

package oracle.ldap.odip.gsi;
import oracle.ldap.odip.engine.AttrHandler;
import oracle.ldap.odip.engine.ChangeRecord;
import oracle.ldap.odip.engine.Connector;
import oracle.ldap.odip.engine.ConfigReader;
import oracle.ldap.odip.engine.Constants;
import oracle.ldap.odip.engine.DISReadInterface;
import oracle.ldap.odip.engine.DISFilterInterface;
import oracle.ldap.odip.engine.ODIException;
import oracle.ldap.odip.engine.Debug;
import oracle.ldap.odip.map.MapRules;
import oracle.ldap.odip.map.OrclFilter;
import oracle.ldap.odip.util.Utils;
 //Imports added for ODLLogger
import oracle.core.ojdl.logging.ODLLogger;
import oracle.dms.context.ExecutionContext;
import oracle.core.ojdl.logging.ODLLevel;
import oracle.core.ojdl.logging.ODLHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
 
import oracle.ldap.odip.DIPLogger;
 
public class SampleReader implements DISReadInterface
{
 
  /*
  ** Member variables used
  */
  protected  NamingEnumeration  mEnumerate;
  protected  Attributes         mAttribs;
  protected  Attribute          mAttrib;
  protected  Attribute          mAttribAllValues;
  protected  SearchResult       mResult;
  protected  MapRules           mMapRules;
  /*
  ** Vector to store the list of required attributes
  */
  protected  Vector             mReqAttrList = new Vector();
 
  /*
  ** List of source attributes whose changes need to be mapped
  */
  protected  Vector             mSrcAttrList = new Vector();
  protected  String             mMapFilter;
  protected  int                mAppliedChangeNum = 0;
  protected  int                mAvailableChangeNum = 700;
  protected  DISFilterInterface mFilter;
 
  /*
  ** LastChangeNumber that is read 
  */
 
  protected  String            mReadChangeNum;
 
  /*
  ** List of attributes to be returned in changelog LDAPSearch 
  */
  protected  String[]           mRetAttribs;
  private    int                mErrorCode = 0;
 
 
  /*
  ** Constructor
  */
  public SampleReader()
  {
  }
 
  /**
  ** Constructor with the connector 
  */
  public SampleReader( Connector conn )
  {
    super(conn);
    
  }
 
  /**
  ** Get the last change key value 
  **
  * @param   boolean Operation is success/failure
  * @return  Object  lastkeyvalue to be stored
  */
  public Object getLastChangeKey(boolean val)
  {
      if ( val == false )
      {
          int nval = Integer.parseInt(mReadChangeNum);
          if ( nval > 0 )
          {  
            nval--;
          }
          mReadChangeNum = String.valueOf(nval);
      }
      return (mReadChangeNum);
  }
 
  /**
  ** Initializes required values from hashtable passed from Profile
  **
  ** @param   Connector   connection details with credentials
  ** @param   Hashtable   with the required parameters
  ** @throws  ODIException Indicating connection failure
  */
  public void initialise(Connector conn,Hashtable pHash)
      throws ODIException
  {
       m_logger.finest ( "Entry: SampleReaders.initialise");
      setValues(conn);
      mMapRules = (MapRules)pHash.get(Constants.MAPRULE_STR);
 
      readCtx = connect();
 
      pHash.put("READCONTEXT", readCtx);      
      pHash.put(Constants.READERCHANGEKEY_STR, Constants.CHANGE_NUM);
      String key = (String)pHash.get(Constants.LASTAPPLIEDCHG_STR);
      String val = null;
      if ( key != null )
          val = (String)pHash.get(key);
      if ( val != null )
          mAppliedChangeNum = Integer.parseInt((String)pHash.get(key));
      mReadChangeNum = (String)pHash.get(key);
      pHash.put(key, mReadChangeNum);
      mFilter = (DISFilterInterface)pHash.get(Constants.MATCHRULE_STR);
      mAvailableChangeNum = Integer.parseInt(initAvailableChgKey());
      mSaveLastChgNum = mAppliedChangeNum;
     
      try {
        SearchControls pControls = new SearchControls();
        pControls.setSearchScope(SearchControls.OBJECT_SCOPE);
        pControls.setReturningAttributes(mRetAttribs);
        pControls.setTimeLimit(3000000);
 
        mEnumerate = mLdapCtx.search("","objectclass=*",pControls);
        while ( mEnumerate.hasMoreElements() )
        {
          mResult = (SearchResult)mEnumerate.nextElement();
          mAttribs = mResult.getAttributes();
        }
        // END INFEASIBLE
        ConfigReader configInfo = (ConfigReader) pHash.get(Constants.CONFINFO_STR);
 
        if (configInfo != null) {
            mUpdateSearchCount = configInfo.getUpdateSearchCount();
            mSearchDelta = configInfo.getSearchDeltaSize();
        }
      } catch (Exception ex)
      // BEGIN INFEASIBLE
      {
           
        throw new ODIException(ODIException.LDAP_INITIALIZATION_EXCEPTION,ex);
      }
      // END INFEASIBLE
      m_logger.finest ( "Exit: SampleReaders.initialise");
  }
 
  /**
  ** Search the changelog 
  ** @throws ODIException
  */
  public int searchChanges()
      throws ODIException
  {
 
        int  temp;
        int searchDelta = (int) mSearchDelta;
        if ( mAvailableChangeNum <= mAppliedChangeNum ) return -1;
        int  minChgNum = mAppliedChangeNum+1;
        if ( mAvailableChangeNum -  mAppliedChangeNum >= searchDelta)
            temp = mAppliedChangeNum + searchDelta;
        else
            temp = mAvailableChangeNum; 
 
        String searchF = "";
        if ( mFilter != null ) {
          searchF = mFilter.getSearchFilter();
          m_logger.log(ODLLevel.NOTIFICATION,"SEARCHF", searchF );
        }
 
        StringBuffer filter = new StringBuffer(300);
 
        /**
         * SearchChanges is called to get all changes 
         *
         */
        try {
 
           mEnumerate = mReadCtx.search( 
                                        filter.toString());
 
        }
        catch ( Exception ex ) 
        // BEGIN INFEASIBLE
        {
            throw ( new ODIException(ODIException.LDAP_SEARCH_EXCEPTION, 
                                      ex) );
        } 
        finally {
        
        m_logger.log(ODLLevel.NOTIFICATION, "SEARCH_SUCCESSFUL" ,new Integer( temp ));
 
        mAppliedChangeNum = temp;
      return mErrorCode;
  }
 
  public boolean hasMore()
      throws ODIException
  {
    boolean  retval = false;
    int count =0;
 
    try {   
      if ( mEnumerate.hasMoreElements() )
      {
        retval = true;
      }
      else
      {
        while ( mAvailableChangeNum > mAppliedChangeNum ) {
          if ( count >= mUpdateSearchCount )
              break;
 
          searchChanges();
          count++;
          if (mEnumerate.hasMoreElements())
          {
            retval = true;
            break;
          }
          else
            mReadChangeNum = String.valueOf(mAppliedChangeNum);
        }
      }
    }
    catch( Exception ex ) 
    // BEGIN INFEASIBLE
    {
      throw (new ODIException(ODIException.LDAP_HASMORE_EXCEPTION,ex));
    }
    // END INFEASIBLE
    if (retval == false) {  // no more results
      mReadChangeNum = (new Integer(mAvailableChangeNum)).toString();
    }
    return retval;
  }
 
 
   /**
  ** Read the next change from the source
  **
  ** @return  Object  the header part of the changes read.
  */
  public Object getNextChange()
      throws ODIException
  {
    try {
 
      if ( mEnumerate.hasMoreElements() )
      {
        mResult = (SearchResult)mEnumerate.nextElement();
        mAttribs = mResult.getAttributes();
        
    }
    catch ( Exception e )
    // BEGIN INFEASIBLE
    {
      throw (new ODIException (ODIException.LDAP_GETNEXT_EXCEPTION, e));
    }
    // END INFEASIBLE
 
    return mAttribs;
  }
 
  /**
  ** Create the change record from the data read from the file.
  **
  ** @returns  ChangeRecord
  */
  public ChangeRecord createChangeRecord(String dn)
      throws ODIException
  {
 
      // Create the changerecord based on the mAttribs which contains all the attributes.
 
  }
 
  public String initAvailableChgKey() throws ODIException
  {
      // set the available changekey value. This reads the value equivalent to the latest changelog number in the ldap world.
 
   }
 
}

Sample Writer

 */
 
 
 
import oracle.ldap.odip.engine.AttrHandler;
import oracle.ldap.odip.engine.ChangeRecord;
import oracle.ldap.odip.engine.ConfigReader;
import oracle.ldap.odip.engine.Connector;
import oracle.ldap.odip.engine.Constants;
import oracle.ldap.odip.engine.DISWriteInterface;
import oracle.ldap.odip.engine.ODIException;
import oracle.ldap.odip.map.MapRules;
import oracle.ldap.odip.util.Utils;
 
import oracle.core.ojdl.logging.ODLLogger;
import oracle.core.ojdl.logging.ODLLevel;
import oracle.core.ojdl.logging.ODLHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
 
import oracle.ldap.odip.DIPLogger;
 
 
public class SampleWriter  implements DISWriteInterface {
    protected Hashtable mProfile;
    protected int mErrorCode = 0;
    protected String mLastKeyValue;
    protected String mLastWrittenKey;
    protected Vector mWriteFilter = new Vector();
    protected MapRules mMapRules;
    protected String mNamingContext = "";
    private String mOrigDstDn = "";
    protected boolean mHandleModAsAdd = false;
 
    /* Constructor */
    public LDAPWriter() {
    }
 
    public LDAPWriter(Connector conn) {
        super(conn);
    }
 
    public void initialise(Connector conn, Hashtable pHash)
        throws ODIException {
            m_logger.finest("Entry: LDAPWriter.initialise");    
        setValues(conn);
        mProfile = pHash;
        mMapRules = (MapRules) pHash.get(Constants.MAPRULE_STR);
        
        connect();
       ConfigReader configInfo = (ConfigReader) pHash.get(Constants.CONFINFO_STR);
 
        if (configInfo != null) {
            //mSearchDelta = configInfo.getSearchDeltaSize();
            mHandleModAsAdd = configInfo.getHandleModAsAdd();
        }
 
        mLastWrittenKey = (String) pHash.get(Constants.READERCHANGEKEY_STR);
        pHash.put("WRITECONTEXT", mLdapCtx);
 
        NamingEnumeration filter = (NamingEnumeration) pHash.get("WriteFilter");
 
        try {
            while (filter.hasMoreElements()) {
                mWriteFilter.add((String) filter.next());
            }
        } catch (Exception ex) {
            //System.out.println("Error in initializing filter");
        }
 
        /*
        ** Get the lastapplied changekey value from the profile
        ** and use that string to determine the 'lastappliedchangenum'
        ** or lastappliedchangetime to be stored as the 'lastkeyvalue'
        **
        ** Each of the insert/modify/delete routines, if the operation is
        ** successful, that lastkeyvalue is updated correspondingly. Otherwise
        ** it has the previous successful operation value
        */
        m_logger.finest ( "Exit: LDAPWriter.initialise" );
    }
 
    public void setChanges(ChangeRecord chgrec) {
        mChanges = chgrec;
    }
 
    public ChangeRecord getChanges() {
        return mChanges;
    }
 
    public String getLastChangeKey() {
        return mLastKeyValue;
    }
 
    public int writeChanges() throws ODIException {
            m_logger.finest("Entry: LDAPWriter.writeChanges");    
        mErrorCode = 0;
 
        m_logger.log(ODLLevel.FINE,
            "\n Output ChangeRecord " + mChanges.toString());
 
        String dn = mChanges.getChangeKey();
   
       if ( mHandleModAsAdd && (mChanges.getChangeType() == Constants.CHGTYPE_MODIFY)) {
            try {
              mLdapCtx.getAttributes( mChanges.getChangeKey() );
 
            }
            catch (NameNotFoundException nnfe) {
              m_logger.log(ODLLevel.ERROR,"ERROR_DN_CONN_DIR");
              mChanges.setChangeType(Constants.CHGTYPE_MODRADD);
            }
            catch (NamingException ne) {
              m_logger.log(ODLLevel.ERROR,"LDAP_WNAMING_EXCEPTION" , ne);
            }
         
       }
        m_logger.log(ODLLevel.FINE, 
                     "Changetype is " + mChanges.getChangeType());
        mChanges.setChangeKey(ndn);
 
        if (dn.length() > 1) {
            //testnew(dn);
            switch (mChanges.getChangeType()) {
            case Constants.CHGTYPE_ADD:
 
                if (mChanges.size() > 0) {
                    insert();
                }
 
                break;
 
            case Constants.CHGTYPE_MODIFY:
                // non-changelog-based changes
                if (mChanges.size() > 0) {
                                     modify();
                }
                else {
                    mErrorCode = -1;
                }
 
                break;
 
            case Constants.CHGTYPE_DELETE:
                delete();
 
                break;
 
            case Constants.CHGTYPE_MODRADD:
 
                // non-changelog-based changes
                if (mChanges.size() > 0) {
                    modifyRadd();
                }
 
                break;
 
            case Constants.CHGTYPE_MODRDN:
                modRDNchangelog(dn);
 
                break;
 
            case Constants.CHGTYPE_MODDN:
                m_logger.log(ODLLevel.FINE,
                             "Processing moddn"); 
                modDNchangelog(dn);
                break;
  
            default:
 
                //INFEASIBLE
                break;
            }
        } else // BEGIN INFEASIBLE
         {
            m_logger.log(ODLLevel.ERROR,
                "ENTRY_NOT_EXISTS_DELETE");
            m_logger.log(ODLLevel.FINE,
                "Synchrozing a deletion, entry to delete is not found. Ignore.");
            mErrorCode = 99;
 
            return mErrorCode;
        }
 
        // END INFEASIBLE
        Object chgInfo = mChanges.getChangeInfo();
 
        try {
            if (chgInfo instanceof Attributes) {
                Attributes attrs = (Attributes) chgInfo;
                mLastKeyValue = (String) ((Attribute) attrs.get(mLastWrittenKey)).get();
            }
        } catch (Exception ex) {
            //System.out.println("Caught the exception here " + mErrorCode);
            if (mErrorCode != 0) {
                m_logger.log(ODLLevel.ERROR,
                    "EXCEPTION_FOR_DN", new Object [] { dn, new Integer ( mErrorCode ) , ex.toString()});
            }
        }
 
        mChanges.setChangeKey(mOrigDstDn);
 
        return mErrorCode;
    }
 
    public void insert() throws ODIException {
            m_logger.finest("Entry: LDAPWriter.insert");    
        String dn = mChanges.getChangeKey();
        Enumeration attrdtls = mChanges.getAll();
 
        m_logger.log(ODLLevel.FINE,
            "Processing Insert Operation ..");
 
        while (attrdtls.hasMoreElements()) {
            AttrHandler temp = (AttrHandler) attrdtls.nextElement();
            attr = attrHandlerToAttr((AttrHandler) temp);
            if (attr != null && temp.getAttrChgType() != Constants.ATTRCHGTYPE_DELETE) {
                attrs.put(attr);
            }
        }
        createEntry(dn, attrs);
        m_logger.finest("Exit: LDAPWriter.insert");  
    }
 
    public void modify() throws ODIException {
            m_logger.finest("Entry: LDAPWriter.modify");  
        String attrname = mChanges.getChangeKey();
 
        m_logger.log(ODLLevel.FINE,
            "Processing Modify Operation ..");
 
        int pos = attrname.indexOf('=');
 
        String naming = null;
 
        if (pos > 0) {
            naming = attrname.substring(0, pos).trim();
        }
 
    }
 
   
    /**
    * Delete the entry
    */
    public void delete() {
            m_logger.finest("Entry: LDAPWriter.delete");  
        try {
            m_logger.log(ODLLevel.FINE,
                "Processing Delete Operation ..");
 
         }
 
    /**
    ** Handle the ModRDN operation
    **
    ** @throws ODIException
    */
    protected void modDNchangelog(String newDn) throws ODIException {
      String newDN = null;
      m_logger.log(ODLLevel.FINE,
            "Processing change log based ModRDN operation .." +
            " DN passed in: " + newDn);
 
      String dn = mChanges.getChangeKey();
      
      
    }
 
    /**
    ** Handle the ModRDN operation
    **
    ** @throws ODIException
    */
    protected void modRDNchangelog(String newDn) throws ODIException {
    
    }
 
    protected void performModDN(String oldDN, String newDN)
        throws ODIException {
    }
 
    /*
    ** First check whether the 'dn' already exists.
    ** If exists,
    **     do a modify.
    ** else
    **     construct objectclasses and do a add
    */
 
    // public void modifyRadd(boolean rdn) throws ODIException
    public void modifyRadd() throws ODIException {
            m_logger.finest("Entry: LDAPWriter.modifyRadd");  
        
    }
 
    /**
    ** Compare the value with the old value, and replace it, if the new value
    ** is different from the old value
    */
    public void checkNReplace(String dn, Attributes attrs)
        throws ODIException {
           
    }
 
    //BEGIN INFEASIBLE
    public int getErrorCode() {
        return mErrorCode;
    }
    
   
    public int getChangeType() {
        return mChanges.getChangeType();
    }
  
    public String getEventType() {
        return "";
    }
 
    //END INFEASIBLE
}