git.sur5r.net Git - openldap/blob - libraries/libldap/options.c

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5
   6 #include "portable.h"
   7
   8 #include <stdio.h>
   9
  10 #include <ac/stdlib.h>
  11
  12 #include <ac/socket.h>
  13 #include <ac/string.h>
  14
  15 #include "ldap-int.h"
  16
  17 static const LDAPAPIFeatureInfo features[] = {
  18 #ifdef LDAP_API_FEATURE_X_OPENLDAP
  19         {       /* OpenLDAP Extensions API Feature */
  20                 LDAP_FEATURE_INFO_VERSION,
  21                 "X_OPENLDAP",
  22                 LDAP_API_FEATURE_X_OPENLDAP
  23         },
  24 #endif
  25
  26 #ifdef LDAP_API_FEATURE_THREAD_SAFE
  27         {       /* Basic Thread Safe */
  28                 LDAP_FEATURE_INFO_VERSION,
  29                 "THREAD_SAFE",
  30                 LDAP_API_FEATURE_THREAD_SAFE
  31         },
  32 #endif
  33 #ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE
  34         {       /* Session Thread Safe */
  35                 LDAP_FEATURE_INFO_VERSION,
  36                 "SESSION_THREAD_SAFE",
  37                 LDAP_API_FEATURE_SESSION_THREAD_SAFE
  38         },
  39 #endif
  40 #ifdef LDAP_API_FEATURE_OPERATION_THREAD_SAFE
  41         {       /* Operation Thread Safe */
  42                 LDAP_FEATURE_INFO_VERSION,
  43                 "OPERATION_THREAD_SAFE",
  44                 LDAP_API_FEATURE_OPERATION_THREAD_SAFE
  45         },
  46 #endif
  47 #ifdef LDAP_API_FEATURE_X_OPENLDAP_REENTRANT
  48         {       /* OpenLDAP Reentrant */
  49                 LDAP_FEATURE_INFO_VERSION,
  50                 "X_OPENLDAP_REENTRANT",
  51                 LDAP_API_FEATURE_X_OPENLDAP_REENTRANT
  52         },
  53 #endif
  54 #if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) && \
  55         defined( LDAP_THREAD_SAFE )
  56         {       /* OpenLDAP Thread Safe */
  57                 LDAP_FEATURE_INFO_VERSION,
  58                 "X_OPENLDAP_THREAD_SAFE",
  59                 LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE
  60         },
  61 #endif
  62 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
  63         {       /* DNS */
  64                 LDAP_FEATURE_INFO_VERSION,
  65                 "X_OPENLDAP_V2_DNS",
  66                 LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
  67         },
  68 #endif
  69 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
  70         {       /* V2 Referrals */
  71                 LDAP_FEATURE_INFO_VERSION,
  72                 "X_OPENLDAP_V2_REFERRALS",
  73                 LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
  74         },
  75 #endif
  76         {0, NULL, 0}
  77 };
  78
  79 int
  80 ldap_get_option(
  81         LDAP_CONST LDAP *ld,
  82         int             option,
  83         void    *outvalue)
  84 {
  85         LDAP_CONST struct ldapoptions *lo;
  86
  87         if( ldap_int_global_options.ldo_valid != LDAP_INITIALIZED ) {
  88                 ldap_int_initialize();
  89         }
  90
  91         if(ld == NULL) {
  92                 lo = &ldap_int_global_options;
  93
  94         } else {
  95                 assert( LDAP_VALID( ld ) );
  96
  97                 if( !LDAP_VALID( ld ) ) {
  98                         return LDAP_OPT_ERROR;
  99                 }
 100
 101                 lo = &ld->ld_options;
 102         }
 103
 104         if(outvalue == NULL) {
 105                 /* no place to get to */
 106                 return LDAP_OPT_ERROR;
 107         }
 108
 109         switch(option) {
 110         case LDAP_OPT_API_INFO: {
 111                         struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue;
 112
 113                         if(info == NULL) {
 114                                 /* outvalue must point to an apiinfo structure */
 115                                 return LDAP_OPT_ERROR;
 116                         }
 117
 118                         if(info->ldapai_info_version != LDAP_API_INFO_VERSION) {
 119                                 /* api info version mismatch */
 120                                 info->ldapai_info_version = LDAP_API_INFO_VERSION;
 121                                 return LDAP_OPT_ERROR;
 122                         }
 123
 124                         info->ldapai_api_version = LDAP_API_VERSION;
 125                         info->ldapai_api_version = LDAP_API_VERSION;
 126                         info->ldapai_protocol_version = LDAP_VERSION_MAX;
 127
 128                         if(features[0].ldapaif_name == NULL) {
 129                                 info->ldapai_extensions = NULL;
 130                         } else {
 131                                 int i;
 132                                 info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) *
 133                                         sizeof(features)/sizeof(LDAPAPIFeatureInfo));
 134
 135                                 for(i=0; features[i].ldapaif_name != NULL; i++) {
 136                                         info->ldapai_extensions[i] =
 137                                                 LDAP_STRDUP(features[i].ldapaif_name);
 138                                 }
 139
 140                                 info->ldapai_extensions[i] = NULL;
 141                         }
 142
 143                         info->ldapai_vendor_name = LDAP_STRDUP(LDAP_VENDOR_NAME);
 144                         info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
 145
 146                         return LDAP_OPT_SUCCESS;
 147                 } break;
 148
 149         case LDAP_OPT_DESC:
 150                 if(ld == NULL) {
 151                         /* bad param */
 152                         break;
 153                 }
 154
 155                 * (ber_socket_t *) outvalue = ber_pvt_sb_get_desc( &(ld->ld_sb) );
 156                 return LDAP_OPT_SUCCESS;
 157
 158         case LDAP_OPT_DEREF:
 159                 * (int *) outvalue = lo->ldo_deref;
 160                 return LDAP_OPT_SUCCESS;
 161
 162         case LDAP_OPT_SIZELIMIT:
 163                 * (int *) outvalue = lo->ldo_sizelimit;
 164                 return LDAP_OPT_SUCCESS;
 165
 166         case LDAP_OPT_TIMELIMIT:
 167                 * (int *) outvalue = lo->ldo_timelimit;
 168                 return LDAP_OPT_SUCCESS;
 169
 170         case LDAP_OPT_REFERRALS:
 171                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS);
 172                 return LDAP_OPT_SUCCESS;
 173
 174         case LDAP_OPT_RESTART:
 175                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART);
 176                 return LDAP_OPT_SUCCESS;
 177
 178         case LDAP_OPT_DNS:      /* LDAPv2 */
 179                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_DNS);
 180                 return LDAP_OPT_SUCCESS;
 181
 182         case LDAP_OPT_PROTOCOL_VERSION:
 183                 if ((ld != NULL) && ld->ld_version) {
 184                         * (int *) outvalue = ld->ld_version;
 185                 } else {
 186                         * (int *) outvalue = lo->ldo_version;
 187                 }
 188                 return LDAP_OPT_SUCCESS;
 189
 190         case LDAP_OPT_SERVER_CONTROLS:
 191                 * (LDAPControl ***) outvalue =
 192                         ldap_controls_dup( lo->ldo_sctrls );
 193
 194                 return LDAP_OPT_SUCCESS;
 195
 196         case LDAP_OPT_CLIENT_CONTROLS:
 197                 * (LDAPControl ***) outvalue =
 198                         ldap_controls_dup( lo->ldo_cctrls );
 199
 200                 return LDAP_OPT_SUCCESS;
 201
 202         case LDAP_OPT_HOST_NAME:
 203                 * (char **) outvalue = LDAP_STRDUP(lo->ldo_defhost);
 204                 return LDAP_OPT_SUCCESS;
 205
 206         case LDAP_OPT_ERROR_NUMBER:
 207                 if(ld == NULL) {
 208                         /* bad param */
 209                         break;
 210                 }
 211                 * (int *) outvalue = ld->ld_errno;
 212                 return LDAP_OPT_SUCCESS;
 213
 214         case LDAP_OPT_ERROR_STRING:
 215                 if(ld == NULL) {
 216                         /* bad param */
 217                         break;
 218                 }
 219
 220                 if( ld->ld_error == NULL ) {
 221                         * (char **) outvalue = NULL;
 222                 } else {
 223                         * (char **) outvalue = LDAP_STRDUP(ld->ld_error);
 224                 }
 225
 226                 return LDAP_OPT_SUCCESS;
 227
 228         case LDAP_OPT_MATCHED_DN:
 229                 if(ld == NULL) {
 230                         /* bad param */
 231                         break;
 232                 }
 233
 234                 if( ld->ld_matched == NULL ) {
 235                         * (char **) outvalue = NULL;
 236                 } else {
 237                         * (char **) outvalue = LDAP_STRDUP(ld->ld_matched);
 238                 }
 239
 240                 return LDAP_OPT_SUCCESS;
 241
 242         case LDAP_OPT_API_FEATURE_INFO: {
 243                         LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
 244                         int i;
 245
 246                         if(info == NULL) return LDAP_OPT_ERROR;
 247
 248                         if(info->ldapaif_info_version != LDAP_FEATURE_INFO_VERSION) {
 249                                 /* api info version mismatch */
 250                                 info->ldapaif_info_version = LDAP_FEATURE_INFO_VERSION;
 251                                 return LDAP_OPT_ERROR;
 252                         }
 253
 254                         if(info->ldapaif_name == NULL) return LDAP_OPT_ERROR;
 255
 256                         for(i=0; features[i].ldapaif_name != NULL; i++) {
 257                                 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
 258                                         info->ldapaif_version =
 259                                                 features[i].ldapaif_version;
 260                                         return LDAP_OPT_SUCCESS;
 261                                 }
 262                         }
 263                 }
 264                 break;
 265
 266         case LDAP_OPT_DEBUG_LEVEL:
 267                 * (int *) outvalue = lo->ldo_debug;
 268                 return LDAP_OPT_SUCCESS;
 269
 270         default:
 271 #ifdef HAVE_TLS
 272                 if ( ldap_pvt_tls_get_option(lo, option, outvalue ) == 0 )
 273                         return LDAP_OPT_SUCCESS;
 274 #endif
 275                 /* bad param */
 276                 break;
 277         }
 278
 279         return LDAP_OPT_ERROR;
 280 }
 281
 282 int
 283 ldap_set_option(
 284         LDAP    *ld,
 285         int             option,
 286         LDAP_CONST void *invalue)
 287 {
 288         struct ldapoptions *lo;
 289
 290         if( ldap_int_global_options.ldo_valid != LDAP_INITIALIZED ) {
 291                 ldap_int_initialize();
 292         }
 293
 294         if(ld == NULL) {
 295                 lo = &ldap_int_global_options;
 296
 297         } else {
 298                 assert( LDAP_VALID( ld ) );
 299
 300                 if( !LDAP_VALID( ld ) ) {
 301                         return LDAP_OPT_ERROR;
 302                 }
 303
 304                 lo = &ld->ld_options;
 305         }
 306
 307         switch(option) {
 308         case LDAP_OPT_REFERRALS:
 309                 if(invalue == LDAP_OPT_OFF) {
 310                         LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
 311                 } else {
 312                         LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
 313                 }
 314                 return LDAP_OPT_SUCCESS;
 315
 316         case LDAP_OPT_RESTART:
 317                 if(invalue == LDAP_OPT_OFF) {
 318                         LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
 319                 } else {
 320                         LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
 321                 }
 322                 return LDAP_OPT_SUCCESS;
 323         }
 324
 325         if(invalue == NULL) {
 326                 /* no place to set from */
 327                 return LDAP_OPT_ERROR;
 328         }
 329
 330         switch(option) {
 331         case LDAP_OPT_API_INFO:
 332         case LDAP_OPT_DESC:
 333                 /* READ ONLY */
 334                 break;
 335
 336         case LDAP_OPT_DEREF:
 337                 lo->ldo_deref = * (const int *) invalue;
 338                 return LDAP_OPT_SUCCESS;
 339
 340         case LDAP_OPT_SIZELIMIT:
 341                 lo->ldo_sizelimit = * (const int *) invalue;
 342                 return LDAP_OPT_SUCCESS;
 343
 344         case LDAP_OPT_TIMELIMIT:
 345                 lo->ldo_timelimit = * (const int *) invalue;
 346                 return LDAP_OPT_SUCCESS;
 347
 348         case LDAP_OPT_PROTOCOL_VERSION: {
 349                         int vers = * (const int *) invalue;
 350                         if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
 351                                 /* not supported */
 352                                 break;
 353                         }
 354                         ld->ld_version = vers;
 355                 } return LDAP_OPT_SUCCESS;
 356
 357         case LDAP_OPT_SERVER_CONTROLS: {
 358                         LDAPControl *const *controls =
 359                                 (LDAPControl *const *) invalue;
 360
 361                         ldap_controls_free( lo->ldo_sctrls );
 362
 363                         if( controls == NULL || *controls == NULL ) {
 364                                 lo->ldo_sctrls = NULL;
 365                                 return LDAP_OPT_SUCCESS;
 366                         }
 367
 368                         lo->ldo_sctrls = ldap_controls_dup( controls );
 369
 370                         if(lo->ldo_sctrls == NULL) {
 371                                 /* memory allocation error ? */
 372                                 break;
 373                         }
 374                 } return LDAP_OPT_SUCCESS;
 375
 376         case LDAP_OPT_CLIENT_CONTROLS: {
 377                         LDAPControl *const *controls =
 378                                 (LDAPControl *const *) invalue;
 379
 380                         ldap_controls_free( lo->ldo_cctrls );
 381
 382                         if( controls == NULL || *controls == NULL ) {
 383                                 lo->ldo_cctrls = NULL;
 384                                 return LDAP_OPT_SUCCESS;
 385                         }
 386
 387                         lo->ldo_cctrls = ldap_controls_dup( controls );
 388
 389                         if(lo->ldo_cctrls == NULL) {
 390                                 /* memory allocation error ? */
 391                                 break;
 392                         }
 393                 } return LDAP_OPT_SUCCESS;
 394
 395         case LDAP_OPT_HOST_NAME: {
 396                         const char *host = (const char *) invalue;
 397
 398                         if(lo->ldo_defhost != NULL) {
 399                                 LDAP_FREE(lo->ldo_defhost);
 400                                 lo->ldo_defhost = NULL;
 401                         }
 402
 403                         if(host != NULL) {
 404                                 lo->ldo_defhost = LDAP_STRDUP(host);
 405                                 return LDAP_OPT_SUCCESS;
 406                         }
 407
 408                         if(ld == NULL) {
 409                                 /*
 410                                  * must want global default returned
 411                                  * to initial condition.
 412                                  */
 413                                 lo->ldo_defhost = LDAP_STRDUP("localhost");
 414
 415                         } else {
 416                                 /*
 417                                  * must want the session default
 418                                  *   updated to the current global default
 419                                  */
 420                                 lo->ldo_defhost = LDAP_STRDUP(
 421                                         ldap_int_global_options.ldo_defhost);
 422                         }
 423                 } return LDAP_OPT_SUCCESS;
 424
 425         case LDAP_OPT_ERROR_NUMBER: {
 426                         int err = * (const int *) invalue;
 427
 428                         if(ld == NULL) {
 429                                 /* need a struct ldap */
 430                                 break;
 431                         }
 432
 433                         ld->ld_errno = err;
 434                 } return LDAP_OPT_SUCCESS;
 435
 436         case LDAP_OPT_ERROR_STRING: {
 437                         const char *err = (const char *) invalue;
 438
 439                         if(ld == NULL) {
 440                                 /* need a struct ldap */
 441                                 break;
 442                         }
 443
 444                         if( ld->ld_error ) {
 445                                 LDAP_FREE(ld->ld_error);
 446                         }
 447
 448                         ld->ld_error = LDAP_STRDUP(err);
 449                 } return LDAP_OPT_SUCCESS;
 450
 451         case LDAP_OPT_MATCHED_DN: {
 452                         const char *err = (const char *) invalue;
 453
 454                         if(ld == NULL) {
 455                                 /* need a struct ldap */
 456                                 break;
 457                         }
 458
 459                         if( ld->ld_matched ) {
 460                                 LDAP_FREE(ld->ld_matched);
 461                         }
 462
 463                         ld->ld_matched = LDAP_STRDUP(err);
 464                 } return LDAP_OPT_SUCCESS;
 465
 466         case LDAP_OPT_API_FEATURE_INFO:
 467                 /* read-only */
 468                 break;
 469
 470         case LDAP_OPT_DEBUG_LEVEL:
 471                 lo->ldo_debug = * (const int *) invalue;
 472                 return LDAP_OPT_SUCCESS;
 473
 474         default:
 475 #ifdef HAVE_TLS
 476                 if ( ldap_pvt_tls_set_option( lo, option, invalue ) == 0 )
 477                         return LDAP_OPT_SUCCESS;
 478 #endif
 479                 /* bad param */
 480                 break;
 481         }
 482         return LDAP_OPT_ERROR;
 483 }