1 /*
2 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /*
7 * The contents of this file are subject to the Netscape Public
8 * License Version 1.1 (the "License"); you may not use this file
9 * except in compliance with the License. You may obtain a copy of
10 * the License at http://www.mozilla.org/NPL/
11 *
12 * Software distributed under the License is distributed on an "AS
13 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14 * implied. See the License for the specific language governing
15 * rights and limitations under the License.
16 *
17 * The Original Code is Mozilla Communicator client code, released
18 * March 31, 1998.
19 *
20 * The Initial Developer of the Original Code is Netscape
21 * Communications Corporation. Portions created by Netscape are
22 * Copyright (C) 1998-1999 Netscape Communications Corporation. All
23 * Rights Reserved.
24 *
25 * Contributor(s):
26 */
27 /*
28 * setoption.c - ldap_set_option implementation
29 */
30
31 #include "ldap-int.h"
32 #ifdef _SOLARIS_SDK
33 #include "solaris-priv.h"
34 #endif
35
36 extern int nsldapi_sasl_secprops(const char *in,
37 sasl_security_properties_t *secprops);
38
39 #define LDAP_SETCLR_BITOPT(ld, bit, optdata) \
40 if (optdata != NULL) { \
41 (ld)->ld_options |= bit; \
42 } else { \
43 (ld)->ld_options &= ~bit; \
44 }
45
46
47 int
48 LDAP_CALL
ldap_set_option(LDAP * ld,int option,const void * optdata)49 ldap_set_option(LDAP *ld, int option, const void *optdata)
50 {
51 int rc, i;
52 char *matched, *errstr;
53
54 if (!nsldapi_initialized) {
55 nsldapi_initialize_defaults();
56 }
57
58 /*
59 * process global options (not associated with an LDAP session handle)
60 */
61 if (option == LDAP_OPT_MEMALLOC_FN_PTRS) {
62 struct lber_memalloc_fns memalloc_fns;
63
64 /* set libldap ones via a struct copy */
65 nsldapi_memalloc_fns = *((struct ldap_memalloc_fns *)optdata);
66
67 /* also set liblber memory allocation callbacks */
68 memalloc_fns.lbermem_malloc =
69 nsldapi_memalloc_fns.ldapmem_malloc;
70 memalloc_fns.lbermem_calloc =
71 nsldapi_memalloc_fns.ldapmem_calloc;
72 memalloc_fns.lbermem_realloc =
73 nsldapi_memalloc_fns.ldapmem_realloc;
74 memalloc_fns.lbermem_free =
75 nsldapi_memalloc_fns.ldapmem_free;
76 if (ber_set_option(NULL, LBER_OPT_MEMALLOC_FN_PTRS,
77 &memalloc_fns) != 0) {
78 return (-1);
79 }
80
81 return (0);
82 }
83 /*
84 * LDAP_OPT_DEBUG_LEVEL is global
85 */
86 if (LDAP_OPT_DEBUG_LEVEL == option) {
87 #ifdef LDAP_DEBUG
88 ldap_debug = *((int *)optdata);
89 #endif
90 return (0);
91 }
92
93 /*
94 * if ld is NULL, arrange to modify our default settings
95 */
96 if (ld == NULL) {
97 ld = &nsldapi_ld_defaults;
98 #ifdef LDAP_DEBUG
99 ldap_debug = 0;
100 #endif
101
102 }
103
104 /*
105 * process options that are associated with an LDAP session handle
106 */
107 if (!NSLDAPI_VALID_LDAP_POINTER(ld)) {
108 return (-1); /* punt */
109 }
110
111 rc = 0;
112 if (ld != &nsldapi_ld_defaults &&
113 option != LDAP_OPT_EXTRA_THREAD_FN_PTRS &&
114 option != LDAP_OPT_THREAD_FN_PTRS) {
115 LDAP_MUTEX_LOCK(ld, LDAP_OPTION_LOCK);
116 }
117 switch (option) {
118 /* options that can be turned on and off */
119 #ifdef LDAP_DNS
120 case LDAP_OPT_DNS:
121 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_DNS, optdata);
122 break;
123 #endif
124
125 case LDAP_OPT_REFERRALS:
126 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_REFERRALS, optdata);
127 break;
128
129 #ifdef LDAP_SSLIO_HOOKS
130 case LDAP_OPT_SSL:
131 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_SSL, optdata);
132 break;
133 #endif
134
135 case LDAP_OPT_RESTART:
136 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_RESTART, optdata);
137 break;
138
139 case LDAP_OPT_RECONNECT:
140 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_RECONNECT, optdata);
141 break;
142
143 #ifdef LDAP_ASYNC_IO
144 case LDAP_OPT_ASYNC_CONNECT:
145 LDAP_SETCLR_BITOPT(ld, LDAP_BITOPT_ASYNC, optdata);
146 break;
147 #endif /* LDAP_ASYNC_IO */
148
149 /* fields in the LDAP structure */
150 case LDAP_OPT_DEREF:
151 ld->ld_deref = *((int *)optdata);
152 break;
153 case LDAP_OPT_SIZELIMIT:
154 ld->ld_sizelimit = *((int *)optdata);
155 break;
156 case LDAP_OPT_TIMELIMIT:
157 ld->ld_timelimit = *((int *)optdata);
158 break;
159 case LDAP_OPT_REFERRAL_HOP_LIMIT:
160 ld->ld_refhoplimit = *((int *)optdata);
161 break;
162 case LDAP_OPT_PROTOCOL_VERSION:
163 ld->ld_version = *((int *)optdata);
164 if (ld->ld_defconn != NULL) { /* also set in default conn. */
165 ld->ld_defconn->lconn_version = ld->ld_version;
166 }
167 break;
168 case LDAP_OPT_SERVER_CONTROLS:
169 /* nsldapi_dup_controls returns -1 and sets lderrno on error */
170 rc = nsldapi_dup_controls(ld, &ld->ld_servercontrols,
171 (LDAPControl **)optdata);
172 break;
173 case LDAP_OPT_CLIENT_CONTROLS:
174 /* nsldapi_dup_controls returns -1 and sets lderrno on error */
175 rc = nsldapi_dup_controls(ld, &ld->ld_clientcontrols,
176 (LDAPControl **)optdata);
177 break;
178
179 /* rebind proc */
180 case LDAP_OPT_REBIND_FN:
181 ld->ld_rebind_fn = (LDAP_REBINDPROC_CALLBACK *) optdata;
182 break;
183 case LDAP_OPT_REBIND_ARG:
184 ld->ld_rebind_arg = (void *) optdata;
185 break;
186
187 #ifdef LDAP_SSLIO_HOOKS
188 /* i/o function pointers */
189 case LDAP_OPT_IO_FN_PTRS:
190 if ((rc = nsldapi_install_compat_io_fns(ld,
191 (struct ldap_io_fns *)optdata)) != LDAP_SUCCESS) {
192 LDAP_SET_LDERRNO(ld, rc, NULL, NULL);
193 rc = -1;
194 }
195 break;
196
197 /* extended i/o function pointers */
198 case LDAP_X_OPT_EXTIO_FN_PTRS:
199 /* denotes use of old iofns struct (no writev) */
200 if (((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_size ==
201 LDAP_X_EXTIO_FNS_SIZE_REV0) {
202 ld->ld_extio_size = LDAP_X_EXTIO_FNS_SIZE;
203 ld->ld_extclose_fn =
204 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_close;
205 ld->ld_extconnect_fn =
206 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_connect;
207 ld->ld_extread_fn =
208 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_read;
209 ld->ld_extwrite_fn =
210 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_write;
211 ld->ld_extpoll_fn =
212 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_poll;
213 ld->ld_extnewhandle_fn =
214 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_newhandle;
215 ld->ld_extdisposehandle_fn =
216 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->
217 lextiof_disposehandle;
218 ld->ld_ext_session_arg =
219 ((struct ldap_x_ext_io_fns_rev0 *)optdata)->lextiof_session_arg;
220 ld->ld_extwritev_fn = NULL;
221 if (ber_sockbuf_set_option(ld->ld_sbp, LBER_SOCKBUF_OPT_EXT_IO_FNS,
222 &(ld->ld_ext_io_fns)) != 0) {
223 return (LDAP_LOCAL_ERROR);
224 }
225 } else {
226 /* struct copy */
227 ld->ld_ext_io_fns = *((struct ldap_x_ext_io_fns *)optdata);
228 }
229 if ((rc = nsldapi_install_lber_extiofns(ld, ld->ld_sbp))
230 != LDAP_SUCCESS) {
231 LDAP_SET_LDERRNO(ld, rc, NULL, NULL);
232 rc = -1;
233 }
234 break;
235 #endif
236
237 /* thread function pointers */
238 case LDAP_OPT_THREAD_FN_PTRS:
239 /*
240 * It is only safe to set the thread function pointers
241 * when one thread is using the LDAP session handle.
242 */
243 /* free existing mutexes (some are allocated by ldap_init()) */
244 nsldapi_mutex_free_all(ld);
245
246 /* struct copy */
247 ld->ld_thread = *((struct ldap_thread_fns *)optdata);
248
249 /* allocate new mutexes */
250 nsldapi_mutex_alloc_all(ld);
251
252 /* LDAP_OPTION_LOCK was never locked... so just return */
253 return (rc);
254
255 /* extra thread function pointers */
256 case LDAP_OPT_EXTRA_THREAD_FN_PTRS:
257 /* The extra thread funcs will only pick up the threadid */
258 ld->ld_thread2 = *((struct ldap_extra_thread_fns *)optdata);
259
260 /* Reset the rest of the structure preserving the threadid fn */
261 ld->ld_mutex_trylock_fn = (LDAP_TF_MUTEX_TRYLOCK_CALLBACK *)NULL;
262 ld->ld_sema_alloc_fn = (LDAP_TF_SEMA_ALLOC_CALLBACK *) NULL;
263 ld->ld_sema_free_fn = (LDAP_TF_SEMA_FREE_CALLBACK *) NULL;
264 ld->ld_sema_wait_fn = (LDAP_TF_SEMA_WAIT_CALLBACK *) NULL;
265 ld->ld_sema_post_fn = (LDAP_TF_SEMA_POST_CALLBACK *) NULL;
266
267 /* We assume that only one thread is active when replacing */
268 /* the threadid function. We will now proceed and reset all */
269 /* of the threadid/refcounts */
270 for (i = 0; i < LDAP_MAX_LOCK; i++) {
271 ld->ld_mutex_threadid[i] = (void *) -1;
272 ld->ld_mutex_refcnt[i] = 0;
273 }
274
275 return (rc);
276
277 /* DNS function pointers */
278 case LDAP_OPT_DNS_FN_PTRS:
279 /* struct copy */
280 ld->ld_dnsfn = *((struct ldap_dns_fns *)optdata);
281 break;
282
283 /* cache function pointers */
284 case LDAP_OPT_CACHE_FN_PTRS:
285 /* struct copy */
286 ld->ld_cache = *((struct ldap_cache_fns *)optdata);
287 break;
288 case LDAP_OPT_CACHE_STRATEGY:
289 ld->ld_cache_strategy = *((int *)optdata);
290 break;
291 case LDAP_OPT_CACHE_ENABLE:
292 ld->ld_cache_on = *((int *)optdata);
293 break;
294
295 case LDAP_OPT_ERROR_NUMBER:
296 LDAP_GET_LDERRNO(ld, &matched, &errstr);
297 matched = nsldapi_strdup(matched);
298 errstr = nsldapi_strdup(errstr);
299 LDAP_SET_LDERRNO(ld, *((int *)optdata), matched, errstr);
300 break;
301
302 case LDAP_OPT_ERROR_STRING:
303 rc = LDAP_GET_LDERRNO(ld, &matched, NULL);
304 matched = nsldapi_strdup(matched);
305 LDAP_SET_LDERRNO(ld, rc, matched,
306 nsldapi_strdup((char *)optdata));
307 rc = LDAP_SUCCESS;
308 break;
309
310 case LDAP_OPT_MATCHED_DN:
311 rc = LDAP_GET_LDERRNO(ld, NULL, &errstr);
312 errstr = nsldapi_strdup(errstr);
313 LDAP_SET_LDERRNO(ld, rc,
314 nsldapi_strdup((char *)optdata), errstr);
315 rc = LDAP_SUCCESS;
316 break;
317
318 case LDAP_OPT_PREFERRED_LANGUAGE:
319 if (NULL != ld->ld_preferred_language) {
320 NSLDAPI_FREE(ld->ld_preferred_language);
321 }
322 ld->ld_preferred_language = nsldapi_strdup((char *)optdata);
323 break;
324
325 case LDAP_OPT_HOST_NAME:
326 if (NULL != ld->ld_defhost) {
327 NSLDAPI_FREE(ld->ld_defhost);
328 }
329 ld->ld_defhost = nsldapi_strdup((char *)optdata);
330 break;
331
332 case LDAP_X_OPT_CONNECT_TIMEOUT:
333 ld->ld_connect_timeout = *((int *)optdata);
334 break;
335
336 #ifdef _SOLARIS_SDK
337 /* recursion prevention dns functions */
338 case LDAP_X_OPT_DNS_SKIPDB:
339 rc = prldap_x_install_dns_skipdb(ld, (const char *)optdata);
340 break;
341 #endif
342 #ifdef LDAP_SASLIO_HOOKS
343 /* SASL options */
344 case LDAP_OPT_X_SASL_MECH:
345 if (NULL != ld->ld_def_sasl_mech) {
346
347 NSLDAPI_FREE(ld->ld_def_sasl_mech);
348 }
349 ld->ld_def_sasl_mech = nsldapi_strdup((char *)optdata);
350 break;
351 case LDAP_OPT_X_SASL_REALM:
352 if (NULL != ld->ld_def_sasl_realm) {
353 NSLDAPI_FREE(ld->ld_def_sasl_realm);
354 }
355 ld->ld_def_sasl_realm = nsldapi_strdup((char *)optdata);
356 break;
357 case LDAP_OPT_X_SASL_AUTHCID:
358 if (NULL != ld->ld_def_sasl_authcid) {
359 NSLDAPI_FREE(ld->ld_def_sasl_authcid);
360 }
361 ld->ld_def_sasl_authcid = nsldapi_strdup((char *)optdata);
362 break;
363 case LDAP_OPT_X_SASL_AUTHZID:
364 if (NULL != ld->ld_def_sasl_authzid) {
365 NSLDAPI_FREE(ld->ld_def_sasl_authzid);
366 }
367 ld->ld_def_sasl_authzid = nsldapi_strdup((char *)optdata);
368 break;
369 case LDAP_OPT_X_SASL_SSF_EXTERNAL:
370 {
371 int sc;
372 sasl_ssf_t extprops;
373 sasl_conn_t *ctx;
374 if (ld->ld_defconn == NULL ||
375 ld->ld_defconn->lconn_sb == NULL) {
376 return (-1);
377 }
378 ctx = (sasl_conn_t *)
379 (ld->ld_defconn->lconn_sb->sb_sasl_ctx);
380 if (ctx == NULL) {
381 return (-1);
382 }
383 memset(&extprops, 0L, sizeof (extprops));
384 extprops = * ((sasl_ssf_t *)optdata);
385 sc = sasl_setprop(ctx, SASL_SSF_EXTERNAL,
386 (void *) &extprops);
387 if (sc != SASL_OK) {
388 return (-1);
389 }
390 }
391 break;
392 case LDAP_OPT_X_SASL_SECPROPS:
393 {
394 int sc;
395 sc = nsldapi_sasl_secprops((char *)optdata,
396 &ld->ld_sasl_secprops);
397 return (sc == LDAP_SUCCESS ? 0 : -1);
398 }
399 case LDAP_OPT_X_SASL_SSF_MIN:
400 ld->ld_sasl_secprops.min_ssf = *((sasl_ssf_t *)optdata);
401 break;
402 case LDAP_OPT_X_SASL_SSF_MAX:
403 ld->ld_sasl_secprops.max_ssf = *((sasl_ssf_t *)optdata);
404 break;
405 case LDAP_OPT_X_SASL_MAXBUFSIZE:
406 ld->ld_sasl_secprops.maxbufsize = *((sasl_ssf_t *)optdata);
407 break;
408 case LDAP_OPT_X_SASL_SSF: /* read only */
409 LDAP_SET_LDERRNO(ld, LDAP_PARAM_ERROR, NULL, NULL);
410 rc = -1;
411 break;
412 #endif
413
414 default:
415 LDAP_SET_LDERRNO(ld, LDAP_PARAM_ERROR, NULL, NULL);
416 rc = -1;
417 }
418
419 if (ld != &nsldapi_ld_defaults) {
420 LDAP_MUTEX_UNLOCK(ld, LDAP_OPTION_LOCK);
421 }
422 return (rc);
423 }
424