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                 /* not yet supported */
 146                 break;
 147
 148         case LDAP_OPT_CLIENT_CONTROLS:
 149                 /* not yet supported */
 150                 break;
 151
 152         case LDAP_OPT_HOST_NAME:
 153                 /*
 154                  * draft-ietf-ldapext-ldap-c-api-01 doesn't state
 155                  * whether client to have to free host names or no,
 156                  * we do
 157                  */
 158
 159                 * (char **) outvalue = ldap_strdup(lo->ldo_defhost);
 160                 return 0;
 161
 162         case LDAP_OPT_ERROR_NUMBER:
 163                 if(ld == NULL) {
 164                         /* bad param */
 165                         break;
 166                 }
 167                 * (int *) outvalue = ld->ld_errno;
 168                 return 0;
 169
 170         case LDAP_OPT_ERROR_STRING:
 171                 if(ld == NULL) {
 172                         /* bad param */
 173                         break;
 174                 }
 175
 176                 /*
 177                  * draft-ietf-ldapext-ldap-c-api-01 doesn't require
 178                  *      the client to have to free error strings, we do
 179                  */
 180
 181                 if( ld->ld_error == NULL ) {
 182                         * (char **) outvalue = NULL;
 183                 } else {
 184                         * (char **) outvalue = ldap_strdup(ld->ld_error);
 185                 }
 186                 return 0;
 187
 188         case LDAP_OPT_API_FEATURE_INFO: {
 189                         LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
 190                         int i;
 191
 192                         if(info == NULL) return -1;
 193                         if(info->ldapaif_name == NULL) return -1;
 194
 195                         for(i=0; features[i].ldapaif_name != NULL; i++) {
 196                                 if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) {
 197                                         info->ldapaif_version =
 198                                                 features[i].ldapaif_version;
 199                                         return 0;
 200                                 }
 201                         }
 202                 }
 203                 break;
 204
 205         case LDAP_OPT_DEBUG_LEVEL:
 206                 * (int *) outvalue = lo->ldo_debug;
 207                 return 0;
 208
 209         default:
 210                 /* bad param */
 211                 break;
 212         }
 213
 214         return -1;
 215 }
 216
 217 int
 218 ldap_set_option(
 219         LDAP    *ld,
 220         int             option,
 221         void    *invalue)
 222 {
 223         struct ldapoptions *lo;
 224
 225         if(!openldap_ldap_initialized) {
 226                 openldap_ldap_initialize();
 227         }
 228
 229         if(invalue == NULL) {
 230                 /* no place to set from */
 231                 return -1;
 232         }
 233
 234         if(ld == NULL) {
 235                 lo = &openldap_ldap_global_options;
 236         } else {
 237                 lo = &ld->ld_options;
 238         }
 239
 240         switch(option) {
 241         case LDAP_OPT_API_INFO:
 242         case LDAP_OPT_DESC:
 243                 /* READ ONLY */
 244                 break;
 245
 246         case LDAP_OPT_DEREF:
 247                 lo->ldo_deref = * (int *) invalue;
 248                 return 0;
 249
 250         case LDAP_OPT_SIZELIMIT:
 251                 lo->ldo_sizelimit = * (int *) invalue;
 252                 return 0;
 253
 254         case LDAP_OPT_TIMELIMIT:
 255                 lo->ldo_timelimit = * (int *) invalue;
 256                 return 0;
 257
 258         case LDAP_OPT_REFERRALS:
 259                 if((int) invalue == (int) LDAP_OPT_ON) {
 260                         LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS);
 261                 } else {
 262                         LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS);
 263                 }
 264                 return 0;
 265
 266         case LDAP_OPT_RESTART:
 267                 if((int) invalue == (int) LDAP_OPT_ON) {
 268                         LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART);
 269                 } else {
 270                         LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART);
 271                 }
 272                 return 0;
 273
 274         case LDAP_OPT_PROTOCOL_VERSION: {
 275                         int vers = * (int *) invalue;
 276                         if (vers < LDAP_VERSION_MIN || vers > LDAP_VERSION_MAX) {
 277                                 /* not supported */
 278                                 break;
 279                         }
 280                         ld->ld_version = vers;
 281                 } return 0;
 282
 283         case LDAP_OPT_SERVER_CONTROLS: {
 284                         /* not yet supported */
 285                 } break;
 286
 287         case LDAP_OPT_CLIENT_CONTROLS: {
 288                         /* not yet supported */
 289                 } break;
 290
 291         case LDAP_OPT_HOST_NAME: {
 292                         char* host = (char *) invalue;
 293
 294                         if(lo->ldo_defhost != NULL) {
 295                                 free(lo->ldo_defhost);
 296                                 lo->ldo_defhost = NULL;
 297                         }
 298
 299                         if(host != NULL) {
 300                                 lo->ldo_defhost = ldap_strdup(host);
 301                                 return 0;
 302                         }
 303
 304                         if(ld == NULL) {
 305                                 /*
 306                                  * must want global default returned
 307                                  * to initial condition.
 308                                  */
 309                                 lo->ldo_defhost = ldap_strdup("localhost");
 310
 311                         } else {
 312                                 /*
 313                                  * must want the session default
 314                                  *   updated to the current global default
 315                                  */
 316                                 lo->ldo_defhost = ldap_strdup(
 317                                         openldap_ldap_global_options.ldo_defhost);
 318                         }
 319                 } return 0;
 320
 321         case LDAP_OPT_ERROR_NUMBER: {
 322                         int err = * (int *) invalue;
 323
 324                         if(ld == NULL) {
 325                                 /* need a struct ldap */
 326                                 break;
 327                         }
 328
 329                         ld->ld_errno = err;
 330                 } return 0;
 331
 332         case LDAP_OPT_ERROR_STRING: {
 333                         char* err = (char *) invalue;
 334
 335                         if(ld == NULL) {
 336                                 /* need a struct ldap */
 337                                 break;
 338                         }
 339
 340                         if( ld->ld_error ) {
 341                                 free(ld->ld_error);
 342                         }
 343
 344                         ld->ld_error = strdup(err);
 345                 } return 0;
 346
 347         case LDAP_OPT_API_FEATURE_INFO:
 348                 /* read-only */
 349                 break;
 350
 351         case LDAP_OPT_DEBUG_LEVEL:
 352                 lo->ldo_debug = * (int *) invalue;
 353                 return 0;
 354
 355         default:
 356                 /* bad param */
 357                 break;
 358         }
 359         return -1;
 360 }