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 #include <stdlib.h>
  10
  11 #include <ac/socket.h>
  12 #include <ac/string.h>
  13
  14 #include "ldap-int.h"
  15
  16 static const LDAPAPIFeatureInfo features[] = {
  17 #ifdef LDAP_API_FEATURE_INFO
  18         {"INFO", LDAP_API_FEATURE_INFO},
  19 #endif
  20 #ifdef LDAP_API_FEATURE_THREAD_SAFE
  21         {"THREAD_SAFE", LDAP_API_FEATURE_THREAD_SAFE},
  22 #endif
  23 #ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE
  24         {"SESSION_THREAD_SAFE", LDAP_API_FEATURE_SESSION_THREAD_SAFE},
  25 #endif
  26 #ifdef LDAP_API_FEATURE_OPERATION_THREAD_SAFE
  27         {"OPERATION_THREAD_SAFE", LDAP_API_FEATURE_OPERATION_THREAD_SAFE},
  28 #endif
  29 #ifdef LDAP_API_FEATURE_X_OPENLDAP_REEENTRANT
  30         {"X_OPENLDAP_REENTRANT", LDAP_API_FEATURE_X_OPENLDAP_REENTRANT},
  31 #endif
  32 #if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) && \
  33         defined( LDAP_THREAD_SAFE )
  34         {"X_OPENLDAP_THREAD_SAFE", LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE},
  35 #endif
  36 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
  37         {"X_OPENLDAP_V2_DNS", LDAP_API_FEATURE_X_OPENLDAP_V2_DNS},
  38 #endif
  39 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
  40         {"X_OPENLDAP_V2_REFERRALS", LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS},
  41 #endif
  42         {NULL, 0}
  43 };
  44
  45 int
  46 ldap_get_option(
  47         LDAP    *ld,
  48         int             option,
  49         void    *outvalue)
  50 {
  51         struct ldapoptions *lo;
  52
  53         if(!openldap_ldap_initialized) {
  54                 openldap_ldap_initialize();
  55         }
  56
  57         if(outvalue == NULL) {
  58                 /* no place to get to */
  59                 return -1;
  60         }
  61
  62         if(ld == NULL) {
  63                 lo = &openldap_ldap_global_options;
  64         } else {
  65                 lo = &ld->ld_options;
  66         }
  67
  68         switch(option) {
  69         case LDAP_OPT_API_INFO: {
  70                         struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue;
  71
  72                         if(info == NULL) {
  73                                 /* outvalue must point to an apiinfo structure */
  74                                 return -1;
  75                         }
  76
  77                         if(info->ldapai_info_version != LDAP_API_INFO_VERSION) {
  78                                 /* api info version mismatch */
  79                                 info->ldapai_info_version = LDAP_API_INFO_VERSION;
  80                                 return -1;
  81                         }
  82
  83                         info->ldapai_api_version = LDAP_API_VERSION;
  84                         info->ldapai_api_version = LDAP_API_VERSION;
  85                         info->ldapai_protocol_version = LDAP_VERSION_MAX;
  86
  87                         if(features[0].ldapaif_name == NULL) {
  88                                 info->ldapai_extensions = NULL;
  89                         } else {
  90                                 int i;
  91                                 info->ldapai_extensions = malloc(sizeof(char *) *
  92                                         sizeof(features)/sizeof(LDAPAPIFeatureInfo));
  93
  94                                 for(i=0; features[i].ldapaif_name != NULL; i++) {
  95                                         info->ldapai_extensions[i] =
  96                                                 strdup(features[i].ldapaif_name);
  97                                 }
  98
  99                                 info->ldapai_extensions[i] = NULL;
 100                         }
 101
 102                         info->ldapai_vendor_name = strdup(LDAP_VENDOR_NAME);
 103                         info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
 104
 105                         return 0;
 106                 } break;
 107
 108         case LDAP_OPT_DESC:
 109                 if(ld == NULL) {
 110                         /* bad param */
 111                         break;
 112                 }
 113
 114                 * (int *) outvalue = lber_pvt_sb_get_desc( &(ld->ld_sb) );
 115                 return 0;
 116
 117         case LDAP_OPT_DEREF:
 118                 * (int *) outvalue = lo->ldo_deref;
 119                 return 0;
 120
 121         case LDAP_OPT_SIZELIMIT:
 122                 * (int *) outvalue = lo->ldo_sizelimit;
 123                 return 0;
 124
 125         case LDAP_OPT_TIMELIMIT:
 126                 * (int *) outvalue = lo->ldo_timelimit;
 127                 return 0;
 128
 129         case LDAP_OPT_REFERRALS:
 130                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS);
 131                 return 0;
 132
 133         case LDAP_OPT_RESTART:
 134                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART);
 135                 return 0;
 136
 137         case LDAP_OPT_DNS:      /* LDAPv2 */
 138                 * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_DNS);
 139                 return 0;
 140
 141         case LDAP_OPT_PROTOCOL_VERSION:
 142                 if ((ld != NULL) && ld->ld_version) {
 143                         * (int *) outvalue = ld->ld_version;
 144                 } else {
 145                         * (int *) outvalue = lo->ldo_version;
 146                 }
 147                 return 0;
 148
 149         case LDAP_OPT_SERVER_CONTROLS:
 150                 * (LDAPControl ***) outvalue =
 151                         ldap_controls_dup( lo->ldo_server_controls );
 152
 153                 return 0;
 154
 155         case LDAP_OPT_CLIENT_CONTROLS:
 156                 * (LDAPControl ***) outvalue =
 157                         ldap_controls_dup( lo->ldo_client_controls );
 158
 159                 return 0;
 160
 161         case LDAP_OPT_HOST_NAME:
 162                 /*
 163                  * draft-ietf-ldapext-ldap-c-api-01 doesn't state
 164                  * whether caller has to free host names or not,
 165                  * we do.
 166                  */
 167
 168                 * (char **) outvalue = strdup(lo->ldo_defhost);
 169                 return 0;
 170
 171         case LDAP_OPT_ERROR_NUMBER:
 172                 if(ld == NULL) {
 173                         /* bad param */
 174                         break;
 175                 }
 176                 * (int *) outvalue = ld->ld_errno;
 177                 return 0;
 178
 179         case LDAP_OPT_ERROR_STRING:
 180                 if(ld == NULL) {
 181                         /* bad param */
 182                         break;
 183                 }
 184
 185                 /*
 186                  * draft-ietf-ldapext-ldap-c-api-01 doesn't require
 187                  *      the client to have to free error strings, we do
 188                  */
 189
 190                 if( ld->ld_error == NULL ) {
 191                         * (char **) outvalue = NULL;
 192                 } else {
 193                         * (char **) outvalue = strdup(ld->ld_error);
 194                 }
 195
 196                 return 0;
 197
 198         case LDAP_OPT_API_FEATURE_INFO: {
 199                         LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
 200                         int i;
 201
 202                         if(info == NULL) return -1;
 203                         if(info->ldapaif_name == NULL) return -1;
 204
 205                         for(i=0; features[i].ldapaif_name != NULL; i++) {
 206                                 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
 207                                         info->ldapaif_version =
 208                                                 features[i].ldapaif_version;
 209                                         return 0;
 210                                 }
 211                         }
 212                 }
 213                 break;
 214
 215         case LDAP_OPT_DEBUG_LEVEL:
 216                 * (int *) outvalue = lo->ldo_debug;
 217                 return 0;
 218
 219         default:
 220                 /* bad param */
 221                 break;
 222         }
 223
 224         return -1;
 225 }
 226
 227 int
 228 ldap_set_option(
 229         LDAP    *ld,
 230         int             option,
 231         void    *invalue)
 232 {
 233         struct ldapoptions *lo;
 234
 235         if(!openldap_ldap_initialized) {
 236                 openldap_ldap_initialize();
 237         }
 238
 239         if(invalue == NULL) {
 240                 /* no place to set from */
 241                 return -1;
 242         }
 243
 244         if(ld == NULL) {
 245                 lo = &openldap_ldap_global_options;
 246         } else {
 247                 lo = &ld->ld_options;
 248         }
 249
 250         switch(option) {
 251         case LDAP_OPT_API_INFO:
 252         case LDAP_OPT_DESC:
 253                 /* READ ONLY */
 254                 break;
 255
 256         case LDAP_OPT_DEREF:
 257                 lo->ldo_deref = * (int *) invalue;
 258                 return 0;
 259
 260         case LDAP_OPT_SIZELIMIT:
 261                 lo->ldo_sizelimit = * (int *) invalue;
 262                 return 0;
 263
 264         case LDAP_OPT_TIMELIMIT:
 265                 lo->ldo_timelimit = * (int *) invalue;
 266                 return 0;
 267
 268         case LDAP_OPT_REFERRALS:
 269                 if(invalue == LDAP_OPT_ON) {
 270                         LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
 271                 } else {
 272                         LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
 273                 }
 274                 return 0;
 275
 276         case LDAP_OPT_RESTART:
 277                 if(invalue == LDAP_OPT_ON) {
 278                         LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
 279                 } else {
 280                         LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
 281                 }
 282                 return 0;
 283
 284         case LDAP_OPT_PROTOCOL_VERSION: {
 285                         int vers = * (int *) invalue;
 286                         if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
 287                                 /* not supported */
 288                                 break;
 289                         }
 290                         ld->ld_version = vers;
 291                 } return 0;
 292
 293         case LDAP_OPT_SERVER_CONTROLS: {
 294                         LDAPControl **controls = (LDAPControl **) invalue;
 295
 296                         ldap_controls_free( lo->ldo_server_controls );
 297
 298                         if( controls == NULL || *controls == NULL ) {
 299                                 lo->ldo_server_controls = NULL;
 300                                 return 0;
 301                         }
 302
 303                         lo->ldo_server_controls =
 304                                 ldap_controls_dup( (LDAPControl **) invalue );
 305
 306                         if(lo->ldo_server_controls == NULL) {
 307                                 /* memory allocation error ? */
 308                                 break;
 309                         }
 310                 } return 0;
 311
 312         case LDAP_OPT_CLIENT_CONTROLS: {
 313                         LDAPControl **controls = (LDAPControl **) invalue;
 314
 315                         ldap_controls_free( lo->ldo_client_controls );
 316
 317                         if( controls == NULL || *controls == NULL ) {
 318                                 lo->ldo_client_controls = NULL;
 319                                 return 0;
 320                         }
 321
 322                         lo->ldo_client_controls =
 323                                 ldap_controls_dup( (LDAPControl **) invalue );
 324
 325                         if(lo->ldo_client_controls == NULL) {
 326                                 /* memory allocation error ? */
 327                                 break;
 328                         }
 329                 } return 0;
 330
 331         case LDAP_OPT_HOST_NAME: {
 332                         char* host = (char *) invalue;
 333
 334                         if(lo->ldo_defhost != NULL) {
 335                                 free(lo->ldo_defhost);
 336                                 lo->ldo_defhost = NULL;
 337                         }
 338
 339                         if(host != NULL) {
 340                                 lo->ldo_defhost = strdup(host);
 341                                 return 0;
 342                         }
 343
 344                         if(ld == NULL) {
 345                                 /*
 346                                  * must want global default returned
 347                                  * to initial condition.
 348                                  */
 349                                 lo->ldo_defhost = strdup("localhost");
 350
 351                         } else {
 352                                 /*
 353                                  * must want the session default
 354                                  *   updated to the current global default
 355                                  */
 356                                 lo->ldo_defhost = strdup(
 357                                         openldap_ldap_global_options.ldo_defhost);
 358                         }
 359                 } return 0;
 360
 361         case LDAP_OPT_ERROR_NUMBER: {
 362                         int err = * (int *) invalue;
 363
 364                         if(ld == NULL) {
 365                                 /* need a struct ldap */
 366                                 break;
 367                         }
 368
 369                         ld->ld_errno = err;
 370                 } return 0;
 371
 372         case LDAP_OPT_ERROR_STRING: {
 373                         char* err = (char *) invalue;
 374
 375                         if(ld == NULL) {
 376                                 /* need a struct ldap */
 377                                 break;
 378                         }
 379
 380                         if( ld->ld_error ) {
 381                                 free(ld->ld_error);
 382                         }
 383
 384                         ld->ld_error = strdup(err);
 385                 } return 0;
 386
 387         case LDAP_OPT_API_FEATURE_INFO:
 388                 /* read-only */
 389                 break;
 390
 391         case LDAP_OPT_DEBUG_LEVEL:
 392                 lo->ldo_debug = * (int *) invalue;
 393                 return 0;
 394
 395         default:
 396                 /* bad param */
 397                 break;
 398         }
 399         return -1;
 400 }