2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2010 The OpenLDAP Foundation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted only as authorized by the OpenLDAP
11 * A copy of this license is available in the file LICENSE in the
12 * top-level directory of the distribution or, alternatively, at
13 * <http://www.OpenLDAP.org/license.html>.
20 #include <ac/stdlib.h>
22 #include <ac/socket.h>
23 #include <ac/string.h>
28 #define LDAP_OPT_REBIND_PROC 0x4e814d
29 #define LDAP_OPT_REBIND_PARAMS 0x4e814e
31 #define LDAP_OPT_NEXTREF_PROC 0x4e815d
32 #define LDAP_OPT_NEXTREF_PARAMS 0x4e815e
34 #define LDAP_OPT_URLLIST_PROC 0x4e816d
35 #define LDAP_OPT_URLLIST_PARAMS 0x4e816e
37 static const LDAPAPIFeatureInfo features[] = {
38 #ifdef LDAP_API_FEATURE_X_OPENLDAP
39 { /* OpenLDAP Extensions API Feature */
40 LDAP_FEATURE_INFO_VERSION,
42 LDAP_API_FEATURE_X_OPENLDAP
46 #ifdef LDAP_API_FEATURE_THREAD_SAFE
47 { /* Basic Thread Safe */
48 LDAP_FEATURE_INFO_VERSION,
50 LDAP_API_FEATURE_THREAD_SAFE
53 #ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE
54 { /* Session Thread Safe */
55 LDAP_FEATURE_INFO_VERSION,
56 "SESSION_THREAD_SAFE",
57 LDAP_API_FEATURE_SESSION_THREAD_SAFE
60 #ifdef LDAP_API_FEATURE_OPERATION_THREAD_SAFE
61 { /* Operation Thread Safe */
62 LDAP_FEATURE_INFO_VERSION,
63 "OPERATION_THREAD_SAFE",
64 LDAP_API_FEATURE_OPERATION_THREAD_SAFE
67 #ifdef LDAP_API_FEATURE_X_OPENLDAP_REENTRANT
68 { /* OpenLDAP Reentrant */
69 LDAP_FEATURE_INFO_VERSION,
70 "X_OPENLDAP_REENTRANT",
71 LDAP_API_FEATURE_X_OPENLDAP_REENTRANT
74 #if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) && \
75 defined( LDAP_THREAD_SAFE )
76 { /* OpenLDAP Thread Safe */
77 LDAP_FEATURE_INFO_VERSION,
78 "X_OPENLDAP_THREAD_SAFE",
79 LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE
82 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
84 LDAP_FEATURE_INFO_VERSION,
85 "X_OPENLDAP_V2_REFERRALS",
86 LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
98 struct ldapoptions *lo;
100 /* Get pointer to global option structure */
101 lo = LDAP_INT_GLOBAL_OPT();
103 return LDAP_NO_MEMORY;
106 if( lo->ldo_valid != LDAP_INITIALIZED ) {
107 ldap_int_initialize(lo, NULL);
111 assert( LDAP_VALID( ld ) );
113 if( !LDAP_VALID( ld ) ) {
114 return LDAP_OPT_ERROR;
117 lo = &ld->ld_options;
120 if(outvalue == NULL) {
121 /* no place to get to */
122 return LDAP_OPT_ERROR;
126 case LDAP_OPT_API_INFO: {
127 struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue;
130 /* outvalue must point to an apiinfo structure */
131 return LDAP_OPT_ERROR;
134 if(info->ldapai_info_version != LDAP_API_INFO_VERSION) {
135 /* api info version mismatch */
136 info->ldapai_info_version = LDAP_API_INFO_VERSION;
137 return LDAP_OPT_ERROR;
140 info->ldapai_api_version = LDAP_API_VERSION;
141 info->ldapai_protocol_version = LDAP_VERSION_MAX;
143 if(features[0].ldapaif_name == NULL) {
144 info->ldapai_extensions = NULL;
147 info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) *
148 sizeof(features)/sizeof(LDAPAPIFeatureInfo));
150 for(i=0; features[i].ldapaif_name != NULL; i++) {
151 info->ldapai_extensions[i] =
152 LDAP_STRDUP(features[i].ldapaif_name);
155 info->ldapai_extensions[i] = NULL;
158 info->ldapai_vendor_name = LDAP_STRDUP(LDAP_VENDOR_NAME);
159 info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
161 return LDAP_OPT_SUCCESS;
165 if( ld == NULL || ld->ld_sb == NULL ) {
170 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_GET_FD, outvalue );
171 return LDAP_OPT_SUCCESS;
173 case LDAP_OPT_SOCKBUF:
174 if( ld == NULL ) break;
175 *(Sockbuf **)outvalue = ld->ld_sb;
176 return LDAP_OPT_SUCCESS;
178 case LDAP_OPT_TIMEOUT:
179 /* the caller has to free outvalue ! */
180 if ( lo->ldo_tm_api.tv_sec < 0 ) {
181 *(void **)outvalue = NULL;
182 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_api ) != 0 ) {
183 return LDAP_OPT_ERROR;
185 return LDAP_OPT_SUCCESS;
187 case LDAP_OPT_NETWORK_TIMEOUT:
188 /* the caller has to free outvalue ! */
189 if ( lo->ldo_tm_net.tv_sec < 0 ) {
190 *(void **)outvalue = NULL;
191 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_net ) != 0 ) {
192 return LDAP_OPT_ERROR;
194 return LDAP_OPT_SUCCESS;
197 * (int *) outvalue = lo->ldo_deref;
198 return LDAP_OPT_SUCCESS;
200 case LDAP_OPT_SIZELIMIT:
201 * (int *) outvalue = lo->ldo_sizelimit;
202 return LDAP_OPT_SUCCESS;
204 case LDAP_OPT_TIMELIMIT:
205 * (int *) outvalue = lo->ldo_timelimit;
206 return LDAP_OPT_SUCCESS;
208 case LDAP_OPT_REFERRALS:
209 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS);
210 return LDAP_OPT_SUCCESS;
212 case LDAP_OPT_RESTART:
213 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART);
214 return LDAP_OPT_SUCCESS;
216 case LDAP_OPT_PROTOCOL_VERSION:
217 * (int *) outvalue = lo->ldo_version;
218 return LDAP_OPT_SUCCESS;
220 case LDAP_OPT_SERVER_CONTROLS:
221 * (LDAPControl ***) outvalue =
222 ldap_controls_dup( lo->ldo_sctrls );
224 return LDAP_OPT_SUCCESS;
226 case LDAP_OPT_CLIENT_CONTROLS:
227 * (LDAPControl ***) outvalue =
228 ldap_controls_dup( lo->ldo_cctrls );
230 return LDAP_OPT_SUCCESS;
232 case LDAP_OPT_HOST_NAME:
233 * (char **) outvalue = ldap_url_list2hosts(lo->ldo_defludp);
234 return LDAP_OPT_SUCCESS;
237 * (char **) outvalue = ldap_url_list2urls(lo->ldo_defludp);
238 return LDAP_OPT_SUCCESS;
240 case LDAP_OPT_DEFBASE:
241 if( lo->ldo_defbase == NULL ) {
242 * (char **) outvalue = NULL;
244 * (char **) outvalue = LDAP_STRDUP(lo->ldo_defbase);
247 return LDAP_OPT_SUCCESS;
249 case LDAP_OPT_CONNECT_ASYNC:
250 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_CONNECT_ASYNC);
251 return LDAP_OPT_SUCCESS;
253 case LDAP_OPT_CONNECT_CB:
255 /* Getting deletes the specified callback */
256 ldaplist **ll = &lo->ldo_conn_cbs;
257 for (;*ll;ll = &(*ll)->ll_next) {
258 if ((*ll)->ll_data == outvalue) {
266 return LDAP_OPT_SUCCESS;
268 case LDAP_OPT_RESULT_CODE:
273 * (int *) outvalue = ld->ld_errno;
274 return LDAP_OPT_SUCCESS;
276 case LDAP_OPT_DIAGNOSTIC_MESSAGE:
282 if( ld->ld_error == NULL ) {
283 * (char **) outvalue = NULL;
285 * (char **) outvalue = LDAP_STRDUP(ld->ld_error);
288 return LDAP_OPT_SUCCESS;
290 case LDAP_OPT_MATCHED_DN:
296 if( ld->ld_matched == NULL ) {
297 * (char **) outvalue = NULL;
299 * (char **) outvalue = LDAP_STRDUP( ld->ld_matched );
302 return LDAP_OPT_SUCCESS;
304 case LDAP_OPT_REFERRAL_URLS:
310 if( ld->ld_referrals == NULL ) {
311 * (char ***) outvalue = NULL;
313 * (char ***) outvalue = ldap_value_dup(ld->ld_referrals);
316 return LDAP_OPT_SUCCESS;
318 case LDAP_OPT_API_FEATURE_INFO: {
319 LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
322 if(info == NULL) return LDAP_OPT_ERROR;
324 if(info->ldapaif_info_version != LDAP_FEATURE_INFO_VERSION) {
325 /* api info version mismatch */
326 info->ldapaif_info_version = LDAP_FEATURE_INFO_VERSION;
327 return LDAP_OPT_ERROR;
330 if(info->ldapaif_name == NULL) return LDAP_OPT_ERROR;
332 for(i=0; features[i].ldapaif_name != NULL; i++) {
333 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
334 info->ldapaif_version =
335 features[i].ldapaif_version;
336 return LDAP_OPT_SUCCESS;
342 case LDAP_OPT_DEBUG_LEVEL:
343 * (int *) outvalue = lo->ldo_debug;
344 return LDAP_OPT_SUCCESS;
346 case LDAP_OPT_X_KEEPALIVE_IDLE:
347 * (int *) outvalue = lo->ldo_keepalive_idle;
348 return LDAP_OPT_SUCCESS;
350 case LDAP_OPT_X_KEEPALIVE_PROBES:
351 * (int *) outvalue = lo->ldo_keepalive_probes;
352 return LDAP_OPT_SUCCESS;
354 case LDAP_OPT_X_KEEPALIVE_INTERVAL:
355 * (int *) outvalue = lo->ldo_keepalive_interval;
356 return LDAP_OPT_SUCCESS;
360 if ( ldap_pvt_tls_get_option( ld, option, outvalue ) == 0 ) {
361 return LDAP_OPT_SUCCESS;
364 #ifdef HAVE_CYRUS_SASL
365 if ( ldap_int_sasl_get_option( ld, option, outvalue ) == 0 ) {
366 return LDAP_OPT_SUCCESS;
370 if ( ldap_int_gssapi_get_option( ld, option, outvalue ) == 0 ) {
371 return LDAP_OPT_SUCCESS;
378 return LDAP_OPT_ERROR;
385 LDAP_CONST void *invalue)
387 struct ldapoptions *lo;
390 /* Get pointer to global option structure */
391 lo = LDAP_INT_GLOBAL_OPT();
393 return LDAP_NO_MEMORY;
397 * The architecture to turn on debugging has a chicken and egg
398 * problem. Thus, we introduce a fix here.
401 if (option == LDAP_OPT_DEBUG_LEVEL) {
402 dbglvl = (int *) invalue;
405 if( lo->ldo_valid != LDAP_INITIALIZED ) {
406 ldap_int_initialize(lo, dbglvl);
410 assert( LDAP_VALID( ld ) );
412 if( !LDAP_VALID( ld ) ) {
413 return LDAP_OPT_ERROR;
416 lo = &ld->ld_options;
420 case LDAP_OPT_REFERRALS:
421 if(invalue == LDAP_OPT_OFF) {
422 LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
424 LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
426 return LDAP_OPT_SUCCESS;
428 case LDAP_OPT_RESTART:
429 if(invalue == LDAP_OPT_OFF) {
430 LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
432 LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
434 return LDAP_OPT_SUCCESS;
436 case LDAP_OPT_CONNECT_ASYNC:
437 if(invalue == LDAP_OPT_OFF) {
438 LDAP_BOOL_CLR(lo, LDAP_BOOL_CONNECT_ASYNC);
440 LDAP_BOOL_SET(lo, LDAP_BOOL_CONNECT_ASYNC);
442 return LDAP_OPT_SUCCESS;
445 /* options which can withstand invalue == NULL */
447 case LDAP_OPT_SERVER_CONTROLS: {
448 LDAPControl *const *controls =
449 (LDAPControl *const *) invalue;
452 ldap_controls_free( lo->ldo_sctrls );
454 if( controls == NULL || *controls == NULL ) {
455 lo->ldo_sctrls = NULL;
456 return LDAP_OPT_SUCCESS;
459 lo->ldo_sctrls = ldap_controls_dup( controls );
461 if(lo->ldo_sctrls == NULL) {
462 /* memory allocation error ? */
465 } return LDAP_OPT_SUCCESS;
467 case LDAP_OPT_CLIENT_CONTROLS: {
468 LDAPControl *const *controls =
469 (LDAPControl *const *) invalue;
472 ldap_controls_free( lo->ldo_cctrls );
474 if( controls == NULL || *controls == NULL ) {
475 lo->ldo_cctrls = NULL;
476 return LDAP_OPT_SUCCESS;
479 lo->ldo_cctrls = ldap_controls_dup( controls );
481 if(lo->ldo_cctrls == NULL) {
482 /* memory allocation error ? */
485 } return LDAP_OPT_SUCCESS;
488 case LDAP_OPT_HOST_NAME: {
489 const char *host = (const char *) invalue;
490 LDAPURLDesc *ludlist = NULL;
491 int rc = LDAP_OPT_SUCCESS;
494 rc = ldap_url_parsehosts( &ludlist, host,
495 lo->ldo_defport ? lo->ldo_defport : LDAP_PORT );
497 } else if(ld == NULL) {
499 * must want global default returned
500 * to initial condition.
502 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
503 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
504 | LDAP_PVT_URL_PARSE_DEF_PORT );
508 * must want the session default
509 * updated to the current global default
511 ludlist = ldap_url_duplist(
512 ldap_int_global_options.ldo_defludp);
517 if (rc == LDAP_OPT_SUCCESS) {
518 if (lo->ldo_defludp != NULL)
519 ldap_free_urllist(lo->ldo_defludp);
520 lo->ldo_defludp = ludlist;
526 const char *urls = (const char *) invalue;
527 LDAPURLDesc *ludlist = NULL;
528 int rc = LDAP_OPT_SUCCESS;
531 rc = ldap_url_parselist_ext(&ludlist, urls, NULL,
532 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
533 | LDAP_PVT_URL_PARSE_DEF_PORT );
534 } else if(ld == NULL) {
536 * must want global default returned
537 * to initial condition.
539 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
540 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
541 | LDAP_PVT_URL_PARSE_DEF_PORT );
545 * must want the session default
546 * updated to the current global default
548 ludlist = ldap_url_duplist(
549 ldap_int_global_options.ldo_defludp);
551 rc = LDAP_URL_ERR_MEM;
555 case LDAP_URL_SUCCESS: /* Success */
559 case LDAP_URL_ERR_MEM: /* can't allocate memory space */
563 case LDAP_URL_ERR_PARAM: /* parameter is bad */
564 case LDAP_URL_ERR_BADSCHEME: /* URL doesn't begin with "ldap[si]://" */
565 case LDAP_URL_ERR_BADENCLOSURE: /* URL is missing trailing ">" */
566 case LDAP_URL_ERR_BADURL: /* URL is bad */
567 case LDAP_URL_ERR_BADHOST: /* host port is bad */
568 case LDAP_URL_ERR_BADATTRS: /* bad (or missing) attributes */
569 case LDAP_URL_ERR_BADSCOPE: /* scope string is invalid (or missing) */
570 case LDAP_URL_ERR_BADFILTER: /* bad or missing filter */
571 case LDAP_URL_ERR_BADEXTS: /* bad or missing extensions */
572 rc = LDAP_PARAM_ERROR;
576 if (rc == LDAP_SUCCESS) {
577 if (lo->ldo_defludp != NULL)
578 ldap_free_urllist(lo->ldo_defludp);
579 lo->ldo_defludp = ludlist;
584 case LDAP_OPT_DEFBASE: {
585 const char *newbase = (const char *) invalue;
586 char *defbase = NULL;
588 if ( newbase != NULL ) {
589 defbase = LDAP_STRDUP( newbase );
590 if ( defbase == NULL ) return LDAP_NO_MEMORY;
592 } else if ( ld != NULL ) {
593 defbase = LDAP_STRDUP( ldap_int_global_options.ldo_defbase );
594 if ( defbase == NULL ) return LDAP_NO_MEMORY;
597 if ( lo->ldo_defbase != NULL )
598 LDAP_FREE( lo->ldo_defbase );
599 lo->ldo_defbase = defbase;
600 } return LDAP_OPT_SUCCESS;
602 case LDAP_OPT_DIAGNOSTIC_MESSAGE: {
603 const char *err = (const char *) invalue;
606 /* need a struct ldap */
607 return LDAP_OPT_ERROR;
611 LDAP_FREE(ld->ld_error);
616 ld->ld_error = LDAP_STRDUP(err);
618 } return LDAP_OPT_SUCCESS;
620 case LDAP_OPT_MATCHED_DN: {
621 const char *matched = (const char *) invalue;
624 /* need a struct ldap */
625 return LDAP_OPT_ERROR;
628 if( ld->ld_matched ) {
629 LDAP_FREE(ld->ld_matched);
630 ld->ld_matched = NULL;
634 ld->ld_matched = LDAP_STRDUP( matched );
636 } return LDAP_OPT_SUCCESS;
638 case LDAP_OPT_REFERRAL_URLS: {
639 char *const *referrals = (char *const *) invalue;
642 /* need a struct ldap */
643 return LDAP_OPT_ERROR;
646 if( ld->ld_referrals ) {
647 LDAP_VFREE(ld->ld_referrals);
651 ld->ld_referrals = ldap_value_dup(referrals);
653 } return LDAP_OPT_SUCCESS;
655 /* Only accessed from inside this function by ldap_set_rebind_proc() */
656 case LDAP_OPT_REBIND_PROC: {
657 lo->ldo_rebind_proc = (LDAP_REBIND_PROC *)invalue;
658 } return LDAP_OPT_SUCCESS;
659 case LDAP_OPT_REBIND_PARAMS: {
660 lo->ldo_rebind_params = (void *)invalue;
661 } return LDAP_OPT_SUCCESS;
663 /* Only accessed from inside this function by ldap_set_nextref_proc() */
664 case LDAP_OPT_NEXTREF_PROC: {
665 lo->ldo_nextref_proc = (LDAP_NEXTREF_PROC *)invalue;
666 } return LDAP_OPT_SUCCESS;
667 case LDAP_OPT_NEXTREF_PARAMS: {
668 lo->ldo_nextref_params = (void *)invalue;
669 } return LDAP_OPT_SUCCESS;
671 /* Only accessed from inside this function by ldap_set_urllist_proc() */
672 case LDAP_OPT_URLLIST_PROC: {
673 lo->ldo_urllist_proc = (LDAP_URLLIST_PROC *)invalue;
674 } return LDAP_OPT_SUCCESS;
675 case LDAP_OPT_URLLIST_PARAMS: {
676 lo->ldo_urllist_params = (void *)invalue;
677 } return LDAP_OPT_SUCCESS;
679 /* read-only options */
680 case LDAP_OPT_API_INFO:
682 case LDAP_OPT_SOCKBUF:
683 case LDAP_OPT_API_FEATURE_INFO:
684 return LDAP_OPT_ERROR;
686 /* options which cannot withstand invalue == NULL */
688 case LDAP_OPT_SIZELIMIT:
689 case LDAP_OPT_TIMELIMIT:
690 case LDAP_OPT_PROTOCOL_VERSION:
691 case LDAP_OPT_RESULT_CODE:
692 case LDAP_OPT_DEBUG_LEVEL:
693 case LDAP_OPT_TIMEOUT:
694 case LDAP_OPT_NETWORK_TIMEOUT:
695 case LDAP_OPT_CONNECT_CB:
696 case LDAP_OPT_X_KEEPALIVE_IDLE:
697 case LDAP_OPT_X_KEEPALIVE_PROBES :
698 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
699 if(invalue == NULL) {
700 /* no place to set from */
701 return LDAP_OPT_ERROR;
707 if ( ldap_pvt_tls_set_option( ld, option, (void *)invalue ) == 0 )
708 return LDAP_OPT_SUCCESS;
710 #ifdef HAVE_CYRUS_SASL
711 if ( ldap_int_sasl_set_option( ld, option, (void *)invalue ) == 0 )
712 return LDAP_OPT_SUCCESS;
715 if ( ldap_int_gssapi_set_option( ld, option, (void *)invalue ) == 0 )
716 return LDAP_OPT_SUCCESS;
719 return LDAP_OPT_ERROR;
722 /* options which cannot withstand invalue == NULL */
726 /* FIXME: check value for protocol compliance? */
727 lo->ldo_deref = * (const int *) invalue;
728 return LDAP_OPT_SUCCESS;
730 case LDAP_OPT_SIZELIMIT:
731 /* FIXME: check value for protocol compliance? */
732 lo->ldo_sizelimit = * (const int *) invalue;
733 return LDAP_OPT_SUCCESS;
735 case LDAP_OPT_TIMELIMIT:
736 /* FIXME: check value for protocol compliance? */
737 lo->ldo_timelimit = * (const int *) invalue;
738 return LDAP_OPT_SUCCESS;
740 case LDAP_OPT_TIMEOUT: {
741 const struct timeval *tv =
742 (const struct timeval *) invalue;
744 lo->ldo_tm_api = *tv;
745 } return LDAP_OPT_SUCCESS;
747 case LDAP_OPT_NETWORK_TIMEOUT: {
748 const struct timeval *tv =
749 (const struct timeval *) invalue;
751 lo->ldo_tm_net = *tv;
752 } return LDAP_OPT_SUCCESS;
754 case LDAP_OPT_PROTOCOL_VERSION: {
755 int vers = * (const int *) invalue;
756 if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
760 lo->ldo_version = vers;
761 } return LDAP_OPT_SUCCESS;
763 case LDAP_OPT_RESULT_CODE: {
764 int err = * (const int *) invalue;
767 /* need a struct ldap */
772 } return LDAP_OPT_SUCCESS;
774 case LDAP_OPT_DEBUG_LEVEL:
775 lo->ldo_debug = * (const int *) invalue;
776 return LDAP_OPT_SUCCESS;
778 case LDAP_OPT_CONNECT_CB:
780 /* setting pushes the callback */
782 ll = LDAP_MALLOC( sizeof( *ll ));
783 ll->ll_data = (void *)invalue;
784 ll->ll_next = lo->ldo_conn_cbs;
785 lo->ldo_conn_cbs = ll;
787 return LDAP_OPT_SUCCESS;
788 case LDAP_OPT_X_KEEPALIVE_IDLE:
789 lo->ldo_keepalive_idle = * (const int *) invalue;
790 return LDAP_OPT_SUCCESS;
791 case LDAP_OPT_X_KEEPALIVE_PROBES :
792 lo->ldo_keepalive_probes = * (const int *) invalue;
793 return LDAP_OPT_SUCCESS;
794 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
795 lo->ldo_keepalive_interval = * (const int *) invalue;
796 return LDAP_OPT_SUCCESS;
799 return LDAP_OPT_ERROR;
803 ldap_set_rebind_proc( LDAP *ld, LDAP_REBIND_PROC *proc, void *params )
806 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PROC, (void *)proc );
807 if( rc != LDAP_OPT_SUCCESS ) return rc;
809 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PARAMS, (void *)params );
814 ldap_set_nextref_proc( LDAP *ld, LDAP_NEXTREF_PROC *proc, void *params )
817 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PROC, (void *)proc );
818 if( rc != LDAP_OPT_SUCCESS ) return rc;
820 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PARAMS, (void *)params );
825 ldap_set_urllist_proc( LDAP *ld, LDAP_URLLIST_PROC *proc, void *params )
828 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PROC, (void *)proc );
829 if( rc != LDAP_OPT_SUCCESS ) return rc;
831 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PARAMS, (void *)params );