1 /* 2 * Copyright 2001-2003 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 #pragma ident "%Z%%M% %I% %E% SMI" 7 8 #ifndef _SOLARISINT_H 9 #define _SOLARISINT_H 10 11 #ifdef __cplusplus 12 extern "C" { 13 #endif 14 15 #include <stdio.h> 16 #include <ctype.h> 17 #include <stdarg.h> 18 #include <stdlib.h> 19 20 #include "ldap.h" 21 22 /* 23 * These were moved from lber.h. This should have been ifdef'd with 24 * _SOLARIS_SDK but since we do not want to expose these in lber.h its 25 * not possible to ifndef it there. 26 */ 27 28 /* BerElement set/get options */ 29 #define LBER_OPT_REMAINING_BYTES 0x01 30 #define LBER_OPT_TOTAL_BYTES 0x02 31 #define LBER_OPT_USE_DER 0x04 32 #define LBER_OPT_TRANSLATE_STRINGS 0x08 33 #define LBER_OPT_BYTES_TO_WRITE 0x10 34 #define LBER_OPT_MEMALLOC_FN_PTRS 0x20 35 #define LBER_OPT_DEBUG_LEVEL 0x40 36 /* 37 * LBER_USE_DER is defined for compatibility with the C LDAP API RFC. 38 * In our implementation, we recognize it (instead of the numerically 39 * identical LBER_OPT_REMAINING_BYTES) in calls to ber_alloc_t() and 40 * ber_init_w_nullchar() only. Callers of ber_set_option() or 41 * ber_get_option() must use LBER_OPT_USE_DER instead. Sorry! 42 */ 43 #define LBER_USE_DER 0x01 44 45 /* Sockbuf set/get options */ 46 #define LBER_SOCKBUF_OPT_TO_FILE 0x001 47 #define LBER_SOCKBUF_OPT_TO_FILE_ONLY 0x002 48 #define LBER_SOCKBUF_OPT_MAX_INCOMING_SIZE 0x004 49 #define LBER_SOCKBUF_OPT_NO_READ_AHEAD 0x008 50 #define LBER_SOCKBUF_OPT_DESC 0x010 51 #define LBER_SOCKBUF_OPT_COPYDESC 0x020 52 #define LBER_SOCKBUF_OPT_READ_FN 0x040 53 #define LBER_SOCKBUF_OPT_WRITE_FN 0x080 54 #define LBER_SOCKBUF_OPT_EXT_IO_FNS 0x100 55 56 #ifndef _SOLARIS_SDK 57 /* 58 * The following is not used by solaris. Just kept to stay in sync with 59 * iplanet and also a place holder (0x200) 60 */ 61 #define LBER_SOCKBUF_OPT_VALID_TAG 0x200 62 #endif /* !_SOLARIS_SDK */ 63 64 /* 65 * Socket buffer structure associated to the LDAP connection 66 */ 67 #define LDAP_X_OPT_SOCKBUF (LDAP_OPT_PRIVATE_EXTENSION_BASE + 0x0F02) 68 /* 0x4000 + 0x0F02 = 0x4F02 = 20226 - API extension */ 69 70 71 #define LBER_OPT_ON ((void *) 1) 72 #define LBER_OPT_OFF ((void *) 0) 73 74 /* Used in various functions */ 75 #define LBER_FUNC_VALUE -1 76 77 struct lextiof_socket_private; /* Defined by the extended I/O */ 78 /* callback functions */ 79 struct lextiof_session_private; /* Defined by the extended I/O */ 80 /* callback functions */ 81 82 /* This is modeled after the PRIOVec that is passed to the NSPR 83 writev function! The void* is a char* in that struct */ 84 typedef struct ldap_x_iovec { 85 char *ldapiov_base; 86 int ldapiov_len; 87 } ldap_x_iovec; 88 89 /* 90 * libldap read and write I/O function callbacks. The rest of the I/O callback 91 * types are defined in ldap.h 92 */ 93 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_READ_CALLBACK)( LBER_SOCKET s, 94 void *buf, int bufsize ); 95 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_WRITE_CALLBACK)( LBER_SOCKET s, 96 const void *buf, int len ); 97 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_READ_CALLBACK)( int s, 98 void *buf, int bufsize, struct lextiof_socket_private *arg ); 99 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_WRITE_CALLBACK)( int s, 100 const void *buf, int len, struct lextiof_socket_private *arg ); 101 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_WRITEV_CALLBACK)(int s, 102 const ldap_x_iovec iov[], int iovcnt, struct lextiof_socket_private *socketarg); 103 104 105 /* 106 * Structure for use with LBER_SOCKBUF_OPT_EXT_IO_FNS: 107 */ 108 struct lber_x_ext_io_fns { 109 /* lbextiofn_size should always be set to LBER_X_EXTIO_FNS_SIZE */ 110 int lbextiofn_size; 111 LDAP_X_EXTIOF_READ_CALLBACK *lbextiofn_read; 112 LDAP_X_EXTIOF_WRITE_CALLBACK *lbextiofn_write; 113 struct lextiof_socket_private *lbextiofn_socket_arg; 114 LDAP_X_EXTIOF_WRITEV_CALLBACK *lbextiofn_writev; 115 }; 116 #define LBER_X_EXTIO_FNS_SIZE sizeof(struct lber_x_ext_io_fns) 117 118 /* 119 * liblber memory allocation callback functions. These are global to all 120 * Sockbufs and BerElements. Install your own functions by using a call 121 * like this: ber_set_option( NULL, LBER_OPT_MEMALLOC_FN_PTRS, &memalloc_fns ); 122 */ 123 typedef void * (LDAP_C LDAP_CALLBACK LDAP_MALLOC_CALLBACK)( size_t size ); 124 typedef void * (LDAP_C LDAP_CALLBACK LDAP_CALLOC_CALLBACK)( size_t nelem, 125 size_t elsize ); 126 typedef void * (LDAP_C LDAP_CALLBACK LDAP_REALLOC_CALLBACK)( void *ptr, 127 size_t size ); 128 typedef void (LDAP_C LDAP_CALLBACK LDAP_FREE_CALLBACK)( void *ptr ); 129 130 struct lber_memalloc_fns { 131 LDAP_MALLOC_CALLBACK *lbermem_malloc; 132 LDAP_CALLOC_CALLBACK *lbermem_calloc; 133 LDAP_REALLOC_CALLBACK *lbermem_realloc; 134 LDAP_FREE_CALLBACK *lbermem_free; 135 }; 136 137 /* 138 * Functions marked as Project Private in PSARC case and moved 139 * from lber.h 140 */ 141 typedef struct sockbuf Sockbuf; 142 143 LDAP_API(void) LDAP_CALL ber_special_free(void* buf, BerElement *ber); 144 LDAP_API(void*) LDAP_CALL ber_special_alloc(size_t size, BerElement **ppBer); 145 LDAP_API(ber_uint_t) LDAP_CALL ber_get_next_buffer( void *buffer, 146 size_t buffer_size, ber_len_t *len, BerElement *ber, 147 ber_uint_t *Bytes_Scanned ); 148 LDAP_API(ber_uint_t) LDAP_CALL ber_get_next_buffer_ext( void *buffer, 149 size_t buffer_size, ber_len_t *len, BerElement *ber, 150 ber_len_t *Bytes_Scanned, Sockbuf *sb ); 151 LDAP_API(void) LDAP_CALL ber_init_w_nullchar( BerElement *ber, int options ); 152 LDAP_API(int) LDAP_CALL ber_set_option( BerElement *ber, int option, 153 void *value ); 154 LDAP_API(int) LDAP_CALL ber_get_option( BerElement *ber, int option, 155 void *value ); 156 LDAP_API(Sockbuf*) LDAP_CALL ber_sockbuf_alloc( void ); 157 LDAP_API(void) LDAP_CALL ber_sockbuf_free( Sockbuf* p ); 158 LDAP_API(int) LDAP_CALL ber_sockbuf_set_option( Sockbuf *sb, int option, 159 void *value ); 160 LDAP_API(int) LDAP_CALL ber_sockbuf_get_option( Sockbuf *sb, int option, 161 void *value ); 162 LDAP_API(int) LDAP_CALL ber_flush( Sockbuf *sb, BerElement *ber, int freeit ); 163 LDAP_API(ber_tag_t) LDAP_CALL ber_get_next( Sockbuf *sb, ber_len_t *len, 164 BerElement *ber ); 165 166 /* 167 * The following was moved from ldap.h 168 */ 169 170 /* 171 * These extended I/O function callbacks echo the BSD socket API but accept 172 * an extra pointer parameter at the end of their argument list that can 173 * be used by client applications for their own needs. For some of the calls, 174 * the pointer is a session argument of type struct lextiof_session_private * 175 * that is associated with the LDAP session handle (LDAP *). For others, the 176 * pointer is a socket specific struct lextiof_socket_private * argument that 177 * is associated with a particular socket (a TCP connection). 178 * 179 * The lextiof_session_private and lextiof_socket_private structures are not 180 * defined by the LDAP C API; users of this extended I/O interface should 181 * define these themselves. 182 * 183 * The combination of the integer socket number (i.e., lpoll_fd, which is 184 * the value returned by the CONNECT callback) and the application specific 185 * socket argument (i.e., lpoll_socketarg, which is the value set in *sockargpp 186 * by the CONNECT callback) must be unique. 187 * 188 * The types for the extended READ and WRITE callbacks are actually in lber.h. 189 * 190 * The CONNECT callback gets passed both the session argument (sessionarg) 191 * and a pointer to a socket argument (socketargp) so it has the 192 * opportunity to set the socket-specific argument. The CONNECT callback 193 * also takes a timeout parameter whose value can be set by calling 194 * ldap_set_option( ld, LDAP_X_OPT_..., &val ). The units used for the 195 * timeout parameter are milliseconds. 196 * 197 * A POLL interface is provided instead of a select() one. The timeout is 198 * in milliseconds. 199 200 * A NEWHANDLE callback function is also provided. It is called right 201 * after the LDAP session handle is created, e.g., during ldap_init(). 202 * If the NEWHANDLE callback returns anything other than LDAP_SUCCESS, 203 * the session handle allocation fails. 204 * 205 * A DISPOSEHANDLE callback function is also provided. It is called right 206 * before the LDAP session handle and its contents are destroyed, e.g., 207 * during ldap_unbind(). 208 */ 209 210 /* LDAP poll()-like descriptor: 211 */ 212 typedef struct ldap_x_pollfd { /* used by LDAP_X_EXTIOF_POLL_CALLBACK */ 213 int lpoll_fd; /* integer file descriptor / socket */ 214 struct lextiof_socket_private 215 *lpoll_socketarg; 216 /* pointer socket and for use by */ 217 /* application */ 218 short lpoll_events; /* requested event */ 219 short lpoll_revents; /* returned event */ 220 } LDAP_X_PollFD; 221 222 /* Event flags for lpoll_events and lpoll_revents: 223 */ 224 #define LDAP_X_POLLIN 0x01 /* regular data ready for reading */ 225 #define LDAP_X_POLLPRI 0x02 /* high priority data available */ 226 #define LDAP_X_POLLOUT 0x04 /* ready for writing */ 227 #define LDAP_X_POLLERR 0x08 /* error occurred -- only in lpoll_revents */ 228 #define LDAP_X_POLLHUP 0x10 /* connection closed -- only in lpoll_revents */ 229 #define LDAP_X_POLLNVAL 0x20 /* invalid lpoll_fd -- only in lpoll_revents */ 230 231 /* Options passed to LDAP_X_EXTIOF_CONNECT_CALLBACK to modify socket behavior: 232 */ 233 #define LDAP_X_EXTIOF_OPT_NONBLOCKING 0x01 /* turn on non-blocking mode */ 234 #define LDAP_X_EXTIOF_OPT_SECURE 0x02 /* turn on 'secure' mode */ 235 236 /* extended I/O callback function prototypes: 237 */ 238 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_CONNECT_CALLBACK )( 239 const char *hostlist, int port, /* host byte order */ 240 int timeout /* milliseconds */, 241 unsigned long options, /* bitmapped options */ 242 struct lextiof_session_private *sessionarg, 243 struct lextiof_socket_private **socketargp 244 #ifdef _SOLARIS_SDK 245 , void **datapriv ); 246 #else 247 ); 248 #endif 249 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_CLOSE_CALLBACK )( 250 int s, struct lextiof_socket_private *socketarg ); 251 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_POLL_CALLBACK)( 252 LDAP_X_PollFD fds[], int nfds, int timeout /* milliseconds */, 253 struct lextiof_session_private *sessionarg ); 254 typedef int (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_NEWHANDLE_CALLBACK)( 255 LDAP *ld, struct lextiof_session_private *sessionarg ); 256 typedef void (LDAP_C LDAP_CALLBACK LDAP_X_EXTIOF_DISPOSEHANDLE_CALLBACK)( 257 LDAP *ld, struct lextiof_session_private *sessionarg ); 258 259 260 /* Structure to hold extended I/O function pointers: 261 */ 262 struct ldap_x_ext_io_fns { 263 /* lextiof_size should always be set to LDAP_X_EXTIO_FNS_SIZE */ 264 int lextiof_size; 265 LDAP_X_EXTIOF_CONNECT_CALLBACK *lextiof_connect; 266 LDAP_X_EXTIOF_CLOSE_CALLBACK *lextiof_close; 267 LDAP_X_EXTIOF_READ_CALLBACK *lextiof_read; 268 LDAP_X_EXTIOF_WRITE_CALLBACK *lextiof_write; 269 LDAP_X_EXTIOF_POLL_CALLBACK *lextiof_poll; 270 LDAP_X_EXTIOF_NEWHANDLE_CALLBACK *lextiof_newhandle; 271 LDAP_X_EXTIOF_DISPOSEHANDLE_CALLBACK *lextiof_disposehandle; 272 void *lextiof_session_arg; 273 LDAP_X_EXTIOF_WRITEV_CALLBACK *lextiof_writev; 274 }; 275 #define LDAP_X_EXTIO_FNS_SIZE sizeof(struct ldap_x_ext_io_fns) 276 277 278 /* 279 * Utility functions for parsing space-separated host lists (useful for 280 * implementing an extended I/O CONNECT callback function). 281 */ 282 struct ldap_x_hostlist_status; 283 LDAP_API(int) LDAP_CALL ldap_x_hostlist_first( const char *hostlist, 284 int defport, char **hostp, int *portp /* host byte order */, 285 struct ldap_x_hostlist_status **statusp ); 286 LDAP_API(int) LDAP_CALL ldap_x_hostlist_next( char **hostp, 287 int *portp /* host byte order */, struct ldap_x_hostlist_status *status ); 288 LDAP_API(void) LDAP_CALL ldap_x_hostlist_statusfree( 289 struct ldap_x_hostlist_status *status ); 290 291 292 /* 293 * I/O callback functions (note that types for the read and write callbacks 294 * are actually in lber.h): 295 */ 296 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_SELECT_CALLBACK)( int nfds, 297 fd_set *readfds, fd_set *writefds, fd_set *errorfds, 298 struct timeval *timeout ); 299 typedef LBER_SOCKET (LDAP_C LDAP_CALLBACK LDAP_IOF_SOCKET_CALLBACK)( 300 int domain, int type, int protocol ); 301 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_IOCTL_CALLBACK)( LBER_SOCKET s, 302 int option, ... ); 303 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_CONNECT_CALLBACK )( 304 LBER_SOCKET s, struct sockaddr *name, int namelen ); 305 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_CLOSE_CALLBACK )( 306 LBER_SOCKET s ); 307 typedef int (LDAP_C LDAP_CALLBACK LDAP_IOF_SSL_ENABLE_CALLBACK )( 308 LBER_SOCKET s ); 309 310 311 /* 312 * Structure to hold I/O function pointers: 313 */ 314 struct ldap_io_fns { 315 LDAP_IOF_READ_CALLBACK *liof_read; 316 LDAP_IOF_WRITE_CALLBACK *liof_write; 317 LDAP_IOF_SELECT_CALLBACK *liof_select; 318 LDAP_IOF_SOCKET_CALLBACK *liof_socket; 319 LDAP_IOF_IOCTL_CALLBACK *liof_ioctl; 320 LDAP_IOF_CONNECT_CALLBACK *liof_connect; 321 LDAP_IOF_CLOSE_CALLBACK *liof_close; 322 LDAP_IOF_SSL_ENABLE_CALLBACK *liof_ssl_enable; 323 }; 324 325 /********* the functions in the following section are experimental ***********/ 326 327 #define LDAP_OPT_PREFERRED_LANGUAGE 0x14 /* 20 - API extension */ 328 329 /* 330 * SSL option (an API extension): 331 */ 332 #define LDAP_OPT_SSL 0x0A /* 10 - API extension */ 333 334 /* 335 * Referral hop limit (an API extension): 336 */ 337 #define LDAP_OPT_REFERRAL_HOP_LIMIT 0x10 /* 16 - API extension */ 338 339 /* 340 * DNS resolver callbacks (an API extension --LDAP_API_FEATURE_X_DNS_FUNCTIONS). 341 * Note that gethostbyaddr() is not currently used. 342 */ 343 #define LDAP_OPT_DNS_FN_PTRS 0x60 /* 96 - API extension */ 344 345 typedef struct LDAPHostEnt { 346 char *ldaphe_name; /* official name of host */ 347 char **ldaphe_aliases; /* alias list */ 348 int ldaphe_addrtype; /* host address type */ 349 int ldaphe_length; /* length of address */ 350 char **ldaphe_addr_list; /* list of addresses from name server */ 351 } LDAPHostEnt; 352 353 typedef LDAPHostEnt * (LDAP_C LDAP_CALLBACK LDAP_DNSFN_GETHOSTBYNAME)( 354 const char *name, LDAPHostEnt *result, char *buffer, 355 int buflen, int *statusp, void *extradata); 356 typedef LDAPHostEnt * (LDAP_C LDAP_CALLBACK LDAP_DNSFN_GETHOSTBYADDR)( 357 const char *addr, int length, int type, LDAPHostEnt *result, 358 char *buffer, int buflen, int *statusp, void *extradata); 359 typedef int (LDAP_C LDAP_CALLBACK LDAP_DNSFN_GETPEERNAME)( 360 LDAP *ld, struct sockaddr *netaddr, char *buffer, int buflen); 361 362 struct ldap_dns_fns { 363 void *lddnsfn_extradata; 364 int lddnsfn_bufsize; 365 LDAP_DNSFN_GETHOSTBYNAME *lddnsfn_gethostbyname; 366 LDAP_DNSFN_GETHOSTBYADDR *lddnsfn_gethostbyaddr; 367 LDAP_DNSFN_GETPEERNAME *lddnsfn_getpeername; 368 }; 369 370 /* 371 * Generalized cache callback interface: 372 */ 373 #define LDAP_OPT_CACHE_FN_PTRS 0x0D /* 13 - API extension */ 374 #define LDAP_OPT_CACHE_STRATEGY 0x0E /* 14 - API extension */ 375 #define LDAP_OPT_CACHE_ENABLE 0x0F /* 15 - API extension */ 376 377 /* cache strategies */ 378 #define LDAP_CACHE_CHECK 0 379 #define LDAP_CACHE_POPULATE 1 380 #define LDAP_CACHE_LOCALDB 2 381 382 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_BIND_CALLBACK)(LDAP *ld, int msgid, 383 ber_tag_t tag, const char *dn, const struct berval *creds, 384 int method); 385 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_UNBIND_CALLBACK)(LDAP *ld, 386 int unused0, unsigned long unused1); 387 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_SEARCH_CALLBACK)(LDAP *ld, 388 int msgid, ber_tag_t tag, const char *base, int scope, 389 const char LDAP_CALLBACK *filter, char **attrs, int attrsonly); 390 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_COMPARE_CALLBACK)(LDAP *ld, 391 int msgid, ber_tag_t tag, const char *dn, const char *attr, 392 const struct berval *value); 393 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_ADD_CALLBACK)(LDAP *ld, 394 int msgid, ber_tag_t tag, const char *dn, LDAPMod **attrs); 395 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_DELETE_CALLBACK)(LDAP *ld, 396 int msgid, ber_tag_t tag, const char *dn); 397 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_MODIFY_CALLBACK)(LDAP *ld, 398 int msgid, ber_tag_t tag, const char *dn, LDAPMod **mods); 399 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_MODRDN_CALLBACK)(LDAP *ld, 400 int msgid, ber_tag_t tag, const char *dn, const char *newrdn, 401 int deleteoldrdn); 402 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_RESULT_CALLBACK)(LDAP *ld, 403 int msgid, int all, struct timeval *timeout, LDAPMessage **result); 404 typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_FLUSH_CALLBACK)(LDAP *ld, 405 const char *dn, const char *filter); 406 407 struct ldap_cache_fns { 408 void *lcf_private; 409 LDAP_CF_BIND_CALLBACK *lcf_bind; 410 LDAP_CF_UNBIND_CALLBACK *lcf_unbind; 411 LDAP_CF_SEARCH_CALLBACK *lcf_search; 412 LDAP_CF_COMPARE_CALLBACK *lcf_compare; 413 LDAP_CF_ADD_CALLBACK *lcf_add; 414 LDAP_CF_DELETE_CALLBACK *lcf_delete; 415 LDAP_CF_MODIFY_CALLBACK *lcf_modify; 416 LDAP_CF_MODRDN_CALLBACK *lcf_modrdn; 417 LDAP_CF_RESULT_CALLBACK *lcf_result; 418 LDAP_CF_FLUSH_CALLBACK *lcf_flush; 419 }; 420 421 int LDAP_CALL ldap_cache_flush(LDAP *ld, const char *dn, 422 const char *filter); 423 424 /* 425 * Memory allocation callback functions (an API extension -- 426 * LDAP_API_FEATURE_X_MEMALLOC_FUNCTIONS). These are global and can 427 * not be set on a per-LDAP session handle basis. Install your own 428 * functions by making a call like this: 429 * ldap_set_option( NULL, LDAP_OPT_MEMALLOC_FN_PTRS, &memalloc_fns ); 430 * 431 * look in lber.h for the function typedefs themselves. 432 */ 433 #define LDAP_OPT_MEMALLOC_FN_PTRS 0x61 /* 97 - API extension */ 434 435 struct ldap_memalloc_fns { 436 LDAP_MALLOC_CALLBACK *ldapmem_malloc; 437 LDAP_CALLOC_CALLBACK *ldapmem_calloc; 438 LDAP_REALLOC_CALLBACK *ldapmem_realloc; 439 LDAP_FREE_CALLBACK *ldapmem_free; 440 }; 441 442 443 /* 444 * Memory allocation functions (an API extension) 445 */ 446 void *ldap_x_malloc( size_t size ); 447 void *ldap_x_calloc( size_t nelem, size_t elsize ); 448 void *ldap_x_realloc( void *ptr, size_t size ); 449 void ldap_x_free( void *ptr ); 450 451 /* 452 * Extra thread callback functions (an API extension -- 453 * LDAP_API_FEATURE_X_EXTHREAD_FUNCTIONS) 454 */ 455 #define LDAP_OPT_EXTRA_THREAD_FN_PTRS 0x65 /* 101 - API extension */ 456 457 typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_TRYLOCK_CALLBACK)( void *m ); 458 typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_ALLOC_CALLBACK)( void ); 459 typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_FREE_CALLBACK)( void *s ); 460 typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_WAIT_CALLBACK)( void *s ); 461 typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_POST_CALLBACK)( void *s ); 462 typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_THREADID_CALLBACK)(void); 463 464 struct ldap_extra_thread_fns { 465 LDAP_TF_MUTEX_TRYLOCK_CALLBACK *ltf_mutex_trylock; 466 LDAP_TF_SEMA_ALLOC_CALLBACK *ltf_sema_alloc; 467 LDAP_TF_SEMA_FREE_CALLBACK *ltf_sema_free; 468 LDAP_TF_SEMA_WAIT_CALLBACK *ltf_sema_wait; 469 LDAP_TF_SEMA_POST_CALLBACK *ltf_sema_post; 470 LDAP_TF_THREADID_CALLBACK *ltf_threadid_fn; 471 }; 472 473 474 /* 475 * Debugging level (an API extension) 476 */ 477 #define LDAP_OPT_DEBUG_LEVEL 0x6E /* 110 - API extension */ 478 /* On UNIX, there's only one copy of ldap_debug */ 479 /* On NT, each dll keeps its own module_ldap_debug, which */ 480 /* points to the process' ldap_debug and needs initializing after load */ 481 #ifdef _WIN32 482 extern int *module_ldap_debug; 483 typedef void (*set_debug_level_fn_t)(int*); 484 #endif 485 486 /************************ end of experimental section ************************/ 487 488 489 LDAP_API(int) LDAP_CALL ldap_keysort_entries( LDAP *ld, LDAPMessage **chain, 490 void *arg, LDAP_KEYGEN_CALLBACK *gen, LDAP_KEYCMP_CALLBACK *cmp, 491 LDAP_KEYFREE_CALLBACK *fre ); 492 493 /* 494 * utility routines 495 */ 496 LDAP_API(int) LDAP_CALL ldap_charray_add( char ***a, char *s ); 497 LDAP_API(int) LDAP_CALL ldap_charray_merge( char ***a, char **s ); 498 LDAP_API(void) LDAP_CALL ldap_charray_free( char **array ); 499 LDAP_API(int) LDAP_CALL ldap_charray_inlist( char **a, char *s ); 500 LDAP_API(char **) LDAP_CALL ldap_charray_dup( char **a ); 501 LDAP_API(char **) LDAP_CALL ldap_str2charray( char *str, char *brkstr ); 502 LDAP_API(int) LDAP_CALL ldap_charray_position( char **a, char *s ); 503 504 /* 505 * UTF-8 routines (should these move into libnls?) 506 */ 507 /* number of bytes in character */ 508 LDAP_API(int) LDAP_CALL ldap_utf8len( const char* ); 509 /* find next character */ 510 LDAP_API(char*) LDAP_CALL ldap_utf8next( char* ); 511 /* find previous character */ 512 LDAP_API(char*) LDAP_CALL ldap_utf8prev( char* ); 513 /* copy one character */ 514 LDAP_API(int) LDAP_CALL ldap_utf8copy( char* dst, const char* src ); 515 /* total number of characters */ 516 LDAP_API(size_t) LDAP_CALL ldap_utf8characters( const char* ); 517 /* get one UCS-4 character, and move *src to the next character */ 518 LDAP_API(unsigned long) LDAP_CALL ldap_utf8getcc( const char** src ); 519 /* UTF-8 aware strtok_r() */ 520 LDAP_API(char*) LDAP_CALL ldap_utf8strtok_r( char* src, const char* brk, char** next); 521 522 /* like isalnum(*s) in the C locale */ 523 LDAP_API(int) LDAP_CALL ldap_utf8isalnum( char* s ); 524 /* like isalpha(*s) in the C locale */ 525 LDAP_API(int) LDAP_CALL ldap_utf8isalpha( char* s ); 526 /* like isdigit(*s) in the C locale */ 527 LDAP_API(int) LDAP_CALL ldap_utf8isdigit( char* s ); 528 /* like isxdigit(*s) in the C locale */ 529 LDAP_API(int) LDAP_CALL ldap_utf8isxdigit(char* s ); 530 /* like isspace(*s) in the C locale */ 531 LDAP_API(int) LDAP_CALL ldap_utf8isspace( char* s ); 532 533 #define LDAP_UTF8LEN(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8len (s) : 1) 534 #define LDAP_UTF8NEXT(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8next(s) : (s)+1) 535 #define LDAP_UTF8INC(s) ((0x80 & *(unsigned char*)(s)) ? s=ldap_utf8next(s) : ++s) 536 537 #define LDAP_UTF8PREV(s) ldap_utf8prev(s) 538 #define LDAP_UTF8DEC(s) (s=ldap_utf8prev(s)) 539 540 #define LDAP_UTF8COPY(d,s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8copy(d,s) : ((*(d) = *(s)), 1)) 541 #define LDAP_UTF8GETCC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc (&s) : *s++) 542 #define LDAP_UTF8GETC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc ((const char**)&s) : *s++) 543 544 #ifdef __cplusplus 545 } 546 #endif 547 #endif /* _SOLARISINT_H */ 548 549