This chapter contains the first part of the reference to the public functions for writing plug-ins. The following chapter contains the second part of the reference. This chapter includes the following sections:
In addition to a detailed description of each function, the function descriptions detail the function header file and syntax, the function parameters, the function return value, and possible memory concerns.
This section categorizes plug-in functions by functional area.
Table 16–1 Functions for Handling Parameter Blocks
Function |
Description |
---|---|
Frees a parameter block from memory. |
|
Gets the value from a parameter block. |
|
Creates a new parameter block. |
|
Sets the value of a parameter block. |
Table 16–2 Functions for Handling Memory
Function |
Description |
---|---|
Frees an existing array. |
|
Makes a copy of an existing berval structure. |
|
Makes a copy of an array of existing berval structures. |
|
Allocates space for an array of a number of elements of a specified size. |
|
Frees space allocated by the slapi_ch_malloc(), slapi_ch_realloc(), and slapi_ch_calloc() functions. |
|
Frees an existing string. |
|
Allocates space in memory. |
|
Changes the size of a block of allocated memory. |
|
Makes a copy of an existing string. |
Table 16–3 Functions for Handling Access Control
Function |
Description |
---|---|
Determines if the user requesting the current operation has the access rights to perform an operation on a given entry, attribute, or value. |
|
Determines if a user has the rights to perform the specified modifications on an entry. |
|
Determines whether or not the access control items (ACIs) on an entry are valid. |
Table 16–4 Functions for Handling Attributes
Function |
Description |
---|---|
Adds a value to an attribute. |
|
Returns the base type of an attribute. |
|
Duplicates an attribute. |
|
Gets the first value of an attribute. |
|
Determines if certain flags are set. |
|
Frees an attribute. |
|
Puts the values contained in an attribute into an array of berval structures. |
|
Gets the flags associated with an attribute. |
|
Puts the count of values of an attribute into an integer. |
|
Searches for an attribute type and gives its OID string. |
|
Gets the name of the attribute type. |
|
Copies attribute values into a value set. |
|
Initializes an empty attribute. |
|
Creates a new attribute. |
|
Gets the next value of an attribute. |
|
Returns a copy of the normalized attribute types. |
|
Compares two attributes. |
|
Compares two attribute names to determine if they represent the same attribute. |
|
Compares two attribute values. |
|
Determines if an attribute contains a given value. |
Table 16–5 Functions for Handling Basic Encoding Rule Values
Function |
Description |
---|---|
Compares two berval structures. |
|
Makes a copy of an existing berval structure. |
|
Makes a copy of an array of existing berval structures. |
Table 16–6 Functions for Handling Controls
Function |
Description |
---|---|
Creates an LDAPControl structure based on a BerElement, an OID, and a criticality flag. |
|
Retrieves an allocated array of object identifiers (OIDs) representing the controls supported by Directory Server. |
|
Determines whether or not the specified object identification (OID) identifies a control that is present in a list of controls. |
|
Makes an allocated copy of an LDAPControl. |
|
Registers the specified control with the server. This function associates the control with an object identification (OID). |
Table 16–7 Functions for Handling Distinguished Name Strings
Function |
Description |
---|---|
Gets a copy of the DN of the parent of an entry. |
|
Converts all characters in a DN to lowercase. |
|
Determines if a DN is the suffix of the local database. |
|
Determines if a DN is the suffix of the local database. |
|
Determines if a DN is the parent of a specific DN. |
|
Determines if a DN is the root DN for the local database. |
|
Determines if a DN is equal to a specified suffix. |
|
Converts a DN to canonical format. |
|
Converts a DN to canonical format and all characters to lower case. |
|
Normalizes part of a DN value. |
|
Gets the DN of the parent of an entry. |
|
Adds an RDN to a DN. |
Table 16–8 Functions for Handling Entries
Function |
Description |
---|---|
Generates an LDIF string description. |
|
Generates an LDIF string descriptions with options. |
|
Add components in an entry’s RDN. |
|
Adds a string value to an attribute in an entry. |
|
Adds a data value to an attribute in an entry. |
|
Adds a data value to an attribute in an entry. |
|
Allocates memory for a new entry. |
|
Deletes an attribute from an entry. |
|
Checks if an entry contains a specific attribute. |
|
Gets the first value as a string. |
|
Gets the first value as an integer. |
|
Gets the first value as a long. |
|
Gets the first value as an unsigned integer. |
|
Gets the first value as an unsigned long. |
|
Checks if an attribute in an entry contains a value. |
|
Adds an array to the attribute values in an entry. |
|
Replaces the attribute values in an entry. |
|
Replaces the values of an attribute with a string. |
|
Replaces the value of an attribute with an integer. |
|
Replaces the value of an attribute with a long. |
|
Replaces the value of an attribute with an unsigned integer. |
|
Replaces the value of an attribute with an unsigned long. |
|
Deletes a string from an attribute. |
|
Removes a Slapi_Value array from an attribute. |
|
Copies an entry, its DN, and its attributes. |
|
Finds the first attribute in an entry. |
|
Frees an entry from memory. |
|
Gets the DN from an entry. |
|
Returns the DN of an entry as a constant. |
|
Returns the NDN of an entry. |
|
Returns the Slapi_DN from an entry. |
|
Returns a Slapi_DN from an entry as a constant. |
|
Gets the unique ID from an entry. |
|
Determines if the specified entry has child entries. |
|
Initializes the values of an entry. |
|
Determines whether the entry is that of a directory super user. |
|
Adds an array of data values to an attribute in an entry. |
|
Finds the next attribute in an entry. |
|
Checks if values present in an entry’s RDN are also present as attribute values. |
|
Determines if an entry complies with the schema for its object class. |
|
Determines if a set of modifications to an entry comply with the schema. |
|
Sets the DN of an entry. |
|
Sets the Slapi_DN value in an entry. |
|
Returns the size of an entry. |
|
Determines if the attributes of an entry comply with attribute syntax rules. |
|
Finds the specified virtual attribute in the entry. |
|
Determines if an entry is the root DSE. |
|
Converts an LDIF description into an entry. |
Table 16–9 Functions for Handling Extended Operations
Function |
Description |
---|---|
Gets a copy of the object IDs (OIDs) of the extended operations. |
Table 16–10 Functions for Handling Filters
Function |
Description |
---|---|
Determines if two filters are identical. |
|
Frees the specified filter. |
|
Gets the attribute type for all simple filter choices. |
|
Gets the attribute type and the value from the filter. |
|
Gets the type of the specified filter. |
|
Gets the substring values from the filter. |
|
Gets the attribute type specified in the filter. |
|
Joins two specified filters. |
|
Gets the first filter that makes up the specified filter. |
|
Gets the next filter. |
|
Determines if the specified entry matches a particular filter. |
|
Determines if an entry matches a given filter. |
|
Determines if an entry matches a filter. |
|
Converts a string description of a search filter into a filter of the Slapi_Filter type. |
Table 16–11 Functions for Handling Internal Operations
Function |
Description |
---|---|
Prepare a Slapi_PBlock structure for an internal add operation involving a Slapi_Entry structure. |
|
Adds an LDAP add operation based on a parameter block to add a new directory entry. |
|
Prepare a Slapi_PBlock structure for an internal add operation. |
|
Performs an LDAP delete operation based on a parameter block to remove a directory entry |
|
Prepare a Slapi_PBlock structure for an internal delete operation. |
|
Frees search results. |
|
Performs an LDAP modify operation based on a parameter block to modify a directory entry. |
|
Prepare a Slapi_PBlock structure for an internal modify operation. |
|
Performs an LDAP modify RDN operation based on a parameter block to rename a directory entry. |
|
Prepare a Slapi_PBlock structure for an internal modify RDN operation. |
|
Performs an LDAP search operation based on a parameter block to search the directory. |
|
Performs an internal search operation to read one entry |
|
Performs an LDAP search operation based on a parameter block to search the directory. |
|
Prepare a Slapi_PBlock structure for an internal search operation. |
Table 16–12 Functions for Handling Matching Rules
Function |
Description |
---|---|
Free a Slapi_MatchingRuleEntry after registering the matching rule. |
|
Access a Slapi_MatchingRuleEntry. |
|
Allocate a Slapi_MatchingRuleEntry structure. |
|
Register a matching rule with the server. |
|
Modify a Slapi_MatchingRuleEntry. |
|
Call a matching rule filter index function. |
|
Get a pointer to the indexer factory function for a matching rule. |
Table 16–13 Functions for Handling Modifications
Function |
Description |
---|---|
Creates an array of LDAPMod from a Slapi_Entry. |
|
Determines if the proposed modifications to an entry comply with attribute syntax rules. |
|
Adds a value to a Slapi_Mod structure. |
|
Frees internals of Slapi_Mod structure. |
|
Dumps the contents of an LDAPMod to the server log. |
|
Frees a Slapi_Mod structure. |
|
Initializes a Slapi_Mod iterator and returns the first attribute value. |
|
Increments the Slapi_Mod iterator and returns the next attribute value. |
|
Gets the number of values in a Slapi_Mod structure. |
|
Gets the operation type of Slapi_Mod structure. |
|
Gets the attribute type of a Slapi_Mod structure. |
|
Initializes a Slapi_Mod structure. |
|
Initializes a Slapi_Mod structure that is a wrapper for an existing LDAPMod. |
|
Initializes a Slapi_Mod structure with a copy of an LDAPMod. |
|
Determines whether a Slapi_Mod structure is valid. |
|
Allocates a new Slapi_Mod structure. |
|
Removes the value at the current Slapi_Mod iterator position. |
|
Sets the operation type of a Slapi_Mod structure. |
|
Sets the attribute type of a Slapi_Mod. |
|
Creates a Slapi_Entry from an array of LDAPMod. |
|
Appends a new mod with a single attribute value to Slapi_Mods structure. |
|
Appends an LDAPMod to a Slapi_Mods structure. |
|
Appends a new mod to a Slapi_Mods structure, with attribute values provided as an array of Slapi_Value. |
|
Appends a new mod to a Slapi_Mods structure, with attribute values provided as an array of berval. |
|
Appends a Slapi_Mod to a Slapi_Mods structure. |
|
Appends a new mod to Slapi_Mods structure with a single attribute value provided as a string. |
|
Frees internals of a Slapi_Mods structure. |
|
Dumps the contents of a Slapi_Mods structure to the server log. |
|
Frees a Slapi_Mods structure. |
|
Initializes a Slapi_Mods iterator and returns the first LDAPMod. |
|
Initializes a Slapi_Mods iterator and returns the first mod wrapped in a Slapi_Mods structure. |
|
Gets a reference to the array of LDAPMod in a Slapi_Mods structure. |
|
Retrieves the array of LDAPMod contained in a Slapi_Mods structure. |
|
Increments the Slapi_Mods iterator and returns the next LDAPMod. |
|
Increments the Slapi_Mods iterator and returns the next mod wrapped in a Slapi_Mods. |
|
Gets the number of mods in a Slapi_Mods structure. |
|
Initializes a Slapi_Mods. |
|
Initializes a Slapi_Mods that is a wrapper for an existing array of LDAPMod. |
|
Initializes a Slapi_Mods structure from an array of LDAPMod. |
|
Inserts an LDAPMod into a Slapi_Mods structure after the current iterator position. |
|
Inserts an LDAPMod anywhere in a Slapi_Mods. |
|
Inserts an LDAPMod into a Slapi_Mods structure before the current iterator position. |
|
Inserts a Slapi_Mod anywhere in a Slapi_Mods. |
|
Inserts a Slapi_Mod into a Slapi_Mods structure before the current iterator position. |
|
Decrements the Slapi_Mods current iterator position. |
|
Allocates a new uninitialized Slapi_Mods structure. |
|
Removes the mod at the current Slapi_Mods iterator position. |
|
Removes the mod at the specified Slapi_Mods iterator position. |
Table 16–14 Functions for Handling Operations
Function |
Description |
---|---|
Determines if the client has abandoned the current operation. |
|
Gets the type of a Slapi_Operation. |
Table 16–15 Functions for Handling Passwords
Function |
Description |
---|---|
Determines whether or not a specified password matches one of the hashed values of an attribute. |
|
Determines whether or not a specified password matches one of the hashed values of an attribute. |
Table 16–16 Functions for Handling Roles
Function |
Description |
---|---|
Register a callback to determine the scope of a role. |
|
Checks if the entry pointed to contains the role indicated. |
|
Determine the scope of a role. |
Table 16–17 Functions for Handling SASL Mechanisms
Function |
Description |
---|---|
Gets an array of the names of the supported Simple Authentication and Security Layer (SASL) mechanisms. |
|
Registers the specified Simple Authentication and Security Layer (SASL) mechanism with the server. |
Table 16–18 Functions for Handling Slapi_Backend Structures
Function |
Description |
---|---|
Checks if the backend that contains the specified DN exists. |
|
Returns the name of the specified backend. |
|
Indicates if the database associated with the backend is in read-only mode. |
|
Returns the n+1 suffix associated with the specified backend. |
|
Returns the type of the backend. |
|
Checks if a flag is set in the backend configuration. |
|
Verifies that the specified suffix matches a registered backend suffix. |
|
Indicates if the changes applied to the backend should be logged in the change log. |
|
Verifies if the backend is private. |
|
Finds the backend that should be used to service the entry with the specified DN. |
|
Find the backend used to service the database. |
|
Returns a pointer of the backend structure of the first backend. |
|
Returns a pointer to the next backend. |
|
Checks if a suffix is a root suffix of the DIT. |
Table 16–19 Functions for Handling Slapi_DN Structures
Function |
Description |
---|---|
Builds the new DN of an entry. |
|
Compares two DNs. |
|
Copies a DN. |
|
Clears a Slapi_DN structure. |
|
Duplicates a Slapi_DN structure. |
|
Frees a Slapi_DN structure. |
|
Gets the DN of the parent within a specific backend. |
|
Gets the DN from a Slapi_DN structure. |
|
Gets the normalized DN of a Slapi_DN structure. |
|
Gets the length of the normalized DN of a Slapi_DN structure. |
|
Get the parent DN of a given Slapi_DN structure. |
|
Gets the RDN from a DN. |
|
Gets the suffix holding the entry specified by DN. |
|
Checks if there is a DN value stored in a Slapi_DN structure. |
|
Checks if a DN is the parent of the parent of a DN. |
|
Checks if a DN is the parent of a DN. |
|
Checks if a Slapi_DN structure contains a suffix of another. |
|
Allocates new Slapi_DN structure. |
|
Creates a new Slapi_DN structure pointing to an existing DN string. |
|
Creates a new Slapi_DN structure copying an existing DN string. |
|
Creates a new Slapi_DN structure pointing to a new copy of a DN string. |
|
Creates a new Slapi_DN structure pointing to an existing normalized DN. |
|
Creates a new Slapi_DN structure copying an existing normalized DN. |
|
Checks if an entry is in the scope of a certain base DN. |
|
Sets a DN value in a Slapi_DN structure pointing to an existing DN string. |
|
Sets a DN value in a Slapi_DN structure copying an existing DN string. |
|
Sets a DN value in a Slapi_DN structure pointing to a new copy of a DN string. |
|
Sets a normalized DN in a Slapi_DN structure pointing to an existing normalized DN string. |
|
Sets a normalized DN in a Slapi_DN structure copying an existing normalized DN string. |
|
Sets a new parent in an entry. |
|
Sets a new RDN for an entry. |
Table 16–20 Functions for Handling Slapi_RDN Structures
Function |
Description |
---|---|
Adds a new RDN to an existing RDN structure. |
|
Compares two RDNs. |
|
Checks if a Slapi_RDN structure holds any RDN matching a given type/value pair. |
|
Checks if a Slapi_RDN structure contains any RDN matching a given type. |
|
Clears a Slapi_RDN structure. |
|
Frees a Slapi_RDN structure. |
|
Gets the type/value pair of the first RDN. |
|
Gets the index of the RDN. |
|
Gets the position and the attribute value of the first RDN. |
|
Gets the RDN type/value pair from the RDN. |
|
Gets the number of RDN type/value pairs. |
|
Gets the RDN from a Slapi_RDN structure. |
|
Initializes a Slapi_RDN structure with NULL values. |
|
Initializes a Slapi_RDN structure from an existing DN string. |
|
Initializes a Slapi_RDN structure from an existing Slapi_RDN structure. |
|
Initializes a Slapi_RDN structure from an existing Slapi_DN structure. |
|
Checks if an RDN value is stored in a Slapi_RDN structure. |
|
Creates a new Slapi_RDN structure. |
|
Creates a new Slapi_RDN structure. |
|
Creates a new Slapi_RDN structure. |
|
Creates a new Slapi_RDN structure. |
|
Determines if and RDN complies with attribute syntax rules. |
Table 16–21 Functions for Handling Slapi_Value Structures
Function |
Description |
---|---|
Compares two values. |
|
Frees internals of a value. |
|
Duplicates a value. |
|
Frees a Slapi_Value structure from memory. |
|
Gets the berval structure of the value. |
|
Converts the value of an integer. |
|
Gets the length of a value. |
|
Converts a value into a long integer. |
|
Returns the value as a string. |
|
Converts the value into an unsigned integer. |
|
Converts the value into an unsigned long. |
|
Initializes a Slapi_Value structure with no values. |
|
Initializes a Slapi_Value structure from the berval structure. |
|
Initializes a Slapi_Value structure from a string. |
|
Initializes a Slapi_Value structure with a value contained in a string. |
|
Allocates a new Slapi_Value structure. |
|
Allocates a new Slapi_Value structure from a berval structure. |
|
Allocates a new Slapi_Value structure from a string. |
|
Allocates a new Slapi_Value structure and initializes it from a string. |
|
Allocates a new Slapi_Value from another Slapi_Value structure. |
|
Sets the value. |
|
Copies the value from a berval structure into a Slapi_Value structure. |
|
Sets the integer value of a Slapi_Value structure. |
|
Copies a string into the value. |
|
Sets the value. |
|
Copies the value of a Slapi_Value structure into another Slapi_Value structure. |
Table 16–22 Functions for Handling Slapi_ValueSet Structures
Function |
Description |
---|---|
Adds a Slapi_Value in the Slapi_ValueSet structure. |
|
Returns the number of values contained in a Slapi_ValueSet structure. |
|
Frees the values contained in the Slapi_ValueSet structure. |
|
Finds the value in a value set by using the syntax of an attribute. |
|
Gets the first value of a Slapi_ValueSet structure. |
|
Frees the specified Slapi_ValueSet structure and its members from memory. |
|
Resets a Slapi_ValueSet structure to no values. |
|
Allocates a new Slapi_ValueSet structure. |
|
Gets the next value from a Slapi_ValueSet structure. |
|
Copies the values of Slapi_Mod structure into a Slapi_ValueSet structure. |
|
Initializes a Slapi_ValueSet structure from another Slapi_ValueSet structure. |
Table 16–23 Functions for Handling UTF-8 Strings
Function |
Description |
---|---|
Checks if a string has an 8-bit character. |
|
Compares two UTF-8 strings. |
|
Compares a specified number of UTF-8 characters. |
|
Verifies if a UTF-8 character is lower case. |
|
Verifies if a single UTF-8 character is upper case. |
|
Converts a UTF-8 string to lower case. |
|
Converts a string made up of UTF-8 characters and converts it to upper case. |
|
Converts a UTF-8 character to lower case. |
|
Converts a lower case UTF-8 character to an upper case character. |
Table 16–24 Functions for Writing Log Messages
Function |
Description |
---|---|
Writes an error message to the server error log |
|
Writes an informational message to the server error log |
|
Writes a warning message to the server error log |
Table 16–25 Functions for Handling Virtual Attributes
Function |
Description |
---|---|
Determines if the value of the specified attribute type is virtually generated. |
|
Compares attribute type and name in a given entry. |
|
Frees the value set and type names. |
|
Returns the values for an attribute type from an entry. |
Table 16–26 Functions for Sending Entries, Referrals, and Results to Clients
Function |
Description |
---|---|
Processes an entry’s LDAP v3 referrals. |
|
Sends a result code back to the client. |
|
Sends an entry found by a search back to the client. |
Table 16–27 Function for Registering Plug-Ins
Function |
Description |
---|---|
Register another plug-in. |
The following sections cover plug-in API functions in alphabetical order from slapi_access_allowed() to slapi_moddn_get_newdn().
Subsequent sections in the following chapter cover plug-in API functions from slapi_modify_internal_pb() to slapi_wait_condvar().
Determines if the user requesting the current operation has the access rights to perform an operation on a given entry, attribute, or value.
#include "slapi-plugin.h" int slapi_access_allowed( Slapi_PBlock *pb, Slapi_Entry *e, char *attr, struct berval *val, int access );
This function takes the following parameters:
Parameter block passed into this function.
Entry for which you want to check the access rights.
Attribute for which you want to check the access rights.
Pointer to the berval structure containing the value for which you want to check the access rights.
Type of access rights that you want to check. For example, to check for write access, pass SLAPI_ACL_WRITE as the value of this argument.
The value of the access argument can be one of the following:
Permission to add a specified entry.
Permission to compare the specified values of an attribute in an entry.
Permission to delete a specified entry.
Permission to read a specified attribute.
Permission to search on a specified attribute or value.
Permission to write a specified attribute or value or permission to rename a specified entry.
This function returns one of the following values:
LDAP_SUCCESS if the user has the specified rights to the entry, attribute, or value.
LDAP_INSUFFICIENT_ACCESS if the user does not have the specified rights to the entry, attribute, or value.
If a problem occurs during processing, the function will return one of the following error codes:
An error occurred while executing the operation.
This error can occur if, for example, the type of access rights specified are not recognized by the server. In other words, you did not pass a value from the previous table.
Invalid syntax was specified.
This error can occur if the ACL associated with an entry, attribute, or value uses the wrong syntax.
The DSA (this Directory Server instance) is unable to perform the specified operation.
This error can occur if, for example, you are requesting write access to a read-only database.
Call this function to determine if a user has access rights to a specified entry, attribute, or value. The function performs this check for users who request the operation that invokes this plug-in.
For example, suppose you are writing a preoperation plug-in for the add operation. You can call this function to determine if users have the proper access rights before they can add an entry to the directory.
As part of the process of determining if the user has access rights, this function does the following:
Checks if the user requesting the operation is the root DN.
If so, the function returns LDAP_SUCCESS. (The root DN has permission to perform any operation.)
Gets information about the operation being requested, the connection to the client, and the backend database where directory information is stored.
If for some reason the function cannot determine which operation is being requested, the function returns LDAP_OPERATIONS_ERROR.
If no connection to a client exists— in other words, if the request for the operation was made by the server or its backend— the function returns LDAP_SUCCESS. (The server and its backend are not restricted by access control lists.)
If the backend database is read-only and the request is checking for write access (SLAPI_ACL_WRITE), the function returns LDAP_UNWILLING_TO_PERFORM.
Determines if the user requesting the operation is attempting to modify his or her own entry.
ACLs can be set up to allow users the rights to modify their own entries. The function checks for this condition.
The caller must ensure that the backend specified in the parameter block is set prior to calling this function. For example:
be = slapi_be_select(slapi_entry_get_sdn_const(seObjectEntry)); if (NULL == be) { cleanup("backend selection failed for entry: \"%s\"\n", szObjectDN); slapi_send_ldap_result(pb,LDAP_NO_SUCH_OBJECT,NULL, "Obj not found",0,NULL); return(SLAPI_PLUGIN_EXTENDED_SENT_RESULT); } slapi_pblock_set(pb, SLAPI_BACKEND, be); nAccessResult = slapi_access_allowed(pb,seObjectEntry,"*",bval,SLAPI_ACL_DELETE);
Determines if a user has the rights to perform the specified modifications on an entry.
#include "slapi-plugin.h" int slapi_acl_check_mods( Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char **errbuf );
This function takes the following parameters:
Parameter block passed into this function.
Entry for which you want to check the access rights.
Array of LDAPMod structures that represent the modifications to be made to the entry.
Pointer to a string containing an error message if an error occurs during the processing of this function.
Returns one of the following values:
LDAP_SUCCESS if the user has write permission to the values in the specified attributes.
LDAP_INSUFFICIENT_ACCESS if the user does not have write permission to the values of the specified attribute.
If a problem occurs during processing, the function will return one of the following error codes:
An error occurred while executing the operation.
Invalid syntax was specified.
This error can occur if the ACL associated with an entry, attribute, or value uses the wrong syntax.
The DSA (this directory server) is unable to perform the specified operation.
This error can occur if, for example, you are requesting write access to a read-only database.
Call this function to determine if a user has access rights to modify the specified entry. The function performs this check for users who request the operation that invokes this plug-in.
For example, if you are writing a database plug-in, you can call this function to determine if users have the proper access rights before they can add, modify, or delete entries from the database.
As part of the process of determining if the user has access rights, the function does the following:
Checks to access control for the directory is disabled.
If access control is disabled, the function returns LDAP_SUCCESS.
For each value in each attribute specified in the LDAPMod array, the function determines if the user has permissions to write to that value. Specifically, the function calls slapi_access_allowed() with SLAPI_ACL_WRITE as the access right to check.
If for some reason the function cannot determine which operation is being requested, the function returns LDAP_OPERATIONS_ERROR.
If no connection to a client exists (in other words, if the request for the operation was made by the server or its backend), the function returns LDAP_SUCCESS. (The server and its backend are not restricted by access control lists.)
If the backend database is read-only and the request is checking for write access (SLAPI_ACL_WRITE), the function returns LDAP_UNWILLING_TO_PERFORM.
You must free the errbuf buffer by calling slapi_ch_free() when you are finished using the error message.
Determines whether or not the access control items (ACIs) on an entry are valid.
#include "slapi-plugin.h" int slapi_acl_verify_aci_syntax (Slapi_Entry *e, char **errbuf);
This function takes the following parameters:
Entry for which you want to check the ACIs.
Pointer to the error message returned if the ACI syntax is invalid.
This function returns 0 if successful, or -1 if an error occurs.
You must free the errbuf buffer by calling slapi_ch_free() when you are finished using the error message.
Prepares a parameter block for an internal add operation involving a Slapi_Entry structure.
#include "slapi-plugin.h" int slapi_add_entry_internal_set_pb(Slapi_PBlock *pb, Slapi_Entry *e, LDAPControl **controls, Slapi_ComponentId *plugin_identity, int operation_flags);
This function takes the following parameters:
Parameter block for the internal add operation
Entry to add
Array of controls to request for the add operation; NULL if no controls
Plug-in identifier obtained from SLAPI_PLUGIN_IDENTITY during plug-in initialization
NULL or SLAPI_OP_FLAG_NEVER_CHAIN
This function returns 0 if successful. Otherwise it returns an LDAP error code.
This function prepares a parameter block for use with slapi_add_internal_pb() using the entry.
Allocate the parameter block using slapi_pblock_new() before calling this function.
The entry is consumed during the call to slapi_add_internal_pb() . The LDAPControls are not consumed.
Free the parameter block after calling slapi_add_internal_pb() .
Performs an internal add operation of a new directory entry.
#include "slapi-plugin.h" int slapi_add_internal_pb(Slapi_PBlock *pb);
This function takes the following parameter:
A parameter block that has been initialized using slapi_add_internal_set_pb().
This function returns -1 if the parameter passed is a NULL pointer. Otherwise, it returns 0.
After your code calls this function, the server sets SLAPI_PLUGIN_INTOP_RESULT in the parameter block to the appropriate LDAP result code. You can therefore check SLAPI_PLUGIN_INTOP_RESULT in the parameter block to determine whether an error has occurred.
This function performs an internal add operation based on a parameter block. The parameter block should be initialized by calling slapi_add_internal_set_pb() or slapi_add_entry_internal_set_pb().
None of the parameters that are passed to slapi_add_internal_set_pb() or slapi_add_entry_internal_set_pb() are altered or consumed by this function. The entry parameter that is passed to slapi_add_entry_internal_set_pb() is consumed by a successful call to this function.
Prepares a parameter block for an internal add operation.
#include "slapi-plugin.h" int slapi_add_internal_set_pb(Slapi_PBlock *pb, const char *dn, LDAPMod **attrs, LDAPControl **controls, Slapi_ComponentId *plugin_identity, int operation_flags);
This function takes the following parameters:
Parameter block for the internal add operation
Distinguished Name of the entry to add
Array of attributes of the entry to add
Array of controls to request for the add operation
Plug-in identifier obtained from SLAPI_PLUGIN_IDENTITY during plug-in initialization
NULL or SLAPI_OP_FLAG_NEVER_CHAIN
This function returns 0 if successful. Otherwise, it returns an LDAP error code.
This function prepares a parameter block for use with slapi_add_internal_pb() using the components of the entry.
If the entry has already been prepared as a Slapi_Entry structure, use slapi_add_entry_internal_set_pb() instead.
Allocate the parameter block using slapi_pblock_new() before calling this function.
Directory Server does not free the parameters passed to this function.
Free the parameter block after calling slapi_pblock_destroy() .
slapi_add_entry_internal_set_pb()
Adds a value to an attribute.
#include "slapi-plugin.h" int slapi_attr_add_value(Slapi_Attr *a, const Slapi_Value *v);
This function takes the following parameters:
The attribute that will contain the values.
Values to be added to the attribute.
This function always returns 0.
Directory Server makes a copy of the Slapi_Value to be added to the attribute.
slapi_attr_first_value_const()
Returns the base type of an attribute.
#include "slapi-plugin.h" char *slapi_attr_basetype( char *type, char *buf, size_t bufsiz );
This function takes the following parameters:
Attribute type from which you wish to get the base type.
Buffer to hold the returned base type.
Size of the buffer.
This function returns NULL if the base type fits in the buffer. If the base type is longer than the buffer, the function allocates memory for the base type and returns a pointer to it.
This function returns the base type of an attribute (for example, if given cn;lang-jp, returns cn).
You should free the returned base type when you are finished by calling slapi_ch_free().
Duplicates an attribute.
#include "slapi-plugin.h" Slapi_Attr *slapi_attr_dup(const Slapi_Attr *attr);
This function takes the following parameter:
The attribute to be duplicated.
This function returns the newly created copy of the attribute.
Use this function to make a copy of an attribute.
You must free the returned attribute using slapi_attr_free() .
Gets the first value of an attribute.
#include "slapi-plugin.h" int slapi_attr_first_value_const( const Slapi_Attr *a, const Slapi_Value **v );
This function takes the following parameters:
Attribute containing the desired value.
Holds the first value of the attribute.
This function returns one of the following values:
0, which is the index of the first value.
-1 if NULL.
Use this function to get the first value of an attribute. This is part of a set of functions to enumerate over an Slapi_Attr structure.
Do not free the value held in v.
Determines if certain flags are set for a particular attribute.
#include "slapi-plugin.h" int slapi_attr_flag_is_set( Slapi_Attr *attr, unsigned long flag );
This function takes the following parameters:
Attribute that you want to check.
Flag that you want to check in the attribute.
The value of the flag argument can be one of the following:
Flag that determines if the attribute is single-valued.
Flag that determines if the attribute is an operational attribute.
Flag that determines if the attribute is read-only.
This function returns one of the following values:
1 if the specified flag is set.
0 if the specified flag is not set.
This function determines if certain flags are set for the specified attribute. These flags can identify an attribute as a single-valued attribute, an operational attribute, or as a read-only attribute, and are set from the schema when the Slapi_Attr structure is initialized.
Frees an attribute.
#include "slapi-plugin.h" void slapi_attr_free( Slapi_Attr **a );
This function takes the following parameters:
Attribute to be freed.
Use this function to free an attribute when you are finished with it.
Puts the values contained in an attribute into an array of berval structures.
#include "slapi-plugin.h" int slapi_attr_get_bervals_copy(Slapi_Attr *a, struct berval ***vals );
This function takes the following parameters:
Attribute that contains the desired values.
Pointer to an array of berval structure pointers to hold the desired values.
This function returns one of the following values:
0 if values are found.
-1 if NULL.
This function copies the values from an attribute into an array of berval structure pointers.
Free this array using ber_bvecfree(3LDAP).
Gets the flags associated with the specified attribute.
#include "slapi-plugin.h" int slapi_attr_get_flags( Slapi_Attr *attr, unsigned long *flags );
This function takes the following parameters:
Attribute for which you wish to get the flags.
When you call this function, this parameter is set to a pointer to the flags of the specified attribute. Do not free the flags; the flags are part of the actual data in the attribute, not a copy of the data.
To determine which flags have been set, you can use bitwise AND on the value of the flags argument with one or more of the following:
Flag that determines if the attribute is single-valued.
Flag that determines if the attribute is an operational attribute.
Flag that determines if the attribute is read-only.
This function returns 0 if successful.
This function gets the flags associated with the specified attribute. These flags can identify an attribute as a single-valued attribute, an operational attribute, or as a read-only attribute.
Puts the count of values of an attribute into a provided integer.
#include "slapi-plugin.h" int slapi_attr_get_numvalues( const Slapi_Attr *a, int *numValues);
This function takes the following parameters:
Attribute containing the values to be counted.
Integer to hold the counted values.
This function always returns 0.
This function counts the number of values in an attribute and places that count in an integer.
slapi_attr_first_value_const()
Searches the syntaxes for an attribute type, and returns a copy of its OID string.
#include "slapi-plugin.h" int slapi_attr_get_oid_copy( const Slapi_Attr *attr, char **oidp );
This function takes the following parameters:
Attribute that contains the desired type.
Destination string of the copied attribute type OID.
This function returns one of the following values:
0 if the attribute type is found.
-1 if it is not.
Use this function to search the syntaxes for an attribute type’s OID.
You should free this string using slapi_ch_free().
Gets a pointer to the syntax plug-in used to handle values of the attribute type in question.
#include "slapi-plugin.h" int slapi_attr_get_plugin( Slapi_Attr *a, void **plugin );
This function takes the following parameters:
Attribute whose associated syntax plug-in you want to access.
This parameter is set to a pointer to the plug-in registered to handle attributes of the type passed to this function. Do not free this pointer as it is not a copy.
This function returns 0.
Gets the name of the attribute type from a specified attribute.
#include "slapi-plugin.h" int slapi_attr_get_type( Slapi_Attr *attr, char **type );
This function takes the following parameters:
Attribute of which you wish to get the type.
When you call this function, this parameter is set to a pointer to the type of the specified attribute. Do not free this attribute type; the type is part of the actual data in the attribute, not a copy of the data.
This function returns 0 if successful.
Copies existing values contained in an attribute into a valueset.
#include "slapi-plugin.h" int slapi_attr_get_valueset(const Slapi_Attr *a, Slapi_ValueSet **vs);
This function takes the following parameters:
Attribute containing the values to be placed into a value set. This must be a valid attribute, not NULL.
Receives values from the first parameter.
This function always returns 0.
Free the value set in vs using slapi_valueset_free() .
slapi_valueset_add_value_optimised()
slapi_valueset_first_value_const()
slapi_valueset_next_value_const()
Initializes an empty attribute with a base type.
#include "slapi-plugin.h" Slapi_Attr *slapi_attr_init(Slapi_Attr *a, const char *type);
This function takes the following parameters:
The empty attribute to be initialized.
Attribute type to be initialized.
This function returns the newly initialized attribute, or an empty attribute if the type is not specified in the schema.
Use this function to initialize an empty attribute with an attribute type.
Directory Server makes a copy of the type string.
Creates a new attribute.
#include "slapi-plugin.h" Slapi_Attr *slapi_attr_new( void );
This function takes no parameters.
This function returns the newly created attribute
Use this function to create an empty attribute.
Gets the next value of an attribute.
#include "slapi-plugin.h" int slapi_attr_next_value_const( const Slapi_Attr *a, int index, const Slapi_Value **v );
This function takes the following parameters:
Attribute contained the desired value.
Index of the value to be returned, counting from 0.
Holds the value of the attribute.
This function returns one of the following values:
hint plus 1 if the value is found
-1 if NULL, or if a value at hint is not found
Use this function to get the next value of an attribute. The value of an attribute associated with an index is placed into a value. This is part of a set of functions to enumerate over a Slapi_Attr structure.
slapi_attr_first_value_const()
Searches for an attribute type in the syntaxes, and returns a copy of the normalized attribute types.
#include "slapi-plugin.h" char * slapi_attr_syntax_normalize( const char *s );
This function takes the following parameter:
Attribute type for which you wish to search.
This function returns the copy of the desired normalized attribute, or a normalized copy of what was passed in.
Use this function to search the syntaxes for an attribute type and return its normalized form. If the attribute type is not defined in the schema, this function returns a copy of the type folded to lower case.
You should free the returned string using slapi_ch_free() .
Compares two attribute types to determine if they are the same.
#include "slapi-plugin.h" int slapi_attr_type_cmp( char *t1, char *t2, int opt );
This function takes the following parameters:
Name of the first attribute type that you want to compare.
Name of the second attribute type that you want to compare.
One of the following values:
0 - Compare the types as is.
1 - Compare only the base names of the types (for example, if the type is cn;lang-en, the function compares only the cn part of the type).
2 - Ignore any options in the second type that are not in the first type. For example, if the first type is cn and the second type is cn;lang-en, the lang-en option in the second type is not part of the first type. In this case, the function considers the two types to be the same.
This function returns 0 if the type names are equal, or a non-zero value if they are not equal.
Compares two attribute names to determine if they represent the same attribute.
#include "slapi-plugin.h" int slapi_attr_types_equivalent( const char *t1, const char *t2 );
This function takes the following parameters:
Pointer to the first attribute type that you want to compare.
Pointer to the second attribute type that you want to compare.
This function returns the one of the following values:
1 if t1 and t2 represent the same attribute.
0 if t1 and t2 do not represent the same attribute.
slapi_attr_first_value_const()
Compares two values for a given attribute to determine if they are equal.
#include "slapi-plugin.h" int slapi_attr_value_cmp( Slapi_Attr *attr, struct berval *v1, struct berval *v2 );
This function takes the following parameters:
Attribute used to determine how these values are compared (for example, if the attribute contains case-insensitive strings, the strings are compared without regard to case).
Pointer to the berval structure containing the first value that you want to compare.
Pointer to the berval structure containing the second value that you want to compare.
This function returns one of the following values:
0 if the values are equal.
-1 if they are not equal.
slapi_attr_first_value_const()
Determines if an attribute contains a given value, using the equality matching rule.
#include "slapi-plugin.h" int slapi_attr_value_find( Slapi_Attr *a, struct berval *v );
This function takes the following parameters:
Attribute that you wish to check.
Pointer to the berval structure containing the value for which you wish to search.
This function returns one of the following values:
0 if the attribute contains a match for the specified value according to the equality matching rule.
As an example for CN, BABS JENSEN and Babs Jensen match.
-1 if the attribute does not contain the specified value.
slapi_attr_first_value_const()
Checks if the backend that contains the specified DN exists.
#include "slapi-plugin.h" int slapi_be_exist(const Slapi_DN *sdn);
This function takes the following parameter:
Pointer to the DN in the backends for which you are looking.
This function returns one of the following values:
1 if the backend containing the specified DN exists.
0 if the backend does not exist.
Returns the name of the specified backend.
#include "slapi-plugin.h" char * slapi_be_get_name(Slapi_Backend * be);
This function takes the following parameter:
Pointer to the structure containing the backend configuration.
This function returns the name associated to the specified backend.
You should not free the returned pointer.
Indicates if the database associated with the backend is in read-only mode.
#include "slapi-plugin.h" int slapi_be_get_readonly(Slapi_Backend *be);
This function takes the following parameter:
Pointer to the structure containing the backend configuration.
This function returns one of the following values:
0 if the database is not in read-only mode.
1 if the database is in read-only mode.
Returns the DN of the nth suffix associated with the specified backend.
#include "slapi-plugin.h" const Slapi_DN *slapi_be_getsuffix(Slapi_Backend *be, int n);
This function takes the following parameters:
Pointer to the structure containing the backend configuration.
Index, starting from 0.
This function returns the DN of the suffix if it exists, or NULL if there is no nth suffix in the backend.
This function returns the nth suffix, counting from 0, associated with the specified backend. This function is present for compatibility purposes with previous versions of the Directory Server Plug-In API.
You should not free the returned pointer.
Returns the type of the backend.
#include "slapi-plugin.h" const char * slapi_be_gettype(Slapi_Backend *be);
This function takes the following parameter:
Pointer to the structure containing the backend configuration.
This function returns the type of the backend. Backend types include:
chaining (used for chaining, also known as database links)
default (supporting only binds, used for Pass Through Authentication)
DSE (used for configuration parameters)
ldbm database (housing your directory data)
schema-internal (used for schema configuration)
You should not free the returned pointer.
Checks if a flag is set in the backend configuration.
#include "slapi-plugin.h" int slapi_be_is_flag_set(Slapi_Backend * be, int flag);
This function takes the following parameters:
Pointer to the structure containing the backend configuration.
Flag to check (SLAPI_BE_FLAG_REMOTE_DATA, SLAPI_BE_FLAG_SUSPENDED).
This function returns one of the following values:
0 if a flag is not set in the backend configuration.
1 if a flag is set.
Verifies that the specified suffix matches a registered backend suffix.
#include "slapi-plugin.h" int slapi_be_issuffix(const Slapi_Backend *be, const Slapi_DN *suffix);
This function takes the following parameters:
Pointer to the structure containing the backend configuration.
DN of the suffix for which you are looking.
This function returns one of the following values:
0 if the suffix is not part of the specified backend.
1 if the suffix is part of the specified backend.
This function checks if the specified suffix exactly matches a registered suffix on a specified backend.
Indicates if the changes applied to the LDBM database backend should be logged in the changelog. You can only read this value, not set it.
#include "slapi-plugin.h" int slapi_be_logchanges(Slapi_Backend *be);
This function takes the following parameter:
Pointer to the structure containing the backend configuration.
This function returns one of the following values:
0 if the changes applied to the specific backend should not be logged in the changelog.
1 if the changes should be logged in the changelog.
Verifies if the backend is private.
#include "slapi-plugin.h" int slapi_be_private( Slapi_Backend * be );
This function takes the following parameter:
Pointer to the structure containing the backend configuration.
This function returns one of the following values:
0 if the backend is not hidden from the user (for backend types chaining and ldbm database)
1 if the backend is hidden from the user (for internal use only, backend types default, DSE, schema-internal).
Finds the backend that should be used to service the entry with the specified DN.
#include "slapi-plugin.h" Slapi_Backend * slapi_be_select( const Slapi_DN * sdn );
This function takes the following parameter:
Pointer to the DN of which you wish to get the backend.
This function returns a pointer to the default backend, which is an empty backend allowing only bind operations, if no backend with the appropriate suffix is configured. Otherwise, it returns a pointer to the backend structure.
You should not free the returned pointer.
slapi_be_select_by_instance_name()
Find the backend used to service the database.
#include "slapi-plugin.h" Slapi_Backend *slapi_be_select_by_instance_name( const char *name );
This function takes the following parameter:
Pointer to the value of the CN for the backend whose structure you want, such as userRoot.
This function returns NULL if no backend with the appropriate name is configured. Otherwise, it returns a pointer to the backend structure.
This function finds the backend that should used to service the database named as the parameter.
You should not free the returned pointer.
Compare two berval structures.
#include "slapi-plugin.h" int slapi_berval_cmp(const struct berval* L,const struct berval* R);
This function takes the following parameters:
This function checks whether two berval structures are equivalent.
This function returns 0 if the two berval structures are equivalent. It returns a negative value if L is shorter than R, and a positive value if L is longer than R. If L and R are of the same size but their content differs, this function returns a negative value if L is less than R, or a positive value if L is greater than R, where L and R are compared as arrays of bytes.
Creates an LDAPControl structure based on a BerElement, an OID, and a criticality flag.
#include "slapi-plugin.h" int slapi_build_control( char const *oid, BerElement const *ber, char iscritical, LDAPControl **ctrlp );
This function takes the following parameters:
The OID (object identifier) for the control that is to be created.
A BerElement that contains the control value. Pass NULL if the control has no value.
The criticality flag. If non-zero, the control will be marked as critical. If 0, it will not be marked as critical.
Pointer that will receive the allocated LDAPControl structure.
This function returns LDAP_SUCCESS (LDAP result code) if successful.
This function creates an LDAPControl structure based on a BerElement, an OID, and a criticality flag. The LDAPControl that is created can be used in LDAP client requests or internal operations.
You can construct a BerElement using ber_init(3LDAP) for example.
Directory Server makes a copy of the oid string.
The contents of the ber parameter are the responsibility of the caller.
You can free the ber parameter of the slapi_build_control() using ber_free (3LDAP).
The LDAPControl pointer that is returned in ctrlp should be freed by calling ldap_control_free(3LDAP), which is an LDAP API function.
ber_free(3LDAP) ber_init(3LDAP) ldap_control_free(3LDAP)
slapi_build_control_from_berval()
Creates an LDAPControl structure based on a berval structure, an OID, and a criticality flag.
#include "slapi-plugin.h" int slapi_build_control_from_berval( char const *oid, struct berval *bvp, char iscritical, LDAPControl **ctrlp );
This function takes the following parameters:
The OID (object identifier) for the control that is to be created.
A berval that contains the control value. Pass NULL if the control has no value.
The criticality flag. If non-zero, the control will be marked as critical. If 0, it will not be marked as critical.
Pointer that will receive the allocated LDAPControl structure.
This function always returns LDAP_SUCCESS (LDAP result code).
This function creates an LDAPControl structure based on a berval, an OID, and a criticality flag. The LDAPControl that is created can be used in LDAP client requests or internal operations.
Directory Server makes a copy of the oid string.
The contents of the bvp parameter are consumed by this function. Because of this, the caller should not free the bvp->bv_val pointer once a successful call to this function has been made.
The LDAPControl pointer that is returned in ctrlp should be freed by calling ldap_control_free(3LDAP), which is an LDAP API function.
ldap_control_free(3LDAP)
Frees an existing array.
#include "slapi-plugin.h" void slapi_ch_array_free( char **arrayp );
This function takes the following parameter:
Pointer to the array to be freed. This parameter can be NULL.
This function frees the char ** pointed to by arrayp . In the following excerpt, for example, both array and a1 are freed:
char **array; char *a1; array = malloc(2*sizeof(char *)); a1 = strdup("hello"); array[0] = a1; array[1] = NULL; slapi_ch_array_free(array);
Makes a copy of an existing berval structure.
#include "slapi-plugin.h" struct berval* slapi_ch_bvdup( const struct berval *v );
This function takes the following parameter:
Pointer to the berval structure that you want to copy.
This function returns a pointer to the new copy of the berval structure. If the structure cannot be duplicated (for example, if no more virtual memory exists), the slapd program terminates.
The contents of the v parameter are not altered by this function. The returned berval structure should be freed by calling ber_bvfree(3LDAP), which is an LDAP API function.
ber_bvfree(3LDAP)
Makes a copy of an array of existing berval structures.
#include "slapi-plugin.h" extern struct berval** slapi_ch_bvecdup (const struct berval **v);
This function takes the following parameters:
Pointer to the array of berval structures that you want to copy.
This function returns a pointer to an array of the new copy of the berval structures. If the structures cannot be duplicated (for example, if no more virtual memory exists), the slapd program terminates.
The contents of the v parameter are not altered by this function. The returned berval structure should be freed by calling ber_bvfree(3LDAP), an LDAP API function.
ber_bvfree(3LDAP)
Allocates space for an array of a number of elements of a specified size.
#include "slapi-plugin.h" char * slapi_ch_calloc( unsigned long nelem, unsigned long size );
This function takes the following parameters:
Number of elements for which you wish to allocate memory.
Size in bytes of the element for which you wish to allocate memory.
This function returns a pointer to the newly allocated space of memory. If space cannot be allocated (for example, if no more virtual memory exists), the slapd program terminates.
This function should be called instead of the standard calloc() C function, and terminates the slapd server with an “out of memory” error message if memory cannot be allocated.
You should free the returned pointer by calling slapi_ch_free() .
Frees space allocated by the slapi_ch_malloc(),slapi_ch_realloc(), and slapi_ch_calloc() functions and sets the pointer to NULL. Call this function instead of the standard free() C function.
#include "slapi-plugin.h" void slapi_ch_free( void **ptr );
This function takes the following parameter:
Address of the pointer to the block of memory that you wish to free. If NULL, no action occurs.
The ptr passed to slapi_ch_free() should be the address of a pointer to memory allocated using a call to slapi_ch_malloc(),slapi_ch_realloc(),slapi_ch_calloc(), or slapi_ch_strdup() .
Frees an existing string allocated by the slapi_ch_malloc() ,slapi_ch_realloc(), and slapi_ch_calloc(). Call this function instead of the standard free() C function.
#include "slapi-plugin.h" void slapi_ch_free_string( char **s );
This function takes the following parameter:
Address of the string that you wish to free.
This function frees an existing string, and should be used in favor of slapi_ch_free() when using strings. It will perform compile-time error checking for incorrect error arguments, as opposed to slapi_ch_free(), which defeats the compile-time checking because you must cast the argument to (void**).
Allocates space in memory.
#include "slapi-plugin.h" char * slapi_ch_malloc( unsigned long size );
This function takes the following parameter:
Size in bytes of the space for which you wish to get the memory.
This function returns a pointer to the newly allocated space of memory. If space cannot be allocated (for example, if no more virtual memory exists), the slapd program terminates.
This function should be called instead of the standard malloc() C function, and terminates the slapd server with an “out of memory” error message if memory cannot be allocated.
The returned pointer should be freed by calling slapi_ch_free() .
Changes the size of a block of allocated memory.
#include "slapi-plugin.h" char * slapi_ch_realloc( char *block, unsigned long size );
This function takes the following parameters:
Pointer to an existing block of allocated memory.
New size (in bytes) of the block of memory you want allocated.
This function returns a pointer to the reallocated space of memory. If space cannot be allocated (for example, if no more virtual memory exists), the slapd program terminates.
This function should be called instead of the standard realloc() C function, and terminates the slapd server with an “out of memory” error message if memory cannot be allocated.
The block parameter passed to this function should be the address of a pointer that was allocated using a slapi call such as slapi_ch_malloc(),slapi_ch_calloc(), or slapi_ch_strdup().
The returned pointer should be freed by calling slapi_ch_free() .
Makes a copy of an existing string.
#include "slapi-plugin.h" char * slapi_ch_strdup( char *s );
This function takes the following parameter:
Pointer to the string you want to copy.
This function returns a pointer to a copy of the string. If space cannot be allocated (for example, if no more virtual memory exists), the slapd program terminates.
This function should be called instead of the standard strdup() C function, and terminates the slapd server with an “out of memory” error message if memory cannot be allocated.
The returned pointer should be freed by calling slapi_ch_free() .
Sets a callback for use by the server in evaluating which computed attributes to generate and include in an entry before returning a result to a client.
#include "slapi-plugin.h" int slapi_compute_add_evaluator(slapi_compute_callback_t fcn);
This function takes the following parameters:
Function to call when evaluating computed attributes
This function returns 0 if successful. Otherwise, it returns ENOMEM indicating that no memory could be allocated for the callback.
For a description of the callback, refer to slapi_compute_callback_t . Register the callback as part of plug-in initialization.
Sets callbacks for use by the server in searching against computed attributes.
#include "slapi-plugin.h" int slapi_compute_add_search_rewriter_ex( slapi_search_rewrite_callback_t function, slapi_search_rewrite_callback_t cleanup_function);
This function takes the following parameters:
Function to call to rewrite a filter for the search
Function to call to cleanup after performing the rewritten search
This function returns 0 if successful. Otherwise, it returns ENOMEM indicating that no memory could be allocated for the callback.
For a description of the callbacks, refer to the Chapter 15, Data Type and Structure Reference
Determines whether or not the specified object identifier (OID) identifies a control that is present in a list of controls.
#include "slapi-plugin.h" int slapi_control_present( LDAPControl **controls, char const *oid, struct berval **val, int *iscritical );
This function takes the following parameters:
List of controls that you want to check.
OID of the control that you want to find.
If the control is present in the list of controls, this function specifies the pointer to the berval structure containing the value of the control. If you do not want to receive a pointer to the control value, pass NULL for this parameter.
If the control is present in the list of controls, this function specifies whether or not the control is critical to the operation of the server:
0 means that the control is not critical to the operation.
1 means that the control is critical to the operation.
If you do not want to receive an indication of whether the control is critical or not, pass NULL for this parameter.
This function returns one of the following values:
1 if the specified control is present in the list of controls.
0 if the control is not present in the list of controls.
The val output parameter is set to point into the controls array. A copy of the control value is not made.
slapi_register_supported_control()
Performs an LDAP delete operation based on a parameter block to remove a directory entry.
#include "slapi-plugin.h" int slapi_delete_internal_pb(Slapi_PBlock *pb);
This function takes the following parameter:
A parameter block that has been initialized using slapi_delete_internal_set_pb().
This function returns -1 if the parameter passed is a NULL pointer. Otherwise, it returns 0.
After your code calls this function, the server sets SLAPI_PLUGIN_INTOP_RESULT in the parameter block to the appropriate LDAP result code. You can therefore check SLAPI_PLUGIN_INTOP_RESULT in the parameter block to determine whether an error has occurred.
This function performs an internal delete operation based on a parameter block. The parameter block should be initialized by calling slapi_delete_internal_set_pb() .
None of the parameters that are passed to slapi_delete_internal_set_pb() are altered or consumed by this function.
slapi_delete_internal_set_pb()
Prepares a parameter block for an internal delete operation.
#include "slapi-plugin.h" int slapi_delete_internal_set_pb(Slapi_PBlock *pb, const char *dn, LDAPControl **controls, const char *uniqueid, Slapi_ComponentId *plugin_identity, int operation_flags);
This function takes the following parameters:
Parameter block for the internal add operation
Distinguished Name of the entry to add
Array of controls to request for the add operation
Unique identifier for the entry if using this rather than DN.
Plug-in identifier obtained from SLAPI_PLUGIN_IDENTITY during plug-in initialization
NULL or SLAPI_OP_FLAG_NEVER_CHAIN
This function returns 0 if successful. Otherwise, it returns an LDAP error code.
This function prepares a parameter block for use with slapi_delete_internal_pb() using the components of the entry.
Allocate the parameter block using slapi_pblock_new() before calling this function.
Directory Server does not free the parameters you passed to this function.
Free the parameter block after calling slapi_delete_internal_pb() .
Frees a Slapi_CondVar structure from memory.
#include "slapi-plugin.h" void slapi_destroy_condvar( Slapi_CondVar *cvar );
This function takes the following parameters:
Pointer to the Slapi_CondVar structure that you want to free from memory.
This function frees a Slapi_CondVar structure from memory. Before calling this function, you should make sure that this condition variable is no longer in use.
Frees a Slapi_Mutex structure from memory.
#include "slapi-plugin.h" void slapi_destroy_mutex( Slapi_Mutex *mutex );
This function takes the following parameters:
Pointer to the Slapi_Mutex structure that you want to free from memory.
This function frees a Slapi_Mutex structure from memory. The calling function must ensure that no thread is currently in a lock-specific function. Locks do not provide self-referential protection against deletion.
Gets a copy of the distinguished name (DN) of the parent of an entry, unless the specified entry’s DN is the suffix of the local database.
If you do not want to check if the entry’s DN is the suffix of the local database, call the slapi_dn_parent() function instead.
#include "slapi-plugin.h" char *slapi_dn_beparent( Slapi_PBlock *pb, char *dn );
This function takes the following parameters:
Parameter block.
DN of the entry for which you want to find the parent.
This function returns the DN of the parent entry; or NULL if the specified DN is NULL, if the DN is an empty string, if the DN has no parent (for example, o=example.com), or if the specified DN is the suffix of the local database.
Converts all characters in a distinguished name (DN) to lowercase.
#include "slapi-plugin.h" char *slapi_dn_ignore_case( char *dn );
This function takes the following parameters:
DN that you want to convert to lowercase.
This function returns the DN with lowercase characters. Notice that the variable passed in as the dn argument is also converted in place.
Determines whether or not the specified distinguished name (DN) is the suffix of the local database. Before calling this function, you should call slapi_dn_normalize_case() to normalize the DN and convert all characters to lowercase.
#include "slapi-plugin.h" int slapi_dn_isbesuffix( Slapi_PBlock *pb, char *dn );
This function takes the following parameters:
Parameter block.
DN that you want to check.
This function returns 1 if the specified DN is the suffix for the local database, or 0 if the DN is not the suffix.
Determines whether or not the specified distinguished name (DN) is the suffix of the local database.
#include "slapi-plugin.h" int slapi_dn_isbesuffix_norm( Slapi_PBlock *pb, const char *dn );
This function takes the following parameters:
Parameter block.
DN that you want to check.
This function returns 1 if the specified DN is the suffix for the local database, or 0 if the DN is not the suffix.
Determines whether or not a particular DN is the parent of another specified DN. Before calling this function, you should call slapi_dn_normalize_case() to normalize the DNs and convert all characters to lowercase.
#include "slapi-plugin.h" int slapi_dn_isparent( const char *parentdn, char *childdn );
This function takes the following parameters:
Determine if this DN is the parent of childdn.
Determine if this DN is the child of parentdn.
This function returns a non-zero value if parentdn is the parent of childdn, or 0 if the parentdn is not the parent of childdn.
Determines if the specified DN is the root DN for this local database. Before calling this function, you should call slapi_dn_normalize_case() to normalize the DN and convert all characters to lowercase.
#include "slapi-plugin.h" int slapi_dn_isroot( Slapi_PBlock *pb, char *dn );
This function takes the following parameters:
Parameter block.
DN that you want to check.
This function returns 1 if the specified DN is the root DN of the local database, or 0 if the DN is not the root DN.
Determines if a DN is equal to the specified suffix. Before calling this function, you should call slapi_dn_normalize_case() to normalize the DN and convert all characters to lowercase.
If you want to determine if a DN is the same as the suffix for the local database, call the slapi_dn_isbesuffix_norm() function instead.
#include "slapi-plugin.h" int slapi_dn_issuffix( const char *dn, const char *suffix );
This function takes the following parameters:
DN that you want to check.
Suffix that you want compared against the DN.
This function returns 1 if the specified DN is the same as the specified suffix, or 0 if the DN is not the same as the suffix.
Converts a distinguished name (DN) to canonical format (no leading or trailing spaces, no spaces between components, and no spaces around the equals sign). For example, given the following DN:
cn = Moxie Cross , ou = Engineering , dc = example , dc = com
the function returns:
cn=Moxie Cross,ou=Engineering,dc=example,dc=com
#include "slapi-plugin.h" char *slapi_dn_normalize( char *dn );
This function takes the following parameters:
DN that you want to normalize.
This function returns the normalized DN. Notice that the variable passed in as the dn argument is also converted in place.
Converts a distinguished name (DN) to canonical format and converts all characters to lowercase. Calling this function has the same effect as calling the slapi_dn_normalize() function followed by the slapi_dn_ignore_case() function.
#include "slapi-plugin.h" char *slapi_dn_normalize_case( char *dn );
This function takes the following parameters:
DN that you want to normalize and convert to lowercase.
This function returns the normalized DN with all lowercase characters. Notice that variable passed in as the dn argument is also converted in-place.
Normalizes part of a DN value, specifically, the part going from what is pointed to by dn to that pointed to by end.
Notice that this routine does not NULL terminate the normalized bit pointed to by dn at the return of the function.
If the argument end happens to be NULL, this routine does basically the same thing as slapi_dn_normalize(), except for NULL terminating the normalized DN.
#include "slapi-plugin.h" char *slapi_dn_normalize_to_end( char *dn, char *end );
This function takes the following parameters:
DN value to be normalized.
Pointer to the end of what will be normalized from the DN value in dn. If this argument is NULL, the DN value in dn will be wholly normalized.
This function returns a pointer to the end of the dn that has been normalized. In other words, the normalized portion is from * dn to * (returnValue - 1).
Gets a copy of the distinguished name (DN) of the parent of an entry. Before calling this function, you should call slapi_dn_normalize_case() to normalize the DN and convert all characters to lowercase.
If you want to check if the DN is the suffix of the local database, call the slapi_dn_beparent() function instead.
#include "slapi-plugin.h" char *slapi_dn_parent( char *dn );
This function takes the following parameter:
DN of the entry for which you want to find the parent.
This function returns the DN of the parent entry. If the specified DN is NULL, if the DN is an empty string, or if the DN has no parent (for example, o=example.com), the function returns NULL.
Adds an RDN to DN.
#include "slapi-plugin.h" char *slapi_dn_plus_rdn( const char *dn, const char *rdn);
This function takes the following parameters:
DN value to which a new RDN is to be added.
RDN value that is to be added to the DN value in dn.
This function returns the new DN formed by adding the RDN value in rdn to the DN value in dn.
You must free the string returned with slapi_ch_free_string().
Makes an allocated copy of an LDAPControl.
#include "slapi-plugin.h" LDAPControl * slapi_dup_control( LDAPControl const *ctrl );
This function takes the following parameter:
Pointer to an LDAPControl structure whose contents are to be duplicated.
This function returns a pointer to an allocated LDAPControl structure if successful, or NULL if an error occurs.
This function duplicates the contents of an LDAPControl structure. All fields within the LDAPControl are copied to a new, allocated structure, and a pointer to the new structure is returned.
The structure that is returned should be freed by calling ldap_control_free(3LDAP) , an LDAP API function.
ldap_control_free(3LDAP)
Creates an array of LDAPMod from a Slapi_Entry.
#include "slapi-plugin.h" int slapi_entry2mods(const Slapi_Entry *e, char **dn, LDAPMod ***attrs);
This function takes the following parameters:
Pointer to a Slapi_Entry.
Address of a char* that will be set on return to the entry DN.
Address of an array of LDAPMod that will be set on return to a copy of the entry attributes.
This function returns one of the following values:
0 if successful.
non-0 if not successful.
This function creates an array of LDAPMod of type LDAP_MOD_ADD from a Slapi_Entry. Such structures may be useful for example when performing LDAP add and modify operations as a client from inside a plug-in.
Generates an LDIF string description of an LDAP entry.
#include "slapi-plugin.h" char *slapi_entry2str( Slapi_Entry const *e, int *len );
This function takes the following parameters:
Entry that you want to convert into an LDIF string.
Length of the returned LDIF string.
Returns the LDIF string representation of the entry you specify. If an error occurs, the function returns NULL.
This function generates an LDIF string value conforming to the following format:
dn: dn\n [attr: value\n]*
For example:
dn: uid=jdoe, ou=People, o=example.com cn: Jane Doe sn: Doe ...
To convert a string description in LDIF format to an entry of the Slapi_Entry data type, call the slapi_str2entry() function.
When you no longer need to use the string, you should free it from memory by calling the slapi_ch_free_string() function.
slapi_entry2str_with_options()
Generates a description of an entry as an LDIF string. This function behaves much like slapi_str2entry(). You can however specify output options with this function.
#include "slapi-plugin.h" char *slapi_entry2str_with_options( Slapi_Entry const *e, int *len, int options );
This function takes the following parameters:
Entry that you want to convert into an LDIF string.
Length of the LDIF string returned by this function.
An option set that specifies how you want the string converted.
You can OR together any of the following options when you call this function:
This function returns the LDIF string representation of the entry you specify or NULL if an error occurs.
This function generates an LDIF string value conforming to the following syntax:
dn: dn\n [attr: value\n]*
For example:
dn: uid=jdoe, ou=People, o=example.com cn: Jane Doe sn: Doe ...
To convert an entry described in LDIF string format to an LDAP entry using the Slapi_Entry data type, call the slapi_str2entry() function.
When you no longer need to use the string, you should free it from memory by calling the slapi_ch_free_string() function.
Adds the components in an entry’s relative distinguished name (RDN) to the entry as attribute values. (For example, if the entry’s RDN is uid=bjensen, the function adds uid=bjensen to the entry as an attribute value.)
#include "slapi-plugin.h" int slapi_entry_add_rdn_values( Slapi_Entry *e );
This function takes the following parameter:
Entry to which you want to add the RDN attributes.
This function returns one of the following values:
LDAP_SUCCESS if the values were successfully added to the entry. The function also returns LDAP_SUCCESS if the entry is NULL, if the entry’s DN is NULL, or if the entry’s RDN is NULL.
LDAP_INVALID_DN_SYNTAX if the DN of the entry cannot be parsed.
If the attribute type corresponding to the RDN already has a value matching the RDN value for equality, the value is not added. This function does not however examine other attrbute types not in the RDN, whose values may match the RDN value for equality.
Free the entry from memory by using slapi_entry_free() if the entry was allocated by the user.
Adds a string value to an attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_add_string (Slapi_Entry *e, const char *type, const char *value);
This function takes the following parameters:
Entry to which you want to add a string value.
Attribute to which you want to add a string value.
String value you want to add.
This function returns 0 when successful; any other value returned signals failure.
This function adds a string value to the existing attribute values in an entry. If the specified attribute does not exist in the entry, the attribute is created with the string value specified.
This function does not check whether the value is already present for the attribute. Use slapi_entry_attr_delete() before using this function.
This function also does not check whether the value added is a duplicate of an existing value.
This routine makes a copy of the parameter value. If value is NULL, the entry is not changed.
Adds a specified Slapi_Value data value to an attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_add_value (Slapi_Entry *e, const char *type, const Slapi_Value *value);
This function takes the following parameters:
Entry to which you want to add a value.
Attribute to which you want to add a value.
The Slapi_Value data value you want to add to the entry.
Returns 0 when successful; any other value returned signals failure.
This function adds a Slapi_Value data value to the existing attribute values in an entry. If the specified attribute does not exist in the entry, the attribute is created with the Slapi_Value specified.
This function does not check whether the value added is a duplicate of an existing value.
This routine makes a copy of the parameter value. If value is NULL, the entry is not changed.
Adds an array of Slapi_Value data values to the specified attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_add_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals );
This function takes the following parameters:
Entry to which you want to add values.
Attribute type to which you want to add values.
Array of Slapi_Value data values that you want to add.
Returns one of the following values:
LDAP_SUCCESS if the Slapi_Value array is successfully added to the attribute.
LDAP_TYPE_OR_VALUE_EXISTS if any values you are trying to add duplicate an existing value in the attribute.
LDAP_OPERATIONS_ERROR if there are pre-existing duplicate values in the attribute.
This function adds an array of Slapi_Value data values to an attribute. If the attribute does not exist, it is created and given the value contained in the Slapi_Value array.
This function replaces the deprecated slapi_entry_add_values() function. This function uses Slapi_Value attribute values instead of the berval attribute values.
This routine makes a copy of the parameter vals. vals can be NULL.
Add a Slapi_ValueSet data value to the specified attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs);
This function takes the following parameters:
Entry to which you want to add values.
Attribute type to which you want to add values.
Slapi_ValueSet data value that you want to add to the entry.
Returns 0 when successful; any other value returned signals failure.
This function adds a set of values to an attribute in an entry. The values added are in the form of a Slapi_ValueSet data type. If the entry does not contain the attribute specified, it is created with the specified Slapi_ValueSet value.
This routine makes a copy of the parameter vs. vs can be NULL.
Allocates memory for a new entry of the data type Slapi_Entry .
#include "slapi-plugin.h" Slapi_Entry *slapi_entry_alloc();
Returns a pointer to the newly allocated entry of the data type Slapi_Entry. If space cannot be allocated (for example, if no more virtual memory exists), the slapd program terminates.
This function returns an empty Slapi_Entry structure.
When you are no longer using the entry, you should free it from memory by calling the slapi_entry_free() function.
Deletes an attribute (and all its associated values) from an entry.
#include "slapi-plugin.h" int slapi_entry_attr_delete( Slapi_Entry *e, const char *type );
This function takes the following parameters:
Entry from which you want to delete the attribute.
Attribute type that you want to delete.
This function returns one of the following values:
0 if successful.
1 if the specified attribute is not part of the entry.
-1 if an error occurred.
Determines if an entry contains the specified attribute. If the entry contains the attribute, the function returns a pointer to the attribute.
#include "slapi-plugin.h" int slapi_entry_attr_find( const Slapi_Entry *e, const char *type, Slapi_Attr **attr );
This function takes the following parameters:
Entry that you want to check.
Name of the attribute that you want to check.
Pointer to the attribute, if the attribute is in the entry.
This function returns 0 if the entry contains the specified attribute; otherwise it returns -1.
Do not free the returned attr. It is a pointer to the internal entry data structure. It is usually wise to make a copy of the returned attr, using slapi_attr_dup(), to avoid dangling pointers if the entry is freed while the pointer to attr is still being used.
Gets the first value of an attribute in an entry as a string.
#include "slapi-plugin.h" char *slapi_entry_attr_get_charptr(const Slapi_Entry* e, const char *type);
This function takes the following parameters:
Entry from which you want to get the string value.
Attribute type from which you want to get the value.
This function returns a copy of the first value in the attribute, or NULL if the entry does not contain the attribute.
When you are done working with this value, you should free it from memory by calling the slapi_ch_free() function.
Gets the first value of an attribute in an entry as an integer.
#include "slapi-plugin.h" int slapi_entry_attr_get_int(const Slapi_Entry* e,const char *type);
This function takes the following parameters:
Entry from which you want to get the integer value.
Attribute type from which you want to get the value.
Returns the first value in the attribute converted to an integer or 0 if the entry does not contain the attribute.
Gets the first value of an attribute in an entry as a long data type.
#include "slapi-plugin.h" long slapi_entry_attr_get_long( const Slapi_Entry* e, const char *type);
This function takes the following parameters:
Entry from which you want to get the long value.
Attribute type from which you want to get the value.
This function returns the first value in the attribute converted to a long type. The function returns 0 if the entry does not contain the attribute specified.
Gets the first value of an attribute in an entry as a unsigned integer data type.
#include "slapi-plugin.h" unsigned int slapi_entry_attr_get_uint( const Slapi_Entry* e, const char *type);
This function takes the following parameters:
Entry from which you want to get the value.
Attribute type from which you want to get the value.
This function returns the first value in the attribute converted to an unsigned integer. The function returns 0 if the entry does not contain the attribute specified.
Gets the first value of an attribute in an entry as a unsigned long data type.
#include "slapi-plugin.h" unsigned long slapi_entry_attr_get_ulong( const Slapi_Entry* e, const char *type);
This function takes the following parameters:
Entry from which you want to get the value.
Attribute type from which you want to get the value.
This function returns the first value in the attribute converted to an unsigned long. The function returns 0 if the entry does not contain the attribute specified.
This function is deprecated. It determines if an attribute in an entry contains a specified value by comparing the specified value as a string with the existing values, and does not compare using the equality matching rule.
#include "slapi-plugin.h" int slapi_entry_attr_hasvalue(Slapi_Entry *e, const char *type, const char *value);
This function takes the following parameters:
Entry that you want to check.
Attribute type that you want to test for the value specified.
Value that you want to find in the attribute.
Returns one of the following values:
1 if the attribute contains the specified value.
0 if the attribute does not contain the specified value.
value must not be NULL.
Adds an array of Slapi_Value data values to the existing attribute values in an entry. If the attribute does not exist, it is created with the Slapi_Value specified.
#include "slapi-plugin.h" int slapi_entry_attr_merge_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals );
This function takes the following parameters:
Entry to which you want to add values.
Attribute to which you want to add values.
Array of Slapi_Value data values you want to add.
Returns 0 if successful; any other value returned signals failure.
This function replaces the deprecated slapi_entry_attr_merge() function. This function uses Slapi_Value attribute values instead of the berval attribute values.
This function makes a copy of the parameter vals. vals can be NULL.
Replaces the values of an attribute with the Slapi_Value data value you specify.
#include "slapi-plugin.h" int slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals );
This function takes the following parameters:
Entry in which you want to replace values.
Attribute type which will receive the replaced values.
Array containing the Slapi_Value values that should replace the existing values of the attribute.
This function returns 0 when successful; any other value returned signals failure.
This function replaces existing attribute values in a specified entry with a single Slapi_Value data value. The function first deletes the existing attribute from the entry, then replaces it with the new value specified.
This function replaces the deprecated slapi_entry_attr_replace() function. This function uses Slapi_Value attribute values instead of the berval attribute values.
This function makes a copy of the parameter vals. vals can be NULL.
Replaces the value or values of an attribute in an entry with a specified string value.
#include "slapi-plugin.h" void slapi_entry_attr_set_charptr(Slapi_Entry* e, const char *type, const char *value);
This function takes the following parameters:
Entry in which you want to set the value.
Attribute type in which you want to set the value.
String value that you want to assign to the attribute.
This function makes a copy of the parameter values. values can be NULL, and if so, this function is roughly equivalent to slapi_entry_attr_delete().
Replaces the value or values of an attribute in an entry with a specified integer data value.
#include "slapi-plugin.h" void slapi_entry_attr_set_int(Slapi_Entry* e, const char *type, int l);
This function takes the following parameters:
Entry in which you want to set the value.
Attribute type in which you want to set the value.
Integer value that you want assigned to the attribute.
This function will replace the value or values of an attribute with the integer value that you specify. If the attribute does not exist, it is created with the integer value that you specify.
Replaces the value or values of an attribute in an entry with a specified long data type value.
#include "slapi-plugin.h" void slapi_entry_attr_set_long(Slapi_Entry* e, const char *type, unsigned long l);
This function takes the following parameters:
Entry in which you want to set the value.
Attribute type in which you want to set the value.
Long integer value that you want assigned to the attribute.
Replaces the value or values of an attribute in an entry with a specified unsigned integer data type value.
#include "slapi-plugin.h" void slapi_entry_attr_set_uint(Slapi_Entry* e, const char *type, unsigned int l);
This function takes the following parameters:
Entry in which you want to set the value.
Attribute type in which you want to set the value.
Unsigned integer value that you want assigned to the attribute.
This function will replace the value or values of an attribute with the unsigned integer value that you specify. If the attribute does not exist, it is created with the unsigned integer value you specify.
Replaces the value or values of an attribute in an entry with a specified unsigned long data type value.
#include "slapi-plugin.h" void slapi_entry_attr_set_ulong(Slapi_Entry* e, const char *type, unsigned long l);
This function takes the following parameters:
Entry in which you want to set the value.
Attribute type in which you want to set the value.
Unsigned long value that you want assigned to the attribute.
This function will replace the value or values of an attribute with the unsigned long value that you specify. If the attribute does not exist, it is created with the unsigned long value that you specify.
Deletes a string value from an attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value);
This function takes the following parameters:
Entry from which you want the string deleted.
Attribute type from which you want the string deleted.
Value of string to delete.
Returns 0 when successful; any other value returned signals failure.
Removes an array of Slapi_Value data values from an attribute in an entry.
#include "slapi-plugin.h" int slapi_entry_delete_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals );
This function takes the following parameters:
Entry from which you want to delete values.
Attribute from which you want to delete values.
Array of Slapi_Value data values that you want to delete.
Returns LDAP_SUCCESS if the specified attribute and the array of Slapi_Value data values are deleted from the entry.
If the specified attribute contains a NULL value, the attribute is deleted from the attribute list and the function returns LDAP_NO_SUCH_ATTRIBUTE . Additionally, if the attribute is not found in the list of attributes for the specified entry, the function returns LDAP_NO_SUCH_ATTRIBUTE.
If there is an operational error during the processing of this call (such as a duplicate value found), the function will return LDAP_OPERATIONS_ERROR . If this occurs, please report the problem to Sun support services.
This function removes an attribute/value set from an entry. Notice that both the attribute and its Slapi_Value data values are removed from the entry. If you supply a Slapi_Value whose value is NULL, the function will delete the specified attribute from the entry. In either case, the function returns LDAP_SUCCESS.
This function replaces the deprecated slapi_entry_delete_values() function. This function uses Slapi_Value attribute values instead of the berval attribute values.
The vals parameter can be NULL, in which case, this function does nothing.
Makes a copy of an entry, its DN, and its attributes.
#include "slapi-plugin.h" Slapi_Entry *slapi_entry_dup( const Slapi_Entry *e );
This function takes the following parameter:
Entry that you want to copy.
This function returns the new copy of the entry. If the structure cannot be duplicated (for example, if no more virtual memory exists), the slapd program terminates.
This function returns a copy of an existing Slapi_Entry structure. You can call other front-end functions to change the DN and attributes of this entry.
When you are no longer using the entry, you should free it from memory by calling the slapi_entry_free() function.
Finds the first attribute in an entry. If you want to iterate through the attributes in an entry, use this function in conjunction with the slapi_entry_next_attr() function.
#include "slapi-plugin.h" int slapi_entry_first_attr( Slapi_Entry *e, Slapi_Attr **attr );
This function takes the following parameters:
Entry from which you want to get the attribute.
Pointer to the first attribute in the entry.
Returns 0 when successful; any other value returned signals failure.
Do not free the returned attr. This is a pointer into the internal entry data structure. If you need a copy, use slapi_attr_dup() .
Frees an entry, its DN, and its attributes from memory.
#include "slapi-plugin.h" void slapi_entry_free( Slapi_Entry *e );
This function takes the following parameter:
Entry that you want to free. If NULL, no action occurs.
Call this function to free an entry that you have allocated by using the slapi_entry_alloc() function or the slapi_entry_dup() function.
To free entries, always use this function, as opposed to using slapi_ch_free(), or free().
Gets the distinguished name (DN) of the specified entry.
#include "slapi-plugin.h" char *slapi_entry_get_dn( Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to get the DN.
This function returns the DN of the entry. Notice that this returns a pointer to the actual DN in the entry, not a copy of the DN. You should not free the DN unless you plan to replace it by calling slapi_entry_set_dn().
Use slapi_ch_free() if you are replacing the DN with slapi_entry_set_dn().
Returns as a const the DN value of the entry that you specify.
#include "slapi-plugin.h" const char *slapi_entry_get_dn_const( const Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to get the DN as a constant.
This function returns the DN of the entry that you specify. The DN is returned as a const; you are not able to modify the DN value. If the DN of the Slapi_DN object is NULL, the NDN value of Slapi_DN is returned.
Never free this value.
Returns the normalized DN from the entry that you specify.
#include "slapi-plugin.h" char *slapi_entry_get_ndn( Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to obtain the normalized DN.
This function returns the normalized DN from the entry that you specify. If the entry you specify does not contain a normalized DN, one is created through the processing of this function.
Never free this value.
Returns the Slapi_DN object from the entry that you specify.
#include "slapi-plugin.h" Slapi_DN *slapi_entry_get_sdn( Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to get the Slapi_DN object.
This function returns the Slapi_DN object from the entry that you specify.
Never free this value. If you need a copy, use slapi_sdn_dup() .
Returns as a const the value of the Slapi_DN object from the entry that you specify.
#include "slapi-plugin.h" const Slapi_DN *slapi_entry_get_sdn_const ( const Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to get the Slapi_DN object.
Returns as a const the value of the Slapi_DN object from the entry that you specify.
Never free this value. If you need a copy, use slapi_sdn_dup() .
Gets the unique ID value of the entry.
#include "slapi-plugin.h" const char *slapi_entry_get_uniqueid( const Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want obtain the unique ID.
This function returns the unique ID value of the entry specified.
Never free this value. If you need a copy, use slapi_ch_strdup() .
This function determines if the specified entry has child entries in the backend where it resides.
#include "slapi-plugin.h" int slapi_entry_has_children( const Slapi_Entry *e );
This function takes the following parameter:
Entry that you want to test for child entries.
This function returns 1 if the entry you supply has child entries in the backend where it resides; otherwise it returns 0. Notice that if a subsuffix is in another backend, this function does not find children contained in that subsuffix.
Initializes the values of an entry with the DN and attribute value pairs you supply.
#include "slapi-plugin.h" void slapi_entry_init(Slapi_Entry *e, char *dn, Slapi_Attr *a);
This function takes the following parameters:
The entry you want to initialize.
The DN of the entry you are initializing.
Initialization list of attribute value pairs, supplied as a Slapi_Attr data value.
This function initializes the attributes and the corresponding attribute values of an entry. Also, during the course of processing, the unique ID of the entry is set to NULL and the flag value is set to 0.
Use this function to initialize a Slapi_Entry pointer.
This function should always be used after slapi_entry_alloc() , and never otherwise. For example:
Slapi_Entry *e = slapi_entry_alloc(); slapi_entry_init(e, NULL, NULL);
To set the DN in the entry:
slapi_sdn_set_dn_passin(slapi_entry_get_sdn(e), dn);
In this case, the dn argument is not copied, but is consumed by the function. To copy the argument, see the following example:
char *dn = slapi_ch_strdup(some_dn); Slapi_Entry *e = slapi_entry_alloc(); slapi_entry_init(e, dn, NULL);
dn is not freed in this context, but is eventually be freed when slapi_entry_free() is called.
Identifies whether the entry having the specified DN is a root DN (directory super user).
#include "slapi-plugin.h" into slapi_entry_isroot( const char *dn );
This function takes the following parameter:
The DN of the entry to check.
This function returns one of the following values:
The entry with the specified DN is that of a root user (directory super user).
The entry with the specified DN is not that of a root user.
Merges (adds) an array of Slapi_Value data values to a specified attribute in an entry. If the entry does not contain the attribute specified, the attribute is created with the value supplied.
#include "slapi-plugin.h" int slapi_entry_merge_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals );
This function takes the following parameters:
Entry into which you want to merge values.
Attribute type that contains the values you want to merge.
Values that you want to merge into the entry. Values are of type Slapi_Value.
This function returns either LDAP_SUCCESS or LDAP_NO_SUCH_ATTRIBUTE .
This function adds additional Slapi_Value data values to the existing values contained in an attribute. If the attribute type does not exist, it is created.
If the specified attribute exists in the entry, the function merges the value specified and returns LDAP_SUCCESS. If the attribute is not found in the entry, the function creates it with the Slapi_Value specified and returns LDAP_NO_SUCH_ATTRIBUTE.
Notice that if this function fails, it leaves the values for type within a pointer to e in an indeterminate state. The present value set may be truncated.
This function makes a copy of vals. vals can be NULL.
Finds the next attribute after prevattr in an entry. To iterate through the attributes in an entry, use this function in conjunction with the slapi_entry_first_attr() function.
#include "slapi-plugin.h" int slapi_entry_next_attr( Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr **attr );
This function takes the following parameters:
Entry from which you want to get the attribute.
Previous attribute in the entry.
Pointer to the next attribute after prevattr in the entry.
This function returns 0 if successful or -1 if prevattr was the last attribute in the entry.
Never free the returned attr. Use slapi_attr_dup() to make a copy if a copy is needed.
Determines if the values in an entry’s relative distinguished name (RDN) are also present as attribute values. (For example, if the entry’s RDN is cn=Barbara Jensen, the function determines if the entry has the cn attribute with the value Barbara Jensen.)
#include "slapi-plugin.h" int slapi_entry_rdn_values_present( Slapi_Entry *e );
This function takes the following parameter:
Entry from which you want to get the attribute.
This function returns 1 if the values in the RDN are present in attributes of the entry or 0 if the values are not present.
Determines whether or not the specified entry complies with the schema for its object class.
#include "slapi-plugin.h" int slapi_entry_schema_check( Slapi_PBlock *pb, Slapi_Entry *e );
This function takes the following parameters:
Parameter block.
Entry of which you want to check the schema.
Returns one of the following values:
0 if the entry complies with the schema or if schema checking is turned off. The function also returns 0 if the entry has additional attributes not allowed by the schema and has the object class extensibleObject.
1 if the entry is missing the objectclass attribute, if it is missing any required attributes, if it has any attributes not allowed by the schema (but does not have the object class extensibleObject ), or if the entry has multiple values for a single-valued attribute.
The pb argument can be NULL. It is used only to get the SLAPI_IS_REPLICATED_OPERATION flag. If that flag is present, no schema checking is done.
Determines whether or not the proposed modifications to the specified entry comply with the schema for the entry's object class. This function does not check existing attributes not affected by the modifications.
#include "slapi-plugin.h" int slapi_entry_schema_check_ext( Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods );
This function takes the following parameters:
Parameter block.
Entry of which you want to check the schema.
Pointer to the modify structure whose attribute values are to be checked.
Returns one of the following values:
0 if the proposed modifications to the entry comply with the schema or if schema checking is turned off. The function also returns 0 if the entry has additional attributes not allowed by the schema and has the object class extensibleObject.
1 if the modifications cause the objectclass attribute or other required attributes to be missing, if the modifications add any attributes not allowed by the schema, or if the modifications result in multiple values for a single-valued attribute.
The pb argument can be NULL. It is used only to get the SLAPI_IS_REPLICATED_OPERATION flag. If that flag is present, no schema checking is done.
Sets the distinguished name (DN) of an entry.
#include "slapi-plugin.h" void slapi_entry_set_dn( Slapi_Entry *e, char *dn );
This function takes the following parameters:
Entry to which you want to assign the DN.
Distinguished name you want assigned to the entry.
This function sets a pointer to the DN supplied in the specified entry.
dn is freed when slapi_entry_free() is called.
A copy of dn should be passed, for example:
char *dn = slapi_ch_strdup(some_dn); slapi_entry_set_dn(e, dn);
The old dn is freed as a result of this call. Do not pass in a NULL value.
Sets the Slapi_DN value in an entry.
#include "slapi-plugin.h" void slapi_entry_set_sdn( Slapi_Entry *e, const Slapi_DN *sdn );
This function takes the following parameters:
Entry to which you want to set the value of the Slapi_DN.
The specified Slapi_DN value that you want to set.
This function sets the value for the Slapi_DN object in the entry you specify.
This function makes a copy of the sdn argument.
This function returns the approximate size of an entry, rounded to the nearest 1k. This can be useful for checking cache sizes, estimating storage needs, and so on.
#include "slapi-plugin.h" size_t slapi_entry_size(Slapi_Entry *e);
This function takes the following parameter:
Entry from which you want the size returned.
This function returns the size of the entry, rounded to the nearest 1k. The value returned is a size_t data type, with is a u_long value. If the entry is empty, a size of 1k is returned.
When determining the size of an entry, only the sizes of the attribute values are counted; the size of other entry values (such as the size of attribute names, variously-normalized DNs, or any metadata) are not included in the size returned. It is assumed that the size of the metadata is well enough accounted for by the rounding of the size to the next largest 1k (this holds true especially in larger entries, where the actual size of the attribute values far outweighs the size of the metadata).
Notice that when determining the size of the entry, both deleted values and deleted attributes are included in the count.
This function determines whether the values of attributes present on the specified entry comply with attribute syntax rules.
#include "slapi-plugin.h" int slapi_entry_syntax_check( Slapi_PBlock *pb, Slapi_Entry *e );
This function takes the following parameters:
Parameter block.
Entry whose attributes to check for syntax compliance.
Returns one of the following values:
0 if the entry attribute values comply or if syntax checking is turned off.
1 if the entry attribute values do not comply with attribute syntax rules.
The pb argument can be NULL. It is used only to get the SLAPI_IS_REPLICATED_OPERATION flag. If that flag is present, no syntax checking is done.
This function determines whether the specified virtual attribute is present, and returns that attribute if available.
#include "slapi-plugin.h" int slapi_entry_vattr_find(const Slapi_Entry *e, const char *type, Slapi_Attr **a, int *buffer_flags);
This function takes the following parameters:
Entry to check for the virtual attribute.
Attribute type of the virtual attribute.
Structure to hold the virtual attribute.
Bitmask indicated whether the caller needs to free the attribute.
Returns one of the following values:
0 if the entry contains the virtual attribute specified by type.
In this case a points to the virtual attribute, and buffer_flags holds SLAPI_VIRTUALATTRS_RETURNED_COPIES meaning the structure a must be freed, or SLAPI_VIRTUALATTRS_RETURNED_POINTERS and it should not be freed.
-1 if the entry does not contain the attribute.
Determines if two filters are identical.
#include "slapi-plugin.h" int slapi_filter_compare(struct slapi_filter *f1, struct slapi_filter *f2);
This function takes the following parameters:
First filter to compare.
Second filter to compare.
This function returns 0 if the two filters are identical, or a value other than 0 if they are not.
This function allows you to determine if two filters are identical, and/or are allowed to be in a different order.
Frees the specified filter and (optionally) the set of filters that comprise it (for example, the set of filters in an LDAP_FILTER_AND type filter).
#include "slapi-plugin.h" void slapi_filter_free( Slapi_Filter *f, int recurse );
This function takes the following parameters:
Filter that you want to free.
If 1, recursively frees all filters that comprise this filter. If 0, only frees the filter specified by f.
Description
This function frees the filter in parameter f.
Filters created using slapi_str2filter() must be freed after using this function. Filters extracted from a parameter block using:
slapi_pblock_get( pb, SLAPI_SEARCH_FILTER, &filter );
must not be freed.
Gets the attribute type for all simple filter choices.
#include "slapi-plugin.h" int slapi_filter_get_attribute_type( Slapi_Filter *f, char **type );
This function takes the following parameters:
Filter from which you wish to get the substring values.
Pointer to the attribute type of the filter.
This function returns the attribute type of the filter.
This function gets the attribute type for all simple filter choices:
LDAP_FILTER_GE
LDAP_FILTER_LE
LDAP_FILTER_APPROX
LDAP_FILTER_EQUALITY
LDAP_FILTER_SUBSTRINGS
LDAP_FILTER_PRESENT
LDAP_FILTER_EXTENDED
LDAP_FILTER_AND
LDAP_FILTER_OR
LDAP_FILTER_NOT
A filter such as (mail-foo) will return the type mail.
The attribute type is returned in type and should not be freed after calling this function. It will be freed at the same time as the Slapi_Filter structure when slapi_filter_free() is called.
(Applies only to filters of the types LDAP_FILTER_EQUALITY, LDAP_FILTER_GE, LDAP_FILTER_LE, LDAP_FILTER_APPROX ) Gets the attribute type and the value from the filter.
#include "slapi-plugin.h" int slapi_filter_get_ava( Slapi_Filter *f, char **type, struct berval **bval );
This function takes the following parameters:
Filter from which you wish to get the attribute and value.
Pointer to the attribute type of the filter.
Pointer to the address of the berval structure containing the value of the filter.
This function returns 0 if successful, or -1 if the filter is not one of the types listed above.
Filters of the type LDAP_FILTER_EQUALITY, LDAP_FILTER_GE , LDAP_FILTER_LE, and LDAP_FILTER_APPROX generally compare a value against an attribute. For example:
(cn=Barbara Jensen)
This filter finds entries in which the value of the cn attribute is equal to Barbara Jensen.
The attribute type is returned in the parameter type, and the value is returned in the parameter bval.
The strings within the parameters type and bval are direct pointers to memory inside the Slapi_Filter , and therefore should not be freed after usage. They will be freed when a server entity calls slapi_filter_free() after usage of the Slapi_Filter structure.
slapi_filter_get_attribute_type()
Gets the type of the specified filter such as LDAP_FILTER_EQUALITY, for example.
#include "slapi-plugin.h" int slapi_filter_get_choice( Slapi_Filter *f );
This function takes the following parameter:
Filter type that you wish to get.
This function returns one of the following values:
LDAP_FILTER_AND (AND filter)
For example: (&(ou=Accounting)(l=Sunnyvale))
LDAP_FILTER_OR (OR filter)
For example: (|(ou=Accounting)(l=Sunnyvale))
LDAP_FILTER_NOT (NOT filter)
For example: (!(l=Sunnyvale))
LDAP_FILTER_EQUALITY (equals filter)
For example: (ou=Accounting)
LDAP_FILTER_SUBSTRINGS (substring filter)
For example: (ou=Account*Department)
LDAP_FILTER_GE (“greater than or equal to” filter)
For example: (supportedLDAPVersion>=3)
LDAP_FILTER_LE (“less than or equal to” filter)
For example: (supportedLDAPVersion<=2)
LDAP_FILTER_PRESENT (presence filter)
For example: (mail=*)
LDAP_FILTER_APPROX (approximation filter)
For example: (ou~=Sales)
LDAP_FILTER_EXTENDED (extensible filter)
For example: (o:dn:=Example)
slapi_filter_get_attribute_type()
(Applies only to filters of the type LDAP_FILTER_SUBSTRINGS) Gets the substring values from the filter.
#include "slapi-plugin.h" int slapi_filter_get_subfilt( Slapi_Filter *f, char **type, char **initial, char ***any, char **final );
This function takes the following parameters:
Filter from which you wish to get the substring values.
Pointer to the attribute type of the filter.
Pointer to the initial substring (“starts with”) of the filter.
Pointer to an array of the substrings (“contains”) for the filter.
Pointer to the final substring (“ends with”) of the filter.
This function returns one of the following values:
0 if successful.
-1 if the filter is not one of the types listed above.
Filters of the type LDAP_FILTER_SUBSTRINGS generally compare a set of substrings against an attribute. For example:
(cn=John*Q*Public)
This filter finds entries in which the value of the cn attribute starts with John, contains Q, and ends with Public.
Call this function to get these substring values as well as the attribute type from this filter. In the case of the example above, calling this function gets the initial substring John, the any substring Q, and the final substring Public in addition to the attribute type cn.
slapi_filter_get_attribute_type()
(Applies only to filters of the type LDAP_FILTER_PRESENT) Gets the attribute type specified in the filter.
#include "slapi-plugin.h" int slapi_filter_get_type( Slapi_Filter *f, char **type );
This function takes the following parameters:
Filter from which you want to get the substring values.
Pointer to the attribute type of the filter.
This function returns 0 if successful, or -1 if the filter is not one of the types listed above.
Filters of the type LDAP_FILTER_PRESENT generally determine if a specified attribute is assigned a value. For example:
(mail=*)
This filter finds entries that have a value assigned to the mail attribute.
Call this function to get the attribute type from this filter. In the case of the example above, calling this function gets the attribute type mail.
The string returned in the parameter type must not be freed after calling this function. It will be freed when the structure Slapi_Filter is freed by calling slapi_filter_free() .
slapi_filter_get_attribute_type()
Joins the two specified filters using one of the following filter types: LDAP_FILTER_AND, LDAP_FILTER_OR, or LDAP_FILTER_NOT . When specifying the filter type LDAP_FILTER_NOT, the second filter should be NULL.
#include "slapi-plugin.h" Slapi_Filter *slapi_filter_join( int ftype, Slapi_Filter *f1, Slapi_Filter *f2 );
This function takes the following parameters:
Type of composite filter you want to create.
First filter that you want to join.
Second filter that you want to join. If ftype is LDAP_FILTER_NOT, specify NULL for this argument.
This function returns the new filter constructed from the other two filters.
Filters of the type LDAP_FILTER_AND, LDAP_FILTER_OR , and LDAP_FILTER_NOT generally consist of one or more other filters. For example:
(&(ou=Accounting)(l=Sunnyvale)) (|(ou=Accounting)(l=Sunnyvale)) (!(l=Sunnyvale))
Each of these examples contain one or more LDAP_FILTER_EQUALITY filters.
Call the slapi_filter_join() function to create a new filter of the type LDAP_FILTER_AND, LDAP_FILTER_OR, or LDAP_FILTER_NOT.
The f1 and f2 filters are not copied, nor freed, during the join process, but the resulting filter will have references pointing to these two filters.
(Applies only to filters of the types LDAP_FILTER_EQUALITY, LDAP_FILTER_GE, LDAP_FILTER_LE, LDAP_FILTER_APPROX ) Gets the first filter that makes up the specified filter.
#include "slapi-plugin.h" Slapi_Filter *slapi_filter_list_first( Slapi_Filter *f );
This function takes the following parameter:
Filter of which you wish to get the first component.
The first filter that makes up the specified filter f.
To iterate through all filters that make up a specified filter, use this function in conjunction with the slapi_filter_list_next() function.
Filters of the type LDAP_FILTER_AND, LDAP_FILTER_OR , and LDAP_FILTER_NOT generally consist of one or more other filters. For example, if the filter is:
(&(ou=Accounting)(l=Sunnyvale))
the first filter in this list is:
(ou=Accounting)
Call this function to get the first filter in the list.
No duplication of the filter is done, so this filter should not be freed independently of the original filter.
(Applies only to filters of the types LDAP_FILTER_EQUALITY, LDAP_FILTER_GE, LDAP_FILTER_LE, LDAP_FILTER_APPROX ) Gets the next filter (following fprev) that makes up the specified filter f.
#include "slapi-plugin.h" Slapi_Filter *slapi_filter_list_next(Slapi_Filter *f, Slapi_Filter *fprev);
This function takes the following parameters:
Filter from which you want to get the next component (after fprev).
Filter within the specified filter f.
The next filter (after fprev) that makes up the specified filter f.
To iterate through all filters that make up a specified filter, use this function in conjunction with the slapi_filter_list_first() function.
Filters of the type LDAP_FILTER_AND, LDAP_FILTER_OR , and LDAP_FILTER_NOT generally consist of one or more other filters. For example, if the filter is:
(&(ou=Accounting)(l=Sunnyvale))
the next filter after (ou=Accounting) in this list is:
(l=Sunnyvale)
Call the slapi_filter_list_next() function to get the filters from this list.
No duplication of the filter is done, so the filter should not be freed independently of the original filter.
Determines if the specified entry matches a particular filter.
#include "slapi-plugin.h" int slapi_filter_test( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f, int verify_access );
This function takes the following parameters:
Parameter block.
Entry that you want to test.
Filter that you want to test the entry against.
If 1, verifies that the current user has access rights to search the specified entry. If 0, bypasses any access control.
One of the following values:
0 if the entry matched the filter or if the specified filter is NULL.
-1 if the filter type is unknown.
A positive value (an LDAP error code) if an error occurred.
Determines if an entry matches a given filter.
#include "slapi-plugin.h" int slapi_filter_test_ext( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f, int verify_access, int only_test_access)
This function takes the following parameters:
Parameter block from which the user is extracted
The entry on which filter matching must be verified.
The filter used for filter matching.
0 when access checking is not to be done.
1 when access checking must be done.
0 when filter matching must be done.
1 when filter matching must not be done.
This function returns one of the following values:
0 if the entry matched the filter, or if the specified filter is NULL.
-1 if the filter type is unknown, or if the entry does not match the filter.
A positive value (an LDAP error code) if an error occurred, or if the current user does not have access rights to search the specified entry.
This function allows you to determine if an entry matches a given filter, or that the current user has the permission to access the entry.
Determines if an entry matches a filter.
#include "slapi-plugin.h" int slapi_filter_test_simple( Slapi_Entry *e, Slapi_Filter *f);
This function takes the following parameters:
Entry that you wish to test.
Filter to match the entry against.
This function returns one of the following values:
0 if the entry matched the filter, or if the specified filter is NULL.
-1 if the filter type is unknown, or if the entry does not match the filter.
A positive value (an LDAP error code) if an error occurred.
This function allows you to check if entry e matches filter f.
Find a right parenthesis matching a left parenthesis.
#include "slapi-plugin.h" char *slapi_find_matching_paren( const char *str );
This function takes the following parameters:
Pointer to a string starting with a left parenthesis
This function returns a pointer to the right parenthesis if successful. Otherwise, it returns NULL indicating that no matching right parenthesis was found.
This function takes a pointer to a string starting with a left parenthesis, (, and returns a pointer to the matching right parenthesis, ). It may be useful when evaluating complex search filter strings.
Frees search results returned by the slapi_search_internal_pb() and slapi_search_internal_callback_pb() functions.
#include "slapi-plugin.h" void slapi_free_search_results_internal(Slapi_PBlock *pb);
This function takes the following parameter:
Parameter block returned by the slapi_search_internal_pb() and slapi_search_internal_callback_pb() functions.
This function must be called when you are finished with the entries before freeing the parameter block.
Free a list of directory suffixes, such as a list obtained using slapi_get_suffix_list().
#include "slapi-plugin.h" void slapi_free_suffix_list(Slapi_DN ** suffix_list);
This function takes the following parameters:
Array of Distinguished Names for the suffixes to free.
This function frees each entry in suffix_list, and the suffix_list itself. It does not remove data from a database associated with the suffix.
Returns a pointer of the backend structure of the first backend.
#include "slapi-plugin.h" Slapi_Backend* slapi_get_first_backend(char **cookie);
This function takes the following parameter:
Output parameter containing the index of the returned backed. This is useful for calls to slapi_get_next_backend(). Contains 0 in output if no backend is returned.
This function returns a pointer to the backend structure of the first backend, and its index, in the cookie parameter, or NULL if there is no backend.
This function returns a pointer to the backend structure of the first backend. If you wish to iterate through all of the backends, use this function in conjunction with slapi_get_next_backend(). For example:
Slapi_Backend *be = NULL; char *cookie = NULL; be = slapi_get_first_backend (&cookie); while (be) { ... be = slapi_get_next_backend (cookie); } slapi_ch_free ((void**)&cookie);
Free the cookie parameter after the iteration using slapi_ch_free().
Access an object extension.
#include "slapi-plugin.h" void *slapi_get_object_extension(int objecttype, void *object, int extensionhandle);
This function takes the following parameters:
Type set by the server
Pointer to the object you extended
Handle set by the server
This function returns a pointer to the object extension registered using slapi_register_object_extension().
slapi_register_object_extension()
Returns a pointer to the next backend.
#include "slapi-plugin.h" Slapi_Backend* slapi_get_next_backend(char *cookie);
This function takes the following parameters:
Upon input, contains the index from which the search for the next backend is done. Upon output, contains the index of the returned backend.
This function returns a pointer to the next backend, if it exists, and updates the cookie parameter. Otherwise, it returns NULL and cookie is not changed.
This function returns a pointer to the next backend. If you wish to iterate through all of the backends, use this function in conjunction with slapi_get_first_backend(). For example:
Slapi_Backend *be = NULL; char *cookie = NULL; be = slapi_get_first_backend (&cookie); while (be ) { ... be = slapi_get_next_backend (cookie); } slapi_ch_free ((void**)&cookie);
Free the cookie parameter after the iteration using slapi_ch_free().
Returns an array of suffix DNs handled by the server.
#include "slapi-plugin.h" Slapi_DN ** slapi_get_suffix_list(int show_private, int *count);
This function takes the following parameters:
If set to 1, this list of DNs returned includes suffixes used by Directory Server that do not contain user data. Otherwise, only DNs of suffixes containing user data are returned.
Placeholder to contain the number of suffixes in the list.
This function returns a pointer to an array of Slapi_DN structures containing the base DNs of the suffixes. The count parameter contains the number of suffixes whose DNs are returned.
Free the list returned using slapi_free_suffix_list().
Retrieves an allocated array of object identifiers (OIDs) representing the controls supported by Directory Server. You can register new controls by calling slapi_register_supported_control().
#include "slapi-plugin.h" int slapi_get_supported_controls_copy( char ***ctrloidsp, unsigned long **ctrlopsp );
This function takes the following parameters:
Pointer to a character array that will receive the set of supported control OIDs. Pass NULL for this parameter if you do not wish to receive the OIDs.
Pointer to an unsigned long array that will receive the supported operation values for each control in the ctrloidsp array. Pass NULL for this parameter if you do not wish to receive the supported operation values.
This function returns 0 if successful, or a non-zero value if an error occurs.
This function replaces the deprecated slapi_get_supported_controls() function from previous releases, as it was not multithread safe.
When you call slapi_register_supported_control() to register a control, you specify the OID of the control and the IDs of the operations that support the control. The server records this information in two arrays; an array of control OIDs, and an array of operations that support the control. You can get copies of these arrays by calling slapi_entry_get_uniqueid() .
For each OID returned in the ctrloidsp array, the corresponding array element (with the same index) in the ctrlopsp array identifies the operations that support the control. For a list of the possible IDs for the operations, see slapi_register_supported_control().
The returned ctrloidsp array should be freed by calling slapi_ch_array_free(). The returned ctrlopsp array should be freed by calling slapi_ch_free().
slapi_register_supported_control()
Gets a copy of the object IDs (OIDs) of the extended operations.
#include "slapi-plugin.h" char **slapi_get_supported_extended_ops_copy ( void );
This function takes no parameters.
This function returns a pointer to an array of the OIDs of the extended operations supported by the server.
This function replaces the deprecated slapi_get_supported_extended_ops() function from earlier releases, as slapi_get_supported_extended_ops() was not multithread safe.
This function gets a copy of the object IDs (OIDs) of the extended operations supported by the server. You can register new extended operations by putting the OID in the SLAPI_PLUGIN_EXT_OP_OIDLIST parameter and calling slapi_pblock_set().
The array returned by this function should be freed by calling the slapi_ch_array_free() function.
Gets an array of the names of the supported Simple Authentication and Security Layer (SASL) mechanisms. You can register new SASL mechanisms by calling the slapi_register_supported_saslmechanism() function.
#include "slapi-plugin.h" char ** slapi_get_supported_saslmechanisms_copy( void );
This function returns a pointer to an array of the names of SASL mechanisms supported by the server.
Checks if a string has an 8-bit character.
#include "slapi-plugin.h" int slapi_has8thBit(unsigned char *s);
This function takes the following parameter:
Pointer to the NULL terminated string to test.
This function returns 1 if the string contains an 8-bit character, or 0 if it does not.
This function determines if an entry is the root DSE. The root DSE is a special entry that contains information about the Directory Server, including its capabilities and configuration.
#include "slapi-plugin.h" int slapi_is_rootdse ( const char *dn );
This function takes the following parameters:
The DN that you want to test to see if it is the root DSE entry.
This function returns 1 if dn is the root DSE; otherwise the function returns 0.
Checks if a suffix is a root suffix of the DIT.
#include "slapi-plugin.h" int slapi_is_root_suffix(Slapi_DN * dn);
This function takes the following parameter:
DN that you wish to check.
This function returns one of the following values:
0 if the DN is not a root suffix
1 if the DN is a root suffix
Get a thread-safe handle to an LDAP connection.
#include "slapi-plugin.h" LDAP *slapi_ldap_init(char *ldaphost, int ldapport, int secure, int shared);
This function takes the following parameters:
Host on which the LDAP server is running
Port on which the LDAP server is listening
1 for a secure connection over SSL, NULL otherwise
If not NULL, then the connection may be shared between threads
This function allows a plug-in to retrieve a thread-safe handle to an LDAP connection. When done with the handle, call slapi_ldap_unbind().
A timeout may be set for the connection using the Directory SDK for C provided as part of Directory Server Resource Kit. Example 16–1 demonstrates how to set a timeout.
#include "slapi-plugin.h" #include "ldap.h" void my_ldap_function(void) { LDAP * ld; int to = 5000; /* 5000 ms == 5 s timeout */ if ((ld = slapi_ldap_init(host, port, 0, 1)) == NULL) { /* error trying to create an LDAP session */ return -1; } if (ldap_set_option(ld, LDAP_X_OPT_CONNECT_TIMEOUT, &to) != 0) { /* error setting timeout */ slapi_ldap_unbind(ld); return -1; } /* Use the handle for a search for example. */ slapi_ldap_unbind(ld); return 0; }
This function returns an LDAP connection handle if successful. Otherwise, it returns NULL.
Release an LDAP connection obtained using slapi_ldap_init() .
#include "slapi-plugin.h" void slapi_ldap_unbind( LDAP *ld );
This function takes the following parameters:
Handle to the LDAP connection
This function allows a plug-in to release an LDAP connection obtained using slapi_ldap_init().
Determines whether the proposed modifications comply with attribute syntax rules.
#include "slapi-plugin.h" int slapi_ldapmods_syntax_check( Slapi_PBlock *pb, LDAPMod **mods );
This function takes the following parameters:
Parameter block.
Pointer to the modify structure whose attribute values are to be checked.
Returns one of the following values:
0 if the proposed modifications comply with attribute syntax rules, or if syntax checking is turned off.
1 if the modifications do not comply with attribute syntax rules.
The pb argument can be NULL. It is used only to get the SLAPI_IS_REPLICATED_OPERATION flag. If that flag is present, no syntax checking is done.
Lock a mutex.
#include "slapi-plugin.h" void slapi_lock_mutex( Slapi_Mutex *mutex );
This function takes the following parameters:
Mutex for thread synchronization
This function allows thread synchronization. Once a thread has locked a mutex using this function, other threads attempting to acquire the lock are blocked until the thread holding the mutex calls slapi_UTF-8STRTOLOWER().
Write an error message to the server error log.
#include "slapi-plugin.h" int slapi_log_error_ex(long errorId, long msgId, int connId, int opId, char const * subsystem, char const * humanReadableMsg, char const * fmt, /* args */ ...);
This function takes the following parameters:
Unique identifier you provide for this error message
Identifier for the current message obtained using SLAPI_OPERATION_MSGID
Identifier for the current connection obtained using SLAPI_CONN_ID
Identifier for the current operation obtained using SLAPI_OPERATION_ID
String indicating the context in which the warning arose such as the name of the plug-in function logging the message
String message identifying this warning
Format specification in the style of printf()
Arguments for the format specification in fmt
This function writes the specified error message to the server error log in synchronous fashion. This function does not return until the log message has been flushed to disk, thus blocking the server for the duration of the write operation. By default, the error log is $INSTANCE_PATH/logs/errors.
Unlike slapi_log_info_ex(), this function cannot be turned off.
Error messages typically concern fatal errors. For warnings, use slapi_log_warning_ex(). For informational log messages, use slapi_log_info_ex().
Example 16–2 shows a call to slapi_log_error_ex().
#include "slapi-plugin.h" #include "example-com-error-ids.h" /* example.com unique error IDs file */ int foobar(Slapi_PBlock * pb) { char * error_cause; int apocalypse = 1; /* Expect the worst. */ /* ... */ if (apocalypse) { /* Server to crash soon */ slapi_log_error_ex( EXCOM_SERVER_MORIBUND, /* Unique error ID */ SLAPI_LOG_NO_MSGID, SLAPI_LOG_NO_CONNID, SLAPI_LOG_NO_OPID, "example.com: foobar in baz plug-in", "cannot write to file system: %s\n", error_cause ); return -1; } return 0; }
This function returns 0 if successful. Otherwise, it returns -1.
Write an informational message to the server error log.
#include "slapi-plugin.h" int slapi_log_info_ex(slapi_log_info_area_t area, slapi_log_info_level_t level, long msgId, int connId, int opId, char const * subsystem, char const * fmt, /* args */, ...);
This function takes the following parameters:
Identifies the server component so logging can be turned on by adding the decimal value of the area to the value for nsslapd-infolog-area. Subtract from the value to turn informational logging off.
Identifies whether the server should log this message when informational logging is activated for area.
When informational logging is activated, setting level to:
SLAPI_LOG_INFO_LEVEL_DEFAULT means always log the message.
SLAPI_LOG_INFO_LEVEL_EXTRA means only log if the value of nsslapd-infolog-level is greater than 0.
Identifier for the current message obtained using SLAPI_OPERATION_MSGID
Identifier for the current connection obtained using SLAPI_CONN_ID
Identifier for the current operation obtained using SLAPI_OPERATION_ID
String indicating the context in which the warning arose such as the name of the plug-in function logging the message
Format specification in the style of printf()
Arguments for the format specification in fmt
This function writes the specified error message to the server error log in synchronous fashion. This function does not return until the log message has been flushed to disk, thus blocking the server for the duration of the write operation. By default, the error log is $INSTANCE_PATH/logs/errors.
This function is turned off by default. Activate logging of the message with the dsconf set-log-prop command.
You can also manage logs using Directory Service Control Center.
Informational message are typically those that system administrators may ignore unless trying to debug server behavior. For errors, use slapi_log_error_ex() . For warnings, use slapi_log_warning_ex().
Example 16–3 shows a call to slapi_log_info_ex().
#include "slapi-plugin.h" int hello() { slapi_log_info_ex( SLAPI_LOG_INFO_AREA_PLUGIN, SLAPI_LOG_INFO_LEVEL_DEFAULT, SLAPI_LOG_NO_MSGID, SLAPI_LOG_NO_CONNID, SLAPI_LOG_NO_OPID, "hello() from a plug-in", "Hello, World!\n" ); return 0; }
This function returns 0 if successful. Otherwise, it returns -1.
Write a warning message to the server error log.
#include "slapi-plugin.h" int slapi_log_warning_ex(long warningId, long msgId, int connId, int opId, char const * subsystem, char const * humanReadableMsg, char const * fmt, /* args */ ...);
This function takes the following parameters:
Unique identifier you provide for this warning message
Identifier for the current message obtained using SLAPI_OPERATION_MSGID
Identifier for the current connection obtained using SLAPI_CONN_ID
Identifier for the current operation obtained using SLAPI_OPERATION_ID
String indicating the context in which the warning arose such as the name of the plug-in function logging the message
String message identifying this warning
Format specification in the style of printf()
Arguments for the format specification in fmt
This function writes the specified error message to the server error log in synchronous fashion. This function does not return until the log message has been flushed to disk, thus blocking the server for the duration of the write operation. By default, the error log is $INSTANCE_PATH/logs/errors.
Unlike slapi_log_info_ex(), this function cannot be turned off.
Warning messages typically concern potentially serious situations, but not fatal errors. For fatal errors, use slapi_log_error_ex(). For informational log messages, use slapi_log_info_ex().
Example 16–4 shows a call to slapi_log_warning_ex().
#include "slapi-plugin.h" #include "example-com-warning-ids.h" /* example.com unique warning IDs file */ int foobar() { int disk_use_percentage; /* ... */ if (disk_use_percentage >= 95){ slapi_log_warning_ex( EXCOM_DISK_FULL_WARN, /* unique warning ID */ SLAPI_LOG_NO_MSGID, SLAPI_LOG_NO_CONNID, SLAPI_LOG_NO_OPID, "example.com: foobar in baz plug-in", "disk %.0f%% full, find more space\n", (float)disk_use_percentage ); } return 0; } |
This function returns 0 if successful. Otherwise, it returns -1.
Free a Slapi_MatchingRuleEntry after registering the matching rule.
#include "slapi-plugin.h" void slapi_matchingrule_free(Slapi_MatchingRuleEntry **mrEntry, int freeMembers);
This function takes the following parameters:
Matching rule registration object
Whether to free the members of the Slapi_MatchingRuleEntry
If 0, do not free the members of the Slapi_MatchingRuleEntry.
This function frees memory allocated to a Slapi_MatchingRuleEntry after the structure has been used to register a matching rule.
Access a Slapi_MatchingRuleEntry member.
#include "slapi-plugin.h" int slapi_matchingrule_get(Slapi_MatchingRuleEntry *mr, int arg, void *value);
This function takes the following parameters:
Matching rule registration object
Identifier for the Slapi_MatchingRuleEntry member:
SLAPI_MATCHINGRULE_DESC, a string describing the matching rule
SLAPI_MATCHINGRULE_NAME, a string identifying the matching rule
SLAPI_MATCHINGRULE_OID, a string representing the matching rule object identifier
SLAPI_MATCHINGRULE_SYNTAX, the matching rule syntax OID string 1.3.6.1.4.1.1466.115.121.1.15
SLAPI_MATCHINGRULE_OBSOLETE, an int identifying whether the rule is obsolete
Value retrieved from the member
This function accesses a Slapi_MatchingRuleEntry member based on the identifier in arg.
This function returns 0 if successful. Otherwise, it returns -1.
Allocate a Slapi_MatchingRuleEntry.
#include "slapi-plugin.h" Slapi_MatchingRuleEntry *slapi_matchingrule_new(void);
This function allocates a Slapi_MatchingRuleEntry used to register a matching rule.
This function returns a pointer to the matching rule registration object if successful. Otherwise, it returns NULL.
Register a matching rule with the server.
#include "slapi-plugin.h" int slapi_matchingrule_register(Slapi_MatchingRuleEntry *mrEntry);
This function takes the following parameters:
Matching rule registration object
This function registers a Slapi_MatchingRuleEntry with the server. Register matching rules as part of the plug-in initialization function.
First, allocate the structure using slapi_matchingrule_new() . Next, set the members of the matching rule entry using slapi_matchingrule_set(). After setting the members, register the matching rule with the server using this function. Finally, free the memory allocated using slapi_matchingrule_free().
This function returns 0 if successful. Otherwise, it returns -1.
Modify a Slapi_MatchingRuleEntry member.
#include "slapi-plugin.h" int slapi_matchingrule_set(Slapi_MatchingRuleEntry *mr, int arg, void *value);
This function takes the following parameters:
Matching rule registration object
Identifier for the Slapi_MatchingRuleEntry member:
SLAPI_MATCHINGRULE_DESC, a string describing the matching rule
SLAPI_MATCHINGRULE_NAME, a string identifying the matching rule
SLAPI_MATCHINGRULE_OID, a string representing the matching rule object identifier
SLAPI_MATCHINGRULE_SYNTAX, the matching rule syntax OID string 1.3.6.1.4.1.1466.115.121.1.15
SLAPI_MATCHINGRULE_OBSOLETE, an int identifying whether the rule is obsolete
Value to affect to the member
This function modifies a Slapi_MatchingRuleEntry member based on the identifier in arg.
This function returns 0 if successful. Otherwise, it returns -1.
Adds a value to a Slapi_Mod structure.
#include "slapi-plugin.h" void slapi_mod_add_value(Slapi_Mod *smod, const struct berval *val);
This function takes the following parameters:
Adds a copy of a given attribute to the Slapi_Mod.
Frees the internals of Slapi_Mod structure.
#include "slapi-plugin.h" void slapi_mod_done(Slapi_Mod *mod);
This function takes the following parameter:
Pointer to a Slapi_Mod.
This function frees the internals of a Slapi_Mod, leaving it in the uninitialized state.
Use this function on a stack-allocated Slapi_Mod when you have finished with it, or wish to reuse it.
Dumps the contents of an LDAPMod to the server log.
#include "slapi-plugin.h" void slapi_mod_dump(LDAPMod *mod, int n);
This function takes the following parameters:
Pointer to an LDAPMod.
Numeric label that will be included in the log.
This function uses the LDAP_DEBUG_ANY log level to dump the contents of an LDAPMod to $INSTANCE_PATH/logs/errors for debugging.
Frees a Slapi_Mod structure.
#include "slapi-plugin.h" void slapi_mod_free(Slapi_Mod **smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function frees a Slapi_Mod structure that was allocated by slapi_mod_new().
Initializes a Slapi_Mod iterator and returns the first attribute value.
#include "slapi-plugin.h" struct berval *slapi_mod_get_first_value(Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns a pointer to the first attribute value in the Slapi_Mod, or NULL if no values exist.
Use this function with slapi_mod_get_next_value() to iterate through the attribute values in a Slapi_Mod structure.
Gets a reference to the LDAPMod in a Slapi_Mod structure.
#include "slapi-plugin.h" const LDAPMod *slapi_mod_get_ldapmod_byref(const Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns a pointer to a read-only LDAPMod owned by the Slapi_Mod.
Use this function to get direct access to the LDAPMod contained in a Slapi_Mod.
Responsibility for the LDAPMod remains with the Slapi_Mod.
slapi_mod_get_ldapmod_passout()
Retrieves the LDAPMod contained in a Slapi_Mod structure.
#include "slapi-plugin.h" LDAPMod *slapi_mod_get_ldapmod_passout(Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns a pointer to an LDAPMod owned by the caller.
Use this function to get the LDAPMod out of a Slapi_Mod.
Responsibility for the LDAPMod transfers to the caller. The Slapi_Mod is left in the uninitialized state.
Increments the Slapi_Mod iterator and returns the next attribute value.
#include "slapi-plugin.h" struct berval *slapi_mod_get_next_value(Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns a pointer to the next attribute value in the Slapi_Mod, or NULL if there are no more.
Use this function with slapi_mod_get_first_value() to iterate through the attribute values in a Slapi_Mod.
Gets the number of values in a Slapi_Mod structure.
#include "slapi-plugin.h" int slapi_mod_get_num_values(const Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns the number of attribute values in the Slapi_Mod.
Gets the operation type of Slapi_Mod structure.
#include "slapi-plugin.h" int slapi_mod_get_operation(const Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns one of LDAP_MOD_ADD, LDAP_MOD_DELETE , LDAP_MOD_REPLACE, combined using the bitwise or operator with LDAP_MOD_BVALUES.
Gets the attribute type of a Slapi_Mod structure.
#include "slapi-plugin.h" const char *slapi_mod_get_type(const Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
This function returns a read-only pointer to the attribute type in the Slapi_Mod.
Gets the LDAP attribute type of a Slapi_Mod.
Initializes a Slapi_Mod structure.
#include "slapi-plugin.h" void slapi_mod_init(Slapi_Mod *smod, int initCount);
This function takes the following parameters:
Pointer to an uninitialized Slapi_Mod.
Suggested number of attribute values for which to make room. Minimum value is 0.
This function initializes a Slapi_Mod so that it is empty, but initially has room for the given number of attribute values.
If you are unsure of the room you will need, you may use an initCount of 0. The Slapi_Mod expands as necessary.
Initializes a Slapi_Mod structure that is a wrapper for an existing LDAPMod.
#include "slapi-plugin.h" void slapi_mod_init_byref(Slapi_Mod *smod, LDAPMod *mod);
This function takes the following parameters:
This function initializes a Slapi_Mod containing a reference to an LDAPMod. Use this function when you have an LDAPMod and would like the convenience of the Slapi_Mod functions to access it.
Initializes a Slapi_Mod structure with a copy of an LDAPMod.
#include "slapi-plugin.h" void slapi_mod_init_byval(Slapi_Mod *smod, const LDAPMod *mod);
This function takes the following parameters:
Initializes a Slapi_Mod from an LDAPMod.
#include "slapi-plugin.h" void slapi_mod_init_passin(Slapi_Mod *smod, LDAPMod *mod);
This function takes the following parameters:
This function initializes a Slapi_Mod by passing in an LDAPMod. Use this function to convert an LDAPMod to a Slapi_Mod.
Responsibility for the LDAPMod is transferred to the Slapi_Mod. The LDAPMod is destroyed when the Slapi_Mod is destroyed.
Determines whether a Slapi_Mod structure is valid.
#include "slapi-plugin.h" int slapi_mod_isvalid(const Slapi_Mod *mod);
This function takes the following parameters:
Pointer to a Slapi_Mod.
This function returns one of the following values:
Use this function to verify that the contents of Slapi_Mod are valid. It is considered valid if the operation type is one of LDAP_MOD_ADD, LDAP_MOD_DELETE, LDAP_MOD_REPLACE , combined using the bitwise or operator with LDAP_MOD_BVALUES ; the attribute type is not NULL; and there is at least one attribute value for add and replace operations.
Allocates a new Slapi_Mod structure.
#include "slapi-plugin.h" Slapi_Mod* slapi_mod_new( void );
This function takes no parameters.
This function returns a pointer to an allocated, uninitialized Slapi_Mod.
This function allocates a new uninitialized Slapi_Mod . Use this function when you need to a Slapi_Mod allocated from the heap, rather than from the stack.
Removes the value at the current Slapi_Mod iterator position.
#include "slapi-plugin.h" void slapi_mod_remove_value(Slapi_Mod *smod);
This function takes the following parameter:
Pointer to an initialized Slapi_Mod.
Sets the operation type of a Slapi_Mod structure.
#include "slapi-plugin.h" void slapi_mod_set_operation(Slapi_Mod *smod, int op);
This function takes the following parameters:
Pointer to an initialized Slapi_Mod.
One of LDAP_MOD_ADD, LDAP_MOD_DELETE, LDAP_MOD_REPLACE, combined using the bitwise or operator with LDAP_MOD_BVALUES.
Sets the attribute type of a Slapi_Mod.
#include "slapi-plugin.h" void slapi_mod_set_type(Slapi_Mod *smod, const char *type);
This function takes the following parameters:
Pointer to an initialized Slapi_Mod.
An attribute type.
Sets the attribute type of the Slapi_Mod to a copy of the given value.
Builds the new DN of an entry.
#include "slapi-plugin.h" char * slapi_moddn_get_newdn(Slapi_DN *dn_olddn, char *newrdn, char *newsuperiordn);
This function takes the following parameters:
The old DN value.
The new RDN value.
If not NULL, will be the DN of the future superior entry of the new DN, which will be worked out by adding the value in newrdn in front of the content of this parameter.
This function returns the new DN for the entry whose previous DN was dn_olddn.
This function is used for moddn operations and builds a new DN out of a new RDN and the DN of the new parent.
The new DN is worked out by adding the new RDN in newrdn to a parent DN. The parent will be the value in newsuperiordn, if different from NULL, and will otherwise be taken from dn_olddn by removing the old RDN. (The parent of the entry will still be the same as the new DN).
You must free the DN returned using slapi_ch_free_string() .