X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Foptions.c;h=ef19dfda61f273e2ea341c128f99b7863324a252;hb=64d5725662d33a168055df6db2ea06c366a1d0f1;hp=a4b5d8ae2b2bb043c25f6b76ba7589b2ca9ad714;hpb=2c06d0da0991ff2ea4d91b2b80bbb667df8ca9e1;p=openldap diff --git a/libraries/libldap/options.c b/libraries/libldap/options.c index a4b5d8ae2b..ef19dfda61 100644 --- a/libraries/libldap/options.c +++ b/libraries/libldap/options.c @@ -6,7 +6,8 @@ #include "portable.h" #include -#include + +#include #include #include @@ -14,70 +15,110 @@ #include "ldap-int.h" static const LDAPAPIFeatureInfo features[] = { -#ifdef LDAP_API_FEATURE_INFO - {"INFO", LDAP_API_FEATURE_INFO}, +#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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_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", LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS}, + { /* V2 Referrals */ + LDAP_FEATURE_INFO_VERSION, + "X_OPENLDAP_V2_REFERRALS", + LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS + }, #endif - {NULL, 0} + {0, NULL, 0} }; int ldap_get_option( - LDAP *ld, + LDAP_CONST LDAP *ld, int option, void *outvalue) { - struct ldapoptions *lo; - - if(!openldap_ldap_initialized) { - openldap_ldap_initialize(); - } + LDAP_CONST struct ldapoptions *lo; - 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; @@ -88,21 +129,21 @@ ldap_get_option( info->ldapai_extensions = NULL; } else { int i; - info->ldapai_extensions = malloc(sizeof(char *) * + info->ldapai_extensions = LDAP_MALLOC(sizeof(char *) * sizeof(features)/sizeof(LDAPAPIFeatureInfo)); for(i=0; features[i].ldapaif_name != NULL; i++) { info->ldapai_extensions[i] = - strdup(features[i].ldapaif_name); + LDAP_STRDUP(features[i].ldapaif_name); } info->ldapai_extensions[i] = NULL; } - info->ldapai_vendor_name = 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: @@ -111,32 +152,32 @@ ldap_get_option( break; } - * (int *) outvalue = lber_pvt_sb_get_desc( &(ld->ld_sb) ); - 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) { @@ -144,29 +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_server_controls ); + ldap_controls_dup( lo->ldo_sctrls ); - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_CLIENT_CONTROLS: * (LDAPControl ***) outvalue = - ldap_controls_dup( lo->ldo_client_controls ); + ldap_controls_dup( lo->ldo_cctrls ); - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_HOST_NAME: - /* - * draft-ietf-ldapext-ldap-c-api-01 doesn't state - * whether caller has to free host names or not, - * we do. - */ - - * (char **) outvalue = strdup(lo->ldo_defhost); - return 0; + * (char **) outvalue = LDAP_STRDUP(lo->ldo_defhost); + return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_NUMBER: if(ld == NULL) { @@ -174,7 +209,7 @@ ldap_get_option( break; } * (int *) outvalue = ld->ld_errno; - return 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_STRING: if(ld == NULL) { @@ -182,31 +217,47 @@ ldap_get_option( 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 = 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 0; + return LDAP_OPT_SUCCESS; case LDAP_OPT_API_FEATURE_INFO: { LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue; int i; - if(info == NULL) return -1; - if(info->ldapaif_name == NULL) return -1; + 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 0; + return LDAP_OPT_SUCCESS; } } } @@ -214,39 +265,64 @@ ldap_get_option( case LDAP_OPT_DEBUG_LEVEL: * (int *) outvalue = lo->ldo_debug; - return 0; + 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: @@ -255,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(invalue == 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(invalue == 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; @@ -288,57 +348,57 @@ ldap_set_option( break; } ld->ld_version = vers; - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_SERVER_CONTROLS: { LDAPControl **controls = (LDAPControl **) invalue; - ldap_controls_free( lo->ldo_server_controls ); + ldap_controls_free( lo->ldo_sctrls ); if( controls == NULL || *controls == NULL ) { - lo->ldo_server_controls = NULL; - return 0; + lo->ldo_sctrls = NULL; + return LDAP_OPT_SUCCESS; } - lo->ldo_server_controls = + lo->ldo_sctrls = ldap_controls_dup( (LDAPControl **) invalue ); - if(lo->ldo_server_controls == NULL) { + if(lo->ldo_sctrls == NULL) { /* memory allocation error ? */ break; } - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_CLIENT_CONTROLS: { LDAPControl **controls = (LDAPControl **) invalue; - ldap_controls_free( lo->ldo_client_controls ); + ldap_controls_free( lo->ldo_cctrls ); if( controls == NULL || *controls == NULL ) { - lo->ldo_client_controls = NULL; - return 0; + lo->ldo_cctrls = NULL; + return LDAP_OPT_SUCCESS; } - lo->ldo_client_controls = + lo->ldo_cctrls = ldap_controls_dup( (LDAPControl **) invalue ); - if(lo->ldo_client_controls == NULL) { + if(lo->ldo_cctrls == NULL) { /* memory allocation error ? */ break; } - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_HOST_NAME: { 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 = strdup(host); - return 0; + lo->ldo_defhost = LDAP_STRDUP(host); + return LDAP_OPT_SUCCESS; } if(ld == NULL) { @@ -346,17 +406,17 @@ ldap_set_option( * must want global default returned * to initial condition. */ - lo->ldo_defhost = strdup("localhost"); + lo->ldo_defhost = LDAP_STRDUP("localhost"); } else { /* * must want the session default * updated to the current global default */ - lo->ldo_defhost = 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; @@ -367,7 +427,7 @@ ldap_set_option( } ld->ld_errno = err; - } return 0; + } return LDAP_OPT_SUCCESS; case LDAP_OPT_ERROR_STRING: { char* err = (char *) invalue; @@ -378,11 +438,26 @@ ldap_set_option( } if( ld->ld_error ) { - free(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; + } + + if( ld->ld_matched ) { + LDAP_FREE(ld->ld_matched); } - ld->ld_error = strdup(err); - } return 0; + ld->ld_matched = LDAP_STRDUP(err); + } return LDAP_OPT_SUCCESS; case LDAP_OPT_API_FEATURE_INFO: /* read-only */ @@ -390,11 +465,11 @@ ldap_set_option( case LDAP_OPT_DEBUG_LEVEL: lo->ldo_debug = * (int *) invalue; - return 0; + return LDAP_OPT_SUCCESS; default: /* bad param */ break; } - return -1; + return LDAP_OPT_ERROR; }