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

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