diff options
Diffstat (limited to 'ldap/c-sdk/include/ldap-extension.h')
| -rw-r--r-- | ldap/c-sdk/include/ldap-extension.h | 853 |
1 files changed, 853 insertions, 0 deletions
diff --git a/ldap/c-sdk/include/ldap-extension.h b/ldap/c-sdk/include/ldap-extension.h new file mode 100644 index 000000000..7bbefdfb2 --- /dev/null +++ b/ldap/c-sdk/include/ldap-extension.h @@ -0,0 +1,853 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla Communicator client code, released + * March 31, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* ldap-extension.h - extensions to the ldap c api specification */ + +#ifndef _LDAP_EXTENSION_H +#define _LDAP_EXTENSION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define LDAP_PORT_MAX 65535 /* API extension */ +#define LDAP_VERSION1 1 /* API extension */ +#define LDAP_VERSION LDAP_VERSION3 /* API extension */ + +/* + * C LDAP features we support that are not (yet) part of the LDAP C API + * Internet Draft. Use the ldap_get_option() call with an option value of + * LDAP_OPT_API_FEATURE_INFO to retrieve information about a feature. + * + * Note that this list is incomplete; it includes only the most widely + * used extensions. Also, the version is 1 for all of these for now. + */ +#define LDAP_API_FEATURE_SERVER_SIDE_SORT 1 +#define LDAP_API_FEATURE_VIRTUAL_LIST_VIEW 1 +#define LDAP_API_FEATURE_PERSISTENT_SEARCH 1 +#define LDAP_API_FEATURE_PROXY_AUTHORIZATION 1 +#define LDAP_API_FEATURE_X_LDERRNO 1 +#define LDAP_API_FEATURE_X_MEMCACHE 1 +#define LDAP_API_FEATURE_X_IO_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_EXTIO_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_DNS_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_MEMALLOC_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_THREAD_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_EXTHREAD_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_GETLANGVALUES 1 +#define LDAP_API_FEATURE_X_CLIENT_SIDE_SORT 1 +#define LDAP_API_FEATURE_X_URL_FUNCTIONS 1 +#define LDAP_API_FEATURE_X_FILTER_FUNCTIONS 1 + +#define LDAP_ROOT_DSE "" /* API extension */ + +#define LDAP_OPT_DESC 0x01 /* 1 */ + +#define NULLMSG ((LDAPMessage *)0) + +/*built-in SASL methods */ +#define LDAP_SASL_EXTERNAL "EXTERNAL" /* TLS/SSL extension */ + +/* possible error codes we can be returned */ +#define LDAP_PARTIAL_RESULTS 0x09 /* 9 (UMich LDAPv2 extn) */ +#define NAME_ERROR(n) ((n & 0xf0) == 0x20) + +#define LDAP_SORT_CONTROL_MISSING 0x3C /* 60 (server side sort extn) */ +#define LDAP_INDEX_RANGE_ERROR 0x3D /* 61 (VLV extn) */ + +/* + * LDAPv3 server controls we know about + */ +#define LDAP_CONTROL_MANAGEDSAIT "2.16.840.1.113730.3.4.2" +#define LDAP_CONTROL_SORTREQUEST "1.2.840.113556.1.4.473" +#define LDAP_CONTROL_SORTRESPONSE "1.2.840.113556.1.4.474" +#define LDAP_CONTROL_PERSISTENTSEARCH "2.16.840.1.113730.3.4.3" +#define LDAP_CONTROL_ENTRYCHANGE "2.16.840.1.113730.3.4.7" +#define LDAP_CONTROL_VLVREQUEST "2.16.840.1.113730.3.4.9" +#define LDAP_CONTROL_VLVRESPONSE "2.16.840.1.113730.3.4.10" +#define LDAP_CONTROL_PROXYAUTH "2.16.840.1.113730.3.4.12" /* version 1 +*/ +#define LDAP_CONTROL_PROXIEDAUTH "2.16.840.1.113730.3.4.18" /* version 2 +*/ + +/* Authorization Identity Request and Response Controls */ +#define LDAP_CONTROL_AUTHZID_REQ "2.16.840.1.113730.3.4.16" +#define LDAP_CONTROL_AUTHZID_RES "2.16.840.1.113730.3.4.15" + +/* Authentication request and response controls */ +#define LDAP_CONTROL_AUTH_REQUEST LDAP_CONTROL_AUTHZID_REQ +#define LDAP_CONTROL_AUTH_RESPONSE LDAP_CONTROL_AUTHZID_RES + +/* Password information sent back to client */ +#define LDAP_CONTROL_PWEXPIRED "2.16.840.1.113730.3.4.4" +#define LDAP_CONTROL_PWEXPIRING "2.16.840.1.113730.3.4.5" + +/* Password Policy Control */ +#define LDAP_CONTROL_PASSWD_POLICY "1.3.6.1.4.1.42.2.27.8.5.1" + +/* Password Policy Control compatibility macros */ +#define LDAP_X_CONTROL_PWPOLICY_REQUEST LDAP_CONTROL_PASSWD_POLICY +#define LDAP_X_CONTROL_PWPOLICY_RESPONSE LDAP_CONTROL_PASSWD_POLICY +#define LDAP_CONTROL_PASSWORDPOLICYREQUEST LDAP_CONTROL_PASSWD_POLICY +#define LDAP_CONTROL_PASSWORDPOLICYRESPONSE LDAP_CONTROL_PASSWD_POLICY + +/* Password Modify Extended Operation */ +#define LDAP_EXOP_MODIFY_PASSWD "1.3.6.1.4.1.4203.1.11.1" + +/* Suppress virtual/inherited attribute values */ +#define LDAP_CONTROL_REAL_ATTRS_ONLY "2.16.840.1.113730.3.4.17" + +/* Only return virtual/inherited attribute values */ +#define LDAP_CONTROL_VIRTUAL_ATTRS_ONLY "2.16.840.1.113730.3.4.19" + +/* getEffectiveRights request */ +#define LDAP_CONTROL_GETEFFECTIVERIGHTS_REQUEST "1.3.6.1.4.1.42.2.27.9.5.2" + +/* Password Policy Control to get account availability */ +#define LDAP_CONTROL_ACCOUNT_USABLE "1.3.6.1.4.1.42.2.27.9.5.8" + +/* "Who am I?" Extended Operation */ +#define LDAP_EXOP_WHO_AM_I "1.3.6.1.4.1.4203.1.11.3" + +LDAP_API(void) LDAP_CALL ldap_ber_free( BerElement *ber, int freebuf ); + +LDAP_API(LDAPControl *) LDAP_CALL ldap_find_control( const char *oid, + LDAPControl **ctrls ); + +/* + * Server side sorting of search results (an LDAPv3 extension -- + * LDAP_API_FEATURE_SERVER_SIDE_SORT) + */ +typedef struct LDAPsortkey { /* structure for a sort-key */ + char * sk_attrtype; + char * sk_matchruleoid; + int sk_reverseorder; +} LDAPsortkey; + +/* where LDAP_CONTROL_ACCOUNT_USABLE control parse results */ +typedef struct LDAPuserstatus { /* user account availability */ + unsigned int us_available; /* availability status */ +#define LDAP_US_ACCOUNT_USABLE 1 +#define LDAP_US_ACCOUNT_NOT_USABLE 0 + int us_expire; /* will expire in seconds */ + int us_inactive; /* boolean inactivation status */ +#define LDAP_US_ACCOUNT_ACTIVE 0 +#define LDAP_US_ACCOUNT_INACTIVE 1 + int us_reset; /* boolean password reset */ +#define LDAP_US_ACCOUNT_NOT_RESET 0 +#define LDAP_US_ACCOUNT_RESET 1 + int us_expired; /* boolean password expired */ +#define LDAP_US_ACCOUNT_NOT_EXPIRED 0 +#define LDAP_US_ACCOUNT_EXPIRED 1 + int us_remaining; /* remaining logins */ + int us_seconds; /* will unlock in seconds */ +} LDAPuserstatus; + +/* LDAP_CONTROL_PASSWD_POLICY results */ +typedef enum passpolicyerror_enum { + PP_passwordExpired = 0, + PP_accountLocked = 1, + PP_changeAfterReset = 2, + PP_passwordModNotAllowed = 3, + PP_mustSupplyOldPassword = 4, + PP_insufficientPasswordQuality = 5, + PP_passwordTooShort = 6, + PP_passwordTooYoung = 7, + PP_passwordInHistory = 8, + PP_noError = 65535 +} LDAPPasswordPolicyError; + +LDAP_API(int) LDAP_CALL ldap_create_sort_control( LDAP *ld, + LDAPsortkey **sortKeyList, const char ctl_iscritical, + LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_parse_sort_control( LDAP *ld, + LDAPControl **ctrls, ber_int_t *result, char **attribute ); + +LDAP_API(void) LDAP_CALL ldap_free_sort_keylist( LDAPsortkey **sortKeyList ); +LDAP_API(int) LDAP_CALL ldap_create_sort_keylist( LDAPsortkey ***sortKeyList, + const char *string_rep ); + +LDAP_API(int) LDAP_CALL ldap_create_userstatus_control( + LDAP *ld, const char ctl_iscritical, LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_parse_userstatus_control( LDAP *ld, + LDAPControl **ctrlp, LDAPuserstatus *us ); + +LDAP_API(int) LDAP_CALL ldap_create_passwordpolicy_control( LDAP *ld, + LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_create_passwordpolicy_control_ext( LDAP *ld, + const char ctl_iscritical, LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_parse_passwordpolicy_control( LDAP *ld, + LDAPControl *ctrlp, ber_int_t *expirep, ber_int_t *gracep, + LDAPPasswordPolicyError *errorp ); +LDAP_API(int) LDAP_CALL ldap_parse_passwordpolicy_control_ext ( LDAP *ld, + LDAPControl **ctrlp, ber_int_t *expirep, ber_int_t *gracep, + LDAPPasswordPolicyError *errorp ); +LDAP_API(const char *) LDAP_CALL ldap_passwordpolicy_err2txt( + LDAPPasswordPolicyError err ); + +LDAP_API(int) LDAP_CALL ldap_create_authzid_control( LDAP *ld, + const char ctl_iscritical, LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_parse_authzid_control( LDAP *ld, + LDAPControl **ctrlp, char **authzid ); + +LDAP_API(int) LDAP_CALL ldap_whoami( LDAP *ld, LDAPControl **serverctrls, + LDAPControl **clientctrls, int *msgidp ); +LDAP_API(int) LDAP_CALL ldap_whoami_s( LDAP *ld, struct berval **authzid, + LDAPControl **serverctrls, LDAPControl **clientctrls ); +LDAP_API(int) LDAP_CALL ldap_parse_whoami( LDAP *ld, LDAPMessage *result, + struct berval **authzid ); + +LDAP_API(int) LDAP_CALL ldap_create_geteffectiveRights_control( LDAP *ld, + const char *authzid, const char **attrlist, const char ctl_iscritical, + LDAPControl **ctrlp ); + +/* + * Virtual list view (an LDAPv3 extension -- LDAP_API_FEATURE_VIRTUAL_LIST_VIEW) + */ +/* + * structure that describes a VirtualListViewRequest control. + * note that ldvlist_index and ldvlist_size are only relevant to + * ldap_create_virtuallist_control() if ldvlist_attrvalue is NULL. + */ +typedef struct ldapvirtuallist { + ber_int_t ldvlist_before_count; /* # entries before target */ + ber_int_t ldvlist_after_count; /* # entries after target */ + char *ldvlist_attrvalue; /* jump to this value */ + ber_int_t ldvlist_index; /* list offset */ + ber_int_t ldvlist_size; /* number of items in vlist */ + void *ldvlist_extradata; /* for use by application */ +} LDAPVirtualList; + +/* + * VLV functions: + */ +LDAP_API(int) LDAP_CALL ldap_create_virtuallist_control( LDAP *ld, + LDAPVirtualList *ldvlistp, LDAPControl **ctrlp ); + +LDAP_API(int) LDAP_CALL ldap_parse_virtuallist_control( LDAP *ld, + LDAPControl **ctrls, ber_int_t *target_posp, + ber_int_t *list_sizep, int *errcodep ); + +/* + * Routines for creating persistent search controls and for handling + * "entry changed notification" controls (an LDAPv3 extension -- + * LDAP_API_FEATURE_PERSISTENT_SEARCH) + */ +#define LDAP_CHANGETYPE_ADD 1 +#define LDAP_CHANGETYPE_DELETE 2 +#define LDAP_CHANGETYPE_MODIFY 4 +#define LDAP_CHANGETYPE_MODDN 8 +#define LDAP_CHANGETYPE_ANY (1|2|4|8) +LDAP_API(int) LDAP_CALL ldap_create_persistentsearch_control( LDAP *ld, + int changetypes, int changesonly, int return_echg_ctls, + char ctl_iscritical, LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_parse_entrychange_control( LDAP *ld, + LDAPControl **ctrls, ber_int_t *chgtypep, char **prevdnp, + int *chgnumpresentp, ber_int_t *chgnump ); + +/* + * Routines for creating Proxied Authorization controls (an LDAPv3 + * extension -- LDAP_API_FEATURE_PROXY_AUTHORIZATION) + * ldap_create_proxyauth_control() is for the old (version 1) control. + * ldap_create_proxiedauth_control() is for the newer (version 2) control. + */ +LDAP_API(int) LDAP_CALL ldap_create_proxyauth_control( LDAP *ld, + const char *dn, const char ctl_iscritical, LDAPControl **ctrlp ); +LDAP_API(int) LDAP_CALL ldap_create_proxiedauth_control( LDAP *ld, + const char *authzid, LDAPControl **ctrlp ); + +/* + * Functions to get and set LDAP error information (API extension -- + * LDAP_API_FEATURE_X_LDERRNO ) + * + * By using LDAP_OPT_THREAD_FN_PTRS, you can arrange for the error info. to + * be thread-specific. + */ +LDAP_API(int) LDAP_CALL ldap_get_lderrno( LDAP *ld, char **m, char **s ); +LDAP_API(int) LDAP_CALL ldap_set_lderrno( LDAP *ld, int e, char *m, char *s ); + + +/* + * LDAP URL functions and definitions (an API extension -- + * LDAP_API_FEATURE_X_URL_FUNCTIONS) + */ +/* + * types for ldap URL handling + */ +typedef struct ldap_url_desc { + char *lud_host; + int lud_port; + char *lud_dn; + char **lud_attrs; + int lud_scope; + char *lud_filter; + unsigned long lud_options; +#define LDAP_URL_OPT_SECURE 0x01 + char *lud_string; /* for internal use only */ +} LDAPURLDesc; + +#define NULLLDAPURLDESC ((LDAPURLDesc *)NULL) + +/* + * possible errors returned by ldap_url_parse() + */ +#define LDAP_URL_ERR_NOTLDAP 1 /* URL doesn't begin with "ldap://" */ +#define LDAP_URL_ERR_NODN 2 /* URL has no DN (required) */ +#define LDAP_URL_ERR_BADSCOPE 3 /* URL scope string is invalid */ +#define LDAP_URL_ERR_MEM 4 /* can't allocate memory space */ +#define LDAP_URL_ERR_PARAM 5 /* bad parameter to an URL function */ +#define LDAP_URL_UNRECOGNIZED_CRITICAL_EXTENSION 6 + +/* + * URL functions: + */ +LDAP_API(int) LDAP_CALL ldap_is_ldap_url( const char *url ); +LDAP_API(int) LDAP_CALL ldap_url_parse( const char *url, LDAPURLDesc **ludpp ); +LDAP_API(int) LDAP_CALL ldap_url_parse_no_defaults( const char *url, + LDAPURLDesc **ludpp, int dn_required); +LDAP_API(void) LDAP_CALL ldap_free_urldesc( LDAPURLDesc *ludp ); +LDAP_API(int) LDAP_CALL ldap_url_search( LDAP *ld, const char *url, + int attrsonly ); +LDAP_API(int) LDAP_CALL ldap_url_search_s( LDAP *ld, const char *url, + int attrsonly, LDAPMessage **res ); +LDAP_API(int) LDAP_CALL ldap_url_search_st( LDAP *ld, const char *url, + int attrsonly, struct timeval *timeout, LDAPMessage **res ); + + +/* + * Function to dispose of an array of LDAPMod structures (an API extension). + * Warning: don't use this unless the mods array was allocated using the + * same memory allocator as is being used by libldap. + */ +LDAP_API(void) LDAP_CALL ldap_mods_free( LDAPMod **mods, int freemods ); + +/* + * SSL option (an API extension): + */ +#define LDAP_OPT_SSL 0x0A /* 10 - API extension */ + +/* + * Referral hop limit (an API extension): + */ +#define LDAP_OPT_REFERRAL_HOP_LIMIT 0x10 /* 16 - API extension */ + +/* + * Rebind callback function (an API extension) + */ +#define LDAP_OPT_REBIND_FN 0x06 /* 6 - API extension */ +#define LDAP_OPT_REBIND_ARG 0x07 /* 7 - API extension */ +typedef int (LDAP_CALL LDAP_CALLBACK LDAP_REBINDPROC_CALLBACK)( LDAP *ld, + char **dnp, char **passwdp, int *authmethodp, int freeit, void *arg); +LDAP_API(void) LDAP_CALL ldap_set_rebind_proc( LDAP *ld, + LDAP_REBINDPROC_CALLBACK *rebindproc, void *arg ); + +/* + * Thread function callbacks (an API extension -- + * LDAP_API_FEATURE_X_THREAD_FUNCTIONS). + */ +#define LDAP_OPT_THREAD_FN_PTRS 0x05 /* 5 - API extension */ + +/* + * Thread callback functions: + */ +typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_ALLOC_CALLBACK)( void ); +typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_FREE_CALLBACK)( void *m ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_LOCK_CALLBACK)( void *m ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_UNLOCK_CALLBACK)( void *m ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_GET_ERRNO_CALLBACK)( void ); +typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_SET_ERRNO_CALLBACK)( int e ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_GET_LDERRNO_CALLBACK)( + char **matchedp, char **errmsgp, void *arg ); +typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_SET_LDERRNO_CALLBACK)( int err, + char *matched, char *errmsg, void *arg ); + +/* + * Structure to hold thread function pointers: + */ +struct ldap_thread_fns { + LDAP_TF_MUTEX_ALLOC_CALLBACK *ltf_mutex_alloc; + LDAP_TF_MUTEX_FREE_CALLBACK *ltf_mutex_free; + LDAP_TF_MUTEX_LOCK_CALLBACK *ltf_mutex_lock; + LDAP_TF_MUTEX_UNLOCK_CALLBACK *ltf_mutex_unlock; + LDAP_TF_GET_ERRNO_CALLBACK *ltf_get_errno; + LDAP_TF_SET_ERRNO_CALLBACK *ltf_set_errno; + LDAP_TF_GET_LDERRNO_CALLBACK *ltf_get_lderrno; + LDAP_TF_SET_LDERRNO_CALLBACK *ltf_set_lderrno; + void *ltf_lderrno_arg; +}; + +/* + * Extended I/O function callbacks option (an API extension -- + * LDAP_API_FEATURE_X_EXTIO_FUNCTIONS). + */ +#define LDAP_X_OPT_EXTIO_FN_PTRS (LDAP_OPT_PRIVATE_EXTENSION_BASE + 0x0F00) + /* 0x4000 + 0x0F00 = 0x4F00 = 20224 - API extension */ + +/* Additional Extended I/O function callback option (for Extended Socket Arg callback) */ +#define LDAP_X_OPT_SOCKETARG (LDAP_OPT_PRIVATE_EXTENSION_BASE + 0x0F02) + /* 0x4000 + 0x0F02 = 0x4F02 = 20226 - API extension */ + +/* + * These extended I/O function callbacks echo the BSD socket API but accept + * an extra pointer parameter at the end of their argument list that can + * be used by client applications for their own needs. For some of the calls, + * the pointer is a session argument of type struct lextiof_session_private * + * that is associated with the LDAP session handle (LDAP *). For others, the + * pointer is a socket specific struct lextiof_socket_private * argument that + * is associated with a particular socket (a TCP connection). + * + * The lextiof_session_private and lextiof_socket_private structures are not + * defined by the LDAP C API; users of this extended I/O interface should + * define these themselves. + * + * The combination of the integer socket number (i.e., lpoll_fd, which is + * the value returned by the CONNECT callback) and the application specific + * socket argument (i.e., lpoll_socketarg, which is the value set in *sockargpp + * by the CONNECT callback) must be unique. + * + * The types for the extended READ and WRITE callbacks are actually in lber.h. + * + * The CONNECT callback gets passed both the session argument (sessionarg) + * and a pointer to a socket argument (socketargp) so it has the + * opportunity to set the socket-specific argument. The CONNECT callback + * also takes a timeout parameter whose value can be set by calling + * ldap_set_option( ld, LDAP_X_OPT_..., &val ). The units used for the + * timeout parameter are milliseconds. + * + * A POLL interface is provided instead of a select() one. The timeout is + * in milliseconds. + * + * A NEWHANDLE callback function is also provided. It is called right + * after the LDAP session handle is created, e.g., during ldap_init(). + * If the NEWHANDLE callback returns anything other than LDAP_SUCCESS, + * the session handle allocation fails. + * + * A DISPOSEHANDLE callback function is also provided. It is called right + * before the LDAP session handle and its contents are destroyed, e.g., + * during ldap_unbind(). + */ + +/* + * Special timeout values for poll and connect: + */ +#define LDAP_X_IO_TIMEOUT_NO_WAIT 0 /* return immediately */ +#define LDAP_X_IO_TIMEOUT_NO_TIMEOUT (-1) /* block indefinitely */ + +/* LDAP poll()-like descriptor: + */ +typedef struct ldap_x_pollfd { /* used by LDAP_X_EXTIOF_POLL_CALLBACK */ + int lpoll_fd; /* integer file descriptor / socket */ + struct lextiof_socket_private + *lpoll_socketarg; + /* pointer socket and for use by */ + /* application */ + short lpoll_events; /* requested event */ + short lpoll_revents; /* returned event */ +} LDAP_X_PollFD; + +/* Event flags for lpoll_events and lpoll_revents: + */ +#define LDAP_X_POLLIN 0x01 /* regular data ready for reading */ +#define LDAP_X_POLLPRI 0x02 /* high priority data available */ +#define LDAP_X_POLLOUT 0x04 /* ready for writing */ +#define LDAP_X_POLLERR 0x08 /* error occurred -- only in lpoll_revents */ +#define LDAP_X_POLLHUP 0x10 /* connection closed -- only in lpoll_revents */ +#define LDAP_X_POLLNVAL 0x20 /* invalid lpoll_fd -- only in lpoll_revents */ + +/* Options passed to LDAP_X_EXTIOF_CONNECT_CALLBACK to modify socket behavior: + */ +#define LDAP_X_EXTIOF_OPT_NONBLOCKING 0x01 /* turn on non-blocking mode */ +#define LDAP_X_EXTIOF_OPT_SECURE 0x02 /* turn on 'secure' mode */ + + +/* extended I/O callback function prototypes: + */ +typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_CONNECT_CALLBACK )( + const char *hostlist, int port, /* host byte order */ + int timeout /* milliseconds */, + unsigned long options, /* bitmapped options */ + struct lextiof_session_private *sessionarg, + struct lextiof_socket_private **socketargp ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_CLOSE_CALLBACK )( + int s, struct lextiof_socket_private *socketarg ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_POLL_CALLBACK)( + LDAP_X_PollFD fds[], int nfds, int timeout /* milliseconds */, + struct lextiof_session_private *sessionarg ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_NEWHANDLE_CALLBACK)( + LDAP *ld, struct lextiof_session_private *sessionarg ); +typedef void (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_DISPOSEHANDLE_CALLBACK)( + LDAP *ld, struct lextiof_session_private *sessionarg ); + + +/* Structure to hold extended I/O function pointers: + */ +struct ldap_x_ext_io_fns { + /* lextiof_size should always be set to LDAP_X_EXTIO_FNS_SIZE */ + int lextiof_size; + LDAP_X_EXTIOF_CONNECT_CALLBACK *lextiof_connect; + LDAP_X_EXTIOF_CLOSE_CALLBACK *lextiof_close; + LDAP_X_EXTIOF_READ_CALLBACK *lextiof_read; + LDAP_X_EXTIOF_WRITE_CALLBACK *lextiof_write; + LDAP_X_EXTIOF_POLL_CALLBACK *lextiof_poll; + LDAP_X_EXTIOF_NEWHANDLE_CALLBACK *lextiof_newhandle; + LDAP_X_EXTIOF_DISPOSEHANDLE_CALLBACK *lextiof_disposehandle; + void *lextiof_session_arg; + LDAP_X_EXTIOF_WRITEV_CALLBACK *lextiof_writev; +}; +#define LDAP_X_EXTIO_FNS_SIZE sizeof(struct ldap_x_ext_io_fns) + +/* + * Utility functions for parsing space-separated host lists (useful for + * implementing an extended I/O CONNECT callback function). + */ +struct ldap_x_hostlist_status; +LDAP_API(int) LDAP_CALL ldap_x_hostlist_first( const char *hostlist, + int defport, char **hostp, int *portp /* host byte order */, + struct ldap_x_hostlist_status **statusp ); +LDAP_API(int) LDAP_CALL ldap_x_hostlist_next( char **hostp, + int *portp /* host byte order */, struct ldap_x_hostlist_status *status +); +LDAP_API(void) LDAP_CALL ldap_x_hostlist_statusfree( + struct ldap_x_hostlist_status *status ); + +/* + * Client side sorting of entries (an API extension -- + * LDAP_API_FEATURE_X_CLIENT_SIDE_SORT) + */ +/* + * Client side sorting callback functions: + */ +typedef const struct berval* (LDAP_C LDAP_CALLBACK + LDAP_KEYGEN_CALLBACK)( void *arg, LDAP *ld, LDAPMessage *entry ); +typedef int (LDAP_C LDAP_CALLBACK + LDAP_KEYCMP_CALLBACK)( void *arg, const struct berval*, + const struct berval* ); +typedef void (LDAP_C LDAP_CALLBACK + LDAP_KEYFREE_CALLBACK)( void *arg, const struct berval* ); +typedef int (LDAP_C LDAP_CALLBACK + LDAP_CMP_CALLBACK)(const char *val1, const char *val2); +typedef int (LDAP_C LDAP_CALLBACK + LDAP_VALCMP_CALLBACK)(const char **val1p, const char **val2p); + +/* + * Client side sorting functions: + */ +LDAP_API(int) LDAP_CALL ldap_keysort_entries( LDAP *ld, LDAPMessage **chain, + void *arg, LDAP_KEYGEN_CALLBACK *gen, LDAP_KEYCMP_CALLBACK *cmp, + LDAP_KEYFREE_CALLBACK *fre ); +LDAP_API(int) LDAP_CALL ldap_multisort_entries( LDAP *ld, LDAPMessage **chain, + char **attr, LDAP_CMP_CALLBACK *cmp ); +LDAP_API(int) LDAP_CALL ldap_sort_entries( LDAP *ld, LDAPMessage **chain, + char *attr, LDAP_CMP_CALLBACK *cmp ); +LDAP_API(int) LDAP_CALL ldap_sort_values( LDAP *ld, char **vals, + LDAP_VALCMP_CALLBACK *cmp ); +LDAP_API(int) LDAP_C LDAP_CALLBACK ldap_sort_strcasecmp( const char **a, + const char **b ); + + +/* + * Filter functions and definitions (an API extension -- + * LDAP_API_FEATURE_X_FILTER_FUNCTIONS) + */ +/* + * Structures, constants, and types for filter utility routines: + */ +typedef struct ldap_filt_info { + char *lfi_filter; + char *lfi_desc; + int lfi_scope; /* LDAP_SCOPE_BASE, etc */ + int lfi_isexact; /* exact match filter? */ + struct ldap_filt_info *lfi_next; +} LDAPFiltInfo; + +#define LDAP_FILT_MAXSIZ 1024 + +typedef struct ldap_filt_list LDAPFiltList; /* opaque filter list handle */ +typedef struct ldap_filt_desc LDAPFiltDesc; /* opaque filter desc handle */ + +/* + * Filter utility functions: + */ +LDAP_API(LDAPFiltDesc *) LDAP_CALL ldap_init_getfilter( char *fname ); +LDAP_API(LDAPFiltDesc *) LDAP_CALL ldap_init_getfilter_buf( char *buf, + long buflen ); +LDAP_API(LDAPFiltInfo *) LDAP_CALL ldap_getfirstfilter( LDAPFiltDesc *lfdp, + char *tagpat, char *value ); +LDAP_API(LDAPFiltInfo *) LDAP_CALL ldap_getnextfilter( LDAPFiltDesc *lfdp ); +LDAP_API(int) LDAP_CALL ldap_set_filter_additions( LDAPFiltDesc *lfdp, + char *prefix, char *suffix ); +LDAP_API(int) LDAP_CALL ldap_create_filter( char *buf, unsigned long buflen, + char *pattern, char *prefix, char *suffix, char *attr, + char *value, char **valwords ); +LDAP_API(void) LDAP_CALL ldap_getfilter_free( LDAPFiltDesc *lfdp ); + +/* + * Friendly mapping structure and routines (an API extension) + */ +typedef struct friendly { + char *f_unfriendly; + char *f_friendly; +} *FriendlyMap; +LDAP_API(char *) LDAP_CALL ldap_friendly_name( char *filename, char *name, + FriendlyMap *map ); +LDAP_API(void) LDAP_CALL ldap_free_friendlymap( FriendlyMap *map ); + +/* + * In Memory Cache (an API extension -- LDAP_API_FEATURE_X_MEMCACHE) + */ +typedef struct ldapmemcache LDAPMemCache; /* opaque in-memory cache handle */ + +LDAP_API(int) LDAP_CALL ldap_memcache_init( unsigned long ttl, + unsigned long size, char **baseDNs, struct ldap_thread_fns *thread_fns, + LDAPMemCache **cachep ); +LDAP_API(int) LDAP_CALL ldap_memcache_set( LDAP *ld, LDAPMemCache *cache ); +LDAP_API(int) LDAP_CALL ldap_memcache_get( LDAP *ld, LDAPMemCache **cachep ); +LDAP_API(void) LDAP_CALL ldap_memcache_flush( LDAPMemCache *cache, char *dn, + int scope ); +LDAP_API(void) LDAP_CALL ldap_memcache_flush_results( LDAPMemCache *cache, + char *dn, int scope ); +LDAP_API(void) LDAP_CALL ldap_memcache_destroy( LDAPMemCache *cache ); +LDAP_API(void) LDAP_CALL ldap_memcache_update( LDAPMemCache *cache ); + +/* + * Timeout value for nonblocking connect call + */ +#define LDAP_X_OPT_CONNECT_TIMEOUT (LDAP_OPT_PRIVATE_EXTENSION_BASE + 0x0F01) + /* 0x4000 + 0x0F01 = 0x4F01 = 20225 - API extension */ + +/* + * Socket buffer structure associated to the LDAP connection + */ +#define LDAP_X_OPT_SOCKBUF (LDAP_OPT_PRIVATE_EXTENSION_BASE + 0x0F03) + /* 0x4000 + 0x0F03 = 0x4F03 = 20227 - API extension */ + +/* + * Memory allocation callback functions (an API extension -- + * LDAP_API_FEATURE_X_MEMALLOC_FUNCTIONS). These are global and can + * not be set on a per-LDAP session handle basis. Install your own + * functions by making a call like this: + * ldap_set_option( NULL, LDAP_OPT_MEMALLOC_FN_PTRS, &memalloc_fns ); + * + * look in lber.h for the function typedefs themselves. + */ +#define LDAP_OPT_MEMALLOC_FN_PTRS 0x61 /* 97 - API extension */ + +struct ldap_memalloc_fns { + LDAP_MALLOC_CALLBACK *ldapmem_malloc; + LDAP_CALLOC_CALLBACK *ldapmem_calloc; + LDAP_REALLOC_CALLBACK *ldapmem_realloc; + LDAP_FREE_CALLBACK *ldapmem_free; +}; + + +/* + * Memory allocation functions (an API extension) + */ +void *ldap_x_malloc( size_t size ); +void *ldap_x_calloc( size_t nelem, size_t elsize ); +void *ldap_x_realloc( void *ptr, size_t size ); +void ldap_x_free( void *ptr ); + +/* + * Server reconnect (an API extension). + */ +#define LDAP_OPT_RECONNECT 0x62 /* 98 - API extension */ + + +/* + * Extra thread callback functions (an API extension -- + * LDAP_API_FEATURE_X_EXTHREAD_FUNCTIONS) + */ +#define LDAP_OPT_EXTRA_THREAD_FN_PTRS 0x65 /* 101 - API extension */ + +/* + * When bind is called, don't bind if there's a connection open with the same DN + */ +#define LDAP_OPT_NOREBIND 0x66 /* 102 - API extension */ + +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_TRYLOCK_CALLBACK)( void *m ); +typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_ALLOC_CALLBACK)( void ); +typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_FREE_CALLBACK)( void *s ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_WAIT_CALLBACK)( void *s ); +typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_POST_CALLBACK)( void *s ); +typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_THREADID_CALLBACK)(void); + +struct ldap_extra_thread_fns { + LDAP_TF_MUTEX_TRYLOCK_CALLBACK *ltf_mutex_trylock; + LDAP_TF_SEMA_ALLOC_CALLBACK *ltf_sema_alloc; + LDAP_TF_SEMA_FREE_CALLBACK *ltf_sema_free; + LDAP_TF_SEMA_WAIT_CALLBACK *ltf_sema_wait; + LDAP_TF_SEMA_POST_CALLBACK *ltf_sema_post; + LDAP_TF_THREADID_CALLBACK *ltf_threadid_fn; +}; + +/* + * Debugging level (an API extension) + */ +#define LDAP_OPT_DEBUG_LEVEL 0x6E /* 110 - API extension */ +/* On UNIX, there's only one copy of ldap_debug */ +/* On NT, each dll keeps its own module_ldap_debug, which */ +/* points to the process' ldap_debug and needs initializing after load */ +#ifdef _WIN32 +extern int *module_ldap_debug; +typedef void (*set_debug_level_fn_t)(int*); +#endif + +#ifdef LDAP_DNS +#define LDAP_OPT_DNS 0x0C /* 12 - API extension */ +#endif + +/* + * UTF-8 routines (should these move into libnls?) + */ +/* number of bytes in character */ +LDAP_API(int) LDAP_CALL ldap_utf8len( const char* ); +/* find next character */ +LDAP_API(char*) LDAP_CALL ldap_utf8next( char* ); +/* find previous character */ +LDAP_API(char*) LDAP_CALL ldap_utf8prev( char* ); +/* copy one character */ +LDAP_API(int) LDAP_CALL ldap_utf8copy( char* dst, const char* src ); +/* total number of characters */ +LDAP_API(size_t) LDAP_CALL ldap_utf8characters( const char* ); +/* get one UCS-4 character, and move *src to the next character */ +LDAP_API(unsigned long) LDAP_CALL ldap_utf8getcc( const char** src ); +/* UTF-8 aware strtok_r() */ +LDAP_API(char*) LDAP_CALL ldap_utf8strtok_r( char* src, const char* brk, char** +next); + +/* like isalnum(*s) in the C locale */ +LDAP_API(int) LDAP_CALL ldap_utf8isalnum( char* s ); +/* like isalpha(*s) in the C locale */ +LDAP_API(int) LDAP_CALL ldap_utf8isalpha( char* s ); +/* like isdigit(*s) in the C locale */ +LDAP_API(int) LDAP_CALL ldap_utf8isdigit( char* s ); +/* like isxdigit(*s) in the C locale */ +LDAP_API(int) LDAP_CALL ldap_utf8isxdigit(char* s ); +/* like isspace(*s) in the C locale */ +LDAP_API(int) LDAP_CALL ldap_utf8isspace( char* s ); + +#define LDAP_UTF8LEN(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8len (s) : 1) +#define LDAP_UTF8NEXT(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8next(s) : ( s)+1) +#define LDAP_UTF8INC(s) ((0x80 & *(unsigned char*)(s)) ? s=ldap_utf8next(s) : ++s) + +#define LDAP_UTF8PREV(s) ldap_utf8prev(s) +#define LDAP_UTF8DEC(s) (s=ldap_utf8prev(s)) + +#define LDAP_UTF8COPY(d,s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8copy(d,s) : ((*(d) = *(s)), 1)) +#define LDAP_UTF8GETCC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc (&s) : *s++) +#define LDAP_UTF8GETC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc ((const char**)&s) : *s++) + +/* SASL options */ +#define LDAP_OPT_X_SASL_MECH 0x6100 +#define LDAP_OPT_X_SASL_REALM 0x6101 +#define LDAP_OPT_X_SASL_AUTHCID 0x6102 +#define LDAP_OPT_X_SASL_AUTHZID 0x6103 +#define LDAP_OPT_X_SASL_SSF 0x6104 /* read-only */ +#define LDAP_OPT_X_SASL_SSF_EXTERNAL 0x6105 /* write-only */ +#define LDAP_OPT_X_SASL_SECPROPS 0x6106 /* write-only */ +#define LDAP_OPT_X_SASL_SSF_MIN 0x6107 +#define LDAP_OPT_X_SASL_SSF_MAX 0x6108 +#define LDAP_OPT_X_SASL_MAXBUFSIZE 0x6109 + +/* ldap_interactive_bind_s Interaction flags + * Interactive: prompt always - REQUIRED + */ +#define LDAP_SASL_AUTOMATIC 0U /* only prompt for missing items not supplied as defaults */ +#define LDAP_SASL_INTERACTIVE 1U /* prompt for everything and print defaults, if any */ +#define LDAP_SASL_QUIET 2U /* no prompts - only use defaults (e.g. for non-interactive apps) */ + +/* + * V3 SASL Interaction Function Callback Prototype + * when using Cyrus SASL, interact is pointer to sasl_interact_t + * should likely passed in a control (and provided controls) + */ +typedef int (LDAP_SASL_INTERACT_PROC) + (LDAP *ld, unsigned flags, void* defaults, void *interact ); + +LDAP_API(int) LDAP_CALL ldap_sasl_interactive_bind_s ( + LDAP *ld, + const char *dn, /* usually NULL */ + const char *saslMechanism, + LDAPControl **serverControls, + LDAPControl **clientControls, + + /* should be client controls */ + unsigned flags, + LDAP_SASL_INTERACT_PROC *proc, + void *defaults ); + +LDAP_API(int) LDAP_CALL ldap_sasl_interactive_bind_ext_s ( + LDAP *ld, + const char *dn, /* usually NULL */ + const char *saslMechanism, + LDAPControl **serverControls, + LDAPControl **clientControls, + + /* should be client controls */ + unsigned flags, + LDAP_SASL_INTERACT_PROC *proc, + void *defaults, + LDAPControl ***responseControls ); + +/* + * Password modify functions + */ +LDAP_API(int) LDAP_CALL ldap_passwd( LDAP *ld, struct berval *userid, + struct berval *oldpasswd, struct berval *newpasswd, + LDAPControl **serverctrls, LDAPControl **clientctrls, + int *msgidp ); + +LDAP_API(int) LDAP_CALL ldap_passwd_s( LDAP *ld, struct berval *userid, + struct berval *oldpasswd, struct berval *newpasswd, + struct berval *genpasswd, LDAPControl **serverctrls, + LDAPControl **clientctrls ); + +LDAP_API(int) LDAP_CALL ldap_parse_passwd( LDAP *ld, LDAPMessage *result, + struct berval *genpasswd ); + +/* + * in reslist.c + */ +LDAP_API(LDAPMessage *) LDAP_CALL ldap_delete_result_entry( LDAPMessage **list, LDAPMessage *e ); +LDAP_API(void) LDAP_CALL ldap_add_result_entry( LDAPMessage **list, LDAPMessage *e ); + +#ifdef __cplusplus +} +#endif +#endif /* _LDAP_EXTENSION_H */ + |