git.sur5r.net Git - openldap/blob - servers/slapd/ad.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /* ad.c - routines for dealing with attribute descriptions */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/errno.h>
  14 #include <ac/socket.h>
  15 #include <ac/string.h>
  16 #include <ac/time.h>
  17
  18 #include "ldap_pvt.h"
  19 #include "slap.h"
  20
  21 static int ad_keystring(
  22         struct berval *bv )
  23 {
  24         ber_len_t i;
  25
  26         if( !AD_CHAR( bv->bv_val[0] ) ) {
  27                 return 1;
  28         }
  29
  30         for( i=1; i<bv->bv_len; i++ ) {
  31                 if( !AD_CHAR( bv->bv_val[i] ) ) {
  32                         return 1;
  33                 }
  34         }
  35         return 0;
  36 }
  37
  38 void ad_destroy( AttributeDescription *ad )
  39 {
  40         AttributeDescription *n;
  41
  42         for (; ad != NULL; ad = n) {
  43                 n = ad->ad_next;
  44                 ldap_memfree( ad );
  45         }
  46 }
  47
  48 /* Is there an AttributeDescription for this type that uses this language? */
  49 AttributeDescription * ad_find_lang(
  50         AttributeType *type,
  51         struct berval *lang )
  52 {
  53         AttributeDescription *ad;
  54
  55         ldap_pvt_thread_mutex_lock( &type->sat_ad_mutex );
  56         for (ad = type->sat_ad; ad; ad=ad->ad_next)
  57         {
  58                 if (ad->ad_lang.bv_len == lang->bv_len &&
  59                         !strcasecmp(ad->ad_lang.bv_val, lang->bv_val))
  60                         break;
  61         }
  62         ldap_pvt_thread_mutex_unlock( &type->sat_ad_mutex );
  63         return ad;
  64 }
  65
  66 int slap_str2ad(
  67         const char *str,
  68         AttributeDescription **ad,
  69         const char **text )
  70 {
  71         struct berval bv;
  72         bv.bv_val = (char *) str;
  73         bv.bv_len = strlen( str );
  74
  75         return slap_bv2ad( &bv, ad, text );
  76 }
  77
  78 static char *strchrlen(
  79         const char *p,
  80         const char ch,
  81         int *len )
  82 {
  83         int i;
  84
  85         for( i=0; p[i]; i++ ) {
  86                 if( p[i] == ch ) {
  87                         *len = i;
  88                         return (char *) &p[i];
  89                 }
  90         }
  91
  92         *len = i;
  93         return NULL;
  94 }
  95
  96 int slap_bv2ad(
  97         struct berval *bv,
  98         AttributeDescription **ad,
  99         const char **text )
 100 {
 101         int rtn = LDAP_UNDEFINED_TYPE;
 102         AttributeDescription desc, *d2;
 103         char *name, *options;
 104         char *opt, *next;
 105         int nlang;
 106         int langlen;
 107
 108         /* hardcoded limits for speed */
 109 #define MAX_LANG_OPTIONS 128
 110         struct berval langs[MAX_LANG_OPTIONS+1];
 111 #define MAX_LANG_LEN 1024
 112         char langbuf[MAX_LANG_LEN];
 113
 114         assert( ad != NULL );
 115         assert( *ad == NULL ); /* temporary */
 116
 117         if( bv == NULL || bv->bv_len == 0 ) {
 118                 *text = "empty attribute description";
 119                 return rtn;
 120         }
 121
 122         /* make sure description is IA5 */
 123         if( ad_keystring( bv ) ) {
 124                 *text = "attribute description contains inappropriate characters";
 125                 return rtn;
 126         }
 127
 128         /* find valid base attribute type; parse in place */
 129         memset( &desc, 0, sizeof( desc ));
 130         desc.ad_cname = *bv;
 131         name = bv->bv_val;
 132         options = strchr(name, ';');
 133         if( options != NULL ) {
 134                 desc.ad_cname.bv_len = options - name;
 135         }
 136         desc.ad_type = at_bvfind( &desc.ad_cname );
 137         if( desc.ad_type == NULL ) {
 138                 *text = "attribute type undefined";
 139                 return rtn;
 140         }
 141
 142         if( is_at_operational( desc.ad_type ) && options != NULL ) {
 143                 *text = "operational attribute with options undefined";
 144                 return rtn;
 145         }
 146
 147         /*
 148          * parse options in place
 149          */
 150         nlang = 0;
 151         memset( langs, 0, sizeof( langs ));
 152         langlen = 0;
 153
 154         for( opt=options; opt != NULL; opt=next ) {
 155                 int optlen;
 156                 opt++;
 157                 next = strchrlen( opt, ';', &optlen );
 158
 159                 if( optlen == 0 ) {
 160                         *text = "zero length option is invalid";
 161                         return rtn;
 162
 163                 } else if ( optlen == sizeof("binary")-1 &&
 164                         strncasecmp( opt, "binary", sizeof("binary")-1 ) == 0 )
 165                 {
 166                         /* binary option */
 167                         if( slap_ad_is_binary( &desc ) ) {
 168                                 *text = "option \"binary\" specified multiple times";
 169                                 return rtn;
 170                         }
 171
 172                         if( !slap_syntax_is_binary( desc.ad_type->sat_syntax )) {
 173                                 /* not stored in binary, disallow option */
 174                                 *text = "option \"binary\" with type not supported";
 175                                 return rtn;
 176                         }
 177
 178                         desc.ad_flags |= SLAP_DESC_BINARY;
 179                         continue;
 180
 181                 } else if ( optlen >= sizeof("lang-")-1 &&
 182                         strncasecmp( opt, "lang-", sizeof("lang-")-1 ) == 0 )
 183                 {
 184                         int i;
 185
 186                         if( opt[optlen-1] == '-' ) {
 187                                 desc.ad_flags |= SLAP_DESC_LANG_RANGE;
 188                         }
 189
 190                         if( nlang >= MAX_LANG_OPTIONS ) {
 191                                 *text = "too many language options";
 192                                 return rtn;
 193                         }
 194
 195                         /*
 196                          * tags should be presented in sorted order,
 197                          * so run the array in reverse.
 198                          */
 199                         for( i=nlang-1; i>=0; i-- ) {
 200                                 int rc;
 201
 202                                 rc = strncasecmp( opt, langs[i].bv_val,
 203                                         (unsigned) optlen < langs[i].bv_len
 204                                                 ? optlen : langs[i].bv_len );
 205
 206                                 if( rc == 0 && (unsigned)optlen == langs[i].bv_len ) {
 207                                         /* duplicate (ignore) */
 208                                         goto done;
 209
 210                                 } else if ( rc > 0 ||
 211                                         ( rc == 0 && (unsigned)optlen > langs[i].bv_len ))
 212                                 {
 213                                         AC_MEMCPY( &langs[i+1], &langs[i],
 214                                                 (nlang-i)*sizeof(struct berval) );
 215                                         langs[i].bv_val = opt;
 216                                         langs[i].bv_len = optlen;
 217                                         goto done;
 218                                 }
 219                         }
 220
 221                         if( nlang ) {
 222                                 AC_MEMCPY( &langs[1], &langs[0],
 223                                         nlang*sizeof(struct berval) );
 224                         }
 225                         langs[0].bv_val = opt;
 226                         langs[0].bv_len = optlen;
 227
 228 done:;
 229                         langlen += optlen + 1;
 230                         nlang++;
 231
 232                 } else {
 233                         *text = "unrecognized option";
 234                         return rtn;
 235                 }
 236         }
 237
 238         if( nlang > 0 ) {
 239                 int i;
 240
 241                 if( langlen > MAX_LANG_LEN ) {
 242                         *text = "language options too long";
 243                         return rtn;
 244                 }
 245
 246                 desc.ad_lang.bv_val = langbuf;
 247                 langlen = 0;
 248
 249                 for( i=0; i<nlang; i++ ) {
 250                         AC_MEMCPY( &desc.ad_lang.bv_val[langlen],
 251                                 langs[i].bv_val, langs[i].bv_len );
 252
 253                         langlen += langs[i].bv_len;
 254                         desc.ad_lang.bv_val[langlen++] = ';';
 255                 }
 256
 257                 desc.ad_lang.bv_val[--langlen] = '\0';
 258                 desc.ad_lang.bv_len = langlen;
 259         }
 260
 261         /* see if a matching description is already cached */
 262         for (d2 = desc.ad_type->sat_ad; d2; d2=d2->ad_next) {
 263                 if( d2->ad_flags != desc.ad_flags ) {
 264                         continue;
 265                 }
 266                 if( d2->ad_lang.bv_len != desc.ad_lang.bv_len ) {
 267                         continue;
 268                 }
 269                 if( d2->ad_lang.bv_len == 0 ) {
 270                         break;
 271                 }
 272                 if( strncasecmp( d2->ad_lang.bv_val, desc.ad_lang.bv_val,
 273                         desc.ad_lang.bv_len ) == 0 )
 274                 {
 275                         break;
 276                 }
 277         }
 278
 279         /* Not found, add new one */
 280         while (d2 == NULL) {
 281                 int dlen = 0;
 282                 ldap_pvt_thread_mutex_lock( &desc.ad_type->sat_ad_mutex );
 283                 /* check again now that we've locked */
 284                 for (d2 = desc.ad_type->sat_ad; d2; d2=d2->ad_next) {
 285                         if (d2->ad_flags != desc.ad_flags)
 286                                 continue;
 287                         if (d2->ad_lang.bv_len != desc.ad_lang.bv_len)
 288                                 continue;
 289                         if (d2->ad_lang.bv_len == 0)
 290                                 break;
 291                         if (strncasecmp(d2->ad_lang.bv_val, desc.ad_lang.bv_val,
 292                                 desc.ad_lang.bv_len) == 0)
 293                                 break;
 294                 }
 295                 if (d2) {
 296                         ldap_pvt_thread_mutex_unlock( &desc.ad_type->sat_ad_mutex );
 297                         break;
 298                 }
 299
 300                 /* Allocate a single contiguous block. If there are no
 301                  * options, we just need space for the AttrDesc structure.
 302                  * Otherwise, we need to tack on the full name length +
 303                  * options length.
 304                  */
 305                 if (desc.ad_lang.bv_len || desc.ad_flags != SLAP_DESC_NONE) {
 306                         if (desc.ad_lang.bv_len) {
 307                                 dlen = desc.ad_lang.bv_len+1;
 308                         }
 309                         dlen += desc.ad_type->sat_cname.bv_len+1;
 310                         if( slap_ad_is_binary( &desc ) ) {
 311                                 dlen += sizeof("binary");
 312                         }
 313                 }
 314
 315                 d2 = ch_malloc(sizeof(AttributeDescription) + dlen);
 316                 d2->ad_type = desc.ad_type;
 317                 d2->ad_flags = desc.ad_flags;
 318                 d2->ad_cname.bv_len = desc.ad_cname.bv_len;
 319                 d2->ad_lang.bv_len = desc.ad_lang.bv_len;
 320                 if (dlen == 0) {
 321                         d2->ad_cname.bv_val = d2->ad_type->sat_cname.bv_val;
 322                         d2->ad_lang.bv_val = NULL;
 323                 } else {
 324                         d2->ad_cname.bv_val = (char *)(d2+1);
 325                         strcpy(d2->ad_cname.bv_val, d2->ad_type->sat_cname.bv_val);
 326                         if( slap_ad_is_binary( &desc ) ) {
 327                                 strcpy(d2->ad_cname.bv_val+d2->ad_cname.bv_len,
 328                                         ";binary");
 329                                 d2->ad_cname.bv_len += sizeof("binary");
 330                         }
 331                         if( d2->ad_lang.bv_len ) {
 332                                 d2->ad_cname.bv_val[d2->ad_cname.bv_len++]=';';
 333                                 d2->ad_lang.bv_val = d2->ad_cname.bv_val+
 334                                         d2->ad_cname.bv_len;
 335                                 strncpy(d2->ad_lang.bv_val,desc.ad_lang.bv_val,
 336                                         d2->ad_lang.bv_len);
 337                                 d2->ad_lang.bv_val[d2->ad_lang.bv_len] = '\0';
 338                                 ldap_pvt_str2lower(d2->ad_lang.bv_val);
 339                                 d2->ad_cname.bv_len += d2->ad_lang.bv_len;
 340                         }
 341                 }
 342                 /* Add new desc to list. We always want the bare Desc with
 343                  * no options to stay at the head of the list, assuming
 344                  * that one will be used most frequently.
 345                  */
 346                 if (desc.ad_type->sat_ad == NULL || dlen == 0) {
 347                         d2->ad_next = desc.ad_type->sat_ad;
 348                         desc.ad_type->sat_ad = d2;
 349                 } else {
 350                         d2->ad_next = desc.ad_type->sat_ad->ad_next;
 351                         desc.ad_type->sat_ad->ad_next = d2;
 352                 }
 353                 ldap_pvt_thread_mutex_unlock( &desc.ad_type->sat_ad_mutex );
 354         }
 355
 356         if( *ad == NULL ) {
 357                 *ad = d2;
 358         } else {
 359                 **ad = *d2;
 360         }
 361
 362         return LDAP_SUCCESS;
 363 }
 364
 365 static int is_ad_sublang(
 366         const char *sublang,
 367         const char *suplang )
 368 {
 369         const char *supp, *supdelimp;
 370         const char *subp, *subdelimp;
 371         int  suplen, sublen;
 372
 373         if( suplang == NULL ) return 1;
 374         if( sublang == NULL ) return 0;
 375
 376         for( supp=suplang ; supp; supp=supdelimp ) {
 377                 supdelimp = strchrlen( supp, ';', &suplen );
 378                 if( supdelimp ) supdelimp++;
 379
 380                 for( subp=sublang ; subp; subp=subdelimp ) {
 381                         subdelimp = strchrlen( subp, ';', &sublen );
 382                         if( subdelimp ) subdelimp++;
 383
 384                         if ((( suplen < sublen && supp[suplen-1] == '-' ) ||
 385                                 suplen == sublen ) && strncmp( supp, subp, suplen ) == 0 )
 386                         {
 387                                 goto match;
 388                         }
 389                 }
 390
 391                 return 0;
 392 match:;
 393         }
 394         return 1;
 395 }
 396
 397 int is_ad_subtype(
 398         AttributeDescription *sub,
 399         AttributeDescription *super
 400 )
 401 {
 402         int lr;
 403
 404         if( !is_at_subtype( sub->ad_type, super->ad_type ) ) {
 405                 return 0;
 406         }
 407
 408         /* ensure sub does support all flags of super */
 409         lr = sub->ad_lang.bv_len ? SLAP_DESC_LANG_RANGE : 0;
 410         if(( super->ad_flags & ( sub->ad_flags | lr )) != super->ad_flags ) {
 411                 return 0;
 412         }
 413
 414         /* check for language tags */
 415         if ( !is_ad_sublang( sub->ad_lang.bv_val, super->ad_lang.bv_val )) {
 416                 return 0;
 417         }
 418
 419         return 1;
 420 }
 421
 422 int ad_inlist(
 423         AttributeDescription *desc,
 424         AttributeName *attrs )
 425 {
 426         if (! attrs ) return 0;
 427
 428         for( ; attrs->an_name.bv_val; attrs++ ) {
 429                 ObjectClass *oc;
 430                 int rc;
 431
 432                 if ( attrs->an_desc ) {
 433                         if ( is_ad_subtype( desc, attrs->an_desc ))
 434                                 return 1;
 435                         continue;
 436                 }
 437
 438                 /*
 439                  * EXTENSION: see if requested description is an object class
 440                  * if so, return attributes which the class requires/allows
 441                  */
 442                 oc = attrs->an_oc;
 443                 if( oc == NULL ) {
 444                         oc = oc_bvfind( &attrs->an_name );
 445                         attrs->an_oc = oc;
 446                 }
 447                 if( oc != NULL ) {
 448                         if ( oc == slap_schema.si_oc_extensibleObject ) {
 449                                 /* extensibleObject allows the return of anything */
 450                                 return 1;
 451                         }
 452
 453                         if( oc->soc_required ) {
 454                                 /* allow return of required attributes */
 455                                 int i;
 456                                 for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
 457                                         rc = is_at_subtype( desc->ad_type,
 458                                                 oc->soc_allowed[i] );
 459                                         if( rc ) return 1;
 460                                 }
 461                         }
 462
 463                         if( oc->soc_allowed ) {
 464                                 /* allow return of allowed attributes */
 465                                 int i;
 466                                 for ( i = 0; oc->soc_allowed[i] != NULL; i++ ) {
 467                                         rc = is_at_subtype( desc->ad_type,
 468                                                 oc->soc_allowed[i] );
 469                                         if( rc ) return 1;
 470                                 }
 471                         }
 472
 473                 } else {
 474                         /* short-circuit this search next time around */
 475                         if (!slap_schema.si_at_undefined->sat_ad) {
 476                                 const char *text;
 477                                 slap_bv2undef_ad(&attrs->an_name,
 478                                         &attrs->an_desc, &text);
 479                         } else {
 480                                 attrs->an_desc =
 481                                         slap_schema.si_at_undefined->sat_ad;
 482                         }
 483                 }
 484         }
 485
 486         return 0;
 487 }
 488
 489
 490 int slap_str2undef_ad(
 491         const char *str,
 492         AttributeDescription **ad,
 493         const char **text )
 494 {
 495         struct berval bv;
 496         bv.bv_val = (char *) str;
 497         bv.bv_len = strlen( str );
 498
 499         return slap_bv2undef_ad( &bv, ad, text );
 500 }
 501
 502 int slap_bv2undef_ad(
 503         struct berval *bv,
 504         AttributeDescription **ad,
 505         const char **text )
 506 {
 507         AttributeDescription *desc;
 508
 509         assert( ad != NULL );
 510
 511         if( bv == NULL || bv->bv_len == 0 ) {
 512                 *text = "empty attribute description";
 513                 return LDAP_UNDEFINED_TYPE;
 514         }
 515
 516         /* make sure description is IA5 */
 517         if( ad_keystring( bv ) ) {
 518                 *text = "attribute description contains inappropriate characters";
 519                 return LDAP_UNDEFINED_TYPE;
 520         }
 521
 522         for( desc = slap_schema.si_at_undefined->sat_ad; desc;
 523                 desc=desc->ad_next )
 524         {
 525                 if( desc->ad_cname.bv_len == bv->bv_len &&
 526                     !strcasecmp( desc->ad_cname.bv_val, bv->bv_val ))
 527                 {
 528                         break;
 529                 }
 530         }
 531
 532         if( !desc ) {
 533                 desc = ch_malloc(sizeof(AttributeDescription) +
 534                         bv->bv_len + 1);
 535
 536                 desc->ad_flags = SLAP_DESC_NONE;
 537                 desc->ad_lang.bv_val = NULL;
 538                 desc->ad_lang.bv_len = 0;
 539
 540                 desc->ad_cname.bv_len = bv->bv_len;
 541                 desc->ad_cname.bv_val = (char *)(desc+1);
 542                 strcpy(desc->ad_cname.bv_val, bv->bv_val);
 543
 544                 /* canonical to upper case */
 545                 ldap_pvt_str2upper( desc->ad_cname.bv_val );
 546
 547                 desc->ad_type = slap_schema.si_at_undefined;
 548                 desc->ad_next = desc->ad_type->sat_ad;
 549                 desc->ad_type->sat_ad = desc;
 550         }
 551
 552         if( !*ad ) {
 553                 *ad = desc;
 554         } else {
 555                 **ad = *desc;
 556         }
 557
 558         return LDAP_SUCCESS;
 559 }
 560
 561 int
 562 an_find(
 563     AttributeName *a,
 564     struct berval *s
 565 )
 566 {
 567         if( a == NULL ) return 0;
 568
 569         for ( ; a->an_name.bv_val; a++ ) {
 570                 if ( a->an_name.bv_len != s->bv_len) continue;
 571                 if ( strcasecmp( s->bv_val, a->an_name.bv_val ) == 0 ) {
 572                         return( 1 );
 573                 }
 574         }
 575
 576         return( 0 );
 577 }
 578
 579 /* Convert a delimited string into a list of AttributeNames; Add on
 580  * to an existing list if it was given.
 581  */
 582 AttributeName *
 583 str2anlist( AttributeName *an, char *in, const char *brkstr )
 584 {
 585         char    *str;
 586         char    *s;
 587         char    *lasts;
 588         int     i, j;
 589         const char *text;
 590         AttributeName *anew;
 591
 592         /* find last element in list */
 593         for (i = 0; an && an[i].an_name.bv_val; i++);
 594
 595         /* protect the input string from strtok */
 596         str = ch_strdup( in );
 597
 598         /* Count words in string */
 599         j=1;
 600         for ( s = str; *s; s++ ) {
 601                 if ( strchr( brkstr, *s ) != NULL ) {
 602                         j++;
 603                 }
 604         }
 605
 606         an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) );
 607         anew = an + i;
 608         for ( s = ldap_pvt_strtok( str, brkstr, &lasts );
 609                 s != NULL;
 610                 s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )
 611         {
 612                 anew->an_desc = NULL;
 613                 anew->an_oc = NULL;
 614                 ber_str2bv(s, 0, 1, &anew->an_name);
 615                 slap_bv2ad(&anew->an_name, &anew->an_desc, &text);
 616                 if ( !anew->an_desc ) {
 617                         anew->an_oc = oc_bvfind( &anew->an_name );
 618                         if ( !anew->an_oc ) {
 619                                 free( an );
 620                                 /* overwrites input string on error! */
 621                                 strcpy( in, s );
 622                                 return NULL;
 623                         }
 624                 }
 625                 anew++;
 626         }
 627         anew->an_name.bv_val = NULL;
 628
 629         free( str );
 630         return( an );
 631 }
 632