X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Foptions.c;h=ef19dfda61f273e2ea341c128f99b7863324a252;hb=64d5725662d33a168055df6db2ea06c366a1d0f1;hp=c595972bc2c415bc427efd1d67402d5ad825cd7d;hpb=8aba5c5059645e657016eee3d3d68e1c67b99b13;p=openldap diff --git a/libraries/libldap/options.c b/libraries/libldap/options.c index c595972bc2..ef19dfda61 100644 --- a/libraries/libldap/options.c +++ b/libraries/libldap/options.c @@ -1,98 +1,149 @@ +/* + * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ + #include "portable.h" #include -#include + +#include #include #include #include "ldap-int.h" -static const char* features[] = { +static const LDAPAPIFeatureInfo features[] = { +#ifdef LDAP_API_FEATURE_X_OPENLDAP + { /* OpenLDAP Extensions API Feature */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP", + LDAP_API_FEATURE_X_OPENLDAP + }, +#endif + #ifdef LDAP_API_FEATURE_THREAD_SAFE - "THREAD_SAFE", + { /* Basic Thread Safe */ + LDAP_FEATURE_INFO_VERSION, + "THREAD_SAFE", + LDAP_API_FEATURE_THREAD_SAFE + }, #endif #ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE - "SESSION_THREAD_SAFE", + { /* Session Thread Safe */ + LDAP_FEATURE_INFO_VERSION, + "SESSION_THREAD_SAFE", + LDAP_API_FEATURE_SESSION_THREAD_SAFE + }, #endif #ifdef LDAP_API_FEATURE_OPERATION_THREAD_SAFE - "OPERATION_THREAD_SAFE", + { /* Operation Thread Safe */ + LDAP_FEATURE_INFO_VERSION, + "OPERATION_THREAD_SAFE", + LDAP_API_FEATURE_OPERATION_THREAD_SAFE + }, #endif -#ifdef LDAP_API_FEATURE_X_OPENLDAP_REEENTRANT - "X_OPENLDAP_REENTRANT", +#ifdef LDAP_API_FEATURE_X_OPENLDAP_REENTRANT + { /* OpenLDAP Reentrant */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP_REENTRANT", + LDAP_API_FEATURE_X_OPENLDAP_REENTRANT + }, #endif #if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) && \ defined( LDAP_THREAD_SAFE ) - "X_OPENLDAP_THREAD_SAFE", + { /* OpenLDAP Thread Safe */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP_THREAD_SAFE", + LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE + }, #endif #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS - "X_OPENLDAP_V2_DNS", + { /* DNS */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP_V2_DNS", + LDAP_API_FEATURE_X_OPENLDAP_V2_DNS + }, #endif #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS - "X_OPENLDAP_V2_REFERRALS", + { /* V2 Referrals */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP_V2_REFERRALS", + LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS + }, #endif - NULL + {0, NULL, 0} }; int ldap_get_option( - LDAP *ld, + LDAP_CONST LDAP *ld, int option, void *outvalue) { - struct ldapoptions *lo; + LDAP_CONST struct ldapoptions *lo; - if(!openldap_ldap_initialized) { - openldap_ldap_initialize(); - } - - if(outvalue == NULL) { - /* no place to get to */ - return -1; + if( ldap_int_global_options.ldo_valid != LDAP_INITIALIZED ) { + ldap_int_initialize(); } if(ld == NULL) { - lo = &openldap_ldap_global_options; + lo = &ldap_int_global_options; + } else { + assert( LDAP_VALID( ld ) ); + + if( !LDAP_VALID( ld ) ) { + return LDAP_OPT_ERROR; + } + lo = &ld->ld_options; } + if(outvalue == NULL) { + /* no place to get to */ + return LDAP_OPT_ERROR; + } + switch(option) { case LDAP_OPT_API_INFO: { struct ldapapiinfo *info = (struct ldapapiinfo *) outvalue; if(info == NULL) { /* outvalue must point to an apiinfo structure */ - return -1; + return LDAP_OPT_ERROR; } if(info->ldapai_info_version != LDAP_API_INFO_VERSION) { /* api info version mismatch */ info->ldapai_info_version = LDAP_API_INFO_VERSION; - return -1; + return LDAP_OPT_ERROR; } info->ldapai_api_version = LDAP_API_VERSION; info->ldapai_api_version = LDAP_API_VERSION; info->ldapai_protocol_version = LDAP_VERSION_MAX; - if(features[0] == NULL) { + + if(features[0].ldapaif_name == NULL) { info->ldapai_extensions = NULL; } else { int i; - info->ldapai_extensions = malloc(sizeof(features)); + info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) * + sizeof(features)/sizeof(LDAPAPIFeatureInfo)); - for(i=0; features[i] != NULL; i++) { + for(i=0; features[i].ldapaif_name != NULL; i++) { info->ldapai_extensions[i] = - ldap_strdup(features[i]); + LDAP_STRDUP(features[i].ldapaif_name); } info->ldapai_extensions[i] = NULL; } - info->ldapai_vendor_name = ldap_strdup(LDAP_VENDOR_NAME); + info->ldapai_vendor_name = LDAP_STRDUP(LDAP_VENDOR_NAME); info->ldapai_vendor_version = LDAP_VENDOR_VERSION; - return 0; + return LDAP_OPT_SUCCESS; } break; case LDAP_OPT_DESC: @@ -101,32 +152,32 @@ ldap_get_option( break; } - * (int *) outvalue = ld->ld_sb.sb_sd; - return 0; + * (ber_socket_t *) outvalue = ber_pvt_sb_get_desc( &(ld->ld_sb) ); + return LDAP_OPT_SUCCESS; case LDAP_OPT_DEREF: * (int *) outvalue = lo->ldo_deref; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_SIZELIMIT: * (int *) outvalue = lo->ldo_sizelimit; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_TIMELIMIT: * (int *) outvalue = lo->ldo_timelimit; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_REFERRALS: * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_REFERRALS); - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_RESTART: * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_RESTART); - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_DNS: /* LDAPv2 */ * (int *) outvalue = (int) LDAP_BOOL_GET(lo, LDAP_BOOL_DNS); - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_PROTOCOL_VERSION: if ((ld != NULL) && ld->ld_version) { @@ -134,22 +185,23 @@ ldap_get_option( } else { * (int *) outvalue = lo->ldo_version; } - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_SERVER_CONTROLS: + * (LDAPControl ***) outvalue = + ldap_controls_dup( lo->ldo_sctrls ); + + return LDAP_OPT_SUCCESS; + case LDAP_OPT_CLIENT_CONTROLS: - /* not yet supported */ - break; + * (LDAPControl ***) outvalue = + ldap_controls_dup( lo->ldo_cctrls ); - case LDAP_OPT_HOST_NAME: - /* - * draft-ietf-ldapext-ldap-c-api-01 doesn't state - * whether client to have to free host names or no, - * we do - */ + return LDAP_OPT_SUCCESS; - * (char **) outvalue = ldap_strdup(lo->ldo_defhost); - return 0; + case LDAP_OPT_HOST_NAME: + * (char **) outvalue = LDAP_STRDUP(lo->ldo_defhost); + return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_NUMBER: if(ld == NULL) { @@ -157,58 +209,120 @@ ldap_get_option( break; } * (int *) outvalue = ld->ld_errno; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_STRING: - /* not yet supported */ if(ld == NULL) { /* bad param */ break; } - /* - * draft-ietf-ldapext-ldap-c-api-01 doesn't require - * the client to have to free error strings, we do - */ - if( ld->ld_error == NULL ) { * (char **) outvalue = NULL; } else { - * (char **) outvalue = ldap_strdup(ld->ld_error); + * (char **) outvalue = LDAP_STRDUP(ld->ld_error); + } + + return LDAP_OPT_SUCCESS; + + case LDAP_OPT_MATCHED_DN: + if(ld == NULL) { + /* bad param */ + break; + } + + if( ld->ld_matched == NULL ) { + * (char **) outvalue = NULL; + } else { + * (char **) outvalue = LDAP_STRDUP(ld->ld_matched); + } + + return LDAP_OPT_SUCCESS; + + case LDAP_OPT_API_FEATURE_INFO: { + LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue; + int i; + + if(info == NULL) return LDAP_OPT_ERROR; + + if(info->ldapaif_info_version != LDAP_FEATURE_INFO_VERSION) { + /* api info version mismatch */ + info->ldapaif_info_version = LDAP_FEATURE_INFO_VERSION; + return LDAP_OPT_ERROR; + } + + if(info->ldapaif_name == NULL) return LDAP_OPT_ERROR; + + for(i=0; features[i].ldapaif_name != NULL; i++) { + if(!strcmp(info->ldapaif_name, features[i].ldapaif_name)) { + info->ldapaif_version = + features[i].ldapaif_version; + return LDAP_OPT_SUCCESS; + } + } } break; + case LDAP_OPT_DEBUG_LEVEL: + * (int *) outvalue = lo->ldo_debug; + return LDAP_OPT_SUCCESS; + default: /* bad param */ break; } - return -1; + return LDAP_OPT_ERROR; } int ldap_set_option( LDAP *ld, int option, - void *invalue) + LDAP_CONST void *invalue) { struct ldapoptions *lo; - if(!openldap_ldap_initialized) { - openldap_ldap_initialize(); - } - - if(invalue == NULL) { - /* no place to set from */ - return -1; + if( ldap_int_global_options.ldo_valid != LDAP_INITIALIZED ) { + ldap_int_initialize(); } if(ld == NULL) { - lo = &openldap_ldap_global_options; + lo = &ldap_int_global_options; + } else { + assert( LDAP_VALID( ld ) ); + + if( !LDAP_VALID( ld ) ) { + return LDAP_OPT_ERROR; + } + lo = &ld->ld_options; } + switch(option) { + case LDAP_OPT_REFERRALS: + if(invalue == LDAP_OPT_OFF) { + LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS); + } else { + LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS); + } + return LDAP_OPT_SUCCESS; + + case LDAP_OPT_RESTART: + if(invalue == LDAP_OPT_OFF) { + LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART); + } else { + LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART); + } + return LDAP_OPT_SUCCESS; + } + + if(invalue == NULL) { + /* no place to set from */ + return LDAP_OPT_ERROR; + } + switch(option) { case LDAP_OPT_API_INFO: case LDAP_OPT_DESC: @@ -217,31 +331,15 @@ ldap_set_option( case LDAP_OPT_DEREF: lo->ldo_deref = * (int *) invalue; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_SIZELIMIT: lo->ldo_sizelimit = * (int *) invalue; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_TIMELIMIT: lo->ldo_timelimit = * (int *) invalue; - return 0; - - case LDAP_OPT_REFERRALS: - if((int) invalue == (int) LDAP_OPT_ON) { - LDAP_BOOL_SET(lo, LDAP_BOOL_REFERRALS); - } else { - LDAP_BOOL_CLR(lo, LDAP_BOOL_REFERRALS); - } - return 0; - - case LDAP_OPT_RESTART: - if((int) invalue == (int) LDAP_OPT_ON) { - LDAP_BOOL_SET(lo, LDAP_BOOL_RESTART); - } else { - LDAP_BOOL_CLR(lo, LDAP_BOOL_RESTART); - } - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_PROTOCOL_VERSION: { int vers = * (int *) invalue; @@ -250,24 +348,57 @@ ldap_set_option( break; } ld->ld_version = vers; - } return 0; + } return LDAP_OPT_SUCCESS; - case LDAP_OPT_SERVER_CONTROLS: - case LDAP_OPT_CLIENT_CONTROLS: - /* not yet supported */ - break; + case LDAP_OPT_SERVER_CONTROLS: { + LDAPControl **controls = (LDAPControl **) invalue; + + ldap_controls_free( lo->ldo_sctrls ); + + if( controls == NULL || *controls == NULL ) { + lo->ldo_sctrls = NULL; + return LDAP_OPT_SUCCESS; + } + + lo->ldo_sctrls = + ldap_controls_dup( (LDAPControl **) invalue ); + + if(lo->ldo_sctrls == NULL) { + /* memory allocation error ? */ + break; + } + } return LDAP_OPT_SUCCESS; + + case LDAP_OPT_CLIENT_CONTROLS: { + LDAPControl **controls = (LDAPControl **) invalue; + + ldap_controls_free( lo->ldo_cctrls ); + + if( controls == NULL || *controls == NULL ) { + lo->ldo_cctrls = NULL; + return LDAP_OPT_SUCCESS; + } + + lo->ldo_cctrls = + ldap_controls_dup( (LDAPControl **) invalue ); + + if(lo->ldo_cctrls == NULL) { + /* memory allocation error ? */ + break; + } + } return LDAP_OPT_SUCCESS; case LDAP_OPT_HOST_NAME: { - char* host = * (char **) invalue; + char* host = (char *) invalue; if(lo->ldo_defhost != NULL) { - free(lo->ldo_defhost); + LDAP_FREE(lo->ldo_defhost); lo->ldo_defhost = NULL; } if(host != NULL) { - lo->ldo_defhost = ldap_strdup(host); - return 0; + lo->ldo_defhost = LDAP_STRDUP(host); + return LDAP_OPT_SUCCESS; } if(ld == NULL) { @@ -275,55 +406,70 @@ ldap_set_option( * must want global default returned * to initial condition. */ - lo->ldo_defhost = ldap_strdup("localhost"); + lo->ldo_defhost = LDAP_STRDUP("localhost"); } else { /* * must want the session default * updated to the current global default */ - lo->ldo_defhost = ldap_strdup( - openldap_ldap_global_options.ldo_defhost); + lo->ldo_defhost = LDAP_STRDUP( + ldap_int_global_options.ldo_defhost); } - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_NUMBER: { int err = * (int *) invalue; - if (err != 0 ) { - /* not supported */ - /* we only allow ld_errno to be cleared. */ - break; - } - if(ld == NULL) { /* need a struct ldap */ break; } ld->ld_errno = err; - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_STRING: { - char* err = * (char **) invalue; + char* err = (char *) invalue; - if (err != NULL ) { - /* not supported */ - /* we only allow ld_error to be cleared. */ + if(ld == NULL) { + /* need a struct ldap */ break; } + if( ld->ld_error ) { + LDAP_FREE(ld->ld_error); + } + + ld->ld_error = LDAP_STRDUP(err); + } return LDAP_OPT_SUCCESS; + + case LDAP_OPT_MATCHED_DN: { + char* err = (char *) invalue; + if(ld == NULL) { /* need a struct ldap */ break; } - ld->ld_error = err; - } return 0; + if( ld->ld_matched ) { + LDAP_FREE(ld->ld_matched); + } + + ld->ld_matched = LDAP_STRDUP(err); + } return LDAP_OPT_SUCCESS; + + case LDAP_OPT_API_FEATURE_INFO: + /* read-only */ + break; + + case LDAP_OPT_DEBUG_LEVEL: + lo->ldo_debug = * (int *) invalue; + return LDAP_OPT_SUCCESS; default: /* bad param */ break; } - return -1; + return LDAP_OPT_ERROR; }