2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1998-2018 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);
109 if ( lo->ldo_valid != LDAP_INITIALIZED )
110 return LDAP_LOCAL_ERROR;
114 assert( LDAP_VALID( ld ) );
116 if( !LDAP_VALID( ld ) ) {
117 return LDAP_OPT_ERROR;
120 lo = &ld->ld_options;
123 if(outvalue == NULL) {
124 /* no place to get to */
125 return LDAP_OPT_ERROR;
128 LDAP_MUTEX_LOCK( &lo->ldo_mutex );
131 case LDAP_OPT_API_INFO: {
132 struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue;
135 /* outvalue must point to an apiinfo structure */
136 break; /* LDAP_OPT_ERROR */
139 if(info->ldapai_info_version != LDAP_API_INFO_VERSION) {
140 /* api info version mismatch */
141 info->ldapai_info_version = LDAP_API_INFO_VERSION;
142 break; /* LDAP_OPT_ERROR */
145 info->ldapai_api_version = LDAP_API_VERSION;
146 info->ldapai_protocol_version = LDAP_VERSION_MAX;
148 if(features[0].ldapaif_name == NULL) {
149 info->ldapai_extensions = NULL;
152 info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) *
153 sizeof(features)/sizeof(LDAPAPIFeatureInfo));
155 for(i=0; features[i].ldapaif_name != NULL; i++) {
156 info->ldapai_extensions[i] =
157 LDAP_STRDUP(features[i].ldapaif_name);
160 info->ldapai_extensions[i] = NULL;
163 info->ldapai_vendor_name = LDAP_STRDUP(LDAP_VENDOR_NAME);
164 info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
166 rc = LDAP_OPT_SUCCESS;
171 if( ld == NULL || ld->ld_sb == NULL ) {
176 ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_GET_FD, outvalue );
177 rc = LDAP_OPT_SUCCESS;
180 case LDAP_OPT_SOCKBUF:
181 if( ld == NULL ) break;
182 *(Sockbuf **)outvalue = ld->ld_sb;
183 rc = LDAP_OPT_SUCCESS;
186 case LDAP_OPT_TIMEOUT:
187 /* the caller has to free outvalue ! */
188 if ( lo->ldo_tm_api.tv_sec < 0 ) {
189 *(void **)outvalue = NULL;
190 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_api ) != 0 ) {
191 break; /* LDAP_OPT_ERROR */
193 rc = LDAP_OPT_SUCCESS;
196 case LDAP_OPT_NETWORK_TIMEOUT:
197 /* the caller has to free outvalue ! */
198 if ( lo->ldo_tm_net.tv_sec < 0 ) {
199 *(void **)outvalue = NULL;
200 } else if ( ldap_int_timeval_dup( outvalue, &lo->ldo_tm_net ) != 0 ) {
201 break; /* LDAP_OPT_ERROR */
203 rc = LDAP_OPT_SUCCESS;
207 * (int *) outvalue = lo->ldo_deref;
208 rc = LDAP_OPT_SUCCESS;
211 case LDAP_OPT_SIZELIMIT:
212 * (int *) outvalue = lo->ldo_sizelimit;
213 rc = LDAP_OPT_SUCCESS;
216 case LDAP_OPT_TIMELIMIT:
217 * (int *) outvalue = lo->ldo_timelimit;
218 rc = LDAP_OPT_SUCCESS;
221 case LDAP_OPT_REFERRALS:
222 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS);
223 rc = LDAP_OPT_SUCCESS;
226 case LDAP_OPT_RESTART:
227 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART);
228 rc = LDAP_OPT_SUCCESS;
231 case LDAP_OPT_PROTOCOL_VERSION:
232 * (int *) outvalue = lo->ldo_version;
233 rc = LDAP_OPT_SUCCESS;
236 case LDAP_OPT_SERVER_CONTROLS:
237 * (LDAPControl ***) outvalue =
238 ldap_controls_dup( lo->ldo_sctrls );
239 rc = LDAP_OPT_SUCCESS;
242 case LDAP_OPT_CLIENT_CONTROLS:
243 * (LDAPControl ***) outvalue =
244 ldap_controls_dup( lo->ldo_cctrls );
245 rc = LDAP_OPT_SUCCESS;
248 case LDAP_OPT_HOST_NAME:
249 * (char **) outvalue = ldap_url_list2hosts(lo->ldo_defludp);
250 rc = LDAP_OPT_SUCCESS;
254 * (char **) outvalue = ldap_url_list2urls(lo->ldo_defludp);
255 rc = LDAP_OPT_SUCCESS;
258 case LDAP_OPT_DEFBASE:
259 if( lo->ldo_defbase == NULL ) {
260 * (char **) outvalue = NULL;
262 * (char **) outvalue = LDAP_STRDUP(lo->ldo_defbase);
264 rc = LDAP_OPT_SUCCESS;
267 case LDAP_OPT_CONNECT_ASYNC:
268 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_CONNECT_ASYNC);
269 rc = LDAP_OPT_SUCCESS;
272 case LDAP_OPT_CONNECT_CB:
274 /* Getting deletes the specified callback */
275 ldaplist **ll = &lo->ldo_conn_cbs;
276 for (;*ll;ll = &(*ll)->ll_next) {
277 if ((*ll)->ll_data == outvalue) {
285 rc = LDAP_OPT_SUCCESS;
288 case LDAP_OPT_RESULT_CODE:
293 * (int *) outvalue = ld->ld_errno;
294 rc = LDAP_OPT_SUCCESS;
297 case LDAP_OPT_DIAGNOSTIC_MESSAGE:
303 if( ld->ld_error == NULL ) {
304 * (char **) outvalue = NULL;
306 * (char **) outvalue = LDAP_STRDUP(ld->ld_error);
308 rc = LDAP_OPT_SUCCESS;
311 case LDAP_OPT_MATCHED_DN:
317 if( ld->ld_matched == NULL ) {
318 * (char **) outvalue = NULL;
320 * (char **) outvalue = LDAP_STRDUP( ld->ld_matched );
322 rc = LDAP_OPT_SUCCESS;
325 case LDAP_OPT_REFERRAL_URLS:
331 if( ld->ld_referrals == NULL ) {
332 * (char ***) outvalue = NULL;
334 * (char ***) outvalue = ldap_value_dup(ld->ld_referrals);
336 rc = LDAP_OPT_SUCCESS;
339 case LDAP_OPT_API_FEATURE_INFO: {
340 LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
344 break; /* LDAP_OPT_ERROR */
346 if(info->ldapaif_info_version != LDAP_FEATURE_INFO_VERSION) {
347 /* api info version mismatch */
348 info->ldapaif_info_version = LDAP_FEATURE_INFO_VERSION;
349 break; /* LDAP_OPT_ERROR */
352 if(info->ldapaif_name == NULL)
353 break; /* LDAP_OPT_ERROR */
355 for(i=0; features[i].ldapaif_name != NULL; i++) {
356 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
357 info->ldapaif_version =
358 features[i].ldapaif_version;
359 rc = LDAP_OPT_SUCCESS;
366 case LDAP_OPT_DEBUG_LEVEL:
367 * (int *) outvalue = lo->ldo_debug;
368 rc = LDAP_OPT_SUCCESS;
371 case LDAP_OPT_SESSION_REFCNT:
376 LDAP_MUTEX_LOCK( &ld->ld_ldcmutex );
377 * (int *) outvalue = ld->ld_ldcrefcnt;
378 LDAP_MUTEX_UNLOCK( &ld->ld_ldcmutex );
379 rc = LDAP_OPT_SUCCESS;
382 case LDAP_OPT_X_KEEPALIVE_IDLE:
383 * (int *) outvalue = lo->ldo_keepalive_idle;
384 rc = LDAP_OPT_SUCCESS;
387 case LDAP_OPT_X_KEEPALIVE_PROBES:
388 * (int *) outvalue = lo->ldo_keepalive_probes;
389 rc = LDAP_OPT_SUCCESS;
392 case LDAP_OPT_X_KEEPALIVE_INTERVAL:
393 * (int *) outvalue = lo->ldo_keepalive_interval;
394 rc = LDAP_OPT_SUCCESS;
399 if ( ldap_pvt_tls_get_option( ld, option, outvalue ) == 0 ) {
400 rc = LDAP_OPT_SUCCESS;
404 #ifdef HAVE_CYRUS_SASL
405 if ( ldap_int_sasl_get_option( ld, option, outvalue ) == 0 ) {
406 rc = LDAP_OPT_SUCCESS;
411 if ( ldap_int_gssapi_get_option( ld, option, outvalue ) == 0 ) {
412 rc = LDAP_OPT_SUCCESS;
420 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
428 LDAP_CONST void *invalue)
430 struct ldapoptions *lo;
432 int rc = LDAP_OPT_ERROR;
434 /* Get pointer to global option structure */
435 lo = LDAP_INT_GLOBAL_OPT();
437 return LDAP_NO_MEMORY;
441 * The architecture to turn on debugging has a chicken and egg
442 * problem. Thus, we introduce a fix here.
445 if (option == LDAP_OPT_DEBUG_LEVEL) {
446 dbglvl = (int *) invalue;
449 if( lo->ldo_valid != LDAP_INITIALIZED ) {
450 ldap_int_initialize(lo, dbglvl);
451 if ( lo->ldo_valid != LDAP_INITIALIZED )
452 return LDAP_LOCAL_ERROR;
456 assert( LDAP_VALID( ld ) );
458 if( !LDAP_VALID( ld ) ) {
459 return LDAP_OPT_ERROR;
462 lo = &ld->ld_options;
465 LDAP_MUTEX_LOCK( &lo->ldo_mutex );
469 /* options with boolean values */
470 case LDAP_OPT_REFERRALS:
471 if(invalue == LDAP_OPT_OFF) {
472 LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
474 LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
476 rc = LDAP_OPT_SUCCESS;
479 case LDAP_OPT_RESTART:
480 if(invalue == LDAP_OPT_OFF) {
481 LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
483 LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
485 rc = LDAP_OPT_SUCCESS;
488 case LDAP_OPT_CONNECT_ASYNC:
489 if(invalue == LDAP_OPT_OFF) {
490 LDAP_BOOL_CLR(lo, LDAP_BOOL_CONNECT_ASYNC);
492 LDAP_BOOL_SET(lo, LDAP_BOOL_CONNECT_ASYNC);
494 rc = LDAP_OPT_SUCCESS;
497 /* options which can withstand invalue == NULL */
498 case LDAP_OPT_SERVER_CONTROLS: {
499 LDAPControl *const *controls =
500 (LDAPControl *const *) invalue;
503 ldap_controls_free( lo->ldo_sctrls );
505 if( controls == NULL || *controls == NULL ) {
506 lo->ldo_sctrls = NULL;
507 rc = LDAP_OPT_SUCCESS;
511 lo->ldo_sctrls = ldap_controls_dup( controls );
513 if(lo->ldo_sctrls == NULL) {
514 /* memory allocation error ? */
515 break; /* LDAP_OPT_ERROR */
518 rc = LDAP_OPT_SUCCESS;
521 case LDAP_OPT_CLIENT_CONTROLS: {
522 LDAPControl *const *controls =
523 (LDAPControl *const *) invalue;
526 ldap_controls_free( lo->ldo_cctrls );
528 if( controls == NULL || *controls == NULL ) {
529 lo->ldo_cctrls = NULL;
530 rc = LDAP_OPT_SUCCESS;
534 lo->ldo_cctrls = ldap_controls_dup( controls );
536 if(lo->ldo_cctrls == NULL) {
537 /* memory allocation error ? */
538 break; /* LDAP_OPT_ERROR */
541 rc = LDAP_OPT_SUCCESS;
545 case LDAP_OPT_HOST_NAME: {
546 const char *host = (const char *) invalue;
547 LDAPURLDesc *ludlist = NULL;
548 rc = LDAP_OPT_SUCCESS;
551 rc = ldap_url_parsehosts( &ludlist, host,
552 lo->ldo_defport ? lo->ldo_defport : LDAP_PORT );
554 } else if(ld == NULL) {
556 * must want global default returned
557 * to initial condition.
559 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
560 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
561 | LDAP_PVT_URL_PARSE_DEF_PORT );
565 * must want the session default
566 * updated to the current global default
568 ludlist = ldap_url_duplist(
569 ldap_int_global_options.ldo_defludp);
574 if (rc == LDAP_OPT_SUCCESS) {
575 if (lo->ldo_defludp != NULL)
576 ldap_free_urllist(lo->ldo_defludp);
577 lo->ldo_defludp = ludlist;
583 const char *urls = (const char *) invalue;
584 LDAPURLDesc *ludlist = NULL;
585 rc = LDAP_OPT_SUCCESS;
588 rc = ldap_url_parselist_ext(&ludlist, urls, NULL,
589 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
590 | LDAP_PVT_URL_PARSE_DEF_PORT );
591 } else if(ld == NULL) {
593 * must want global default returned
594 * to initial condition.
596 rc = ldap_url_parselist_ext(&ludlist, "ldap://localhost/", NULL,
597 LDAP_PVT_URL_PARSE_NOEMPTY_HOST
598 | LDAP_PVT_URL_PARSE_DEF_PORT );
602 * must want the session default
603 * updated to the current global default
605 ludlist = ldap_url_duplist(
606 ldap_int_global_options.ldo_defludp);
608 rc = LDAP_URL_ERR_MEM;
612 case LDAP_URL_SUCCESS: /* Success */
616 case LDAP_URL_ERR_MEM: /* can't allocate memory space */
620 case LDAP_URL_ERR_PARAM: /* parameter is bad */
621 case LDAP_URL_ERR_BADSCHEME: /* URL doesn't begin with "ldap[si]://" */
622 case LDAP_URL_ERR_BADENCLOSURE: /* URL is missing trailing ">" */
623 case LDAP_URL_ERR_BADURL: /* URL is bad */
624 case LDAP_URL_ERR_BADHOST: /* host port is bad */
625 case LDAP_URL_ERR_BADATTRS: /* bad (or missing) attributes */
626 case LDAP_URL_ERR_BADSCOPE: /* scope string is invalid (or missing) */
627 case LDAP_URL_ERR_BADFILTER: /* bad or missing filter */
628 case LDAP_URL_ERR_BADEXTS: /* bad or missing extensions */
629 rc = LDAP_PARAM_ERROR;
633 if (rc == LDAP_SUCCESS) {
634 if (lo->ldo_defludp != NULL)
635 ldap_free_urllist(lo->ldo_defludp);
636 lo->ldo_defludp = ludlist;
641 case LDAP_OPT_DEFBASE: {
642 const char *newbase = (const char *) invalue;
643 char *defbase = NULL;
645 if ( newbase != NULL ) {
646 defbase = LDAP_STRDUP( newbase );
647 if ( defbase == NULL ) {
652 } else if ( ld != NULL ) {
653 defbase = LDAP_STRDUP( ldap_int_global_options.ldo_defbase );
654 if ( defbase == NULL ) {
660 if ( lo->ldo_defbase != NULL )
661 LDAP_FREE( lo->ldo_defbase );
662 lo->ldo_defbase = defbase;
664 rc = LDAP_OPT_SUCCESS;
667 case LDAP_OPT_DIAGNOSTIC_MESSAGE: {
668 const char *err = (const char *) invalue;
671 /* need a struct ldap */
672 break; /* LDAP_OPT_ERROR */
676 LDAP_FREE(ld->ld_error);
681 ld->ld_error = LDAP_STRDUP(err);
684 rc = LDAP_OPT_SUCCESS;
687 case LDAP_OPT_MATCHED_DN: {
688 const char *matched = (const char *) invalue;
691 /* need a struct ldap */
692 break; /* LDAP_OPT_ERROR */
695 if( ld->ld_matched ) {
696 LDAP_FREE(ld->ld_matched);
697 ld->ld_matched = NULL;
701 ld->ld_matched = LDAP_STRDUP( matched );
704 rc = LDAP_OPT_SUCCESS;
707 case LDAP_OPT_REFERRAL_URLS: {
708 char *const *referrals = (char *const *) invalue;
711 /* need a struct ldap */
712 break; /* LDAP_OPT_ERROR */
715 if( ld->ld_referrals ) {
716 LDAP_VFREE(ld->ld_referrals);
720 ld->ld_referrals = ldap_value_dup(referrals);
723 rc = LDAP_OPT_SUCCESS;
726 /* Only accessed from inside this function by ldap_set_rebind_proc() */
727 case LDAP_OPT_REBIND_PROC: {
728 lo->ldo_rebind_proc = (LDAP_REBIND_PROC *)invalue;
730 rc = LDAP_OPT_SUCCESS;
732 case LDAP_OPT_REBIND_PARAMS: {
733 lo->ldo_rebind_params = (void *)invalue;
735 rc = LDAP_OPT_SUCCESS;
738 /* Only accessed from inside this function by ldap_set_nextref_proc() */
739 case LDAP_OPT_NEXTREF_PROC: {
740 lo->ldo_nextref_proc = (LDAP_NEXTREF_PROC *)invalue;
742 rc = LDAP_OPT_SUCCESS;
744 case LDAP_OPT_NEXTREF_PARAMS: {
745 lo->ldo_nextref_params = (void *)invalue;
747 rc = LDAP_OPT_SUCCESS;
750 /* Only accessed from inside this function by ldap_set_urllist_proc() */
751 case LDAP_OPT_URLLIST_PROC: {
752 lo->ldo_urllist_proc = (LDAP_URLLIST_PROC *)invalue;
754 rc = LDAP_OPT_SUCCESS;
756 case LDAP_OPT_URLLIST_PARAMS: {
757 lo->ldo_urllist_params = (void *)invalue;
759 rc = LDAP_OPT_SUCCESS;
762 /* read-only options */
763 case LDAP_OPT_API_INFO:
765 case LDAP_OPT_SOCKBUF:
766 case LDAP_OPT_API_FEATURE_INFO:
767 break; /* LDAP_OPT_ERROR */
769 /* options which cannot withstand invalue == NULL */
771 case LDAP_OPT_SIZELIMIT:
772 case LDAP_OPT_TIMELIMIT:
773 case LDAP_OPT_PROTOCOL_VERSION:
774 case LDAP_OPT_RESULT_CODE:
775 case LDAP_OPT_DEBUG_LEVEL:
776 case LDAP_OPT_TIMEOUT:
777 case LDAP_OPT_NETWORK_TIMEOUT:
778 case LDAP_OPT_CONNECT_CB:
779 case LDAP_OPT_X_KEEPALIVE_IDLE:
780 case LDAP_OPT_X_KEEPALIVE_PROBES :
781 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
782 if(invalue == NULL) {
783 /* no place to set from */
784 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
785 return ( LDAP_OPT_ERROR );
791 if ( ldap_pvt_tls_set_option( ld, option, (void *)invalue ) == 0 ) {
792 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
793 return ( LDAP_OPT_SUCCESS );
796 #ifdef HAVE_CYRUS_SASL
797 if ( ldap_int_sasl_set_option( ld, option, (void *)invalue ) == 0 ) {
798 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
799 return ( LDAP_OPT_SUCCESS );
803 if ( ldap_int_gssapi_set_option( ld, option, (void *)invalue ) == 0 ) {
804 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
805 return ( LDAP_OPT_SUCCESS );
809 break; /* LDAP_OPT_ERROR */
812 /* options which cannot withstand invalue == NULL */
816 /* FIXME: check value for protocol compliance? */
817 lo->ldo_deref = * (const int *) invalue;
818 rc = LDAP_OPT_SUCCESS;
821 case LDAP_OPT_SIZELIMIT:
822 /* FIXME: check value for protocol compliance? */
823 lo->ldo_sizelimit = * (const int *) invalue;
824 rc = LDAP_OPT_SUCCESS;
827 case LDAP_OPT_TIMELIMIT:
828 /* FIXME: check value for protocol compliance? */
829 lo->ldo_timelimit = * (const int *) invalue;
830 rc = LDAP_OPT_SUCCESS;
833 case LDAP_OPT_TIMEOUT: {
834 const struct timeval *tv =
835 (const struct timeval *) invalue;
837 lo->ldo_tm_api = *tv;
839 rc = LDAP_OPT_SUCCESS;
842 case LDAP_OPT_NETWORK_TIMEOUT: {
843 const struct timeval *tv =
844 (const struct timeval *) invalue;
846 lo->ldo_tm_net = *tv;
848 rc = LDAP_OPT_SUCCESS;
851 case LDAP_OPT_PROTOCOL_VERSION: {
852 int vers = * (const int *) invalue;
853 if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
857 lo->ldo_version = vers;
859 rc = LDAP_OPT_SUCCESS;
862 case LDAP_OPT_RESULT_CODE: {
863 int err = * (const int *) invalue;
866 /* need a struct ldap */
872 rc = LDAP_OPT_SUCCESS;
875 case LDAP_OPT_DEBUG_LEVEL:
876 lo->ldo_debug = * (const int *) invalue;
877 rc = LDAP_OPT_SUCCESS;
880 case LDAP_OPT_CONNECT_CB:
882 /* setting pushes the callback */
884 ll = LDAP_MALLOC( sizeof( *ll ));
885 ll->ll_data = (void *)invalue;
886 ll->ll_next = lo->ldo_conn_cbs;
887 lo->ldo_conn_cbs = ll;
889 rc = LDAP_OPT_SUCCESS;
891 case LDAP_OPT_X_KEEPALIVE_IDLE:
892 lo->ldo_keepalive_idle = * (const int *) invalue;
893 rc = LDAP_OPT_SUCCESS;
895 case LDAP_OPT_X_KEEPALIVE_PROBES :
896 lo->ldo_keepalive_probes = * (const int *) invalue;
897 rc = LDAP_OPT_SUCCESS;
899 case LDAP_OPT_X_KEEPALIVE_INTERVAL :
900 lo->ldo_keepalive_interval = * (const int *) invalue;
901 rc = LDAP_OPT_SUCCESS;
905 LDAP_MUTEX_UNLOCK( &lo->ldo_mutex );
910 ldap_set_rebind_proc( LDAP *ld, LDAP_REBIND_PROC *proc, void *params )
913 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PROC, (void *)proc );
914 if( rc != LDAP_OPT_SUCCESS ) return rc;
916 rc = ldap_set_option( ld, LDAP_OPT_REBIND_PARAMS, (void *)params );
921 ldap_set_nextref_proc( LDAP *ld, LDAP_NEXTREF_PROC *proc, void *params )
924 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PROC, (void *)proc );
925 if( rc != LDAP_OPT_SUCCESS ) return rc;
927 rc = ldap_set_option( ld, LDAP_OPT_NEXTREF_PARAMS, (void *)params );
932 ldap_set_urllist_proc( LDAP *ld, LDAP_URLLIST_PROC *proc, void *params )
935 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PROC, (void *)proc );
936 if( rc != LDAP_OPT_SUCCESS ) return rc;
938 rc = ldap_set_option( ld, LDAP_OPT_URLLIST_PARAMS, (void *)params );