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 ( is_ad_subtype( desc, attrs->an_desc ))
 438                                 return 1;
 439                         continue;
 440                 }
 441
 442                 /*
 443                  * EXTENSION: see if requested description is an object class
 444                  * if so, return attributes which the class requires/allows
 445                  */
 446                 oc = attrs->an_oc;
 447                 if( oc == NULL && attrs->an_name.bv_val ) {
 448                         switch( attrs->an_name.bv_val[0] ) {
 449                                 case '+':
 450                                 case '-': {
 451                                         struct berval ocname;
 452                                         ocname.bv_len = attrs->an_name.bv_len - 1;
 453                                         ocname.bv_val = &attrs->an_name.bv_val[1];
 454                                         oc = oc_bvfind( &ocname );
 455                                 } break;
 456                                 default:
 457                                         oc = oc_bvfind( &attrs->an_name );
 458                         }
 459                         attrs->an_oc = oc;
 460                 }
 461                 if( oc != NULL ) {
 462                         if ( oc == slap_schema.si_oc_extensibleObject ) {
 463                                 /* extensibleObject allows the return of anything */
 464                                 return 1;
 465                         }
 466
 467                         if( oc->soc_required ) {
 468                                 /* allow return of required attributes */
 469                                 int i;
 470                                 for ( i = 0; oc->soc_required[i] != NULL; i++ ) {
 471                                         rc = is_at_subtype( desc->ad_type,
 472                                                 oc->soc_required[i] );
 473                                         if( rc ) return 1;
 474                                 }
 475                         }
 476
 477                         if( oc->soc_allowed ) {
 478                                 /* allow return of allowed attributes */
 479                                 int i;
 480                                 for ( i = 0; oc->soc_allowed[i] != NULL; i++ ) {
 481                                         rc = is_at_subtype( desc->ad_type,
 482                                                 oc->soc_allowed[i] );
 483                                         if( rc ) return 1;
 484                                 }
 485                         }
 486
 487                 } else {
 488                         /* short-circuit this search next time around */
 489                         if (!slap_schema.si_at_undefined->sat_ad) {
 490                                 const char *text;
 491                                 slap_bv2undef_ad(&attrs->an_name,
 492                                         &attrs->an_desc, &text);
 493                         } else {
 494                                 attrs->an_desc =
 495                                         slap_schema.si_at_undefined->sat_ad;
 496                         }
 497                 }
 498         }
 499
 500         return 0;
 501 }
 502
 503
 504 int slap_str2undef_ad(
 505         const char *str,
 506         AttributeDescription **ad,
 507         const char **text )
 508 {
 509         struct berval bv;
 510         bv.bv_val = (char *) str;
 511         bv.bv_len = strlen( str );
 512
 513         return slap_bv2undef_ad( &bv, ad, text );
 514 }
 515
 516 int slap_bv2undef_ad(
 517         struct berval *bv,
 518         AttributeDescription **ad,
 519         const char **text )
 520 {
 521         AttributeDescription *desc;
 522
 523         assert( ad != NULL );
 524
 525         if( bv == NULL || bv->bv_len == 0 ) {
 526                 *text = "empty attribute description";
 527                 return LDAP_UNDEFINED_TYPE;
 528         }
 529
 530         /* make sure description is IA5 */
 531         if( ad_keystring( bv ) ) {
 532                 *text = "attribute description contains inappropriate characters";
 533                 return LDAP_UNDEFINED_TYPE;
 534         }
 535
 536         for( desc = slap_schema.si_at_undefined->sat_ad; desc;
 537                 desc=desc->ad_next )
 538         {
 539                 if( desc->ad_cname.bv_len == bv->bv_len &&
 540                     !strcasecmp( desc->ad_cname.bv_val, bv->bv_val ))
 541                 {
 542                         break;
 543                 }
 544         }
 545
 546         if( !desc ) {
 547                 desc = ch_malloc(sizeof(AttributeDescription) + 1 +
 548                         bv->bv_len);
 549
 550                 desc->ad_flags = SLAP_DESC_NONE;
 551                 desc->ad_lang.bv_val = NULL;
 552                 desc->ad_lang.bv_len = 0;
 553
 554                 desc->ad_cname.bv_len = bv->bv_len;
 555                 desc->ad_cname.bv_val = (char *)(desc+1);
 556                 strcpy(desc->ad_cname.bv_val, bv->bv_val);
 557
 558                 /* canonical to upper case */
 559                 ldap_pvt_str2upper( desc->ad_cname.bv_val );
 560
 561                 desc->ad_type = slap_schema.si_at_undefined;
 562                 desc->ad_next = desc->ad_type->sat_ad;
 563                 desc->ad_type->sat_ad = desc;
 564         }
 565
 566         if( !*ad ) {
 567                 *ad = desc;
 568         } else {
 569                 **ad = *desc;
 570         }
 571
 572         return LDAP_SUCCESS;
 573 }
 574
 575 int
 576 an_find(
 577     AttributeName *a,
 578     struct berval *s
 579 )
 580 {
 581         if( a == NULL ) return 0;
 582
 583         for ( ; a->an_name.bv_val; a++ ) {
 584                 if ( a->an_name.bv_len != s->bv_len) continue;
 585                 if ( strcasecmp( s->bv_val, a->an_name.bv_val ) == 0 ) {
 586                         return( 1 );
 587                 }
 588         }
 589
 590         return( 0 );
 591 }
 592
 593 /* Convert a delimited string into a list of AttributeNames; Add on
 594  * to an existing list if it was given.
 595  */
 596 AttributeName *
 597 str2anlist( AttributeName *an, char *in, const char *brkstr )
 598 {
 599         char    *str;
 600         char    *s;
 601         char    *lasts;
 602         int     i, j;
 603         const char *text;
 604         AttributeName *anew;
 605
 606         /* find last element in list */
 607         for (i = 0; an && an[i].an_name.bv_val; i++);
 608
 609         /* protect the input string from strtok */
 610         str = ch_strdup( in );
 611
 612         /* Count words in string */
 613         j=1;
 614         for ( s = str; *s; s++ ) {
 615                 if ( strchr( brkstr, *s ) != NULL ) {
 616                         j++;
 617                 }
 618         }
 619
 620         an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) );
 621         anew = an + i;
 622         for ( s = ldap_pvt_strtok( str, brkstr, &lasts );
 623                 s != NULL;
 624                 s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )
 625         {
 626                 anew->an_desc = NULL;
 627                 anew->an_oc = NULL;
 628                 ber_str2bv(s, 0, 1, &anew->an_name);
 629                 slap_bv2ad(&anew->an_name, &anew->an_desc, &text);
 630                 if ( !anew->an_desc ) {
 631                         anew->an_oc = oc_bvfind( &anew->an_name );
 632                         if ( !anew->an_oc ) {
 633                                 free( an );
 634                                 /* overwrites input string on error! */
 635                                 strcpy( in, s );
 636                                 return NULL;
 637                         }
 638                 }
 639                 anew++;
 640         }
 641         anew->an_name.bv_val = NULL;
 642
 643         free( str );
 644         return( an );
 645 }
 646