X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fmodify.c;h=f84026220864d369fd6276fadf76659b3f2e2736;hb=c3960b98d3b5fbd6ebeb200ca7799ece7b766d50;hp=9770919784b8283a008b4a3c9cce0c8c9eef0b14;hpb=5487575086d2060ab05a408543ff07be31b400a8;p=openldap diff --git a/servers/slapd/modify.c b/servers/slapd/modify.c index 9770919784..f840262208 100644 --- a/servers/slapd/modify.c +++ b/servers/slapd/modify.c @@ -183,7 +183,7 @@ do_modify( goto cleanup; } - rs->sr_err = slap_mods_check( modlist, + rs->sr_err = slap_mods_check( op, modlist, &rs->sr_text, textbuf, textlen, NULL ); if ( rs->sr_err != LDAP_SUCCESS ) { @@ -442,7 +442,7 @@ slap_mods_obsolete_check( char *textbuf, size_t textlen ) { - if( get_manageDIT( op ) ) return LDAP_SUCCESS; + if( get_relax( op ) ) return LDAP_SUCCESS; for ( ; ml != NULL; ml = ml->sml_next ) { if ( is_at_obsolete( ml->sml_desc->ad_type ) && @@ -481,7 +481,7 @@ slap_mods_no_user_mod_check( continue; } - if ( get_manageDIT( op ) ) { + if ( get_relax( op ) ) { if ( ml->sml_desc->ad_type->sat_flags & SLAP_AT_MANAGEABLE ) { ml->sml_flags |= SLAP_MOD_MANAGING; continue; @@ -539,6 +539,7 @@ slap_mods_no_repl_user_mod_check( * Do basic attribute type checking and syntax validation. */ int slap_mods_check( + Operation *op, Modifications *ml, const char **text, char *textbuf, @@ -553,6 +554,12 @@ int slap_mods_check( /* convert to attribute description */ if ( ml->sml_desc == NULL ) { rc = slap_bv2ad( &ml->sml_type, &ml->sml_desc, text ); + if( rc != LDAP_SUCCESS ) { + if ( get_no_schema_check( op )) { + rc = slap_bv2undef_ad( &ml->sml_type, &ml->sml_desc, + text, 0 ); + } + } if( rc != LDAP_SUCCESS ) { snprintf( textbuf, textlen, "%s: %s", ml->sml_type.bv_val, *text ); @@ -656,21 +663,11 @@ int slap_mods_check( struct berval pval; if ( pretty ) { -#ifdef SLAP_ORDERED_PRETTYNORM rc = ordered_value_pretty( ad, &ml->sml_values[nvals], &pval, ctx ); -#else /* ! SLAP_ORDERED_PRETTYNORM */ - rc = pretty( ad->ad_type->sat_syntax, - &ml->sml_values[nvals], &pval, ctx ); -#endif /* ! SLAP_ORDERED_PRETTYNORM */ } else { -#ifdef SLAP_ORDERED_PRETTYNORM rc = ordered_value_validate( ad, &ml->sml_values[nvals], ml->sml_op ); -#else /* ! SLAP_ORDERED_PRETTYNORM */ - rc = validate( ad->ad_type->sat_syntax, - &ml->sml_values[nvals] ); -#endif /* ! SLAP_ORDERED_PRETTYNORM */ } if( rc != 0 ) { @@ -716,19 +713,11 @@ int slap_mods_check( (nvals+1)*sizeof(struct berval), ctx ); for ( nvals = 0; !BER_BVISNULL( &ml->sml_values[nvals] ); nvals++ ) { -#ifdef SLAP_ORDERED_PRETTYNORM rc = ordered_value_normalize( SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, ad, ad->ad_type->sat_equality, &ml->sml_values[nvals], &ml->sml_nvalues[nvals], ctx ); -#else /* ! SLAP_ORDERED_PRETTYNORM */ - rc = ad->ad_type->sat_equality->smr_normalize( - SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, - ad->ad_type->sat_syntax, - ad->ad_type->sat_equality, - &ml->sml_values[nvals], &ml->sml_nvalues[nvals], ctx ); -#endif /* ! SLAP_ORDERED_PRETTYNORM */ if ( rc ) { Debug( LDAP_DEBUG_ANY, "<= str2entry NULL (ssyn_normalize %d)\n", @@ -747,6 +736,8 @@ int slap_mods_check( /* check for duplicates, but ignore Deletes. */ if( nvals > 1 && ml->sml_op != LDAP_MOD_DELETE ) { +#define SLAP_MODS_CHECK_QUICKSORT +#ifndef SLAP_MODS_CHECK_QUICKSORT int i, j, rc, match; MatchingRule *mr = ad->ad_type->sat_equality; @@ -778,8 +769,164 @@ int slap_mods_check( } } } +#else /* SLAP_MODS_CHECK_QUICKSORT */ + +/* Quicksort + Insertion sort for small arrays */ + +#define SMALL 8 +#define SWAP(a,b,tmp) tmp=(a);(a)=(b);(b)=tmp +#define COMP(a,b) match=0; rc = ordered_value_match( &match, \ + ml->sml_desc, mr, SLAP_MR_EQUALITY \ + | SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX \ + | SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH \ + | SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH, \ + &(a), &(b), text ); + + MatchingRule *mr = ad->ad_type->sat_equality; + int istack[sizeof(int)*16]; + int i,j,k,l,ir,jstack, rc, match, *ix, itmp; + struct berval a, *cv; + +/* If PRESERVE_ORDER is defined only the index array is sorted; the + * actual values are left in their incoming order. Otherwise, the + * only reason to keep the index array is to identify the offending + * value when duplicates are found. + */ +#define PRESERVE_ORDER +#ifndef PRESERVE_ORDER + struct berval va, *v, *nv, bvtmp; + +#define IX(x) x +#define EXCH(x,y) SWAP(ix[x],ix[y],itmp); SWAP(cv[x],cv[y],bvtmp); \ + if (nv) {SWAP(v[x],v[y],bvtmp);} +#define SETA(x) itmp = ix[x]; a = cv[x]; if (nv) va=v[x] +#define GETA(x) ix[x] = itmp; cv[x] = a; if (nv) v[x]=va +#define SET(x,y) ix[x] = ix[y]; cv[x] = cv[y]; if (nv) v[x]=v[y] + + v = ml->sml_values; + nv = ml->sml_nvalues; + +#else /* PRESERVE_ORDER */ + +#define IX(x) ix[x] +#define EXCH(x,y) SWAP(ix[x],ix[y],itmp) +#define SETA(x) itmp = ix[x]; a = cv[itmp] +#define GETA(x) ix[x] = itmp; +#define SET(x,y) ix[x] = ix[y] + +#endif /* PRESERVE_ORDER */ + + cv = ml->sml_nvalues ? ml->sml_nvalues : ml->sml_values; + if ( ad == slap_schema.si_ad_objectClass ) + mr = NULL; /* shortcut matching */ + + /* record indices to preserve input ordering */ + ix = slap_sl_malloc( nvals * sizeof(int), ctx ); + for (i=0; i=0;i--) { + COMP(cv[IX(i)], a); + if ( match <= 0 ) + break; + SET(i+1,i); + } + GETA(i+1); + if ( match == 0 ) goto done; + } + if ( jstack == 0 ) break; + if ( match == 0 ) break; + ir = istack[jstack--]; + l = istack[jstack--]; + } else { + k = (l + ir) >> 1; /* Choose median of left, center, right */ + EXCH(k, l+1); + COMP( cv[IX(l)], cv[IX(ir)] ); + if ( match > 0 ) { + EXCH(l, ir); + } else if ( match == 0 ) { + i = ir; + break; + } + COMP( cv[IX(l+1)], cv[IX(ir)] ); + if ( match > 0 ) { + EXCH(l+1, ir); + } else if ( match == 0 ) { + i = ir; + break; + } + COMP( cv[IX(l)], cv[IX(l+1)] ); + if ( match > 0 ) { + EXCH(l, l+1); + } else if ( match == 0 ) { + i = l; + break; + } + i = l+1; + j = ir; + a = cv[IX(i)]; + for(;;) { + do { + i++; + COMP( cv[IX(i)], a ); + } while( match < 0 ); + while( match > 0 ) { + j--; + COMP( cv[IX(j)], a ); + } + if (j < i) { + match = 1; + break; + } + if ( match == 0 ) { + i = l+1; + break; + } + EXCH(i,j); + } + if ( match == 0 ) + break; + EXCH(l+1,j); + jstack += 2; + if (ir-i+1 >= j) { + istack[jstack] = ir; + istack[jstack-1] = i; + ir = j; + } else { + istack[jstack] = j; + istack[jstack-1] = l; + l = i; + } + } + } +done: + if ( i >= 0 ) + j = ix[i]; + + slap_sl_free( ix, ctx ); + + if ( rc != LDAP_SUCCESS ) { + return rc; + } else if ( match == 0 ) { + /* value exists already */ + assert( i >= 0 ); + assert( i < nvals ); + snprintf( textbuf, textlen, + "%s: value #%d provided more than once", + ml->sml_desc->ad_cname.bv_val, j ); + *text = textbuf; + return LDAP_TYPE_OR_VALUE_EXISTS; + } +#endif /* SLAP_MODS_CHECK_QUICKSORT */ } - } }