libldapschema: adding initial support for matchingRules

8 files changed, 332 insertions, 8 deletions

diff --git a/lib/libldapschema/libldapschema.h b/lib/libldapschema/libldapschema.h
index 19fb624..ec47bbb 100644
--- a/lib/libldapschema/libldapschema.h
+++ b/lib/libldapschema/libldapschema.h
@@ -82,6 +82,8 @@ struct ldap_schema
    size_t                                 syntaxes_len;     ///< length of syntaxes array
    LDAPSchemaAlias                     ** attrs;            ///< array of attributeTypes
    size_t                                 attrs_len;        ///< length of attributeTypes array
+   LDAPSchemaAlias                     ** mtchngrls;        ///< array of objectClasses
+   size_t                                 mtchngrls_len;    ///< length of objectClasses array
    LDAPSchemaAlias                     ** objclses;         ///< array of objectClasses
    size_t                                 objclses_len;     ///< length of objectClasses array
    char                                ** schema_errs;      ///< list of schema errors discovered
@@ -148,6 +150,9 @@ struct ldap_schema_attributetype
    size_t                                 min_upper;
    LDAPSchemaAttributeType              * sup;
    char                                 * sup_name;
+   LDAPSchemaMatchingRule               * equality;
+   LDAPSchemaMatchingRule               * ordering;
+   LDAPSchemaMatchingRule               * substr;
    char                                ** names;
    LDAPSchemaObjectclass               ** allowed_by;
    LDAPSchemaObjectclass               ** required_by;
@@ -196,6 +201,11 @@ struct ldap_schema_syntax
 struct ldap_schema_matchingrule
 {
    LDAPSchemaModel                        model;
+   LDAPSchemaSyntax *                     syntax;
+   LDAPSchemaAttributeType **             used_by;
+   size_t                                 used_by_len;
+   char **                                names;
+   size_t                                 names_len;
 };
 
 
diff --git a/lib/libldapschema/lldap.c b/lib/libldapschema/lldap.c
index 1ee7777..edefb71 100644
--- a/lib/libldapschema/lldap.c
+++ b/lib/libldapschema/lldap.c
@@ -152,6 +152,22 @@ int ldapschema_fetch(LDAPSchema * lsd, LDAP * ld)
       ldap_value_free_len(vals);
    };
 
+   // process matchingRule
+   if ((vals = ldap_get_values_len(ld, msg, "matchingRules")) != NULL)
+   {
+      for(x = 0; ((vals[x])); x++)
+      {
+         if ( ((ptr = ldapschema_parse_matchingrule(lsd, vals[x])) == NULL) &&
+              (lsd->errcode != LDAPSCHEMA_SCHEMA_ERROR) )
+         {
+            ldap_value_free_len(vals);
+            ldap_msgfree(res);
+            return(-1);
+         };
+      };
+      ldap_value_free_len(vals);
+   };
+
    // process attributeTypes
    if ((vals = ldap_get_values_len(ld, msg, "attributeTypes")) != NULL)
    {
@@ -197,6 +213,12 @@ int ldapschema_fetch(LDAPSchema * lsd, LDAP * ld)
                attr->min_upper = attrsup->min_upper;
             if (!(attr->usage))
                attr->usage = attrsup->usage;
+            if (!(attr->equality))
+               attr->equality = attrsup->equality;
+            if (!(attr->ordering))
+               attr->ordering = attrsup->ordering;
+            if (!(attr->substr))
+               attr->substr = attrsup->substr;
          };
       };
    };
diff --git a/lib/libldapschema/llexer.c b/lib/libldapschema/llexer.c
index b009e6a..fa6439f 100644
--- a/lib/libldapschema/llexer.c
+++ b/lib/libldapschema/llexer.c
@@ -588,18 +588,24 @@ LDAPSchemaAttributeType * ldapschema_parse_attributetype(LDAPSchema * lsd, const
       else if (!(strcasecmp(argv[pos], "EQUALITY")))
       {
          pos++;
+         if ((alias = ldapschema_find_alias(lsd, argv[pos], lsd->mtchngrls, lsd->mtchngrls_len)) != NULL)
+            attr->equality = alias->matchingrule;
       }
 
       // inteprets attributeType ORDERING
       else if (!(strcasecmp(argv[pos], "ORDERING")))
       {
          pos++;
+         if ((alias = ldapschema_find_alias(lsd, argv[pos], lsd->mtchngrls, lsd->mtchngrls_len)) != NULL)
+            attr->ordering = alias->matchingrule;
       }
 
       // inteprets attributeType SUBSTR
       else if (!(strcasecmp(argv[pos], "SUBSTR")))
       {
          pos++;
+         if ((alias = ldapschema_find_alias(lsd, argv[pos], lsd->mtchngrls, lsd->mtchngrls_len)) != NULL)
+            attr->substr = alias->matchingrule;
       }
 
       // inteprets attributeType SYNTAX
@@ -732,6 +738,179 @@ int ldapschema_parse_ext(LDAPSchema * lsd, LDAPSchemaModel * model, const char *
 }
 
 
+/// parses a matching rule definition string
+/// @param[in]    lsd         Reference to pointer used to store allocated ldap_schema struct.
+/// @param[in]    def         Reference to pointer used to store allocated ldap_schema struct.
+///
+/// @return    If the definition was successfully parsed, an LDAPSchemaMatchingRule
+///            object is added to the schema returned. NULL is returned if
+///            an error was encountered.  Use ldapschema_errno() to obtain
+///            the error.
+/// @see       ldapschema_errno, ldapschema_syntax_free
+LDAPSchemaMatchingRule * ldapschema_parse_matchingrule(LDAPSchema * lsd, const struct berval * def)
+{
+   //
+   // RFC 4512                      LDAP Models                      June 2006
+   //
+   // 4.1.3.  Matching Rules
+   //
+   //    Matching rules are used in performance of attribute value assertions,
+   //    such as in performance of a Compare operation.  They are also used in
+   //    evaluating search filters, determining which individual values are to
+   //    be added or deleted during performance of a Modify operation, and in
+   //    comparing distinguished names.
+   //
+   //    Each matching rule is identified by an object identifier (OID) and,
+   //    optionally, one or more short names (descriptors).
+   //
+   //    Matching rule definitions are written according to the ABNF:
+   //
+   //      MatchingRuleDescription = LPAREN WSP
+   //          numericoid                 ; object identifier
+   //          [ SP "NAME" SP qdescrs ]   ; short names (descriptors)
+   //          [ SP "DESC" SP qdstring ]  ; description
+   //          [ SP "OBSOLETE" ]          ; not active
+   //          SP "SYNTAX" SP numericoid  ; assertion syntax
+   //          extensions WSP RPAREN      ; extensions
+   //
+   //    where:
+   //      <numericoid> is object identifier assigned to this matching rule;
+   //      NAME <qdescrs> are short names (descriptors) identifying this
+   //          matching rule;
+   //      DESC <qdstring> is a short descriptive string;
+   //      OBSOLETE indicates this matching rule is not active;
+   //      SYNTAX identifies the assertion syntax (the syntax of the assertion
+   //          value) by object identifier; and
+   //
+   char **                    argv;
+   int64_t                    pos;
+   int                        argc;
+   int                        err;
+   LDAPSchemaMatchingRule *   rule;
+   //LDAPSchemaSyntax *         syntax;
+
+
+   // parses definition
+   argv = NULL;
+   if ((argc = ldapschema_definition_split_len(lsd, NULL, def, &argv)) == -1)
+      return(NULL);
+
+   // initialize matchingRule
+   if ((rule = (LDAPSchemaMatchingRule *)ldapschema_model_initialize(lsd, argv[0], LDAPSCHEMA_MATCHINGRULE, def)) == NULL)
+   {
+      ldapschema_value_free(argv);
+      return(NULL);
+   };
+
+   // processes attribute definition
+   for(pos = 1; pos < argc; pos++)
+   {
+      // inteprets extensions
+      if (!(strncasecmp(argv[pos], "X-", 2)))
+      {
+         if ((err = ldapschema_parse_ext(lsd, &rule->model, argv[pos], argv[pos+1])))
+         {
+            ldapschema_matchingrule_free(rule);
+            ldapschema_value_free(argv);
+            return(NULL);
+         };
+         pos++;
+      }
+
+      // inteprets attributeType NAME
+      else if (!(strcasecmp(argv[pos], "NAME")))
+      {
+         pos++;
+         if (argv[pos][0] == '(')
+         {
+            if ((err = ldapschema_definition_split(lsd, &rule->model, argv[pos], strlen(argv[pos]), &rule->names)) == -1)
+            {
+               ldapschema_value_free(argv);
+               ldapschema_matchingrule_free(rule);
+               return(NULL);
+            };
+            rule->names_len = (size_t)ldapschema_count_values(rule->names);
+         }
+         else
+         {
+            if ((rule->names = malloc(sizeof(char *)*2)) == NULL)
+            {
+               lsd->errcode = LDAPSCHEMA_NO_MEMORY;
+               ldapschema_value_free(argv);
+               ldapschema_matchingrule_free(rule);
+               return(NULL);
+            };
+            rule->names[1]  = NULL;
+            rule->names_len = 1;
+            if ((rule->names[0] = strdup(argv[pos])) == NULL)
+            {
+               lsd->errcode = LDAPSCHEMA_NO_MEMORY;
+               ldapschema_value_free(argv);
+               ldapschema_matchingrule_free(rule);
+               return(NULL);
+            };
+         };
+      }
+
+      // inteprets syntax DESC
+      else if (!(strcasecmp(argv[pos], "DESC")))
+      {
+         pos++;
+         if (pos >= argc)
+         {
+            lsd->errcode = LDAPSCHEMA_SCHEMA_ERROR;
+            ldapschema_value_free(argv);
+            ldapschema_matchingrule_free(rule);
+            return(NULL);
+         };
+         if ((rule->model.desc))
+            free(rule->model.desc);
+         if ((rule->model.desc = strdup(argv[pos])) == NULL)
+         {
+            lsd->errcode = LDAPSCHEMA_NO_MEMORY;
+            ldapschema_value_free(argv);
+            ldapschema_matchingrule_free(rule);
+            return(NULL);
+         };
+      }
+
+      // inteprets matchingRule OBSOLETE
+      else if (!(strcasecmp(argv[pos], "OBSOLETE")))
+      {
+         rule->model.flags |= LDAPSCHEMA_O_OBSOLETE;
+      }
+
+      // inteprets attributeType SYNTAX
+      else if (!(strcasecmp(argv[pos], "SYNTAX")))
+      {
+         pos++;
+         rule->syntax = ldapschema_oid(lsd, argv[pos], LDAPSCHEMA_SYNTAX);
+      }
+
+      // handle unknown parameters
+      else
+      {
+         lsd->errcode = LDAPSCHEMA_SCHEMA_ERROR;
+         ldapschema_value_free(argv);
+         ldapschema_matchingrule_free(rule);
+         return(NULL);
+      };
+   };
+   ldapschema_value_free(argv);
+
+   // register matchingRule
+   if ((err = ldapschema_model_register(lsd, &rule->model)) != LDAP_SUCCESS)
+   {
+      ldapschema_matchingrule_free(rule);
+      return(NULL);
+   };
+
+
+   return(rule);
+}
+
+
+
 /// parses an LDAP objectClass definition string
 /// @param[in]    lsd         Reference to pointer used to store allocated ldap_schema struct.
 /// @param[in]    def         Reference to pointer used to store allocated ldap_schema struct.
diff --git a/lib/libldapschema/llexer.h b/lib/libldapschema/llexer.h
index 6f36b8d..c84a37a 100644
--- a/lib/libldapschema/llexer.h
+++ b/lib/libldapschema/llexer.h
@@ -96,6 +96,11 @@ ldapschema_parse_ext(
          const char            * key,
          const char            * valstr );
 
+LDAPSchemaMatchingRule *
+ldapschema_parse_matchingrule(
+         LDAPSchema *            lsd,
+         const struct berval *   def );
+
 LDAPSchemaObjectclass *
 ldapschema_parse_objectclass(
          LDAPSchema            * lsd,
diff --git a/lib/libldapschema/lmemory.c b/lib/libldapschema/lmemory.c
index b79143a..9eef1b3 100644
--- a/lib/libldapschema/lmemory.c
+++ b/lib/libldapschema/lmemory.c
@@ -220,6 +220,15 @@ void ldapschema_free(LDAPSchema * lsd)
    };
    lsd->attrs = NULL;
 
+   // frees matching rules list
+   if ((lsd->mtchngrls))
+   {
+      for(pos = 0; pos < lsd->mtchngrls_len; pos++)
+         free(lsd->mtchngrls[pos]);
+      free(lsd->mtchngrls);
+   };
+   lsd->mtchngrls = NULL;
+
    // frees objectclass list
    if ((lsd->objclses))
    {
@@ -391,6 +400,21 @@ int ldapschema_insert(LDAPSchema * lsd, void *** listp, size_t * lenp, void * ob
    return(LDAPSCHEMA_SUCCESS);
 }
 
+
+void ldapschema_matchingrule_free(LDAPSchemaMatchingRule * rule)
+{
+   assert(rule != NULL);
+
+   if ((rule->used_by))
+      free(rule->used_by);
+   ldapschema_object_free(&rule->model);
+
+   free(rule);
+
+   return;
+}
+
+
 void ldapschema_memfree(void * p)
 {
    if (!(p))
diff --git a/lib/libldapschema/lmemory.h b/lib/libldapschema/lmemory.h
index 639f21c..bacc476 100644
--- a/lib/libldapschema/lmemory.h
+++ b/lib/libldapschema/lmemory.h
@@ -73,6 +73,10 @@ LDAPSchemaCur
 ldapschema_curalloc(
          LDAPSchema            * lsd );
 
+void
+ldapschema_matchingrule_free(
+         LDAPSchemaMatchingRule *   rule);
+
 LDAPSchemaModel *
 ldapschema_model_initialize(
          LDAPSchema *               lsd,
diff --git a/lib/libldapschema/loutput.c b/lib/libldapschema/loutput.c
index 3a73952..a9831fd 100644
--- a/lib/libldapschema/loutput.c
+++ b/lib/libldapschema/loutput.c
@@ -124,6 +124,11 @@ ldapschema_print_obj_attributetype(
          LDAPSchemaAttributeType *  attr );
 
 void
+ldapschema_print_obj_matchingrule(
+         LDAPSchema *               lsd,
+         LDAPSchemaMatchingRule *   mtchngrl );
+
+void
 ldapschema_print_obj_model(
          LDAPSchema *               lsd,
          LDAPSchemaModel *          model );
@@ -167,6 +172,12 @@ void ldapschema_print( LDAPSchema * lsd, LDAPSchemaModel * mod )
       ldapschema_print_obj_attributetype(lsd, (LDAPSchemaAttributeType *)mod);
       return;
 
+      case LDAPSCHEMA_MATCHINGRULE:
+      if (mod->size != sizeof(LDAPSchemaMatchingRule))
+         return;
+      ldapschema_print_obj_matchingrule(lsd, (LDAPSchemaMatchingRule *)mod);
+      return;
+
       case LDAPSCHEMA_OBJECTCLASS:
       if (mod->size != sizeof(LDAPSchemaObjectclass))
          return;
@@ -432,6 +443,7 @@ void ldapschema_print_obj_attributetype( LDAPSchema * lsd, LDAPSchemaAttributeTy
    size_t                     flags;
    char                       buff[256];
    LDAPSchemaSyntax *         syntax;
+   LDAPSchemaMatchingRule *   mtchngrl;
 
    assert(lsd  != NULL);
    assert(attr != NULL);
@@ -461,6 +473,13 @@ void ldapschema_print_obj_attributetype( LDAPSchema * lsd, LDAPSchemaAttributeTy
 
    ldapschema_print_spec(lsd, attr->model.spec);
 
+   if ((mtchngrl = attr->equality) != NULL)
+      ldapschema_print_line("equality:", ((mtchngrl->names)) ? mtchngrl->names[0] : mtchngrl->model.oid);
+   if ((mtchngrl = attr->ordering) != NULL)
+      ldapschema_print_line("ordering:", ((mtchngrl->names)) ? mtchngrl->names[0] : mtchngrl->model.oid);
+   if ((mtchngrl = attr->substr) != NULL)
+      ldapschema_print_line("substr:", ((mtchngrl->names)) ? mtchngrl->names[0] : mtchngrl->model.oid);
+
    // print syntax information
    ldapschema_print_unsigned("min upper bound:", attr->min_upper);
    if ((syntax = attr->syntax)  != NULL)
@@ -489,6 +508,34 @@ void ldapschema_print_obj_attributetype( LDAPSchema * lsd, LDAPSchemaAttributeTy
 }
 
 
+void ldapschema_print_obj_matchingrule(LDAPSchema * lsd, LDAPSchemaMatchingRule * mtchngrl)
+{
+   char buff[256];
+
+   assert(lsd        != NULL);
+   assert(mtchngrl   != NULL);
+
+   ldapschema_print_type(lsd, &mtchngrl->model);
+   ldapschema_print_list("name(s):",     mtchngrl->names);
+   ldapschema_print_line("description:", mtchngrl->model.desc);
+   ldapschema_print_flags(lsd, &mtchngrl->model);
+
+   if ((mtchngrl->syntax))
+   {
+      if ((mtchngrl->syntax->model.desc))
+         snprintf(buff, sizeof(buff), "%s ( %s )", mtchngrl->syntax->model.oid, mtchngrl->syntax->model.desc);
+   else
+         snprintf(buff, sizeof(buff), "%s", mtchngrl->syntax->model.oid);
+      ldapschema_print_line("syntax:", buff);
+   };
+
+   ldapschema_print_extensions(lsd, &mtchngrl->model);
+   ldapschema_print_definition(lsd, &mtchngrl->model);
+
+   return;
+}
+
+
 void ldapschema_print_obj_model(LDAPSchema * lsd, LDAPSchemaModel * model)
 {
    assert(lsd   != NULL);
diff --git a/lib/libldapschema/lquery.c b/lib/libldapschema/lquery.c
index b898de2..27f2fa3 100644
--- a/lib/libldapschema/lquery.c
+++ b/lib/libldapschema/lquery.c
@@ -107,8 +107,14 @@ size_t ldapschema_count_ldapsyntaxes(LDAPSchema * lsd)
 
 size_t ldapschema_count_matchingrules(LDAPSchema * lsd)
 {
+   size_t idx;
+   size_t cnt;
    assert(lsd != NULL);
-   return(0);
+   cnt = 0;
+   for(idx = 0; (idx < lsd->oids_len); idx++)
+      if (lsd->oids[idx].model->type == LDAPSCHEMA_MATCHINGRULE)
+         cnt++;
+   return(cnt);
 }
 
 
@@ -223,9 +229,15 @@ LDAPSchemaSyntax * ldapschema_find_ldapsyntax(LDAPSchema * lsd,
 LDAPSchemaMatchingRule * ldapschema_find_matchingrule(LDAPSchema * lsd,
    const char * name)
 {
+   const LDAPSchemaAlias   * alias;
+
    assert(lsd     != NULL);
    assert(name    != NULL);
-   return(NULL);
+
+   if ((alias = ldapschema_find_alias(lsd, name, lsd->mtchngrls, lsd->mtchngrls_len)) == NULL)
+      return(NULL);
+
+   return(alias->matchingrule);
 }
 
 
@@ -301,6 +313,10 @@ const LDAPSchemaMatchingRule * ldapschema_first_matchingrule(LDAPSchema * lsd,
       return(NULL);
    *curp = cur;
 
+   for(cur->cursor = 0; (cur->cursor < lsd->oids_len); cur->cursor++)
+      if (lsd->oids[cur->cursor].model->type == LDAPSCHEMA_MATCHINGRULE)
+         return(lsd->oids[cur->cursor].matchingrule);
+
    return(NULL);
 }
 
@@ -378,13 +394,30 @@ int ldapschema_get_info_ldapsyntax(LDAPSchema * lsd,
 
 
 int ldapschema_get_info_matchingrule(LDAPSchema * lsd,
-   const LDAPSchemaMatchingRule * matchingrule, int field, void * outvalue )
+   const LDAPSchemaMatchingRule * mtchngrl, int field, void * outvalue )
 {
-   assert(lsd           != NULL);
-   assert(matchingrule  != NULL);
-   assert(field         != 0);
-   assert(outvalue      != 0);
-   return(ldapschema_get_info_model(lsd, &matchingrule->model, field, outvalue));
+   char    *** oa;   // output char ** (array of strings)
+
+   assert(lsd        != NULL);
+   assert(mtchngrl   != NULL);
+   assert(field      != 0);
+   assert(outvalue   != 0);
+
+   oa = outvalue;
+
+   switch(field)
+   {
+      // char ** values (arrays of strings)
+      case LDAPSCHEMA_FLD_NAME:  if ((*oa = ldapschema_value_dup(mtchngrl->names)) == NULL) return(LDAPSCHEMA_NO_MEMORY); return(0);
+
+      // misc
+      case LDAPSCHEMA_FLD_SYNTAX: *(LDAPSchemaSyntax **)outvalue = mtchngrl->syntax; return(0);
+
+      default:
+      break;
+   };
+
+   return(ldapschema_get_info_model(lsd, &mtchngrl->model, field, outvalue));
 }