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