LDAP C-API changes

[openldap] / libraries / libldap / options.c

diff --git a/libraries/libldap/options.c b/libraries/libldap/options.c
index b52e95cc7866cd9e9e21b39f1a82359fc757e376..c595972bc2c415bc427efd1d67402d5ad825cd7d 100644 (file)
--- a/libraries/libldap/options.c
+++ b/libraries/libldap/options.c
@@ -8,6 +8,32 @@
 
 #include "ldap-int.h"
 
+static const char* features[] = {
+#ifdef LDAP_API_FEATURE_THREAD_SAFE
+       "THREAD_SAFE",
+#endif
+#ifdef LDAP_API_FEATURE_SESSION_THREAD_SAFE
+       "SESSION_THREAD_SAFE",
+#endif
+#ifdef LDAP_API_FEATURE_OPERATION_THREAD_SAFE
+       "OPERATION_THREAD_SAFE",
+#endif
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_REEENTRANT
+       "X_OPENLDAP_REENTRANT",
+#endif
+#if defined( LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE ) && \
+       defined( LDAP_THREAD_SAFE )
+       "X_OPENLDAP_THREAD_SAFE",
+#endif
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_DNS
+       "X_OPENLDAP_V2_DNS",
+#endif
+#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS
+       "X_OPENLDAP_V2_REFERRALS",
+#endif
+       NULL
+};
+
 int
 ldap_get_option(
        LDAP    *ld,
@@ -49,8 +75,21 @@ ldap_get_option(
                        info->ldapai_api_version = LDAP_API_VERSION;
                        info->ldapai_api_version = LDAP_API_VERSION;
                        info->ldapai_protocol_version = LDAP_VERSION_MAX;
-                       info->ldapai_extensions = NULL;
-                       info->ldapai_vendor_name = strdup(LDAP_VENDOR_NAME);
+                       if(features[0] == NULL) {
+                               info->ldapai_extensions = NULL;
+                       } else {
+                               int i;
+                               info->ldapai_extensions = malloc(sizeof(features));
+
+                               for(i=0; features[i] != NULL; i++) {
+                                       info->ldapai_extensions[i] =
+                                               ldap_strdup(features[i]);
+                               }
+
+                               info->ldapai_extensions[i] = NULL;
+                       }
+
+                       info->ldapai_vendor_name = ldap_strdup(LDAP_VENDOR_NAME);
                        info->ldapai_vendor_version = LDAP_VENDOR_VERSION;
 
                        return 0;
@@ -90,12 +129,11 @@ ldap_get_option(
                return 0;
 
        case LDAP_OPT_PROTOCOL_VERSION:
-               if(ld == NULL) {
-                       /* bad param */
-                       break;
-               } 
-
-               * (int *) outvalue = ld->ld_version;
+               if ((ld != NULL) && ld->ld_version) {
+                       * (int *) outvalue = ld->ld_version;
+               } else { 
+                       * (int *) outvalue = lo->ldo_version;
+               }
                return 0;
 
        case LDAP_OPT_SERVER_CONTROLS:
@@ -104,11 +142,13 @@ ldap_get_option(
                break;
 
        case LDAP_OPT_HOST_NAME:
-               if(ld == NULL) {
-                       /* bad param */
-                       break;
-               } 
-               * (char **) outvalue = ld->ld_host;
+               /*
+                * draft-ietf-ldapext-ldap-c-api-01 doesn't state
+                * whether client to have to free host names or no,
+                * we do
+                */
+
+               * (char **) outvalue = ldap_strdup(lo->ldo_defhost);
                return 0;
 
        case LDAP_OPT_ERROR_NUMBER:
@@ -125,6 +165,17 @@ ldap_get_option(
                        /* 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);
+               }
                break;
 
        default:
@@ -203,11 +254,73 @@ ldap_set_option(
 
        case LDAP_OPT_SERVER_CONTROLS:
        case LDAP_OPT_CLIENT_CONTROLS:
-       case LDAP_OPT_HOST_NAME:
-       case LDAP_OPT_ERROR_NUMBER:
-       case LDAP_OPT_ERROR_STRING:
                /* not yet supported */
                break;
+
+       case LDAP_OPT_HOST_NAME: {
+                       char* host = * (char **) invalue;
+
+                       if(lo->ldo_defhost != NULL) {
+                               free(lo->ldo_defhost);
+                               lo->ldo_defhost = NULL;
+                       }
+
+                       if(host != NULL) {
+                               lo->ldo_defhost = ldap_strdup(host);
+                               return 0;
+                       }
+
+                       if(ld == NULL) {
+                               /*
+                                * must want global default returned
+                                * to initial condition.
+                                */
+                               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);
+                       }
+               } return 0;
+
+       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;
+
+       case LDAP_OPT_ERROR_STRING: {
+                       char* err = * (char **) invalue;
+
+                       if (err != NULL ) {
+                               /* not supported */
+                               /* we only allow ld_error to be cleared. */
+                               break;
+                       }
+
+                       if(ld == NULL) {
+                               /* need a struct ldap */
+                               break;
+                       }
+
+                       ld->ld_error = err;
+               } return 0;
+
        default:
                /* bad param */
                break;