Added the functions ldap_rename2() and ldap_rename2_s() to support LDAP

[openldap] / libraries / libldap / options.c

diff --git a/libraries/libldap/options.c b/libraries/libldap/options.c
index 182e7df67d0a45a9e45eeb42525e58a584557147..7bc03b141dcc389ff7db875906e0a5221cc204b8 100644 (file)
--- a/libraries/libldap/options.c
+++ b/libraries/libldap/options.c
@@ -1,3 +1,8 @@
+/*
+ * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+ */
+
 #include "portable.h"
 
 #include <stdio.h>
@@ -8,14 +13,33 @@
 
 #include "ldap-int.h"
 
-static const char* features[] = {
+static const LDAPAPIFeatureInfo features[] = {
+#ifdef LDAP_API_FEATURE_INFO
+       {"INFO", LDAP_API_FEATURE_INFO},
+#endif
+#ifdef LDAP_API_FEATURE_THREAD_SAFE
+       {"THREAD_SAFE", LDAP_API_FEATURE_THREAD_SAFE},
+#endif
+#ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE
+       {"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},
+#endif
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_REEENTRANT
+       {"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},
+#endif
 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
-       "X_OPENLDAP_V2_DNS",
+       {"X_OPENLDAP_V2_DNS", LDAP_API_FEATURE_X_OPENLDAP_V2_DNS},
 #endif
 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
-       "X_OPENLDAP_V2_REFERRALS",
+       {"X_OPENLDAP_V2_REFERRALS", LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS},
 #endif
-       NULL
+       {NULL, 0}
 };
 
 int
@@ -59,14 +83,17 @@ ldap_get_option(
                        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 = malloc(sizeof(char *) *
+                                       sizeof(features)/sizeof(LDAPAPIFeatureInfo));
 
-                               for(i=0; features[i] != NULL; i++) {
-                                       info->ldapai_extensions[i] = strdup(features[i]);
+                               for(i=0; features[i].ldapaif_name != NULL; i++) {
+                                       info->ldapai_extensions[i] =
+                                               strdup(features[i].ldapaif_name);
                                }
 
                                info->ldapai_extensions[i] = NULL;
@@ -84,7 +111,7 @@ ldap_get_option(
                        break;
                } 
 
-               * (int *) outvalue = ld->ld_sb.sb_sd;
+               * (int *) outvalue = lber_pvt_sb_get_desc( &(ld->ld_sb) );
                return 0;
 
        case LDAP_OPT_DEREF:
@@ -120,15 +147,22 @@ ldap_get_option(
                return 0;
 
        case LDAP_OPT_SERVER_CONTROLS:
+               * (LDAPControl ***) outvalue =
+                       ldap_controls_dup( lo->ldo_server_controls );
+
+               return 0;
+
        case LDAP_OPT_CLIENT_CONTROLS:
-               /* not yet supported */
-               break;
+               * (LDAPControl ***) outvalue =
+                       ldap_controls_dup( lo->ldo_client_controls );
+
+               return 0;
 
        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
+                * whether caller has to free host names or not,
+                * we do.
                 */
 
                * (char **) outvalue = strdup(lo->ldo_defhost);
@@ -143,7 +177,6 @@ ldap_get_option(
                return 0;
 
        case LDAP_OPT_ERROR_STRING:
-               /* not yet supported */
                if(ld == NULL) {
                        /* bad param */
                        break;
@@ -159,8 +192,30 @@ ldap_get_option(
                } else {
                        * (char **) outvalue = strdup(ld->ld_error);
                }
+
+               return 0;
+
+       case LDAP_OPT_API_FEATURE_INFO: {
+                       LDAPAPIFeatureInfo *info = (LDAPAPIFeatureInfo *) outvalue;
+                       int i;
+
+                       if(info == NULL) return -1;
+                       if(info->ldapaif_name == NULL) return -1;
+
+                       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;
+                               }
+                       }
+               }
                break;
 
+       case LDAP_OPT_DEBUG_LEVEL:
+               * (int *) outvalue = lo->ldo_debug;
+               return 0;
+
        default:
                /* bad param */
                break;
@@ -235,13 +290,46 @@ ldap_set_option(
                        ld->ld_version = vers;
                } return 0;
 
-       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_server_controls );
+
+                       if( controls == NULL || *controls == NULL ) {
+                               lo->ldo_server_controls = NULL;
+                               return 0;
+                       }
+                               
+                       lo->ldo_server_controls =
+                               ldap_controls_dup( (LDAPControl **) invalue );
+
+                       if(lo->ldo_server_controls == NULL) {
+                               /* memory allocation error ? */
+                               break;
+                       }
+               } return 0;
+
+       case LDAP_OPT_CLIENT_CONTROLS: {
+                       LDAPControl **controls = (LDAPControl **) invalue;
+
+                       ldap_controls_free( lo->ldo_client_controls );
+
+                       if( controls == NULL || *controls == NULL ) {
+                               lo->ldo_client_controls = NULL;
+                               return 0;
+                       }
+                               
+                       lo->ldo_client_controls =
+                               ldap_controls_dup( (LDAPControl **) invalue );
+
+                       if(lo->ldo_client_controls == NULL) {
+                               /* memory allocation error ? */
+                               break;
+                       }
+               } return 0;
 
        case LDAP_OPT_HOST_NAME: {
-                       char* host = * (char **) invalue;
+                       char* host = (char *) invalue;
 
                        if(lo->ldo_defhost != NULL) {
                                free(lo->ldo_defhost);
@@ -273,12 +361,6 @@ ldap_set_option(
        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;
@@ -288,22 +370,28 @@ ldap_set_option(
                } return 0;
 
        case LDAP_OPT_ERROR_STRING: {
-                       char* err = * (char **) invalue;
-
-                       if (err != NULL ) {
-                               /* not supported */
-                               /* we only allow ld_error to be cleared. */
-                               break;
-                       }
+                       char* err = (char *) invalue;
 
                        if(ld == NULL) {
                                /* need a struct ldap */
                                break;
                        }
 
-                       ld->ld_error = err;
+                       if( ld->ld_error ) {
+                               free(ld->ld_error);
+                       }
+
+                       ld->ld_error = strdup(err);
                } return 0;
 
+       case LDAP_OPT_API_FEATURE_INFO:
+               /* read-only */
+               break;
+
+       case LDAP_OPT_DEBUG_LEVEL:
+               lo->ldo_debug = * (int *) invalue;
+               return 0;
+
        default:
                /* bad param */
                break;