2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2011 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;
99 int rc = LDAP_OPT_ERROR;
101 /* Get pointer to global option structure */
102 lo = LDAP_INT_GLOBAL_OPT();
104 return LDAP_NO_MEMORY;
107 if( lo->ldo_valid != LDAP_INITIALIZED ) {
108 ldap_int_initialize(lo, NULL);
112 assert( LDAP_VALID( ld ) );
114 if( !LDAP_VALID( ld ) ) {
115 return LDAP_OPT_ERROR;
118 lo = &ld->ld_options;
121 if(outvalue == NULL) {
122 /* no place to get to */
123 return LDAP_OPT_ERROR;
126 LDAP_MUTEX_LOCK( &lo->ldo_mutex );
129 case LDAP_OPT_API_INFO: {
130 struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue;
133 /* outvalue must point to an apiinfo structure */
134 break; /* LDAP_OPT_ERROR */
137 if(info->ldapai_info_version != LDAP_API_INFO_VERSION) {
138 /* api info version mismatch */
139 info->ldapai_info_version = LDAP_API_INFO_VERSION;
140 break; /* LDAP_OPT_ERROR */
143 info->ldapai_api_version = LDAP_API_VERSION;
144 info->ldapai_protocol_version = LDAP_VERSION_MAX;
146 if(features[0].ldapaif_name == NULL) {
147 info->ldapai_extensions = NULL;
150 info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) *
151 sizeof(features)/sizeof(LDAPAPIFeatureInfo));
153 for(i=0; features[i].ldapaif_name != NULL; i++) {
154 info->ldapai_extensions[i] =
155 LDAP_STRDUP(features[i].ldapaif_name);
158 info->ldapai_extensions[i] = NULL;
161 info->ldapai_vendor_name = LDAP_STRDUP(LDAP_VENDOR_NAME);
162 info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
164 rc = LDAP_OPT_SUCCESS;
169 if( ld == NULL || ld->ld_sb == NULL ) {
174 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_GET_FD, outvalue );
175 rc = LDAP_OPT_SUCCESS;
178 case LDAP_OPT_SOCKBUF:
179 if( ld == NULL ) break;
180 *(Sockbuf **)outvalue = ld->ld_sb;
181 rc = LDAP_OPT_SUCCESS;
184 case LDAP_OPT_TIMEOUT:
185 /* the caller has to free outvalue ! */
186 if ( lo->ldo_tm_api.tv_sec < 0 ) {
187 *(void **)outvalue = NULL;
188 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_api ) != 0 ) {
189 break; /* LDAP_OPT_ERROR */
191 rc = LDAP_OPT_SUCCESS;
194 case LDAP_OPT_NETWORK_TIMEOUT:
195 /* the caller has to free outvalue ! */
196 if ( lo->ldo_tm_net.tv_sec < 0 ) {
197 *(void **)outvalue = NULL;
198 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_net ) != 0 ) {
199 break; /* LDAP_OPT_ERROR */
201 rc = LDAP_OPT_SUCCESS;
205 * (int *) outvalue = lo->ldo_deref;
206 rc = LDAP_OPT_SUCCESS;
209 case LDAP_OPT_SIZELIMIT:
210 * (int *) outvalue = lo->ldo_sizelimit;
211 rc = LDAP_OPT_SUCCESS;
214 case LDAP_OPT_TIMELIMIT:
215 * (int *) outvalue = lo->ldo_timelimit;
216 rc = LDAP_OPT_SUCCESS;
219 case LDAP_OPT_REFERRALS:
220 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS);
221 rc = LDAP_OPT_SUCCESS;
224 case LDAP_OPT_RESTART:
225 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART);
226 rc = LDAP_OPT_SUCCESS;
229 case LDAP_OPT_PROTOCOL_VERSION:
230 * (int *) outvalue = lo->ldo_version;
231 rc = LDAP_OPT_SUCCESS;
234 case LDAP_OPT_SERVER_CONTROLS:
235 * (LDAPControl ***) outvalue =
236 ldap_controls_dup( lo->ldo_sctrls );
237 rc = LDAP_OPT_SUCCESS;
240 case LDAP_OPT_CLIENT_CONTROLS:
241 * (LDAPControl ***) outvalue =
242 ldap_controls_dup( lo->ldo_cctrls );
243 rc = LDAP_OPT_SUCCESS;
246 case LDAP_OPT_HOST_NAME:
247 * (char **) outvalue = ldap_url_list2hosts(lo->ldo_defludp);
248 rc = LDAP_OPT_SUCCESS;
252 * (char **) outvalue = ldap_url_list2urls(lo->ldo_defludp);
253 rc = LDAP_OPT_SUCCESS;
256 case LDAP_OPT_DEFBASE:
257 if( lo->ldo_defbase == NULL ) {
258 * (char **) outvalue = NULL;
260 * (char **) outvalue = LDAP_STRDUP(lo->ldo_defbase);
262 rc = LDAP_OPT_SUCCESS;
265 case LDAP_OPT_CONNECT_ASYNC:
266 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_CONNECT_ASYNC);
267 rc = LDAP_OPT_SUCCESS;
270 case LDAP_OPT_CONNECT_CB:
272 /* Getting deletes the specified callback */
273 ldaplist **ll = &lo->ldo_conn_cbs;
274 for (;*ll;ll = &(*ll)->ll_next) {
275 if ((*ll)->ll_data == outvalue) {
283 rc = LDAP_OPT_SUCCESS;
286 case LDAP_OPT_RESULT_CODE:
291 * (int *) outvalue = ld->ld_errno;
292 rc = LDAP_OPT_SUCCESS;
295 case LDAP_OPT_DIAGNOSTIC_MESSAGE:
301 if( ld->ld_error == NULL ) {
302 * (char **) outvalue = NULL;
304 * (char **) outvalue = LDAP_STRDUP(ld->ld_error);
306 rc = LDAP_OPT_SUCCESS;
309 case LDAP_OPT_MATCHED_DN:
315 if( ld->ld_matched == NULL ) {
316 * (char **) outvalue = NULL;
318 * (char **) outvalue = LDAP_STRDUP( ld->ld_matched );
320 rc = LDAP_OPT_SUCCESS;
323 case LDAP_OPT_REFERRAL_URLS:
329 if( ld->ld_referrals == NULL ) {
330 * (char ***) outvalue = NULL;
332 * (char ***) outvalue = ldap_value_dup(ld->ld_referrals);
334 rc = LDAP_OPT_SUCCESS;
337 case LDAP_OPT_API_FEATURE_INFO: {
338 LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
342 break; /* LDAP_OPT_ERROR */
344 if(info->ldapaif_info_version != LDAP_FEATURE_INFO_VERSION) {
345 /* api info version mismatch */
346 info->ldapaif_info_version = LDAP_FEATURE_INFO_VERSION;
347 break; /* LDAP_OPT_ERROR */
350 if(info->ldapaif_name == NULL)
351 break; /* LDAP_OPT_ERROR */
353 for(i=0; features[i].ldapaif_name != NULL; i++) {
354 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
355 info->ldapaif_version =
356 features[i].ldapaif_version;
357 rc = LDAP_OPT_SUCCESS;
364 case LDAP_OPT_DEBUG_LEVEL:
365 * (int *) outvalue = lo->ldo_debug;
366 rc = LDAP_OPT_SUCCESS;
369 case LDAP_OPT_SESSION_REFCNT:
374 * (int *) outvalue = ld->ld_ldcrefcnt;
375 rc = LDAP_OPT_SUCCESS;
378 case LDAP_OPT_X_KEEPALIVE_IDLE:
379 * (int *) outvalue = lo->ldo_keepalive_idle;
380 rc = LDAP_OPT_SUCCESS;
383 case LDAP_OPT_X_KEEPALIVE_PROBES:
384 * (int *) outvalue = lo->ldo_keepalive_probes;
385 rc = LDAP_OPT_SUCCESS;
388 case LDAP_OPT_X_KEEPALIVE_INTERVAL:
389 * (int *) outvalue = lo->ldo_keepalive_interval;
390 rc = LDAP_OPT_SUCCESS;
395 if ( ldap_pvt_tls_get_option( ld, option, outvalue ) == 0 ) {
396 rc = LDAP_OPT_SUCCESS;
400 #ifdef HAVE_CYRUS_SASL
401 if ( ldap_int_sasl_get_option( ld, option, outvalue ) == 0 ) {
402 rc = LDAP_OPT_SUCCESS;
407 if ( ldap_int_gssapi_get_option( ld, option, outvalue ) == 0 ) {
408 rc = LDAP_OPT_SUCCESS;
416 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
424 LDAP_CONST void *invalue)
426 struct ldapoptions *lo;
428 int rc = LDAP_OPT_ERROR;
430 /* Get pointer to global option structure */
431 lo = LDAP_INT_GLOBAL_OPT();
433 return LDAP_NO_MEMORY;
437 * The architecture to turn on debugging has a chicken and egg
438 * problem. Thus, we introduce a fix here.
441 if (option == LDAP_OPT_DEBUG_LEVEL) {
442 dbglvl = (int *) invalue;
445 if( lo->ldo_valid != LDAP_INITIALIZED ) {
446 ldap_int_initialize(lo, dbglvl);
450 assert( LDAP_VALID( ld ) );
452 if( !LDAP_VALID( ld ) ) {
453 return LDAP_OPT_ERROR;
456 lo = &ld->ld_options;
459 LDAP_MUTEX_LOCK( &lo->ldo_mutex );
463 /* options with boolean values */
464 case LDAP_OPT_REFERRALS:
465 if(invalue == LDAP_OPT_OFF) {
466 LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
468 LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
470 rc = LDAP_OPT_SUCCESS;
473 case LDAP_OPT_RESTART:
474 if(invalue == LDAP_OPT_OFF) {
475 LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
477 LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
479 rc = LDAP_OPT_SUCCESS;
482 case LDAP_OPT_CONNECT_ASYNC:
483 if(invalue == LDAP_OPT_OFF) {
484 LDAP_BOOL_CLR(lo, LDAP_BOOL_CONNECT_ASYNC);
486 LDAP_BOOL_SET(lo, LDAP_BOOL_CONNECT_ASYNC);
488 rc = LDAP_OPT_SUCCESS;
491 /* options which can withstand invalue == NULL */
492 case LDAP_OPT_SERVER_CONTROLS: {
493 LDAPControl *const *controls =
494 (LDAPControl *const *) invalue;
497 ldap_controls_free( lo->ldo_sctrls );
499 if( controls == NULL || *controls == NULL ) {
500 lo->ldo_sctrls = NULL;
501 rc = LDAP_OPT_SUCCESS;
505 lo->ldo_sctrls = ldap_controls_dup( controls );
507 if(lo->ldo_sctrls == NULL) {
508 /* memory allocation error ? */
509 break; /* LDAP_OPT_ERROR */
512 rc = LDAP_OPT_SUCCESS;
515 case LDAP_OPT_CLIENT_CONTROLS: {
516 LDAPControl *const *controls =
517 (LDAPControl *const *) invalue;
520 ldap_controls_free( lo->ldo_cctrls );
522 if( controls == NULL || *controls == NULL ) {
523 lo->ldo_cctrls = NULL;
524 rc = LDAP_OPT_SUCCESS;
528 lo->ldo_cctrls = ldap_controls_dup( controls );
530 if(lo->ldo_cctrls == NULL) {
531 /* memory allocation error ? */
532 break; /* LDAP_OPT_ERROR */
535 rc = LDAP_OPT_SUCCESS;
539 case LDAP_OPT_HOST_NAME: {
540 const char *host = (const char *) invalue;
541 LDAPURLDesc *ludlist = NULL;
542 rc = LDAP_OPT_SUCCESS;
545 rc = ldap_url_parsehosts( &ludlist, host,
546 lo->ldo_defport ? lo->ldo_defport : LDAP_PORT );
548 } else if(ld == NULL) {
550 * must want global default returned
551 * to initial condition.
553 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
554 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
555 | LDAP_PVT_URL_PARSE_DEF_PORT );
559 * must want the session default
560 * updated to the current global default
562 ludlist = ldap_url_duplist(
563 ldap_int_global_options.ldo_defludp);
568 if (rc == LDAP_OPT_SUCCESS) {
569 if (lo->ldo_defludp != NULL)
570 ldap_free_urllist(lo->ldo_defludp);
571 lo->ldo_defludp = ludlist;
577 const char *urls = (const char *) invalue;
578 LDAPURLDesc *ludlist = NULL;
579 rc = LDAP_OPT_SUCCESS;
582 rc = ldap_url_parselist_ext(&ludlist, urls, NULL,
583 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
584 | LDAP_PVT_URL_PARSE_DEF_PORT );
585 } else if(ld == NULL) {
587 * must want global default returned
588 * to initial condition.
590 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
591 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
592 | LDAP_PVT_URL_PARSE_DEF_PORT );
596 * must want the session default
597 * updated to the current global default
599 ludlist = ldap_url_duplist(
600 ldap_int_global_options.ldo_defludp);
602 rc = LDAP_URL_ERR_MEM;
606 case LDAP_URL_SUCCESS: /* Success */
610 case LDAP_URL_ERR_MEM: /* can't allocate memory space */
614 case LDAP_URL_ERR_PARAM: /* parameter is bad */
615 case LDAP_URL_ERR_BADSCHEME: /* URL doesn't begin with "ldap[si]://" */
616 case LDAP_URL_ERR_BADENCLOSURE: /* URL is missing trailing ">" */
617 case LDAP_URL_ERR_BADURL: /* URL is bad */
618 case LDAP_URL_ERR_BADHOST: /* host port is bad */
619 case LDAP_URL_ERR_BADATTRS: /* bad (or missing) attributes */
620 case LDAP_URL_ERR_BADSCOPE: /* scope string is invalid (or missing) */
621 case LDAP_URL_ERR_BADFILTER: /* bad or missing filter */
622 case LDAP_URL_ERR_BADEXTS: /* bad or missing extensions */
623 rc = LDAP_PARAM_ERROR;
627 if (rc == LDAP_SUCCESS) {
628 if (lo->ldo_defludp != NULL)
629 ldap_free_urllist(lo->ldo_defludp);
630 lo->ldo_defludp = ludlist;
635 case LDAP_OPT_DEFBASE: {
636 const char *newbase = (const char *) invalue;
637 char *defbase = NULL;
639 if ( newbase != NULL ) {
640 defbase = LDAP_STRDUP( newbase );
641 if ( defbase == NULL ) {
646 } else if ( ld != NULL ) {
647 defbase = LDAP_STRDUP( ldap_int_global_options.ldo_defbase );
648 if ( defbase == NULL ) {
654 if ( lo->ldo_defbase != NULL )
655 LDAP_FREE( lo->ldo_defbase );
656 lo->ldo_defbase = defbase;
658 rc = LDAP_OPT_SUCCESS;
661 case LDAP_OPT_DIAGNOSTIC_MESSAGE: {
662 const char *err = (const char *) invalue;
665 /* need a struct ldap */
666 break; /* LDAP_OPT_ERROR */
670 LDAP_FREE(ld->ld_error);
675 ld->ld_error = LDAP_STRDUP(err);
678 rc = LDAP_OPT_SUCCESS;
681 case LDAP_OPT_MATCHED_DN: {
682 const char *matched = (const char *) invalue;
685 /* need a struct ldap */
686 break; /* LDAP_OPT_ERROR */
689 if( ld->ld_matched ) {
690 LDAP_FREE(ld->ld_matched);
691 ld->ld_matched = NULL;
695 ld->ld_matched = LDAP_STRDUP( matched );
698 rc = LDAP_OPT_SUCCESS;
701 case LDAP_OPT_REFERRAL_URLS: {
702 char *const *referrals = (char *const *) invalue;
705 /* need a struct ldap */
706 break; /* LDAP_OPT_ERROR */
709 if( ld->ld_referrals ) {
710 LDAP_VFREE(ld->ld_referrals);
714 ld->ld_referrals = ldap_value_dup(referrals);
717 rc = LDAP_OPT_SUCCESS;
720 /* Only accessed from inside this function by ldap_set_rebind_proc() */
721 case LDAP_OPT_REBIND_PROC: {
722 lo->ldo_rebind_proc = (LDAP_REBIND_PROC *)invalue;
724 rc = LDAP_OPT_SUCCESS;
726 case LDAP_OPT_REBIND_PARAMS: {
727 lo->ldo_rebind_params = (void *)invalue;
729 rc = LDAP_OPT_SUCCESS;
732 /* Only accessed from inside this function by ldap_set_nextref_proc() */
733 case LDAP_OPT_NEXTREF_PROC: {
734 lo->ldo_nextref_proc = (LDAP_NEXTREF_PROC *)invalue;
736 rc = LDAP_OPT_SUCCESS;
738 case LDAP_OPT_NEXTREF_PARAMS: {
739 lo->ldo_nextref_params = (void *)invalue;
741 rc = LDAP_OPT_SUCCESS;
744 /* Only accessed from inside this function by ldap_set_urllist_proc() */
745 case LDAP_OPT_URLLIST_PROC: {
746 lo->ldo_urllist_proc = (LDAP_URLLIST_PROC *)invalue;
748 rc = LDAP_OPT_SUCCESS;
750 case LDAP_OPT_URLLIST_PARAMS: {
751 lo->ldo_urllist_params = (void *)invalue;
753 rc = LDAP_OPT_SUCCESS;
756 /* read-only options */
757 case LDAP_OPT_API_INFO:
759 case LDAP_OPT_SOCKBUF:
760 case LDAP_OPT_API_FEATURE_INFO:
761 break; /* LDAP_OPT_ERROR */
763 /* options which cannot withstand invalue == NULL */
765 case LDAP_OPT_SIZELIMIT:
766 case LDAP_OPT_TIMELIMIT:
767 case LDAP_OPT_PROTOCOL_VERSION:
768 case LDAP_OPT_RESULT_CODE:
769 case LDAP_OPT_DEBUG_LEVEL:
770 case LDAP_OPT_TIMEOUT:
771 case LDAP_OPT_NETWORK_TIMEOUT:
772 case LDAP_OPT_CONNECT_CB:
773 case LDAP_OPT_X_KEEPALIVE_IDLE:
774 case LDAP_OPT_X_KEEPALIVE_PROBES :
775 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
776 if(invalue == NULL) {
777 /* no place to set from */
778 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
779 return ( LDAP_OPT_ERROR );
785 if ( ldap_pvt_tls_set_option( ld, option, (void *)invalue ) == 0 ) {
786 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
787 return ( LDAP_OPT_SUCCESS );
790 #ifdef HAVE_CYRUS_SASL
791 if ( ldap_int_sasl_set_option( ld, option, (void *)invalue ) == 0 ) {
792 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
793 return ( LDAP_OPT_SUCCESS );
797 if ( ldap_int_gssapi_set_option( ld, option, (void *)invalue ) == 0 ) {
798 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
799 return ( LDAP_OPT_SUCCESS );
803 break; /* LDAP_OPT_ERROR */
806 /* options which cannot withstand invalue == NULL */
810 /* FIXME: check value for protocol compliance? */
811 lo->ldo_deref = * (const int *) invalue;
812 rc = LDAP_OPT_SUCCESS;
815 case LDAP_OPT_SIZELIMIT:
816 /* FIXME: check value for protocol compliance? */
817 lo->ldo_sizelimit = * (const int *) invalue;
818 rc = LDAP_OPT_SUCCESS;
821 case LDAP_OPT_TIMELIMIT:
822 /* FIXME: check value for protocol compliance? */
823 lo->ldo_timelimit = * (const int *) invalue;
824 rc = LDAP_OPT_SUCCESS;
827 case LDAP_OPT_TIMEOUT: {
828 const struct timeval *tv =
829 (const struct timeval *) invalue;
831 lo->ldo_tm_api = *tv;
833 rc = LDAP_OPT_SUCCESS;
836 case LDAP_OPT_NETWORK_TIMEOUT: {
837 const struct timeval *tv =
838 (const struct timeval *) invalue;
840 lo->ldo_tm_net = *tv;
842 rc = LDAP_OPT_SUCCESS;
845 case LDAP_OPT_PROTOCOL_VERSION: {
846 int vers = * (const int *) invalue;
847 if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
851 lo->ldo_version = vers;
853 rc = LDAP_OPT_SUCCESS;
856 case LDAP_OPT_RESULT_CODE: {
857 int err = * (const int *) invalue;
860 /* need a struct ldap */
866 rc = LDAP_OPT_SUCCESS;
869 case LDAP_OPT_DEBUG_LEVEL:
870 lo->ldo_debug = * (const int *) invalue;
871 rc = LDAP_OPT_SUCCESS;
874 case LDAP_OPT_CONNECT_CB:
876 /* setting pushes the callback */
878 ll = LDAP_MALLOC( sizeof( *ll ));
879 ll->ll_data = (void *)invalue;
880 ll->ll_next = lo->ldo_conn_cbs;
881 lo->ldo_conn_cbs = ll;
883 rc = LDAP_OPT_SUCCESS;
885 case LDAP_OPT_X_KEEPALIVE_IDLE:
886 lo->ldo_keepalive_idle = * (const int *) invalue;
887 rc = LDAP_OPT_SUCCESS;
889 case LDAP_OPT_X_KEEPALIVE_PROBES :
890 lo->ldo_keepalive_probes = * (const int *) invalue;
891 rc = LDAP_OPT_SUCCESS;
893 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
894 lo->ldo_keepalive_interval = * (const int *) invalue;
895 rc = LDAP_OPT_SUCCESS;
899 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
904 ldap_set_rebind_proc( LDAP *ld, LDAP_REBIND_PROC *proc, void *params )
907 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PROC, (void *)proc );
908 if( rc != LDAP_OPT_SUCCESS ) return rc;
910 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PARAMS, (void *)params );
915 ldap_set_nextref_proc( LDAP *ld, LDAP_NEXTREF_PROC *proc, void *params )
918 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PROC, (void *)proc );
919 if( rc != LDAP_OPT_SUCCESS ) return rc;
921 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PARAMS, (void *)params );
926 ldap_set_urllist_proc( LDAP *ld, LDAP_URLLIST_PROC *proc, void *params )
929 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PROC, (void *)proc );
930 if( rc != LDAP_OPT_SUCCESS ) return rc;
932 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PARAMS, (void *)params );