We'll need queue macros in -llber...

[openldap] / libraries / libldap / schema.c

diff --git a/libraries/libldap/schema.c b/libraries/libldap/schema.c
index dac2eb267ba43d5bad32fe35a07dd0747db48398..e77f063328b2661e66d06457c143c1d2988c4772 100644 (file)
--- a/libraries/libldap/schema.c
+++ b/libraries/libldap/schema.c
@@ -110,6 +110,17 @@ safe_string_val(safe_string * ss)
        return(ss->val);
 }
 
+static char *
+safe_strdup(safe_string * ss)
+{
+       char *ret = LDAP_MALLOC(ss->pos+1);
+       if (!ret)
+               return NULL;
+       AC_MEMCPY(ret, ss->val, ss->pos);
+       ret[ss->pos] = '\0';
+       return ret;
+}
+
 static int
 append_to_safe_string(safe_string * ss, char * s)
 {
@@ -297,9 +308,18 @@ print_extensions(safe_string *ss, LDAPSchemaExtensionItem **extensions)
 
 char *
 ldap_syntax2str( LDAPSyntax * syn )
+{
+       struct berval bv;
+       if (ldap_syntax2bv( syn, &bv ))
+               return(bv.bv_val);
+       else
+               return NULL;
+}
+
+struct berval *
+ldap_syntax2bv( LDAPSyntax * syn, struct berval *bv )
 {
        safe_string * ss;
-       char * retstring;
        
        ss = new_safe_string(256);
        if ( !ss )
@@ -322,16 +342,26 @@ ldap_syntax2str( LDAPSyntax * syn )
 
        print_literal(ss,/*(*/ ")");
 
-       retstring = LDAP_STRDUP(safe_string_val(ss));
+       bv->bv_val = safe_strdup(ss);
+       bv->bv_len = ss->pos;
        safe_string_free(ss);
-       return(retstring);
+       return(bv);
 }
 
 char *
 ldap_matchingrule2str( LDAPMatchingRule * mr )
+{
+       struct berval bv;
+       if (ldap_matchingrule2bv( mr, &bv ))
+               return(bv.bv_val);
+       else
+               return NULL;
+}
+
+struct berval *
+ldap_matchingrule2bv( LDAPMatchingRule * mr, struct berval *bv )
 {
        safe_string * ss;
-       char * retstring;
        
        ss = new_safe_string(256);
        if ( !ss )
@@ -371,16 +401,26 @@ ldap_matchingrule2str( LDAPMatchingRule * mr )
 
        print_literal(ss,/*(*/")");
 
-       retstring = LDAP_STRDUP(safe_string_val(ss));
+       bv->bv_val = safe_strdup(ss);
+       bv->bv_len = ss->pos;
        safe_string_free(ss);
-       return(retstring);
+       return(bv);
 }
 
 char *
 ldap_matchingruleuse2str( LDAPMatchingRuleUse * mru )
+{
+       struct berval bv;
+       if (ldap_matchingruleuse2bv( mru, &bv ))
+               return(bv.bv_val);
+       else
+               return NULL;
+}
+
+struct berval *
+ldap_matchingruleuse2bv( LDAPMatchingRuleUse * mru, struct berval *bv )
 {
        safe_string * ss;
-       char * retstring;
        
        ss = new_safe_string(256);
        if ( !ss )
@@ -420,16 +460,26 @@ ldap_matchingruleuse2str( LDAPMatchingRuleUse * mru )
 
        print_literal(ss,/*(*/")");
 
-       retstring = LDAP_STRDUP(safe_string_val(ss));
+       bv->bv_val = safe_strdup(ss);
+       bv->bv_len = ss->pos;
        safe_string_free(ss);
-       return(retstring);
+       return(bv);
 }
 
 char *
 ldap_objectclass2str( LDAPObjectClass * oc )
+{
+       struct berval bv;
+       if (ldap_objectclass2bv( oc, &bv ))
+               return(bv.bv_val);
+       else
+               return NULL;
+}
+
+struct berval *
+ldap_objectclass2bv( LDAPObjectClass * oc, struct berval *bv )
 {
        safe_string * ss;
-       char * retstring;
        
        ss = new_safe_string(256);
        if ( !ss )
@@ -499,16 +549,26 @@ ldap_objectclass2str( LDAPObjectClass * oc )
 
        print_literal(ss, /*(*/")");
 
-       retstring = LDAP_STRDUP(safe_string_val(ss));
+       bv->bv_val = safe_strdup(ss);
+       bv->bv_len = ss->pos;
        safe_string_free(ss);
-       return(retstring);
+       return(bv);
 }
 
 char *
-ldap_attributetype2str(  LDAPAttributeType * at )
+ldap_attributetype2str( LDAPAttributeType * at )
+{
+       struct berval bv;
+       if (ldap_attributetype2bv( at, &bv ))
+               return(bv.bv_val);
+       else
+               return NULL;
+}
+
+struct berval *
+ldap_attributetype2bv(  LDAPAttributeType * at, struct berval *bv )
 {
        safe_string * ss;
-       char * retstring;
        
        ss = new_safe_string(256);
        if ( !ss )
@@ -602,9 +662,10 @@ ldap_attributetype2str(  LDAPAttributeType * at )
 
        print_literal(ss,/*(*/")");
 
-       retstring = LDAP_STRDUP(safe_string_val(ss));
+       bv->bv_val = safe_strdup(ss);
+       bv->bv_len = ss->pos;
        safe_string_free(ss);
-       return(retstring);
+       return(bv);
 }
 
 /*
@@ -737,9 +798,9 @@ parse_whsp(const char **sp)
 
 /* Parse a sequence of dot-separated decimal strings */
 char *
-parse_numericoid(const char **sp, int *code, const int flags)
+ldap_int_parse_numericoid(const char **sp, int *code, const int flags)
 {
-       char * res;
+       char * res = NULL;
        const char * start = *sp;
        int len;
        int quoted = 0;
@@ -770,22 +831,25 @@ parse_numericoid(const char **sp, int *code, const int flags)
        }
        /* Now *sp points at the char past the numericoid. Perfect. */
        len = *sp - start;
-       res = LDAP_MALLOC(len+1);
-       if (!res) {
-               *code = LDAP_SCHERR_OUTOFMEM;
-               return(NULL);
-       }
-       strncpy(res,start,len);
-       res[len] = '\0';
        if ( flags & LDAP_SCHEMA_ALLOW_QUOTED && quoted ) {
                if ( **sp == '\'' ) {
                        (*sp)++;
                } else {
                        *code = LDAP_SCHERR_UNEXPTOKEN;
-                       LDAP_FREE(res);
                        return NULL;
                }
        }
+       if (flags & LDAP_SCHEMA_SKIP) {
+               res = (char *)start;
+       } else {
+               res = LDAP_MALLOC(len+1);
+               if (!res) {
+                       *code = LDAP_SCHERR_OUTOFMEM;
+                       return(NULL);
+               }
+               strncpy(res,start,len);
+               res[len] = '\0';
+       }
        return(res);
 }
 
@@ -889,7 +953,7 @@ parse_noidlen(const char **sp, int *code, int *len, int allow_quoted)
                quoted = 1;
                (*sp)++;
        }
-       sval = parse_numericoid(sp, code, 0);
+       sval = ldap_int_parse_numericoid(sp, code, 0);
        if ( !sval ) {
                return NULL;
        }
@@ -1076,8 +1140,8 @@ void
 ldap_syntax_free( LDAPSyntax * syn )
 {
        LDAP_FREE(syn->syn_oid);
-       LDAP_VFREE(syn->syn_names);
-       LDAP_FREE(syn->syn_desc);
+       if (syn->syn_names) LDAP_VFREE(syn->syn_names);
+       if (syn->syn_desc) LDAP_FREE(syn->syn_desc);
        free_extensions(syn->syn_extensions);
        LDAP_FREE(syn);
 }
@@ -1119,7 +1183,7 @@ ldap_str2syntax( LDAP_CONST char * s,
        }
 
        parse_whsp(&ss);
-       syn->syn_oid = parse_numericoid(&ss,code,0);
+       syn->syn_oid = ldap_int_parse_numericoid(&ss,code,0);
        if ( !syn->syn_oid ) {
                *errp = ss;
                ldap_syntax_free(syn);
@@ -1217,9 +1281,9 @@ void
 ldap_matchingrule_free( LDAPMatchingRule * mr )
 {
        LDAP_FREE(mr->mr_oid);
-       LDAP_VFREE(mr->mr_names);
-       LDAP_FREE(mr->mr_desc);
-       LDAP_FREE(mr->mr_syntax_oid);
+       if (mr->mr_names) LDAP_VFREE(mr->mr_names);
+       if (mr->mr_desc) LDAP_FREE(mr->mr_desc);
+       if (mr->mr_syntax_oid) LDAP_FREE(mr->mr_syntax_oid);
        free_extensions(mr->mr_extensions);
        LDAP_FREE(mr);
 }
@@ -1265,7 +1329,7 @@ ldap_str2matchingrule( LDAP_CONST char * s,
 
        parse_whsp(&ss);
        savepos = ss;
-       mr->mr_oid = parse_numericoid(&ss,code,flags);
+       mr->mr_oid = ldap_int_parse_numericoid(&ss,code,flags);
        if ( !mr->mr_oid ) {
                if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
                        /* Backtracking */
@@ -1366,7 +1430,7 @@ ldap_str2matchingrule( LDAP_CONST char * s,
                                seen_syntax = 1;
                                parse_whsp(&ss);
                                mr->mr_syntax_oid =
-                                       parse_numericoid(&ss,code,flags);
+                                       ldap_int_parse_numericoid(&ss,code,flags);
                                if ( !mr->mr_syntax_oid ) {
                                        *errp = ss;
                                        ldap_matchingrule_free(mr);
@@ -1411,9 +1475,9 @@ void
 ldap_matchingruleuse_free( LDAPMatchingRuleUse * mru )
 {
        LDAP_FREE(mru->mru_oid);
-       LDAP_VFREE(mru->mru_names);
-       LDAP_FREE(mru->mru_desc);
-       LDAP_VFREE(mru->mru_applies_oids);
+       if (mru->mru_names) LDAP_VFREE(mru->mru_names);
+       if (mru->mru_desc) LDAP_FREE(mru->mru_desc);
+       if (mru->mru_applies_oids) LDAP_VFREE(mru->mru_applies_oids);
        free_extensions(mru->mru_extensions);
        LDAP_FREE(mru);
 }
@@ -1459,7 +1523,7 @@ ldap_str2matchingruleuse( LDAP_CONST char * s,
 
        parse_whsp(&ss);
        savepos = ss;
-       mru->mru_oid = parse_numericoid(&ss,code,flags);
+       mru->mru_oid = ldap_int_parse_numericoid(&ss,code,flags);
        if ( !mru->mru_oid ) {
                if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
                        /* Backtracking */
@@ -1604,13 +1668,13 @@ void
 ldap_attributetype_free(LDAPAttributeType * at)
 {
        LDAP_FREE(at->at_oid);
-       LDAP_VFREE(at->at_names);
-       LDAP_FREE(at->at_desc);
-       LDAP_FREE(at->at_sup_oid);
-       LDAP_FREE(at->at_equality_oid);
-       LDAP_FREE(at->at_ordering_oid);
-       LDAP_FREE(at->at_substr_oid);
-       LDAP_FREE(at->at_syntax_oid);
+       if (at->at_names) LDAP_VFREE(at->at_names);
+       if (at->at_desc) LDAP_FREE(at->at_desc);
+       if (at->at_sup_oid) LDAP_FREE(at->at_sup_oid);
+       if (at->at_equality_oid) LDAP_FREE(at->at_equality_oid);
+       if (at->at_ordering_oid) LDAP_FREE(at->at_ordering_oid);
+       if (at->at_substr_oid) LDAP_FREE(at->at_substr_oid);
+       if (at->at_syntax_oid) LDAP_FREE(at->at_syntax_oid);
        free_extensions(at->at_extensions);
        LDAP_FREE(at);
 }
@@ -1668,7 +1732,7 @@ ldap_str2attributetype( LDAP_CONST char * s,
         */
        parse_whsp(&ss);
        savepos = ss;
-       at->at_oid = parse_numericoid(&ss,code,0);
+       at->at_oid = ldap_int_parse_numericoid(&ss,code,0);
        if ( !at->at_oid ) {
                if ( ( flags & ( LDAP_SCHEMA_ALLOW_NO_OID
                                | LDAP_SCHEMA_ALLOW_OID_MACRO ) )
@@ -1984,11 +2048,11 @@ void
 ldap_objectclass_free(LDAPObjectClass * oc)
 {
        LDAP_FREE(oc->oc_oid);
-       LDAP_VFREE(oc->oc_names);
-       LDAP_FREE(oc->oc_desc);
-       LDAP_VFREE(oc->oc_sup_oids);
-       LDAP_VFREE(oc->oc_at_oids_must);
-       LDAP_VFREE(oc->oc_at_oids_may);
+       if (oc->oc_names) LDAP_VFREE(oc->oc_names);
+       if (oc->oc_desc) LDAP_FREE(oc->oc_desc);
+       if (oc->oc_sup_oids) LDAP_VFREE(oc->oc_sup_oids);
+       if (oc->oc_at_oids_must) LDAP_VFREE(oc->oc_at_oids_must);
+       if (oc->oc_at_oids_may) LDAP_VFREE(oc->oc_at_oids_may);
        free_extensions(oc->oc_extensions);
        LDAP_FREE(oc);
 }
@@ -2045,7 +2109,7 @@ ldap_str2objectclass( LDAP_CONST char * s,
         */
        parse_whsp(&ss);
        savepos = ss;
-       oc->oc_oid = parse_numericoid(&ss,code,0);
+       oc->oc_oid = ldap_int_parse_numericoid(&ss,code,0);
        if ( !oc->oc_oid ) {
                if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
                        /* Backtracking */