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\" not supported with type";
 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                 size_t 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                         dlen = desc.ad_type->sat_cname.bv_len;
 307                         if (desc.ad_lang.bv_len) {
 308                                 dlen += 1+desc.ad_lang.bv_len;
 309                         }
 310                         if( slap_ad_is_binary( &desc ) ) {
 311                                 dlen += sizeof(";binary")-1;
 312                         }
 313                 }
 314
 315                 d2 = ch_malloc(sizeof(AttributeDescription) + dlen + 1);
 316                 d2->ad_type = desc.ad_type;
 317                 d2->ad_flags = desc.ad_flags;
 318                 d2->ad_cname.bv_len = desc.ad_type->sat_cname.bv_len;
 319                 d2->ad_lang.bv_len = desc.ad_lang.bv_len;
 320
 321                 if (dlen == 0) {
 322                         d2->ad_cname.bv_val = d2->ad_type->sat_cname.bv_val;
 323                         d2->ad_lang.bv_val = NULL;
 324                 } else {
 325                         d2->ad_cname.bv_val = (char *)(d2+1);
 326                         strcpy(d2->ad_cname.bv_val, d2->ad_type->sat_cname.bv_val);
 327                         if( slap_ad_is_binary( &desc ) ) {
 328                                 strcpy(d2->ad_cname.bv_val+d2->ad_cname.bv_len,
 329                                         ";binary");
 330                                 d2->ad_cname.bv_len += sizeof(";binary")-1;
 331                         }
 332                         if( d2->ad_lang.bv_len ) {
 333                                 d2->ad_cname.bv_val[d2->ad_cname.bv_len++]=';';
 334                                 d2->ad_lang.bv_val = d2->ad_cname.bv_val+
 335                                         d2->ad_cname.bv_len;
 336                                 strncpy(d2->ad_lang.bv_val,desc.ad_lang.bv_val,
 337                                         d2->ad_lang.bv_len);
 338                                 d2->ad_lang.bv_val[d2->ad_lang.bv_len] = '\0';
 339                                 ldap_pvt_str2lower(d2->ad_lang.bv_val);
 340                                 d2->ad_cname.bv_len += d2->ad_lang.bv_len;
 341                         }
 342                 }
 343                 /* Add new desc to list. We always want the bare Desc with
 344                  * no options to stay at the head of the list, assuming
 345                  * that one will be used most frequently.
 346                  */
 347                 if (desc.ad_type->sat_ad == NULL || dlen == 0) {
 348                         d2->ad_next = desc.ad_type->sat_ad;
 349                         desc.ad_type->sat_ad = d2;
 350                 } else {
 351                         d2->ad_next = desc.ad_type->sat_ad->ad_next;
 352                         desc.ad_type->sat_ad->ad_next = d2;
 353                 }
 354                 ldap_pvt_thread_mutex_unlock( &desc.ad_type->sat_ad_mutex );
 355         }
 356
 357         if( *ad == NULL ) {
 358                 *ad = d2;
 359         } else {
 360                 **ad = *d2;
 361         }
 362
 363         return LDAP_SUCCESS;
 364 }
 365
 366 static int is_ad_sublang(
 367         struct berval *sublangbv,
 368         struct berval *suplangbv )
 369 {
 370         const char *suplang, *supp, *supdelimp;
 371         const char *sublang, *subp, *subdelimp;
 372         int  suplen, sublen;
 373
 374         if( suplangbv->bv_len == 0 ) return 1;
 375         if( sublangbv->bv_len == 0 ) return 0;
 376
 377         sublang =sublangbv->bv_val;
 378         suplang =suplangbv->bv_val;
 379
 380         for( supp=suplang ; supp; supp=supdelimp ) {
 381                 supdelimp = strchrlen( supp, ';', &suplen );
 382                 if( supdelimp ) supdelimp++;
 383
 384                 for( subp=sublang ; subp; subp=subdelimp ) {
 385                         subdelimp = strchrlen( subp, ';', &sublen );
 386                         if( subdelimp ) subdelimp++;
 387
 388                         if ((( suplen < sublen && supp[suplen-1] == '-' ) ||
 389                                 suplen == sublen ) && strncmp( supp, subp, suplen ) == 0 )
 390                         {
 391                                 goto match;
 392                         }
 393                 }
 394
 395                 return 0;
 396 match:;
 397         }
 398         return 1;
 399 }
 400
 401 int is_ad_subtype(
 402         AttributeDescription *sub,
 403         AttributeDescription *super
 404 )
 405 {
 406         int lr;
 407
 408         if( !is_at_subtype( sub->ad_type, super->ad_type ) ) {
 409                 return 0;
 410         }
 411
 412         /* ensure sub does support all flags of super */
 413         lr = sub->ad_lang.bv_len ? SLAP_DESC_LANG_RANGE : 0;
 414         if(( super->ad_flags & ( sub->ad_flags | lr )) != super->ad_flags ) {
 415                 return 0;
 416         }
 417
 418         /* check for language tags */
 419         if ( !is_ad_sublang( &sub->ad_lang, &super->ad_lang )) {
 420                 return 0;
 421         }
 422
 423         return 1;
 424 }
 425
 426 int ad_inlist(
 427         AttributeDescription *desc,
 428         AttributeName *attrs )
 429 {
 430         if (! attrs ) return 0;
 431
 432         for( ; attrs->an_name.bv_val; attrs++ ) {
 433                 ObjectClass *oc;
 434                 int rc;
 435
 436                 if ( attrs->an_desc ) {
 437                         if ( desc == attrs->an_desc ) {
 438                                 return 1;
 439                         }
 440
 441                         /*
 442                          * EXTENSION: if requested description is preceeded by an
 443                          * a '-' character, do not match on subtypes.
 444                          */
 445                         if ( attrs->an_name.bv_val[0] != '-' &&
 446                                 is_ad_subtype( desc, attrs->an_desc ))
 447                         {
 448                                 return 1;
 449                         }
 450
 451                         continue;
 452                 }
 453
 454                 /*
 455                  * EXTENSION: see if requested description is +objectClass
 456                  * if so, return attributes which the class requires/allows
 457                  */
 458                 oc = attrs->an_oc;
 459                 if( oc == NULL && attrs->an_name.bv_val ) {
 460                         switch( attrs->an_name.bv_val[0] ) {
 461                         case '+': { /* new way */
 462                                         struct berval ocname;
 463                                         ocname.bv_len = attrs->an_name.bv_len - 1;
 464                                         ocname.bv_val = &attrs->an_name.bv_val[1];
 465                                         oc = oc_bvfind( &ocname );
 466                                 } break;
 467                         default: /* old (deprecated) way */
 468                                 oc = oc_bvfind( &attrs->an_name );
 469                         }
 470                         attrs->an_oc = oc;
 471                 }
 472                 if( oc != NULL ) {
 473                         if ( oc == slap_schema.si_oc_extensibleObject ) {
 474                                 /* extensibleObject allows the return of anything */
 475                                 return 1;
 476                         }
 477
 478                         if( oc->soc_required ) {
 479                                 /* allow return of required attributes */
 480                                 int i;
 481                                 for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
 482                                         rc = is_at_subtype( desc->ad_type,
 483                                                 oc->soc_required[i] );
 484                                         if( rc ) return 1;
 485                                 }
 486                         }
 487
 488                         if( oc->soc_allowed ) {
 489                                 /* allow return of allowed attributes */
 490                                 int i;
 491                                 for ( i = 0; oc->soc_allowed[i] != NULL; i++ ) {
 492                                         rc = is_at_subtype( desc->ad_type,
 493                                                 oc->soc_allowed[i] );
 494                                         if( rc ) return 1;
 495                                 }
 496                         }
 497
 498                 } else {
 499                         /* short-circuit this search next time around */
 500                         if (!slap_schema.si_at_undefined->sat_ad) {
 501                                 const char *text;
 502                                 slap_bv2undef_ad(&attrs->an_name,
 503                                         &attrs->an_desc, &text);
 504                         } else {
 505                                 attrs->an_desc =
 506                                         slap_schema.si_at_undefined->sat_ad;
 507                         }
 508                 }
 509         }
 510
 511         return 0;
 512 }
 513
 514
 515 int slap_str2undef_ad(
 516         const char *str,
 517         AttributeDescription **ad,
 518         const char **text )
 519 {
 520         struct berval bv;
 521         bv.bv_val = (char *) str;
 522         bv.bv_len = strlen( str );
 523
 524         return slap_bv2undef_ad( &bv, ad, text );
 525 }
 526
 527 int slap_bv2undef_ad(
 528         struct berval *bv,
 529         AttributeDescription **ad,
 530         const char **text )
 531 {
 532         AttributeDescription *desc;
 533
 534         assert( ad != NULL );
 535
 536         if( bv == NULL || bv->bv_len == 0 ) {
 537                 *text = "empty attribute description";
 538                 return LDAP_UNDEFINED_TYPE;
 539         }
 540
 541         /* make sure description is IA5 */
 542         if( ad_keystring( bv ) ) {
 543                 *text = "attribute description contains inappropriate characters";
 544                 return LDAP_UNDEFINED_TYPE;
 545         }
 546
 547         for( desc = slap_schema.si_at_undefined->sat_ad; desc;
 548                 desc=desc->ad_next )
 549         {
 550                 if( desc->ad_cname.bv_len == bv->bv_len &&
 551                     !strcasecmp( desc->ad_cname.bv_val, bv->bv_val ))
 552                 {
 553                         break;
 554                 }
 555         }
 556
 557         if( !desc ) {
 558                 desc = ch_malloc(sizeof(AttributeDescription) + 1 +
 559                         bv->bv_len);
 560
 561                 desc->ad_flags = SLAP_DESC_NONE;
 562                 desc->ad_lang.bv_val = NULL;
 563                 desc->ad_lang.bv_len = 0;
 564
 565                 desc->ad_cname.bv_len = bv->bv_len;
 566                 desc->ad_cname.bv_val = (char *)(desc+1);
 567                 strcpy(desc->ad_cname.bv_val, bv->bv_val);
 568
 569                 /* canonical to upper case */
 570                 ldap_pvt_str2upper( desc->ad_cname.bv_val );
 571
 572                 desc->ad_type = slap_schema.si_at_undefined;
 573                 desc->ad_next = desc->ad_type->sat_ad;
 574                 desc->ad_type->sat_ad = desc;
 575         }
 576
 577         if( !*ad ) {
 578                 *ad = desc;
 579         } else {
 580                 **ad = *desc;
 581         }
 582
 583         return LDAP_SUCCESS;
 584 }
 585
 586 int
 587 an_find(
 588     AttributeName *a,
 589     struct berval *s
 590 )
 591 {
 592         if( a == NULL ) return 0;
 593
 594         for ( ; a->an_name.bv_val; a++ ) {
 595                 if ( a->an_name.bv_len != s->bv_len) continue;
 596                 if ( strcasecmp( s->bv_val, a->an_name.bv_val ) == 0 ) {
 597                         return( 1 );
 598                 }
 599         }
 600
 601         return( 0 );
 602 }
 603
 604 /* Convert a delimited string into a list of AttributeNames; Add on
 605  * to an existing list if it was given.
 606  */
 607 AttributeName *
 608 str2anlist( AttributeName *an, char *in, const char *brkstr )
 609 {
 610         char    *str;
 611         char    *s;
 612         char    *lasts;
 613         int     i, j;
 614         const char *text;
 615         AttributeName *anew;
 616
 617         /* find last element in list */
 618         for (i = 0; an && an[i].an_name.bv_val; i++);
 619
 620         /* protect the input string from strtok */
 621         str = ch_strdup( in );
 622
 623         /* Count words in string */
 624         j=1;
 625         for ( s = str; *s; s++ ) {
 626                 if ( strchr( brkstr, *s ) != NULL ) {
 627                         j++;
 628                 }
 629         }
 630
 631         an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) );
 632         anew = an + i;
 633         for ( s = ldap_pvt_strtok( str, brkstr, &lasts );
 634                 s != NULL;
 635                 s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )
 636         {
 637                 anew->an_desc = NULL;
 638                 anew->an_oc = NULL;
 639                 ber_str2bv(s, 0, 1, &anew->an_name);
 640                 slap_bv2ad(&anew->an_name, &anew->an_desc, &text);
 641                 if ( !anew->an_desc ) {
 642                         switch( anew->an_name.bv_val[0] ) {
 643                         case '-': {
 644                                         struct berval adname;
 645                                         adname.bv_len = anew->an_name.bv_len - 1;
 646                                         adname.bv_val = &anew->an_name.bv_val[1];
 647                                         slap_bv2ad(&adname, &anew->an_desc, &text);
 648                                         if ( !anew->an_desc ) {
 649                                                 free( an );
 650                                                 /* overwrites input string on error! */
 651                                                 strcpy( in, s );
 652                                                 return NULL;
 653                                         }
 654                                 } break;
 655                         case '+': {
 656                                         struct berval ocname;
 657                                         ocname.bv_len = anew->an_name.bv_len - 1;
 658                                         ocname.bv_val = &anew->an_name.bv_val[1];
 659                                         anew->an_oc = oc_bvfind( &ocname );
 660                                         if ( !anew->an_oc ) {
 661                                                 free( an );
 662                                                 /* overwrites input string on error! */
 663                                                 strcpy( in, s );
 664                                                 return NULL;
 665                                         }
 666                                 } break;
 667                         default:
 668                                 /* old (deprecated) way */
 669                                 anew->an_oc = oc_bvfind( &anew->an_name );
 670                                 if ( !anew->an_oc ) {
 671                                         free( an );
 672                                         /* overwrites input string on error! */
 673                                         strcpy( in, s );
 674                                         return NULL;
 675                                 }
 676                         }
 677                 }
 678                 anew++;
 679         }
 680
 681         anew->an_name.bv_val = NULL;
 682         free( str );
 683         return( an );
 684 }
 685