usr/src/lib/libldap5/sources/ldap/common/setoption.c

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