git.sur5r.net Git - openldap/blob - libraries/libldap/schema.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1998-2005 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15
  16 /*
  17  * schema.c:  parsing routines used by servers and clients to process
  18  *      schema definitions
  19  */
  20
  21 #include "portable.h"
  22
  23 #include <stdio.h>
  24 #include <ac/stdlib.h>
  25
  26 #include <ac/string.h>
  27 #include <ac/time.h>
  28
  29 #include "ldap-int.h"
  30
  31 #include <ldap_schema.h>
  32
  33 static const char *
  34 choose_name( char *names[], const char *fallback )
  35 {
  36         return (names != NULL && names[0] != NULL) ? names[0] : fallback;
  37 }
  38
  39 LDAP_CONST char *
  40 ldap_syntax2name( LDAPSyntax * syn )
  41 {
  42         return( syn->syn_oid );
  43 }
  44
  45 LDAP_CONST char *
  46 ldap_matchingrule2name( LDAPMatchingRule * mr )
  47 {
  48         return( choose_name( mr->mr_names, mr->mr_oid ) );
  49 }
  50
  51 LDAP_CONST char *
  52 ldap_matchingruleuse2name( LDAPMatchingRuleUse * mru )
  53 {
  54         return( choose_name( mru->mru_names, mru->mru_oid ) );
  55 }
  56
  57 LDAP_CONST char *
  58 ldap_attributetype2name( LDAPAttributeType * at )
  59 {
  60         return( choose_name( at->at_names, at->at_oid ) );
  61 }
  62
  63 LDAP_CONST char *
  64 ldap_objectclass2name( LDAPObjectClass * oc )
  65 {
  66         return( choose_name( oc->oc_names, oc->oc_oid ) );
  67 }
  68
  69 LDAP_CONST char *
  70 ldap_contentrule2name( LDAPContentRule * cr )
  71 {
  72         return( choose_name( cr->cr_names, cr->cr_oid ) );
  73 }
  74
  75 LDAP_CONST char *
  76 ldap_nameform2name( LDAPNameForm * nf )
  77 {
  78         return( choose_name( nf->nf_names, nf->nf_oid ) );
  79 }
  80
  81 LDAP_CONST char *
  82 ldap_structurerule2name( LDAPStructureRule * sr )
  83 {
  84         return( choose_name( sr->sr_names, NULL ) );
  85 }
  86
  87 /*
  88  * When pretty printing the entities we will be appending to a buffer.
  89  * Since checking for overflow, realloc'ing and checking if no error
  90  * is extremely boring, we will use a protection layer that will let
  91  * us blissfully ignore the error until the end.  This layer is
  92  * implemented with the help of the next type.
  93  */
  94
  95 typedef struct safe_string {
  96         char * val;
  97         ber_len_t size;
  98         ber_len_t pos;
  99         int at_whsp;
 100 } safe_string;
 101
 102 static safe_string *
 103 new_safe_string(int size)
 104 {
 105         safe_string * ss;
 106
 107         ss = LDAP_MALLOC(sizeof(safe_string));
 108         if ( !ss )
 109                 return(NULL);
 110
 111         ss->val = LDAP_MALLOC(size);
 112         if ( !ss->val ) {
 113                 LDAP_FREE(ss);
 114                 return(NULL);
 115         }
 116
 117         ss->size = size;
 118         ss->pos = 0;
 119         ss->at_whsp = 0;
 120
 121         return ss;
 122 }
 123
 124 static void
 125 safe_string_free(safe_string * ss)
 126 {
 127         if ( !ss )
 128                 return;
 129         LDAP_FREE(ss->val);
 130         LDAP_FREE(ss);
 131 }
 132
 133 #if 0   /* unused */
 134 static char *
 135 safe_string_val(safe_string * ss)
 136 {
 137         ss->val[ss->pos] = '\0';
 138         return(ss->val);
 139 }
 140 #endif
 141
 142 static char *
 143 safe_strdup(safe_string * ss)
 144 {
 145         char *ret = LDAP_MALLOC(ss->pos+1);
 146         if (!ret)
 147                 return NULL;
 148         AC_MEMCPY(ret, ss->val, ss->pos);
 149         ret[ss->pos] = '\0';
 150         return ret;
 151 }
 152
 153 static int
 154 append_to_safe_string(safe_string * ss, char * s)
 155 {
 156         int l = strlen(s);
 157         char * temp;
 158
 159         /*
 160          * Some runaway process is trying to append to a string that
 161          * overflowed and we could not extend.
 162          */
 163         if ( !ss->val )
 164                 return -1;
 165
 166         /* We always make sure there is at least one position available */
 167         if ( ss->pos + l >= ss->size-1 ) {
 168                 ss->size *= 2;
 169                 if ( ss->pos + l >= ss->size-1 ) {
 170                         ss->size = ss->pos + l + 1;
 171                 }
 172
 173                 temp = LDAP_REALLOC(ss->val, ss->size);
 174                 if ( !temp ) {
 175                         /* Trouble, out of memory */
 176                         LDAP_FREE(ss->val);
 177                         return -1;
 178                 }
 179                 ss->val = temp;
 180         }
 181         strncpy(&ss->val[ss->pos], s, l);
 182         ss->pos += l;
 183         if ( ss->pos > 0 && LDAP_SPACE(ss->val[ss->pos-1]) )
 184                 ss->at_whsp = 1;
 185         else
 186                 ss->at_whsp = 0;
 187
 188         return 0;
 189 }
 190
 191 static int
 192 print_literal(safe_string *ss, char *s)
 193 {
 194         return(append_to_safe_string(ss,s));
 195 }
 196
 197 static int
 198 print_whsp(safe_string *ss)
 199 {
 200         if ( ss->at_whsp )
 201                 return(append_to_safe_string(ss,""));
 202         else
 203                 return(append_to_safe_string(ss," "));
 204 }
 205
 206 static int
 207 print_numericoid(safe_string *ss, char *s)
 208 {
 209         if ( s )
 210                 return(append_to_safe_string(ss,s));
 211         else
 212                 return(append_to_safe_string(ss,""));
 213 }
 214
 215 /* This one is identical to print_qdescr */
 216 static int
 217 print_qdstring(safe_string *ss, char *s)
 218 {
 219         print_whsp(ss);
 220         print_literal(ss,"'");
 221         append_to_safe_string(ss,s);
 222         print_literal(ss,"'");
 223         return(print_whsp(ss));
 224 }
 225
 226 static int
 227 print_qdescr(safe_string *ss, char *s)
 228 {
 229         print_whsp(ss);
 230         print_literal(ss,"'");
 231         append_to_safe_string(ss,s);
 232         print_literal(ss,"'");
 233         return(print_whsp(ss));
 234 }
 235
 236 static int
 237 print_qdescrlist(safe_string *ss, char **sa)
 238 {
 239         char **sp;
 240         int ret = 0;
 241
 242         for (sp=sa; *sp; sp++) {
 243                 ret = print_qdescr(ss,*sp);
 244         }
 245         /* If the list was empty, we return zero that is potentially
 246          * incorrect, but since we will be still appending things, the
 247          * overflow will be detected later.  Maybe FIX.
 248          */
 249         return(ret);
 250 }
 251
 252 static int
 253 print_qdescrs(safe_string *ss, char **sa)
 254 {
 255         /* The only way to represent an empty list is as a qdescrlist
 256          * so, if the list is empty we treat it as a long list.
 257          * Really, this is what the syntax mandates.  We should not
 258          * be here if the list was empty, but if it happens, a label
 259          * has already been output and we cannot undo it.
 260          */
 261         if ( !sa[0] || ( sa[0] && sa[1] ) ) {
 262                 print_whsp(ss);
 263                 print_literal(ss,"("/*)*/);
 264                 print_qdescrlist(ss,sa);
 265                 print_literal(ss,/*(*/")");
 266                 return(print_whsp(ss));
 267         } else {
 268           return(print_qdescr(ss,*sa));
 269         }
 270 }
 271
 272 static int
 273 print_woid(safe_string *ss, char *s)
 274 {
 275         print_whsp(ss);
 276         append_to_safe_string(ss,s);
 277         return print_whsp(ss);
 278 }
 279
 280 static int
 281 print_oidlist(safe_string *ss, char **sa)
 282 {
 283         char **sp;
 284
 285         for (sp=sa; *(sp+1); sp++) {
 286                 print_woid(ss,*sp);
 287                 print_literal(ss,"$");
 288         }
 289         return(print_woid(ss,*sp));
 290 }
 291
 292 static int
 293 print_oids(safe_string *ss, char **sa)
 294 {
 295         if ( sa[0] && sa[1] ) {
 296                 print_literal(ss,"("/*)*/);
 297                 print_oidlist(ss,sa);
 298                 print_whsp(ss);
 299                 return(print_literal(ss,/*(*/")"));
 300         } else {
 301                 return(print_woid(ss,*sa));
 302         }
 303 }
 304
 305 static int
 306 print_noidlen(safe_string *ss, char *s, int l)
 307 {
 308         char buf[64];
 309         int ret;
 310
 311         ret = print_numericoid(ss,s);
 312         if ( l ) {
 313                 snprintf(buf, sizeof buf, "{%d}",l);
 314                 ret = print_literal(ss,buf);
 315         }
 316         return(ret);
 317 }
 318
 319 static int
 320 print_ruleid(safe_string *ss, int rid)
 321 {
 322         char buf[64];
 323         snprintf(buf, sizeof buf, "%d", rid);
 324         return print_literal(ss,buf);
 325 }
 326
 327 static int
 328 print_ruleids(safe_string *ss, int n, int *rids)
 329 {
 330         int i;
 331
 332         if( n == 1 ) {
 333                 print_ruleid(ss,rids[0]);
 334                 return print_whsp(ss);
 335         } else {
 336                 print_literal(ss,"("/*)*/);
 337                 for( i=0; i<n; i++ ) {
 338                         print_whsp(ss);
 339                         print_ruleid(ss,rids[i]);
 340                 }
 341                 print_whsp(ss);
 342                 return print_literal(ss,/*(*/")");
 343         }
 344 }
 345
 346
 347 static int
 348 print_extensions(safe_string *ss, LDAPSchemaExtensionItem **extensions)
 349 {
 350         LDAPSchemaExtensionItem **ext;
 351
 352         if ( extensions ) {
 353                 print_whsp(ss);
 354                 for ( ext = extensions; *ext != NULL; ext++ ) {
 355                         print_literal(ss, (*ext)->lsei_name);
 356                         print_whsp(ss);
 357                         /* Should be print_qdstrings */
 358                         print_qdescrs(ss, (*ext)->lsei_values);
 359                         print_whsp(ss);
 360                 }
 361         }
 362
 363         return 0;
 364 }
 365
 366 char *
 367 ldap_syntax2str( LDAPSyntax * syn )
 368 {
 369         struct berval bv;
 370         if (ldap_syntax2bv( syn, &bv ))
 371                 return(bv.bv_val);
 372         else
 373                 return NULL;
 374 }
 375
 376 struct berval *
 377 ldap_syntax2bv( LDAPSyntax * syn, struct berval *bv )
 378 {
 379         safe_string * ss;
 380
 381         ss = new_safe_string(256);
 382         if ( !ss )
 383                 return NULL;
 384
 385         print_literal(ss,"("/*)*/);
 386         print_whsp(ss);
 387
 388         print_numericoid(ss, syn->syn_oid);
 389         print_whsp(ss);
 390
 391         if ( syn->syn_desc ) {
 392                 print_literal(ss,"DESC");
 393                 print_qdstring(ss,syn->syn_desc);
 394         }
 395
 396         print_whsp(ss);
 397
 398         print_extensions(ss, syn->syn_extensions);
 399
 400         print_literal(ss,/*(*/ ")");
 401
 402         bv->bv_val = safe_strdup(ss);
 403         bv->bv_len = ss->pos;
 404         safe_string_free(ss);
 405         return(bv);
 406 }
 407
 408 char *
 409 ldap_matchingrule2str( LDAPMatchingRule * mr )
 410 {
 411         struct berval bv;
 412         if (ldap_matchingrule2bv( mr, &bv ))
 413                 return(bv.bv_val);
 414         else
 415                 return NULL;
 416 }
 417
 418 struct berval *
 419 ldap_matchingrule2bv( LDAPMatchingRule * mr, struct berval *bv )
 420 {
 421         safe_string * ss;
 422
 423         ss = new_safe_string(256);
 424         if ( !ss )
 425                 return NULL;
 426
 427         print_literal(ss,"(" /*)*/);
 428         print_whsp(ss);
 429
 430         print_numericoid(ss, mr->mr_oid);
 431         print_whsp(ss);
 432
 433         if ( mr->mr_names ) {
 434                 print_literal(ss,"NAME");
 435                 print_qdescrs(ss,mr->mr_names);
 436         }
 437
 438         if ( mr->mr_desc ) {
 439                 print_literal(ss,"DESC");
 440                 print_qdstring(ss,mr->mr_desc);
 441         }
 442
 443         if ( mr->mr_obsolete ) {
 444                 print_literal(ss, "OBSOLETE");
 445                 print_whsp(ss);
 446         }
 447
 448         if ( mr->mr_syntax_oid ) {
 449                 print_literal(ss,"SYNTAX");
 450                 print_whsp(ss);
 451                 print_literal(ss, mr->mr_syntax_oid);
 452                 print_whsp(ss);
 453         }
 454
 455         print_whsp(ss);
 456
 457         print_extensions(ss, mr->mr_extensions);
 458
 459         print_literal(ss,/*(*/")");
 460
 461         bv->bv_val = safe_strdup(ss);
 462         bv->bv_len = ss->pos;
 463         safe_string_free(ss);
 464         return(bv);
 465 }
 466
 467 char *
 468 ldap_matchingruleuse2str( LDAPMatchingRuleUse * mru )
 469 {
 470         struct berval bv;
 471         if (ldap_matchingruleuse2bv( mru, &bv ))
 472                 return(bv.bv_val);
 473         else
 474                 return NULL;
 475 }
 476
 477 struct berval *
 478 ldap_matchingruleuse2bv( LDAPMatchingRuleUse * mru, struct berval *bv )
 479 {
 480         safe_string * ss;
 481
 482         ss = new_safe_string(256);
 483         if ( !ss )
 484                 return NULL;
 485
 486         print_literal(ss,"(" /*)*/);
 487         print_whsp(ss);
 488
 489         print_numericoid(ss, mru->mru_oid);
 490         print_whsp(ss);
 491
 492         if ( mru->mru_names ) {
 493                 print_literal(ss,"NAME");
 494                 print_qdescrs(ss,mru->mru_names);
 495         }
 496
 497         if ( mru->mru_desc ) {
 498                 print_literal(ss,"DESC");
 499                 print_qdstring(ss,mru->mru_desc);
 500         }
 501
 502         if ( mru->mru_obsolete ) {
 503                 print_literal(ss, "OBSOLETE");
 504                 print_whsp(ss);
 505         }
 506
 507         if ( mru->mru_applies_oids ) {
 508                 print_literal(ss,"APPLIES");
 509                 print_whsp(ss);
 510                 print_oids(ss, mru->mru_applies_oids);
 511                 print_whsp(ss);
 512         }
 513
 514         print_whsp(ss);
 515
 516         print_extensions(ss, mru->mru_extensions);
 517
 518         print_literal(ss,/*(*/")");
 519
 520         bv->bv_val = safe_strdup(ss);
 521         bv->bv_len = ss->pos;
 522         safe_string_free(ss);
 523         return(bv);
 524 }
 525
 526 char *
 527 ldap_objectclass2str( LDAPObjectClass * oc )
 528 {
 529         struct berval bv;
 530         if (ldap_objectclass2bv( oc, &bv ))
 531                 return(bv.bv_val);
 532         else
 533                 return NULL;
 534 }
 535
 536 struct berval *
 537 ldap_objectclass2bv( LDAPObjectClass * oc, struct berval *bv )
 538 {
 539         safe_string * ss;
 540
 541         ss = new_safe_string(256);
 542         if ( !ss )
 543                 return NULL;
 544
 545         print_literal(ss,"("/*)*/);
 546         print_whsp(ss);
 547
 548         print_numericoid(ss, oc->oc_oid);
 549         print_whsp(ss);
 550
 551         if ( oc->oc_names ) {
 552                 print_literal(ss,"NAME");
 553                 print_qdescrs(ss,oc->oc_names);
 554         }
 555
 556         if ( oc->oc_desc ) {
 557                 print_literal(ss,"DESC");
 558                 print_qdstring(ss,oc->oc_desc);
 559         }
 560
 561         if ( oc->oc_obsolete ) {
 562                 print_literal(ss, "OBSOLETE");
 563                 print_whsp(ss);
 564         }
 565
 566         if ( oc->oc_sup_oids ) {
 567                 print_literal(ss,"SUP");
 568                 print_whsp(ss);
 569                 print_oids(ss,oc->oc_sup_oids);
 570                 print_whsp(ss);
 571         }
 572
 573         switch (oc->oc_kind) {
 574         case LDAP_SCHEMA_ABSTRACT:
 575                 print_literal(ss,"ABSTRACT");
 576                 break;
 577         case LDAP_SCHEMA_STRUCTURAL:
 578                 print_literal(ss,"STRUCTURAL");
 579                 break;
 580         case LDAP_SCHEMA_AUXILIARY:
 581                 print_literal(ss,"AUXILIARY");
 582                 break;
 583         default:
 584                 print_literal(ss,"KIND-UNKNOWN");
 585                 break;
 586         }
 587         print_whsp(ss);
 588
 589         if ( oc->oc_at_oids_must ) {
 590                 print_literal(ss,"MUST");
 591                 print_whsp(ss);
 592                 print_oids(ss,oc->oc_at_oids_must);
 593                 print_whsp(ss);
 594         }
 595
 596         if ( oc->oc_at_oids_may ) {
 597                 print_literal(ss,"MAY");
 598                 print_whsp(ss);
 599                 print_oids(ss,oc->oc_at_oids_may);
 600                 print_whsp(ss);
 601         }
 602
 603         print_whsp(ss);
 604
 605         print_extensions(ss, oc->oc_extensions);
 606
 607         print_literal(ss, /*(*/")");
 608
 609         bv->bv_val = safe_strdup(ss);
 610         bv->bv_len = ss->pos;
 611         safe_string_free(ss);
 612         return(bv);
 613 }
 614
 615 char *
 616 ldap_contentrule2str( LDAPContentRule * cr )
 617 {
 618         struct berval bv;
 619         if (ldap_contentrule2bv( cr, &bv ))
 620                 return(bv.bv_val);
 621         else
 622                 return NULL;
 623 }
 624
 625 struct berval *
 626 ldap_contentrule2bv( LDAPContentRule * cr, struct berval *bv )
 627 {
 628         safe_string * ss;
 629
 630         ss = new_safe_string(256);
 631         if ( !ss )
 632                 return NULL;
 633
 634         print_literal(ss,"("/*)*/);
 635         print_whsp(ss);
 636
 637         print_numericoid(ss, cr->cr_oid);
 638         print_whsp(ss);
 639
 640         if ( cr->cr_names ) {
 641                 print_literal(ss,"NAME");
 642                 print_qdescrs(ss,cr->cr_names);
 643         }
 644
 645         if ( cr->cr_desc ) {
 646                 print_literal(ss,"DESC");
 647                 print_qdstring(ss,cr->cr_desc);
 648         }
 649
 650         if ( cr->cr_obsolete ) {
 651                 print_literal(ss, "OBSOLETE");
 652                 print_whsp(ss);
 653         }
 654
 655         if ( cr->cr_oc_oids_aux ) {
 656                 print_literal(ss,"AUX");
 657                 print_whsp(ss);
 658                 print_oids(ss,cr->cr_oc_oids_aux);
 659                 print_whsp(ss);
 660         }
 661
 662         if ( cr->cr_at_oids_must ) {
 663                 print_literal(ss,"MUST");
 664                 print_whsp(ss);
 665                 print_oids(ss,cr->cr_at_oids_must);
 666                 print_whsp(ss);
 667         }
 668
 669         if ( cr->cr_at_oids_may ) {
 670                 print_literal(ss,"MAY");
 671                 print_whsp(ss);
 672                 print_oids(ss,cr->cr_at_oids_may);
 673                 print_whsp(ss);
 674         }
 675
 676         if ( cr->cr_at_oids_not ) {
 677                 print_literal(ss,"NOT");
 678                 print_whsp(ss);
 679                 print_oids(ss,cr->cr_at_oids_not);
 680                 print_whsp(ss);
 681         }
 682
 683         print_whsp(ss);
 684         print_extensions(ss, cr->cr_extensions);
 685
 686         print_literal(ss, /*(*/")");
 687
 688         bv->bv_val = safe_strdup(ss);
 689         bv->bv_len = ss->pos;
 690         safe_string_free(ss);
 691         return(bv);
 692 }
 693
 694 char *
 695 ldap_structurerule2str( LDAPStructureRule * sr )
 696 {
 697         struct berval bv;
 698         if (ldap_structurerule2bv( sr, &bv ))
 699                 return(bv.bv_val);
 700         else
 701                 return NULL;
 702 }
 703
 704 struct berval *
 705 ldap_structurerule2bv( LDAPStructureRule * sr, struct berval *bv )
 706 {
 707         safe_string * ss;
 708
 709         ss = new_safe_string(256);
 710         if ( !ss )
 711                 return NULL;
 712
 713         print_literal(ss,"("/*)*/);
 714         print_whsp(ss);
 715
 716         print_ruleid(ss, sr->sr_ruleid);
 717         print_whsp(ss);
 718
 719         if ( sr->sr_names ) {
 720                 print_literal(ss,"NAME");
 721                 print_qdescrs(ss,sr->sr_names);
 722         }
 723
 724         if ( sr->sr_desc ) {
 725                 print_literal(ss,"DESC");
 726                 print_qdstring(ss,sr->sr_desc);
 727         }
 728
 729         if ( sr->sr_obsolete ) {
 730                 print_literal(ss, "OBSOLETE");
 731                 print_whsp(ss);
 732         }
 733
 734         print_literal(ss,"FORM");
 735         print_whsp(ss);
 736         print_woid(ss,sr->sr_nameform);
 737         print_whsp(ss);
 738
 739         if ( sr->sr_nsup_ruleids ) {
 740                 print_literal(ss,"SUP");
 741                 print_whsp(ss);
 742                 print_ruleids(ss,sr->sr_nsup_ruleids,sr->sr_sup_ruleids);
 743                 print_whsp(ss);
 744         }
 745
 746         print_whsp(ss);
 747         print_extensions(ss, sr->sr_extensions);
 748
 749         print_literal(ss, /*(*/")");
 750
 751         bv->bv_val = safe_strdup(ss);
 752         bv->bv_len = ss->pos;
 753         safe_string_free(ss);
 754         return(bv);
 755 }
 756
 757
 758 char *
 759 ldap_nameform2str( LDAPNameForm * nf )
 760 {
 761         struct berval bv;
 762         if (ldap_nameform2bv( nf, &bv ))
 763                 return(bv.bv_val);
 764         else
 765                 return NULL;
 766 }
 767
 768 struct berval *
 769 ldap_nameform2bv( LDAPNameForm * nf, struct berval *bv )
 770 {
 771         safe_string * ss;
 772
 773         ss = new_safe_string(256);
 774         if ( !ss )
 775                 return NULL;
 776
 777         print_literal(ss,"("/*)*/);
 778         print_whsp(ss);
 779
 780         print_numericoid(ss, nf->nf_oid);
 781         print_whsp(ss);
 782
 783         if ( nf->nf_names ) {
 784                 print_literal(ss,"NAME");
 785                 print_qdescrs(ss,nf->nf_names);
 786         }
 787
 788         if ( nf->nf_desc ) {
 789                 print_literal(ss,"DESC");
 790                 print_qdstring(ss,nf->nf_desc);
 791         }
 792
 793         if ( nf->nf_obsolete ) {
 794                 print_literal(ss, "OBSOLETE");
 795                 print_whsp(ss);
 796         }
 797
 798         print_literal(ss,"OC");
 799         print_whsp(ss);
 800         print_woid(ss,nf->nf_objectclass);
 801         print_whsp(ss);
 802
 803         print_literal(ss,"MUST");
 804         print_whsp(ss);
 805         print_oids(ss,nf->nf_at_oids_must);
 806         print_whsp(ss);
 807
 808
 809         if ( nf->nf_at_oids_may ) {
 810                 print_literal(ss,"MAY");
 811                 print_whsp(ss);
 812                 print_oids(ss,nf->nf_at_oids_may);
 813                 print_whsp(ss);
 814         }
 815
 816         print_whsp(ss);
 817         print_extensions(ss, nf->nf_extensions);
 818
 819         print_literal(ss, /*(*/")");
 820
 821         bv->bv_val = safe_strdup(ss);
 822         bv->bv_len = ss->pos;
 823         safe_string_free(ss);
 824         return(bv);
 825 }
 826
 827 char *
 828 ldap_attributetype2str( LDAPAttributeType * at )
 829 {
 830         struct berval bv;
 831         if (ldap_attributetype2bv( at, &bv ))
 832                 return(bv.bv_val);
 833         else
 834                 return NULL;
 835 }
 836
 837 struct berval *
 838 ldap_attributetype2bv(  LDAPAttributeType * at, struct berval *bv )
 839 {
 840         safe_string * ss;
 841
 842         ss = new_safe_string(256);
 843         if ( !ss )
 844                 return NULL;
 845
 846         print_literal(ss,"("/*)*/);
 847         print_whsp(ss);
 848
 849         print_numericoid(ss, at->at_oid);
 850         print_whsp(ss);
 851
 852         if ( at->at_names ) {
 853                 print_literal(ss,"NAME");
 854                 print_qdescrs(ss,at->at_names);
 855         }
 856
 857         if ( at->at_desc ) {
 858                 print_literal(ss,"DESC");
 859                 print_qdstring(ss,at->at_desc);
 860         }
 861
 862         if ( at->at_obsolete ) {
 863                 print_literal(ss, "OBSOLETE");
 864                 print_whsp(ss);
 865         }
 866
 867         if ( at->at_sup_oid ) {
 868                 print_literal(ss,"SUP");
 869                 print_woid(ss,at->at_sup_oid);
 870         }
 871
 872         if ( at->at_equality_oid ) {
 873                 print_literal(ss,"EQUALITY");
 874                 print_woid(ss,at->at_equality_oid);
 875         }
 876
 877         if ( at->at_ordering_oid ) {
 878                 print_literal(ss,"ORDERING");
 879                 print_woid(ss,at->at_ordering_oid);
 880         }
 881
 882         if ( at->at_substr_oid ) {
 883                 print_literal(ss,"SUBSTR");
 884                 print_woid(ss,at->at_substr_oid);
 885         }
 886
 887         if ( at->at_syntax_oid ) {
 888                 print_literal(ss,"SYNTAX");
 889                 print_whsp(ss);
 890                 print_noidlen(ss,at->at_syntax_oid,at->at_syntax_len);
 891                 print_whsp(ss);
 892         }
 893
 894         if ( at->at_single_value == LDAP_SCHEMA_YES ) {
 895                 print_literal(ss,"SINGLE-VALUE");
 896                 print_whsp(ss);
 897         }
 898
 899         if ( at->at_collective == LDAP_SCHEMA_YES ) {
 900                 print_literal(ss,"COLLECTIVE");
 901                 print_whsp(ss);
 902         }
 903
 904         if ( at->at_no_user_mod == LDAP_SCHEMA_YES ) {
 905                 print_literal(ss,"NO-USER-MODIFICATION");
 906                 print_whsp(ss);
 907         }
 908
 909         if ( at->at_usage != LDAP_SCHEMA_USER_APPLICATIONS ) {
 910                 print_literal(ss,"USAGE");
 911                 print_whsp(ss);
 912                 switch (at->at_usage) {
 913                 case LDAP_SCHEMA_DIRECTORY_OPERATION:
 914                         print_literal(ss,"directoryOperation");
 915                         break;
 916                 case LDAP_SCHEMA_DISTRIBUTED_OPERATION:
 917                         print_literal(ss,"distributedOperation");
 918                         break;
 919                 case LDAP_SCHEMA_DSA_OPERATION:
 920                         print_literal(ss,"dSAOperation");
 921                         break;
 922                 default:
 923                         print_literal(ss,"UNKNOWN");
 924                         break;
 925                 }
 926         }
 927
 928         print_whsp(ss);
 929
 930         print_extensions(ss, at->at_extensions);
 931
 932         print_literal(ss,/*(*/")");
 933
 934         bv->bv_val = safe_strdup(ss);
 935         bv->bv_len = ss->pos;
 936         safe_string_free(ss);
 937         return(bv);
 938 }
 939
 940 /*
 941  * Now come the parsers.  There is one parser for each entity type:
 942  * objectclasses, attributetypes, etc.
 943  *
 944  * Each of them is written as a recursive-descent parser, except that
 945  * none of them is really recursive.  But the idea is kept: there
 946  * is one routine per non-terminal that eithers gobbles lexical tokens
 947  * or calls lower-level routines, etc.
 948  *
 949  * The scanner is implemented in the routine get_token.  Actually,
 950  * get_token is more than a scanner and will return tokens that are
 951  * in fact non-terminals in the grammar.  So you can see the whole
 952  * approach as the combination of a low-level bottom-up recognizer
 953  * combined with a scanner and a number of top-down parsers.  Or just
 954  * consider that the real grammars recognized by the parsers are not
 955  * those of the standards.  As a matter of fact, our parsers are more
 956  * liberal than the spec when there is no ambiguity.
 957  *
 958  * The difference is pretty academic (modulo bugs or incorrect
 959  * interpretation of the specs).
 960  */
 961
 962 #define TK_NOENDQUOTE   -2
 963 #define TK_OUTOFMEM     -1
 964 #define TK_EOS          0
 965 #define TK_UNEXPCHAR    1
 966 #define TK_BAREWORD     2
 967 #define TK_QDSTRING     3
 968 #define TK_LEFTPAREN    4
 969 #define TK_RIGHTPAREN   5
 970 #define TK_DOLLAR       6
 971 #define TK_QDESCR       TK_QDSTRING
 972
 973 struct token {
 974         int type;
 975         char *sval;
 976 };
 977
 978 static int
 979 get_token( const char ** sp, char ** token_val )
 980 {
 981         int kind;
 982         const char * p;
 983         const char * q;
 984         char * res;
 985
 986         *token_val = NULL;
 987         switch (**sp) {
 988         case '\0':
 989                 kind = TK_EOS;
 990                 (*sp)++;
 991                 break;
 992         case '(':
 993                 kind = TK_LEFTPAREN;
 994                 (*sp)++;
 995                 break;
 996         case ')':
 997                 kind = TK_RIGHTPAREN;
 998                 (*sp)++;
 999                 break;
1000         case '$':
1001                 kind = TK_DOLLAR;
1002                 (*sp)++;
1003                 break;
1004         case '\'':
1005                 kind = TK_QDSTRING;
1006                 (*sp)++;
1007                 p = *sp;
1008                 while ( **sp != '\'' && **sp != '\0' )
1009                         (*sp)++;
1010                 if ( **sp == '\'' ) {
1011                         q = *sp;
1012                         res = LDAP_MALLOC(q-p+1);
1013                         if ( !res ) {
1014                                 kind = TK_OUTOFMEM;
1015                         } else {
1016                                 strncpy(res,p,q-p);
1017                                 res[q-p] = '\0';
1018                                 *token_val = res;
1019                         }
1020                         (*sp)++;
1021                 } else {
1022                         kind = TK_NOENDQUOTE;
1023                 }
1024                 break;
1025         default:
1026                 kind = TK_BAREWORD;
1027                 p = *sp;
1028                 while ( !LDAP_SPACE(**sp) &&
1029                         **sp != '(' &&
1030                         **sp != ')' &&
1031                         **sp != '$' &&
1032                         **sp != '\'' &&
1033                         **sp != '\0' )
1034                         (*sp)++;
1035                 q = *sp;
1036                 res = LDAP_MALLOC(q-p+1);
1037                 if ( !res ) {
1038                         kind = TK_OUTOFMEM;
1039                 } else {
1040                         strncpy(res,p,q-p);
1041                         res[q-p] = '\0';
1042                         *token_val = res;
1043                 }
1044                 break;
1045 /*              kind = TK_UNEXPCHAR; */
1046 /*              break; */
1047         }
1048
1049         return kind;
1050 }
1051
1052 /* Gobble optional whitespace */
1053 static void
1054 parse_whsp(const char **sp)
1055 {
1056         while (LDAP_SPACE(**sp))
1057                 (*sp)++;
1058 }
1059
1060 /* TBC:!!
1061  * General note for all parsers: to guarantee the algorithm halts they
1062  * must always advance the pointer even when an error is found.  For
1063  * this one is not that important since an error here is fatal at the
1064  * upper layers, but it is a simple strategy that will not get in
1065  * endless loops.
1066  */
1067
1068 /* Parse a sequence of dot-separated decimal strings */
1069 char *
1070 ldap_int_parse_numericoid(const char **sp, int *code, const int flags)
1071 {
1072         char * res = NULL;
1073         const char * start = *sp;
1074         int len;
1075         int quoted = 0;
1076
1077         /* Netscape puts the SYNTAX value in quotes (incorrectly) */
1078         if ( flags & LDAP_SCHEMA_ALLOW_QUOTED && **sp == '\'' ) {
1079                 quoted = 1;
1080                 (*sp)++;
1081                 start++;
1082         }
1083         /* Each iteration of this loop gets one decimal string */
1084         while (**sp) {
1085                 if ( !LDAP_DIGIT(**sp) ) {
1086                         /*
1087                          * Initial char is not a digit or char after dot is
1088                          * not a digit
1089                          */
1090                         *code = LDAP_SCHERR_NODIGIT;
1091                         return NULL;
1092                 }
1093                 (*sp)++;
1094                 while ( LDAP_DIGIT(**sp) )
1095                         (*sp)++;
1096                 if ( **sp != '.' )
1097                         break;
1098                 /* Otherwise, gobble the dot and loop again */
1099                 (*sp)++;
1100         }
1101         /* Now *sp points at the char past the numericoid. Perfect. */
1102         len = *sp - start;
1103         if ( flags & LDAP_SCHEMA_ALLOW_QUOTED && quoted ) {
1104                 if ( **sp == '\'' ) {
1105                         (*sp)++;
1106                 } else {
1107                         *code = LDAP_SCHERR_UNEXPTOKEN;
1108                         return NULL;
1109                 }
1110         }
1111         if (flags & LDAP_SCHEMA_SKIP) {
1112                 res = (char *)start;
1113         } else {
1114                 res = LDAP_MALLOC(len+1);
1115                 if (!res) {
1116                         *code = LDAP_SCHERR_OUTOFMEM;
1117                         return(NULL);
1118                 }
1119                 strncpy(res,start,len);
1120                 res[len] = '\0';
1121         }
1122         return(res);
1123 }
1124
1125 /* Parse a sequence of dot-separated decimal strings */
1126 int
1127 ldap_int_parse_ruleid(const char **sp, int *code, const int flags, int *ruleid)
1128 {
1129         *ruleid=0;
1130
1131         if ( !LDAP_DIGIT(**sp) ) {
1132                 *code = LDAP_SCHERR_NODIGIT;
1133                 return -1;
1134         }
1135         *ruleid = (**sp) - '0';
1136         (*sp)++;
1137
1138         while ( LDAP_DIGIT(**sp) ) {
1139                 *ruleid *= 10;
1140                 *ruleid += (**sp) - '0';
1141                 (*sp)++;
1142         }
1143
1144         return 0;
1145 }
1146
1147 /* Parse a qdescr or a list of them enclosed in () */
1148 static char **
1149 parse_qdescrs(const char **sp, int *code)
1150 {
1151         char ** res;
1152         char ** res1;
1153         int kind;
1154         char * sval;
1155         int size;
1156         int pos;
1157
1158         parse_whsp(sp);
1159         kind = get_token(sp,&sval);
1160         if ( kind == TK_LEFTPAREN ) {
1161                 /* Let's presume there will be at least 2 entries */
1162                 size = 3;
1163                 res = LDAP_CALLOC(3,sizeof(char *));
1164                 if ( !res ) {
1165                         *code = LDAP_SCHERR_OUTOFMEM;
1166                         return NULL;
1167                 }
1168                 pos = 0;
1169                 while (1) {
1170                         parse_whsp(sp);
1171                         kind = get_token(sp,&sval);
1172                         if ( kind == TK_RIGHTPAREN )
1173                                 break;
1174                         if ( kind == TK_QDESCR ) {
1175                                 if ( pos == size-2 ) {
1176                                         size++;
1177                                         res1 = LDAP_REALLOC(res,size*sizeof(char *));
1178                                         if ( !res1 ) {
1179                                                 LDAP_VFREE(res);
1180                                                 LDAP_FREE(sval);
1181                                                 *code = LDAP_SCHERR_OUTOFMEM;
1182                                                 return(NULL);
1183                                         }
1184                                         res = res1;
1185                                 }
1186                                 res[pos++] = sval;
1187                                 res[pos] = NULL;
1188                                 parse_whsp(sp);
1189                         } else {
1190                                 LDAP_VFREE(res);
1191                                 LDAP_FREE(sval);
1192                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1193                                 return(NULL);
1194                         }
1195                 }
1196                 parse_whsp(sp);
1197                 return(res);
1198         } else if ( kind == TK_QDESCR ) {
1199                 res = LDAP_CALLOC(2,sizeof(char *));
1200                 if ( !res ) {
1201                         *code = LDAP_SCHERR_OUTOFMEM;
1202                         return NULL;
1203                 }
1204                 res[0] = sval;
1205                 res[1] = NULL;
1206                 parse_whsp(sp);
1207                 return res;
1208         } else {
1209                 LDAP_FREE(sval);
1210                 *code = LDAP_SCHERR_BADNAME;
1211                 return NULL;
1212         }
1213 }
1214
1215 /* Parse a woid */
1216 static char *
1217 parse_woid(const char **sp, int *code)
1218 {
1219         char * sval;
1220         int kind;
1221
1222         parse_whsp(sp);
1223         kind = get_token(sp, &sval);
1224         if ( kind != TK_BAREWORD ) {
1225                 LDAP_FREE(sval);
1226                 *code = LDAP_SCHERR_UNEXPTOKEN;
1227                 return NULL;
1228         }
1229         parse_whsp(sp);
1230         return sval;
1231 }
1232
1233 /* Parse a noidlen */
1234 static char *
1235 parse_noidlen(const char **sp, int *code, int *len, int allow_quoted)
1236 {
1237         char * sval;
1238         int quoted = 0;
1239
1240         *len = 0;
1241         /* Netscape puts the SYNTAX value in quotes (incorrectly) */
1242         if ( allow_quoted && **sp == '\'' ) {
1243                 quoted = 1;
1244                 (*sp)++;
1245         }
1246         sval = ldap_int_parse_numericoid(sp, code, 0);
1247         if ( !sval ) {
1248                 return NULL;
1249         }
1250         if ( **sp == '{' /*}*/ ) {
1251                 (*sp)++;
1252                 *len = atoi(*sp);
1253                 while ( LDAP_DIGIT(**sp) )
1254                         (*sp)++;
1255                 if ( **sp != /*{*/ '}' ) {
1256                         *code = LDAP_SCHERR_UNEXPTOKEN;
1257                         LDAP_FREE(sval);
1258                         return NULL;
1259                 }
1260                 (*sp)++;
1261         }
1262         if ( allow_quoted && quoted ) {
1263                 if ( **sp == '\'' ) {
1264                         (*sp)++;
1265                 } else {
1266                         *code = LDAP_SCHERR_UNEXPTOKEN;
1267                         LDAP_FREE(sval);
1268                         return NULL;
1269                 }
1270         }
1271         return sval;
1272 }
1273
1274 /*
1275  * Next routine will accept a qdstring in place of an oid if
1276  * allow_quoted is set.  This is necessary to interoperate with
1277  * Netscape Directory server that will improperly quote each oid (at
1278  * least those of the descr kind) in the SUP clause.
1279  */
1280
1281 /* Parse a woid or a $-separated list of them enclosed in () */
1282 static char **
1283 parse_oids(const char **sp, int *code, const int allow_quoted)
1284 {
1285         char ** res;
1286         char ** res1;
1287         int kind;
1288         char * sval;
1289         int size;
1290         int pos;
1291
1292         /*
1293          * Strictly speaking, doing this here accepts whsp before the
1294          * ( at the begining of an oidlist, but this is harmless.  Also,
1295          * we are very liberal in what we accept as an OID.  Maybe
1296          * refine later.
1297          */
1298         parse_whsp(sp);
1299         kind = get_token(sp,&sval);
1300         if ( kind == TK_LEFTPAREN ) {
1301                 /* Let's presume there will be at least 2 entries */
1302                 size = 3;
1303                 res = LDAP_CALLOC(3,sizeof(char *));
1304                 if ( !res ) {
1305                         *code = LDAP_SCHERR_OUTOFMEM;
1306                         return NULL;
1307                 }
1308                 pos = 0;
1309                 parse_whsp(sp);
1310                 kind = get_token(sp,&sval);
1311                 if ( kind == TK_BAREWORD ||
1312                      ( allow_quoted && kind == TK_QDSTRING ) ) {
1313                         res[pos++] = sval;
1314                         res[pos] = NULL;
1315                 } else if ( kind == TK_RIGHTPAREN ) {
1316                         /* FIXME: be liberal in what we accept... */
1317                         parse_whsp(sp);
1318                         LDAP_FREE(res);
1319                         return NULL;
1320                 } else {
1321                         *code = LDAP_SCHERR_UNEXPTOKEN;
1322                         LDAP_FREE(sval);
1323                         LDAP_VFREE(res);
1324                         return NULL;
1325                 }
1326                 parse_whsp(sp);
1327                 while (1) {
1328                         kind = get_token(sp,&sval);
1329                         if ( kind == TK_RIGHTPAREN )
1330                                 break;
1331                         if ( kind == TK_DOLLAR ) {
1332                                 parse_whsp(sp);
1333                                 kind = get_token(sp,&sval);
1334                                 if ( kind == TK_BAREWORD ||
1335                                      ( allow_quoted &&
1336                                        kind == TK_QDSTRING ) ) {
1337                                         if ( pos == size-2 ) {
1338                                                 size++;
1339                                                 res1 = LDAP_REALLOC(res,size*sizeof(char *));
1340                                                 if ( !res1 ) {
1341                                                         LDAP_FREE(sval);
1342                                                         LDAP_VFREE(res);
1343                                                         *code = LDAP_SCHERR_OUTOFMEM;
1344                                                         return(NULL);
1345                                                 }
1346                                                 res = res1;
1347                                         }
1348                                         res[pos++] = sval;
1349                                         res[pos] = NULL;
1350                                 } else {
1351                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1352                                         LDAP_FREE(sval);
1353                                         LDAP_VFREE(res);
1354                                         return NULL;
1355                                 }
1356                                 parse_whsp(sp);
1357                         } else {
1358                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1359                                 LDAP_FREE(sval);
1360                                 LDAP_VFREE(res);
1361                                 return NULL;
1362                         }
1363                 }
1364                 parse_whsp(sp);
1365                 return(res);
1366         } else if ( kind == TK_BAREWORD ||
1367                     ( allow_quoted && kind == TK_QDSTRING ) ) {
1368                 res = LDAP_CALLOC(2,sizeof(char *));
1369                 if ( !res ) {
1370                         LDAP_FREE(sval);
1371                         *code = LDAP_SCHERR_OUTOFMEM;
1372                         return NULL;
1373                 }
1374                 res[0] = sval;
1375                 res[1] = NULL;
1376                 parse_whsp(sp);
1377                 return res;
1378         } else {
1379                 LDAP_FREE(sval);
1380                 *code = LDAP_SCHERR_BADNAME;
1381                 return NULL;
1382         }
1383 }
1384
1385 static int
1386 add_extension(LDAPSchemaExtensionItem ***extensions,
1387               char * name, char ** values)
1388 {
1389         int n;
1390         LDAPSchemaExtensionItem **tmp, *ext;
1391
1392         ext = LDAP_CALLOC(1, sizeof(LDAPSchemaExtensionItem));
1393         if ( !ext )
1394                 return 1;
1395         ext->lsei_name = name;
1396         ext->lsei_values = values;
1397
1398         if ( !*extensions ) {
1399                 *extensions =
1400                   LDAP_CALLOC(2, sizeof(LDAPSchemaExtensionItem *));
1401                 if ( !*extensions )
1402                   return 1;
1403                 n = 0;
1404         } else {
1405                 for ( n=0; (*extensions)[n] != NULL; n++ )
1406                         ;
1407                 tmp = LDAP_REALLOC(*extensions,
1408                                    (n+2)*sizeof(LDAPSchemaExtensionItem *));
1409                 if ( !tmp )
1410                         return 1;
1411                 *extensions = tmp;
1412         }
1413         (*extensions)[n] = ext;
1414         (*extensions)[n+1] = NULL;
1415         return 0;
1416 }
1417
1418 static void
1419 free_extensions(LDAPSchemaExtensionItem **extensions)
1420 {
1421         LDAPSchemaExtensionItem **ext;
1422
1423         if ( extensions ) {
1424                 for ( ext = extensions; *ext != NULL; ext++ ) {
1425                         LDAP_FREE((*ext)->lsei_name);
1426                         LDAP_VFREE((*ext)->lsei_values);
1427                         LDAP_FREE(*ext);
1428                 }
1429                 LDAP_FREE(extensions);
1430         }
1431 }
1432
1433 void
1434 ldap_syntax_free( LDAPSyntax * syn )
1435 {
1436         LDAP_FREE(syn->syn_oid);
1437         if (syn->syn_names) LDAP_VFREE(syn->syn_names);
1438         if (syn->syn_desc) LDAP_FREE(syn->syn_desc);
1439         free_extensions(syn->syn_extensions);
1440         LDAP_FREE(syn);
1441 }
1442
1443 LDAPSyntax *
1444 ldap_str2syntax( LDAP_CONST char * s,
1445         int * code,
1446         LDAP_CONST char ** errp,
1447         LDAP_CONST unsigned flags )
1448 {
1449         int kind;
1450         const char * ss = s;
1451         char * sval;
1452         int seen_name = 0;
1453         int seen_desc = 0;
1454         LDAPSyntax * syn;
1455         char ** ext_vals;
1456
1457         if ( !s ) {
1458                 *code = LDAP_SCHERR_EMPTY;
1459                 *errp = "";
1460                 return NULL;
1461         }
1462
1463         *errp = s;
1464         syn = LDAP_CALLOC(1,sizeof(LDAPSyntax));
1465
1466         if ( !syn ) {
1467                 *code = LDAP_SCHERR_OUTOFMEM;
1468                 return NULL;
1469         }
1470
1471         kind = get_token(&ss,&sval);
1472         if ( kind != TK_LEFTPAREN ) {
1473                 LDAP_FREE(sval);
1474                 *code = LDAP_SCHERR_NOLEFTPAREN;
1475                 ldap_syntax_free(syn);
1476                 return NULL;
1477         }
1478
1479         parse_whsp(&ss);
1480         syn->syn_oid = ldap_int_parse_numericoid(&ss,code,0);
1481         if ( !syn->syn_oid ) {
1482                 *errp = ss;
1483                 ldap_syntax_free(syn);
1484                 return NULL;
1485         }
1486         parse_whsp(&ss);
1487
1488         /*
1489          * Beyond this point we will be liberal and accept the items
1490          * in any order.
1491          */
1492         while (1) {
1493                 kind = get_token(&ss,&sval);
1494                 switch (kind) {
1495                 case TK_EOS:
1496                         *code = LDAP_SCHERR_NORIGHTPAREN;
1497                         *errp = ss;
1498                         ldap_syntax_free(syn);
1499                         return NULL;
1500                 case TK_RIGHTPAREN:
1501                         return syn;
1502                 case TK_BAREWORD:
1503                         if ( !strcasecmp(sval,"NAME") ) {
1504                                 LDAP_FREE(sval);
1505                                 if ( seen_name ) {
1506                                         *code = LDAP_SCHERR_DUPOPT;
1507                                         *errp = ss;
1508                                         ldap_syntax_free(syn);
1509                                         return(NULL);
1510                                 }
1511                                 seen_name = 1;
1512                                 syn->syn_names = parse_qdescrs(&ss,code);
1513                                 if ( !syn->syn_names ) {
1514                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1515                                                 *code = LDAP_SCHERR_BADNAME;
1516                                         *errp = ss;
1517                                         ldap_syntax_free(syn);
1518                                         return NULL;
1519                                 }
1520                         } else if ( !strcasecmp(sval,"DESC") ) {
1521                                 LDAP_FREE(sval);
1522                                 if ( seen_desc ) {
1523                                         *code = LDAP_SCHERR_DUPOPT;
1524                                         *errp = ss;
1525                                         ldap_syntax_free(syn);
1526                                         return(NULL);
1527                                 }
1528                                 seen_desc = 1;
1529                                 parse_whsp(&ss);
1530                                 kind = get_token(&ss,&sval);
1531                                 if ( kind != TK_QDSTRING ) {
1532                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1533                                         *errp = ss;
1534                                         LDAP_FREE(sval);
1535                                         ldap_syntax_free(syn);
1536                                         return NULL;
1537                                 }
1538                                 syn->syn_desc = sval;
1539                                 parse_whsp(&ss);
1540                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1541                                 /* Should be parse_qdstrings */
1542                                 ext_vals = parse_qdescrs(&ss, code);
1543                                 if ( !ext_vals ) {
1544                                         *errp = ss;
1545                                         ldap_syntax_free(syn);
1546                                         return NULL;
1547                                 }
1548                                 if ( add_extension(&syn->syn_extensions,
1549                                                     sval, ext_vals) ) {
1550                                         *code = LDAP_SCHERR_OUTOFMEM;
1551                                         *errp = ss;
1552                                         LDAP_FREE(sval);
1553                                         ldap_syntax_free(syn);
1554                                         return NULL;
1555                                 }
1556                         } else {
1557                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1558                                 *errp = ss;
1559                                 LDAP_FREE(sval);
1560                                 ldap_syntax_free(syn);
1561                                 return NULL;
1562                         }
1563                         break;
1564                 default:
1565                         *code = LDAP_SCHERR_UNEXPTOKEN;
1566                         *errp = ss;
1567                         LDAP_FREE(sval);
1568                         ldap_syntax_free(syn);
1569                         return NULL;
1570                 }
1571         }
1572 }
1573
1574 void
1575 ldap_matchingrule_free( LDAPMatchingRule * mr )
1576 {
1577         LDAP_FREE(mr->mr_oid);
1578         if (mr->mr_names) LDAP_VFREE(mr->mr_names);
1579         if (mr->mr_desc) LDAP_FREE(mr->mr_desc);
1580         if (mr->mr_syntax_oid) LDAP_FREE(mr->mr_syntax_oid);
1581         free_extensions(mr->mr_extensions);
1582         LDAP_FREE(mr);
1583 }
1584
1585 LDAPMatchingRule *
1586 ldap_str2matchingrule( LDAP_CONST char * s,
1587         int * code,
1588         LDAP_CONST char ** errp,
1589         LDAP_CONST unsigned flags )
1590 {
1591         int kind;
1592         const char * ss = s;
1593         char * sval;
1594         int seen_name = 0;
1595         int seen_desc = 0;
1596         int seen_obsolete = 0;
1597         int seen_syntax = 0;
1598         LDAPMatchingRule * mr;
1599         char ** ext_vals;
1600         const char * savepos;
1601
1602         if ( !s ) {
1603                 *code = LDAP_SCHERR_EMPTY;
1604                 *errp = "";
1605                 return NULL;
1606         }
1607
1608         *errp = s;
1609         mr = LDAP_CALLOC(1,sizeof(LDAPMatchingRule));
1610
1611         if ( !mr ) {
1612                 *code = LDAP_SCHERR_OUTOFMEM;
1613                 return NULL;
1614         }
1615
1616         kind = get_token(&ss,&sval);
1617         if ( kind != TK_LEFTPAREN ) {
1618                 *code = LDAP_SCHERR_NOLEFTPAREN;
1619                 LDAP_FREE(sval);
1620                 ldap_matchingrule_free(mr);
1621                 return NULL;
1622         }
1623
1624         parse_whsp(&ss);
1625         savepos = ss;
1626         mr->mr_oid = ldap_int_parse_numericoid(&ss,code,flags);
1627         if ( !mr->mr_oid ) {
1628                 if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
1629                         /* Backtracking */
1630                         ss = savepos;
1631                         kind = get_token(&ss,&sval);
1632                         if ( kind == TK_BAREWORD ) {
1633                                 if ( !strcasecmp(sval, "NAME") ||
1634                                      !strcasecmp(sval, "DESC") ||
1635                                      !strcasecmp(sval, "OBSOLETE") ||
1636                                      !strcasecmp(sval, "SYNTAX") ||
1637                                      !strncasecmp(sval, "X-", 2) ) {
1638                                         /* Missing OID, backtrack */
1639                                         ss = savepos;
1640                                 } else {
1641                                         /* Non-numerical OID, ignore */
1642                                 }
1643                         }
1644                         LDAP_FREE(sval);
1645                 } else {
1646                         *errp = ss;
1647                         ldap_matchingrule_free(mr);
1648                         return NULL;
1649                 }
1650         }
1651         parse_whsp(&ss);
1652
1653         /*
1654          * Beyond this point we will be liberal and accept the items
1655          * in any order.
1656          */
1657         while (1) {
1658                 kind = get_token(&ss,&sval);
1659                 switch (kind) {
1660                 case TK_EOS:
1661                         *code = LDAP_SCHERR_NORIGHTPAREN;
1662                         *errp = ss;
1663                         ldap_matchingrule_free(mr);
1664                         return NULL;
1665                 case TK_RIGHTPAREN:
1666                         if( !seen_syntax ) {
1667                                 *code = LDAP_SCHERR_MISSING;
1668                                 ldap_matchingrule_free(mr);
1669                                 return NULL;
1670                         }
1671                         return mr;
1672                 case TK_BAREWORD:
1673                         if ( !strcasecmp(sval,"NAME") ) {
1674                                 LDAP_FREE(sval);
1675                                 if ( seen_name ) {
1676                                         *code = LDAP_SCHERR_DUPOPT;
1677                                         *errp = ss;
1678                                         ldap_matchingrule_free(mr);
1679                                         return(NULL);
1680                                 }
1681                                 seen_name = 1;
1682                                 mr->mr_names = parse_qdescrs(&ss,code);
1683                                 if ( !mr->mr_names ) {
1684                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1685                                                 *code = LDAP_SCHERR_BADNAME;
1686                                         *errp = ss;
1687                                         ldap_matchingrule_free(mr);
1688                                         return NULL;
1689                                 }
1690                         } else if ( !strcasecmp(sval,"DESC") ) {
1691                                 LDAP_FREE(sval);
1692                                 if ( seen_desc ) {
1693                                         *code = LDAP_SCHERR_DUPOPT;
1694                                         *errp = ss;
1695                                         ldap_matchingrule_free(mr);
1696                                         return(NULL);
1697                                 }
1698                                 seen_desc = 1;
1699                                 parse_whsp(&ss);
1700                                 kind = get_token(&ss,&sval);
1701                                 if ( kind != TK_QDSTRING ) {
1702                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1703                                         *errp = ss;
1704                                         LDAP_FREE(sval);
1705                                         ldap_matchingrule_free(mr);
1706                                         return NULL;
1707                                 }
1708                                 mr->mr_desc = sval;
1709                                 parse_whsp(&ss);
1710                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
1711                                 LDAP_FREE(sval);
1712                                 if ( seen_obsolete ) {
1713                                         *code = LDAP_SCHERR_DUPOPT;
1714                                         *errp = ss;
1715                                         ldap_matchingrule_free(mr);
1716                                         return(NULL);
1717                                 }
1718                                 seen_obsolete = 1;
1719                                 mr->mr_obsolete = LDAP_SCHEMA_YES;
1720                                 parse_whsp(&ss);
1721                         } else if ( !strcasecmp(sval,"SYNTAX") ) {
1722                                 LDAP_FREE(sval);
1723                                 if ( seen_syntax ) {
1724                                         *code = LDAP_SCHERR_DUPOPT;
1725                                         *errp = ss;
1726                                         ldap_matchingrule_free(mr);
1727                                         return(NULL);
1728                                 }
1729                                 seen_syntax = 1;
1730                                 parse_whsp(&ss);
1731                                 mr->mr_syntax_oid =
1732                                         ldap_int_parse_numericoid(&ss,code,flags);
1733                                 if ( !mr->mr_syntax_oid ) {
1734                                         *errp = ss;
1735                                         ldap_matchingrule_free(mr);
1736                                         return NULL;
1737                                 }
1738                                 parse_whsp(&ss);
1739                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1740                                 /* Should be parse_qdstrings */
1741                                 ext_vals = parse_qdescrs(&ss, code);
1742                                 if ( !ext_vals ) {
1743                                         *errp = ss;
1744                                         ldap_matchingrule_free(mr);
1745                                         return NULL;
1746                                 }
1747                                 if ( add_extension(&mr->mr_extensions,
1748                                                     sval, ext_vals) ) {
1749                                         *code = LDAP_SCHERR_OUTOFMEM;
1750                                         *errp = ss;
1751                                         LDAP_FREE(sval);
1752                                         ldap_matchingrule_free(mr);
1753                                         return NULL;
1754                                 }
1755                         } else {
1756                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1757                                 *errp = ss;
1758                                 LDAP_FREE(sval);
1759                                 ldap_matchingrule_free(mr);
1760                                 return NULL;
1761                         }
1762                         break;
1763                 default:
1764                         *code = LDAP_SCHERR_UNEXPTOKEN;
1765                         *errp = ss;
1766                         LDAP_FREE(sval);
1767                         ldap_matchingrule_free(mr);
1768                         return NULL;
1769                 }
1770         }
1771 }
1772
1773 void
1774 ldap_matchingruleuse_free( LDAPMatchingRuleUse * mru )
1775 {
1776         LDAP_FREE(mru->mru_oid);
1777         if (mru->mru_names) LDAP_VFREE(mru->mru_names);
1778         if (mru->mru_desc) LDAP_FREE(mru->mru_desc);
1779         if (mru->mru_applies_oids) LDAP_VFREE(mru->mru_applies_oids);
1780         free_extensions(mru->mru_extensions);
1781         LDAP_FREE(mru);
1782 }
1783
1784 LDAPMatchingRuleUse *
1785 ldap_str2matchingruleuse( LDAP_CONST char * s,
1786         int * code,
1787         LDAP_CONST char ** errp,
1788         LDAP_CONST unsigned flags )
1789 {
1790         int kind;
1791         const char * ss = s;
1792         char * sval;
1793         int seen_name = 0;
1794         int seen_desc = 0;
1795         int seen_obsolete = 0;
1796         int seen_applies = 0;
1797         LDAPMatchingRuleUse * mru;
1798         char ** ext_vals;
1799         const char * savepos;
1800
1801         if ( !s ) {
1802                 *code = LDAP_SCHERR_EMPTY;
1803                 *errp = "";
1804                 return NULL;
1805         }
1806
1807         *errp = s;
1808         mru = LDAP_CALLOC(1,sizeof(LDAPMatchingRuleUse));
1809
1810         if ( !mru ) {
1811                 *code = LDAP_SCHERR_OUTOFMEM;
1812                 return NULL;
1813         }
1814
1815         kind = get_token(&ss,&sval);
1816         if ( kind != TK_LEFTPAREN ) {
1817                 *code = LDAP_SCHERR_NOLEFTPAREN;
1818                 LDAP_FREE(sval);
1819                 ldap_matchingruleuse_free(mru);
1820                 return NULL;
1821         }
1822
1823         parse_whsp(&ss);
1824         savepos = ss;
1825         mru->mru_oid = ldap_int_parse_numericoid(&ss,code,flags);
1826         if ( !mru->mru_oid ) {
1827                 if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
1828                         /* Backtracking */
1829                         ss = savepos;
1830                         kind = get_token(&ss,&sval);
1831                         if ( kind == TK_BAREWORD ) {
1832                                 if ( !strcasecmp(sval, "NAME") ||
1833                                      !strcasecmp(sval, "DESC") ||
1834                                      !strcasecmp(sval, "OBSOLETE") ||
1835                                      !strcasecmp(sval, "APPLIES") ||
1836                                      !strncasecmp(sval, "X-", 2) ) {
1837                                         /* Missing OID, backtrack */
1838                                         ss = savepos;
1839                                 } else {
1840                                         /* Non-numerical OID, ignore */
1841                                 }
1842                         }
1843                         LDAP_FREE(sval);
1844                 } else {
1845                         *errp = ss;
1846                         ldap_matchingruleuse_free(mru);
1847                         return NULL;
1848                 }
1849         }
1850         parse_whsp(&ss);
1851
1852         /*
1853          * Beyond this point we will be liberal and accept the items
1854          * in any order.
1855          */
1856         while (1) {
1857                 kind = get_token(&ss,&sval);
1858                 switch (kind) {
1859                 case TK_EOS:
1860                         *code = LDAP_SCHERR_NORIGHTPAREN;
1861                         *errp = ss;
1862                         ldap_matchingruleuse_free(mru);
1863                         return NULL;
1864                 case TK_RIGHTPAREN:
1865                         if( !seen_applies ) {
1866                                 *code = LDAP_SCHERR_MISSING;
1867                                 ldap_matchingruleuse_free(mru);
1868                                 return NULL;
1869                         }
1870                         return mru;
1871                 case TK_BAREWORD:
1872                         if ( !strcasecmp(sval,"NAME") ) {
1873                                 LDAP_FREE(sval);
1874                                 if ( seen_name ) {
1875                                         *code = LDAP_SCHERR_DUPOPT;
1876                                         *errp = ss;
1877                                         ldap_matchingruleuse_free(mru);
1878                                         return(NULL);
1879                                 }
1880                                 seen_name = 1;
1881                                 mru->mru_names = parse_qdescrs(&ss,code);
1882                                 if ( !mru->mru_names ) {
1883                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1884                                                 *code = LDAP_SCHERR_BADNAME;
1885                                         *errp = ss;
1886                                         ldap_matchingruleuse_free(mru);
1887                                         return NULL;
1888                                 }
1889                         } else if ( !strcasecmp(sval,"DESC") ) {
1890                                 LDAP_FREE(sval);
1891                                 if ( seen_desc ) {
1892                                         *code = LDAP_SCHERR_DUPOPT;
1893                                         *errp = ss;
1894                                         ldap_matchingruleuse_free(mru);
1895                                         return(NULL);
1896                                 }
1897                                 seen_desc = 1;
1898                                 parse_whsp(&ss);
1899                                 kind = get_token(&ss,&sval);
1900                                 if ( kind != TK_QDSTRING ) {
1901                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1902                                         *errp = ss;
1903                                         LDAP_FREE(sval);
1904                                         ldap_matchingruleuse_free(mru);
1905                                         return NULL;
1906                                 }
1907                                 mru->mru_desc = sval;
1908                                 parse_whsp(&ss);
1909                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
1910                                 LDAP_FREE(sval);
1911                                 if ( seen_obsolete ) {
1912                                         *code = LDAP_SCHERR_DUPOPT;
1913                                         *errp = ss;
1914                                         ldap_matchingruleuse_free(mru);
1915                                         return(NULL);
1916                                 }
1917                                 seen_obsolete = 1;
1918                                 mru->mru_obsolete = LDAP_SCHEMA_YES;
1919                                 parse_whsp(&ss);
1920                         } else if ( !strcasecmp(sval,"APPLIES") ) {
1921                                 LDAP_FREE(sval);
1922                                 if ( seen_applies ) {
1923                                         *code = LDAP_SCHERR_DUPOPT;
1924                                         *errp = ss;
1925                                         ldap_matchingruleuse_free(mru);
1926                                         return(NULL);
1927                                 }
1928                                 seen_applies = 1;
1929                                 mru->mru_applies_oids = parse_oids(&ss,
1930                                                              code,
1931                                                              flags);
1932                                 if ( !mru->mru_applies_oids && *code != LDAP_SUCCESS ) {
1933                                         *errp = ss;
1934                                         ldap_matchingruleuse_free(mru);
1935                                         return NULL;
1936                                 }
1937                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1938                                 /* Should be parse_qdstrings */
1939                                 ext_vals = parse_qdescrs(&ss, code);
1940                                 if ( !ext_vals ) {
1941                                         *errp = ss;
1942                                         ldap_matchingruleuse_free(mru);
1943                                         return NULL;
1944                                 }
1945                                 if ( add_extension(&mru->mru_extensions,
1946                                                     sval, ext_vals) ) {
1947                                         *code = LDAP_SCHERR_OUTOFMEM;
1948                                         *errp = ss;
1949                                         LDAP_FREE(sval);
1950                                         ldap_matchingruleuse_free(mru);
1951                                         return NULL;
1952                                 }
1953                         } else {
1954                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1955                                 *errp = ss;
1956                                 LDAP_FREE(sval);
1957                                 ldap_matchingruleuse_free(mru);
1958                                 return NULL;
1959                         }
1960                         break;
1961                 default:
1962                         *code = LDAP_SCHERR_UNEXPTOKEN;
1963                         *errp = ss;
1964                         LDAP_FREE(sval);
1965                         ldap_matchingruleuse_free(mru);
1966                         return NULL;
1967                 }
1968         }
1969 }
1970
1971 void
1972 ldap_attributetype_free(LDAPAttributeType * at)
1973 {
1974         LDAP_FREE(at->at_oid);
1975         if (at->at_names) LDAP_VFREE(at->at_names);
1976         if (at->at_desc) LDAP_FREE(at->at_desc);
1977         if (at->at_sup_oid) LDAP_FREE(at->at_sup_oid);
1978         if (at->at_equality_oid) LDAP_FREE(at->at_equality_oid);
1979         if (at->at_ordering_oid) LDAP_FREE(at->at_ordering_oid);
1980         if (at->at_substr_oid) LDAP_FREE(at->at_substr_oid);
1981         if (at->at_syntax_oid) LDAP_FREE(at->at_syntax_oid);
1982         free_extensions(at->at_extensions);
1983         LDAP_FREE(at);
1984 }
1985
1986 LDAPAttributeType *
1987 ldap_str2attributetype( LDAP_CONST char * s,
1988         int * code,
1989         LDAP_CONST char ** errp,
1990         LDAP_CONST unsigned flags )
1991 {
1992         int kind;
1993         const char * ss = s;
1994         char * sval;
1995         int seen_name = 0;
1996         int seen_desc = 0;
1997         int seen_obsolete = 0;
1998         int seen_sup = 0;
1999         int seen_equality = 0;
2000         int seen_ordering = 0;
2001         int seen_substr = 0;
2002         int seen_syntax = 0;
2003         int seen_usage = 0;
2004         LDAPAttributeType * at;
2005         char ** ext_vals;
2006         const char * savepos;
2007
2008         if ( !s ) {
2009                 *code = LDAP_SCHERR_EMPTY;
2010                 *errp = "";
2011                 return NULL;
2012         }
2013
2014         *errp = s;
2015         at = LDAP_CALLOC(1,sizeof(LDAPAttributeType));
2016
2017         if ( !at ) {
2018                 *code = LDAP_SCHERR_OUTOFMEM;
2019                 return NULL;
2020         }
2021
2022         kind = get_token(&ss,&sval);
2023         if ( kind != TK_LEFTPAREN ) {
2024                 *code = LDAP_SCHERR_NOLEFTPAREN;
2025                 LDAP_FREE(sval);
2026                 ldap_attributetype_free(at);
2027                 return NULL;
2028         }
2029
2030         /*
2031          * Definitions MUST begin with an OID in the numericoid format.
2032          * However, this routine is used by clients to parse the response
2033          * from servers and very well known servers will provide an OID
2034          * in the wrong format or even no OID at all.  We do our best to
2035          * extract info from those servers.
2036          */
2037         parse_whsp(&ss);
2038         savepos = ss;
2039         at->at_oid = ldap_int_parse_numericoid(&ss,code,0);
2040         if ( !at->at_oid ) {
2041                 if ( ( flags & ( LDAP_SCHEMA_ALLOW_NO_OID
2042                                 | LDAP_SCHEMA_ALLOW_OID_MACRO ) )
2043                             && (ss == savepos) ) {
2044                         /* Backtracking */
2045                         ss = savepos;
2046                         kind = get_token(&ss,&sval);
2047                         if ( kind == TK_BAREWORD ) {
2048                                 if ( !strcasecmp(sval, "NAME") ||
2049                                      !strcasecmp(sval, "DESC") ||
2050                                      !strcasecmp(sval, "OBSOLETE") ||
2051                                      !strcasecmp(sval, "SUP") ||
2052                                      !strcasecmp(sval, "EQUALITY") ||
2053                                      !strcasecmp(sval, "ORDERING") ||
2054                                      !strcasecmp(sval, "SUBSTR") ||
2055                                      !strcasecmp(sval, "SYNTAX") ||
2056                                      !strcasecmp(sval, "SINGLE-VALUE") ||
2057                                      !strcasecmp(sval, "COLLECTIVE") ||
2058                                      !strcasecmp(sval, "NO-USER-MODIFICATION") ||
2059                                      !strcasecmp(sval, "USAGE") ||
2060                                      !strncasecmp(sval, "X-", 2) ) {
2061                                         /* Missing OID, backtrack */
2062                                         ss = savepos;
2063                                 } else if ( flags
2064                                         & LDAP_SCHEMA_ALLOW_OID_MACRO) {
2065                                         /* Non-numerical OID ... */
2066                                         int len = ss-savepos;
2067                                         at->at_oid = LDAP_MALLOC(len+1);
2068                                         strncpy(at->at_oid, savepos, len);
2069                                         at->at_oid[len] = 0;
2070                                 }
2071                         }
2072                         LDAP_FREE(sval);
2073                 } else {
2074                         *errp = ss;
2075                         ldap_attributetype_free(at);
2076                         return NULL;
2077                 }
2078         }
2079         parse_whsp(&ss);
2080
2081         /*
2082          * Beyond this point we will be liberal and accept the items
2083          * in any order.
2084          */
2085         while (1) {
2086                 kind = get_token(&ss,&sval);
2087                 switch (kind) {
2088                 case TK_EOS:
2089                         *code = LDAP_SCHERR_NORIGHTPAREN;
2090                         *errp = ss;
2091                         ldap_attributetype_free(at);
2092                         return NULL;
2093                 case TK_RIGHTPAREN:
2094                         return at;
2095                 case TK_BAREWORD:
2096                         if ( !strcasecmp(sval,"NAME") ) {
2097                                 LDAP_FREE(sval);
2098                                 if ( seen_name ) {
2099                                         *code = LDAP_SCHERR_DUPOPT;
2100                                         *errp = ss;
2101                                         ldap_attributetype_free(at);
2102                                         return(NULL);
2103                                 }
2104                                 seen_name = 1;
2105                                 at->at_names = parse_qdescrs(&ss,code);
2106                                 if ( !at->at_names ) {
2107                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2108                                                 *code = LDAP_SCHERR_BADNAME;
2109                                         *errp = ss;
2110                                         ldap_attributetype_free(at);
2111                                         return NULL;
2112                                 }
2113                         } else if ( !strcasecmp(sval,"DESC") ) {
2114                                 LDAP_FREE(sval);
2115                                 if ( seen_desc ) {
2116                                         *code = LDAP_SCHERR_DUPOPT;
2117                                         *errp = ss;
2118                                         ldap_attributetype_free(at);
2119                                         return(NULL);
2120                                 }
2121                                 seen_desc = 1;
2122                                 parse_whsp(&ss);
2123                                 kind = get_token(&ss,&sval);
2124                                 if ( kind != TK_QDSTRING ) {
2125                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2126                                         *errp = ss;
2127                                         LDAP_FREE(sval);
2128                                         ldap_attributetype_free(at);
2129                                         return NULL;
2130                                 }
2131                                 at->at_desc = sval;
2132                                 parse_whsp(&ss);
2133                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2134                                 LDAP_FREE(sval);
2135                                 if ( seen_obsolete ) {
2136                                         *code = LDAP_SCHERR_DUPOPT;
2137                                         *errp = ss;
2138                                         ldap_attributetype_free(at);
2139                                         return(NULL);
2140                                 }
2141                                 seen_obsolete = 1;
2142                                 at->at_obsolete = LDAP_SCHEMA_YES;
2143                                 parse_whsp(&ss);
2144                         } else if ( !strcasecmp(sval,"SUP") ) {
2145                                 LDAP_FREE(sval);
2146                                 if ( seen_sup ) {
2147                                         *code = LDAP_SCHERR_DUPOPT;
2148                                         *errp = ss;
2149                                         ldap_attributetype_free(at);
2150                                         return(NULL);
2151                                 }
2152                                 seen_sup = 1;
2153                                 at->at_sup_oid = parse_woid(&ss,code);
2154                                 if ( !at->at_sup_oid ) {
2155                                         *errp = ss;
2156                                         ldap_attributetype_free(at);
2157                                         return NULL;
2158                                 }
2159                         } else if ( !strcasecmp(sval,"EQUALITY") ) {
2160                                 LDAP_FREE(sval);
2161                                 if ( seen_equality ) {
2162                                         *code = LDAP_SCHERR_DUPOPT;
2163                                         *errp = ss;
2164                                         ldap_attributetype_free(at);
2165                                         return(NULL);
2166                                 }
2167                                 seen_equality = 1;
2168                                 at->at_equality_oid = parse_woid(&ss,code);
2169                                 if ( !at->at_equality_oid ) {
2170                                         *errp = ss;
2171                                         ldap_attributetype_free(at);
2172                                         return NULL;
2173                                 }
2174                         } else if ( !strcasecmp(sval,"ORDERING") ) {
2175                                 LDAP_FREE(sval);
2176                                 if ( seen_ordering ) {
2177                                         *code = LDAP_SCHERR_DUPOPT;
2178                                         *errp = ss;
2179                                         ldap_attributetype_free(at);
2180                                         return(NULL);
2181                                 }
2182                                 seen_ordering = 1;
2183                                 at->at_ordering_oid = parse_woid(&ss,code);
2184                                 if ( !at->at_ordering_oid ) {
2185                                         *errp = ss;
2186                                         ldap_attributetype_free(at);
2187                                         return NULL;
2188                                 }
2189                         } else if ( !strcasecmp(sval,"SUBSTR") ) {
2190                                 LDAP_FREE(sval);
2191                                 if ( seen_substr ) {
2192                                         *code = LDAP_SCHERR_DUPOPT;
2193                                         *errp = ss;
2194                                         ldap_attributetype_free(at);
2195                                         return(NULL);
2196                                 }
2197                                 seen_substr = 1;
2198                                 at->at_substr_oid = parse_woid(&ss,code);
2199                                 if ( !at->at_substr_oid ) {
2200                                         *errp = ss;
2201                                         ldap_attributetype_free(at);
2202                                         return NULL;
2203                                 }
2204                         } else if ( !strcasecmp(sval,"SYNTAX") ) {
2205                                 LDAP_FREE(sval);
2206                                 if ( seen_syntax ) {
2207                                         *code = LDAP_SCHERR_DUPOPT;
2208                                         *errp = ss;
2209                                         ldap_attributetype_free(at);
2210                                         return(NULL);
2211                                 }
2212                                 seen_syntax = 1;
2213                                 parse_whsp(&ss);
2214                                 savepos = ss;
2215                                 at->at_syntax_oid =
2216                                         parse_noidlen(&ss,
2217                                                       code,
2218                                                       &at->at_syntax_len,
2219                                                       flags);
2220                                 if ( !at->at_syntax_oid ) {
2221                                     if ( flags & LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2222                                         kind = get_token(&ss,&sval);
2223                                         if (kind == TK_BAREWORD)
2224                                         {
2225                                             char *sp = strchr(sval, '{');
2226                                             at->at_syntax_oid = sval;
2227                                             if (sp)
2228                                             {
2229                                                 *sp++ = 0;
2230                                                 at->at_syntax_len = atoi(sp);
2231                                                 while ( LDAP_DIGIT(*sp) )
2232                                                         sp++;
2233                                                 if ( *sp != '}' ) {
2234                                                     *code = LDAP_SCHERR_UNEXPTOKEN;
2235                                                     *errp = ss;
2236                                                     ldap_attributetype_free(at);
2237                                                     return NULL;
2238                                                 }
2239                                             }
2240                                         }
2241                                     } else {
2242                                         *errp = ss;
2243                                         ldap_attributetype_free(at);
2244                                         return NULL;
2245                                     }
2246                                 }
2247                                 parse_whsp(&ss);
2248                         } else if ( !strcasecmp(sval,"SINGLE-VALUE") ) {
2249                                 LDAP_FREE(sval);
2250                                 if ( at->at_single_value ) {
2251                                         *code = LDAP_SCHERR_DUPOPT;
2252                                         *errp = ss;
2253                                         ldap_attributetype_free(at);
2254                                         return(NULL);
2255                                 }
2256                                 at->at_single_value = LDAP_SCHEMA_YES;
2257                                 parse_whsp(&ss);
2258                         } else if ( !strcasecmp(sval,"COLLECTIVE") ) {
2259                                 LDAP_FREE(sval);
2260                                 if ( at->at_collective ) {
2261                                         *code = LDAP_SCHERR_DUPOPT;
2262                                         *errp = ss;
2263                                         ldap_attributetype_free(at);
2264                                         return(NULL);
2265                                 }
2266                                 at->at_collective = LDAP_SCHEMA_YES;
2267                                 parse_whsp(&ss);
2268                         } else if ( !strcasecmp(sval,"NO-USER-MODIFICATION") ) {
2269                                 LDAP_FREE(sval);
2270                                 if ( at->at_no_user_mod ) {
2271                                         *code = LDAP_SCHERR_DUPOPT;
2272                                         *errp = ss;
2273                                         ldap_attributetype_free(at);
2274                                         return(NULL);
2275                                 }
2276                                 at->at_no_user_mod = LDAP_SCHEMA_YES;
2277                                 parse_whsp(&ss);
2278                         } else if ( !strcasecmp(sval,"USAGE") ) {
2279                                 LDAP_FREE(sval);
2280                                 if ( seen_usage ) {
2281                                         *code = LDAP_SCHERR_DUPOPT;
2282                                         *errp = ss;
2283                                         ldap_attributetype_free(at);
2284                                         return(NULL);
2285                                 }
2286                                 seen_usage = 1;
2287                                 parse_whsp(&ss);
2288                                 kind = get_token(&ss,&sval);
2289                                 if ( kind != TK_BAREWORD ) {
2290                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2291                                         *errp = ss;
2292                                         LDAP_FREE(sval);
2293                                         ldap_attributetype_free(at);
2294                                         return NULL;
2295                                 }
2296                                 if ( !strcasecmp(sval,"userApplications") )
2297                                         at->at_usage =
2298                                             LDAP_SCHEMA_USER_APPLICATIONS;
2299                                 else if ( !strcasecmp(sval,"directoryOperation") )
2300                                         at->at_usage =
2301                                             LDAP_SCHEMA_DIRECTORY_OPERATION;
2302                                 else if ( !strcasecmp(sval,"distributedOperation") )
2303                                         at->at_usage =
2304                                             LDAP_SCHEMA_DISTRIBUTED_OPERATION;
2305                                 else if ( !strcasecmp(sval,"dSAOperation") )
2306                                         at->at_usage =
2307                                             LDAP_SCHEMA_DSA_OPERATION;
2308                                 else {
2309                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2310                                         *errp = ss;
2311                                         LDAP_FREE(sval);
2312                                         ldap_attributetype_free(at);
2313                                         return NULL;
2314                                 }
2315                                 LDAP_FREE(sval);
2316                                 parse_whsp(&ss);
2317                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2318                                 /* Should be parse_qdstrings */
2319                                 ext_vals = parse_qdescrs(&ss, code);
2320                                 if ( !ext_vals ) {
2321                                         *errp = ss;
2322                                         ldap_attributetype_free(at);
2323                                         return NULL;
2324                                 }
2325                                 if ( add_extension(&at->at_extensions,
2326                                                     sval, ext_vals) ) {
2327                                         *code = LDAP_SCHERR_OUTOFMEM;
2328                                         *errp = ss;
2329                                         LDAP_FREE(sval);
2330                                         ldap_attributetype_free(at);
2331                                         return NULL;
2332                                 }
2333                         } else {
2334                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2335                                 *errp = ss;
2336                                 LDAP_FREE(sval);
2337                                 ldap_attributetype_free(at);
2338                                 return NULL;
2339                         }
2340                         break;
2341                 default:
2342                         *code = LDAP_SCHERR_UNEXPTOKEN;
2343                         *errp = ss;
2344                         LDAP_FREE(sval);
2345                         ldap_attributetype_free(at);
2346                         return NULL;
2347                 }
2348         }
2349 }
2350
2351 void
2352 ldap_objectclass_free(LDAPObjectClass * oc)
2353 {
2354         LDAP_FREE(oc->oc_oid);
2355         if (oc->oc_names) LDAP_VFREE(oc->oc_names);
2356         if (oc->oc_desc) LDAP_FREE(oc->oc_desc);
2357         if (oc->oc_sup_oids) LDAP_VFREE(oc->oc_sup_oids);
2358         if (oc->oc_at_oids_must) LDAP_VFREE(oc->oc_at_oids_must);
2359         if (oc->oc_at_oids_may) LDAP_VFREE(oc->oc_at_oids_may);
2360         free_extensions(oc->oc_extensions);
2361         LDAP_FREE(oc);
2362 }
2363
2364 LDAPObjectClass *
2365 ldap_str2objectclass( LDAP_CONST char * s,
2366         int * code,
2367         LDAP_CONST char ** errp,
2368         LDAP_CONST unsigned flags )
2369 {
2370         int kind;
2371         const char * ss = s;
2372         char * sval;
2373         int seen_name = 0;
2374         int seen_desc = 0;
2375         int seen_obsolete = 0;
2376         int seen_sup = 0;
2377         int seen_kind = 0;
2378         int seen_must = 0;
2379         int seen_may = 0;
2380         LDAPObjectClass * oc;
2381         char ** ext_vals;
2382         const char * savepos;
2383
2384         if ( !s ) {
2385                 *code = LDAP_SCHERR_EMPTY;
2386                 *errp = "";
2387                 return NULL;
2388         }
2389
2390         *errp = s;
2391         oc = LDAP_CALLOC(1,sizeof(LDAPObjectClass));
2392
2393         if ( !oc ) {
2394                 *code = LDAP_SCHERR_OUTOFMEM;
2395                 return NULL;
2396         }
2397         oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
2398
2399         kind = get_token(&ss,&sval);
2400         if ( kind != TK_LEFTPAREN ) {
2401                 *code = LDAP_SCHERR_NOLEFTPAREN;
2402                 LDAP_FREE(sval);
2403                 ldap_objectclass_free(oc);
2404                 return NULL;
2405         }
2406
2407         /*
2408          * Definitions MUST begin with an OID in the numericoid format.
2409          * However, this routine is used by clients to parse the response
2410          * from servers and very well known servers will provide an OID
2411          * in the wrong format or even no OID at all.  We do our best to
2412          * extract info from those servers.
2413          */
2414         parse_whsp(&ss);
2415         savepos = ss;
2416         oc->oc_oid = ldap_int_parse_numericoid(&ss,code,0);
2417         if ( !oc->oc_oid ) {
2418                 if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
2419                         /* Backtracking */
2420                         ss = savepos;
2421                         kind = get_token(&ss,&sval);
2422                         if ( kind == TK_BAREWORD ) {
2423                                 if ( !strcasecmp(sval, "NAME") ||
2424                                      !strcasecmp(sval, "DESC") ||
2425                                      !strcasecmp(sval, "OBSOLETE") ||
2426                                      !strcasecmp(sval, "SUP") ||
2427                                      !strcasecmp(sval, "ABSTRACT") ||
2428                                      !strcasecmp(sval, "STRUCTURAL") ||
2429                                      !strcasecmp(sval, "AUXILIARY") ||
2430                                      !strcasecmp(sval, "MUST") ||
2431                                      !strcasecmp(sval, "MAY") ||
2432                                      !strncasecmp(sval, "X-", 2) ) {
2433                                         /* Missing OID, backtrack */
2434                                         ss = savepos;
2435                                 } else if ( flags &
2436                                         LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2437                                         /* Non-numerical OID, ignore */
2438                                         int len = ss-savepos;
2439                                         oc->oc_oid = LDAP_MALLOC(len+1);
2440                                         strncpy(oc->oc_oid, savepos, len);
2441                                         oc->oc_oid[len] = 0;
2442                                 }
2443                         }
2444                         LDAP_FREE(sval);
2445                 } else {
2446                         *errp = ss;
2447                         ldap_objectclass_free(oc);
2448                         return NULL;
2449                 }
2450         }
2451         parse_whsp(&ss);
2452
2453         /*
2454          * Beyond this point we will be liberal an accept the items
2455          * in any order.
2456          */
2457         while (1) {
2458                 kind = get_token(&ss,&sval);
2459                 switch (kind) {
2460                 case TK_EOS:
2461                         *code = LDAP_SCHERR_NORIGHTPAREN;
2462                         *errp = ss;
2463                         ldap_objectclass_free(oc);
2464                         return NULL;
2465                 case TK_RIGHTPAREN:
2466                         return oc;
2467                 case TK_BAREWORD:
2468                         if ( !strcasecmp(sval,"NAME") ) {
2469                                 LDAP_FREE(sval);
2470                                 if ( seen_name ) {
2471                                         *code = LDAP_SCHERR_DUPOPT;
2472                                         *errp = ss;
2473                                         ldap_objectclass_free(oc);
2474                                         return(NULL);
2475                                 }
2476                                 seen_name = 1;
2477                                 oc->oc_names = parse_qdescrs(&ss,code);
2478                                 if ( !oc->oc_names ) {
2479                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2480                                                 *code = LDAP_SCHERR_BADNAME;
2481                                         *errp = ss;
2482                                         ldap_objectclass_free(oc);
2483                                         return NULL;
2484                                 }
2485                         } else if ( !strcasecmp(sval,"DESC") ) {
2486                                 LDAP_FREE(sval);
2487                                 if ( seen_desc ) {
2488                                         *code = LDAP_SCHERR_DUPOPT;
2489                                         *errp = ss;
2490                                         ldap_objectclass_free(oc);
2491                                         return(NULL);
2492                                 }
2493                                 seen_desc = 1;
2494                                 parse_whsp(&ss);
2495                                 kind = get_token(&ss,&sval);
2496                                 if ( kind != TK_QDSTRING ) {
2497                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2498                                         *errp = ss;
2499                                         LDAP_FREE(sval);
2500                                         ldap_objectclass_free(oc);
2501                                         return NULL;
2502                                 }
2503                                 oc->oc_desc = sval;
2504                                 parse_whsp(&ss);
2505                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2506                                 LDAP_FREE(sval);
2507                                 if ( seen_obsolete ) {
2508                                         *code = LDAP_SCHERR_DUPOPT;
2509                                         *errp = ss;
2510                                         ldap_objectclass_free(oc);
2511                                         return(NULL);
2512                                 }
2513                                 seen_obsolete = 1;
2514                                 oc->oc_obsolete = LDAP_SCHEMA_YES;
2515                                 parse_whsp(&ss);
2516                         } else if ( !strcasecmp(sval,"SUP") ) {
2517                                 LDAP_FREE(sval);
2518                                 if ( seen_sup ) {
2519                                         *code = LDAP_SCHERR_DUPOPT;
2520                                         *errp = ss;
2521                                         ldap_objectclass_free(oc);
2522                                         return(NULL);
2523                                 }
2524                                 seen_sup = 1;
2525                                 oc->oc_sup_oids = parse_oids(&ss,
2526                                                              code,
2527                                                              flags);
2528                                 if ( !oc->oc_sup_oids && *code != LDAP_SUCCESS ) {
2529                                         *errp = ss;
2530                                         ldap_objectclass_free(oc);
2531                                         return NULL;
2532                                 }
2533                         } else if ( !strcasecmp(sval,"ABSTRACT") ) {
2534                                 LDAP_FREE(sval);
2535                                 if ( seen_kind ) {
2536                                         *code = LDAP_SCHERR_DUPOPT;
2537                                         *errp = ss;
2538                                         ldap_objectclass_free(oc);
2539                                         return(NULL);
2540                                 }
2541                                 seen_kind = 1;
2542                                 oc->oc_kind = LDAP_SCHEMA_ABSTRACT;
2543                                 parse_whsp(&ss);
2544                         } else if ( !strcasecmp(sval,"STRUCTURAL") ) {
2545                                 LDAP_FREE(sval);
2546                                 if ( seen_kind ) {
2547                                         *code = LDAP_SCHERR_DUPOPT;
2548                                         *errp = ss;
2549                                         ldap_objectclass_free(oc);
2550                                         return(NULL);
2551                                 }
2552                                 seen_kind = 1;
2553                                 oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
2554                                 parse_whsp(&ss);
2555                         } else if ( !strcasecmp(sval,"AUXILIARY") ) {
2556                                 LDAP_FREE(sval);
2557                                 if ( seen_kind ) {
2558                                         *code = LDAP_SCHERR_DUPOPT;
2559                                         *errp = ss;
2560                                         ldap_objectclass_free(oc);
2561                                         return(NULL);
2562                                 }
2563                                 seen_kind = 1;
2564                                 oc->oc_kind = LDAP_SCHEMA_AUXILIARY;
2565                                 parse_whsp(&ss);
2566                         } else if ( !strcasecmp(sval,"MUST") ) {
2567                                 LDAP_FREE(sval);
2568                                 if ( seen_must ) {
2569                                         *code = LDAP_SCHERR_DUPOPT;
2570                                         *errp = ss;
2571                                         ldap_objectclass_free(oc);
2572                                         return(NULL);
2573                                 }
2574                                 seen_must = 1;
2575                                 oc->oc_at_oids_must = parse_oids(&ss,code,0);
2576                                 if ( !oc->oc_at_oids_must && *code != LDAP_SUCCESS ) {
2577                                         *errp = ss;
2578                                         ldap_objectclass_free(oc);
2579                                         return NULL;
2580                                 }
2581                                 parse_whsp(&ss);
2582                         } else if ( !strcasecmp(sval,"MAY") ) {
2583                                 LDAP_FREE(sval);
2584                                 if ( seen_may ) {
2585                                         *code = LDAP_SCHERR_DUPOPT;
2586                                         *errp = ss;
2587                                         ldap_objectclass_free(oc);
2588                                         return(NULL);
2589                                 }
2590                                 seen_may = 1;
2591                                 oc->oc_at_oids_may = parse_oids(&ss,code,0);
2592                                 if ( !oc->oc_at_oids_may && *code != LDAP_SUCCESS ) {
2593                                         *errp = ss;
2594                                         ldap_objectclass_free(oc);
2595                                         return NULL;
2596                                 }
2597                                 parse_whsp(&ss);
2598                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2599                                 /* Should be parse_qdstrings */
2600                                 ext_vals = parse_qdescrs(&ss, code);
2601                                 if ( !ext_vals ) {
2602                                         *errp = ss;
2603                                         ldap_objectclass_free(oc);
2604                                         return NULL;
2605                                 }
2606                                 if ( add_extension(&oc->oc_extensions,
2607                                                     sval, ext_vals) ) {
2608                                         *code = LDAP_SCHERR_OUTOFMEM;
2609                                         *errp = ss;
2610                                         LDAP_FREE(sval);
2611                                         ldap_objectclass_free(oc);
2612                                         return NULL;
2613                                 }
2614                         } else {
2615                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2616                                 *errp = ss;
2617                                 LDAP_FREE(sval);
2618                                 ldap_objectclass_free(oc);
2619                                 return NULL;
2620                         }
2621                         break;
2622                 default:
2623                         *code = LDAP_SCHERR_UNEXPTOKEN;
2624                         *errp = ss;
2625                         LDAP_FREE(sval);
2626                         ldap_objectclass_free(oc);
2627                         return NULL;
2628                 }
2629         }
2630 }
2631
2632 void
2633 ldap_contentrule_free(LDAPContentRule * cr)
2634 {
2635         LDAP_FREE(cr->cr_oid);
2636         if (cr->cr_names) LDAP_VFREE(cr->cr_names);
2637         if (cr->cr_desc) LDAP_FREE(cr->cr_desc);
2638         if (cr->cr_oc_oids_aux) LDAP_VFREE(cr->cr_oc_oids_aux);
2639         if (cr->cr_at_oids_must) LDAP_VFREE(cr->cr_at_oids_must);
2640         if (cr->cr_at_oids_may) LDAP_VFREE(cr->cr_at_oids_may);
2641         if (cr->cr_at_oids_not) LDAP_VFREE(cr->cr_at_oids_not);
2642         free_extensions(cr->cr_extensions);
2643         LDAP_FREE(cr);
2644 }
2645
2646 LDAPContentRule *
2647 ldap_str2contentrule( LDAP_CONST char * s,
2648         int * code,
2649         LDAP_CONST char ** errp,
2650         LDAP_CONST unsigned flags )
2651 {
2652         int kind;
2653         const char * ss = s;
2654         char * sval;
2655         int seen_name = 0;
2656         int seen_desc = 0;
2657         int seen_obsolete = 0;
2658         int seen_aux = 0;
2659         int seen_must = 0;
2660         int seen_may = 0;
2661         int seen_not = 0;
2662         LDAPContentRule * cr;
2663         char ** ext_vals;
2664         const char * savepos;
2665
2666         if ( !s ) {
2667                 *code = LDAP_SCHERR_EMPTY;
2668                 *errp = "";
2669                 return NULL;
2670         }
2671
2672         *errp = s;
2673         cr = LDAP_CALLOC(1,sizeof(LDAPContentRule));
2674
2675         if ( !cr ) {
2676                 *code = LDAP_SCHERR_OUTOFMEM;
2677                 return NULL;
2678         }
2679
2680         kind = get_token(&ss,&sval);
2681         if ( kind != TK_LEFTPAREN ) {
2682                 *code = LDAP_SCHERR_NOLEFTPAREN;
2683                 LDAP_FREE(sval);
2684                 ldap_contentrule_free(cr);
2685                 return NULL;
2686         }
2687
2688         /*
2689          * Definitions MUST begin with an OID in the numericoid format.
2690          */
2691         parse_whsp(&ss);
2692         savepos = ss;
2693         cr->cr_oid = ldap_int_parse_numericoid(&ss,code,0);
2694         if ( !cr->cr_oid ) {
2695                 if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
2696                         /* Backtracking */
2697                         ss = savepos;
2698                         kind = get_token(&ss,&sval);
2699                         if ( kind == TK_BAREWORD ) {
2700                                 if ( !strcasecmp(sval, "NAME") ||
2701                                      !strcasecmp(sval, "DESC") ||
2702                                      !strcasecmp(sval, "OBSOLETE") ||
2703                                      !strcasecmp(sval, "AUX") ||
2704                                      !strcasecmp(sval, "MUST") ||
2705                                      !strcasecmp(sval, "MAY") ||
2706                                      !strcasecmp(sval, "NOT") ||
2707                                      !strncasecmp(sval, "X-", 2) ) {
2708                                         /* Missing OID, backtrack */
2709                                         ss = savepos;
2710                                 } else if ( flags &
2711                                         LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2712                                         /* Non-numerical OID, ignore */
2713                                         int len = ss-savepos;
2714                                         cr->cr_oid = LDAP_MALLOC(len+1);
2715                                         strncpy(cr->cr_oid, savepos, len);
2716                                         cr->cr_oid[len] = 0;
2717                                 }
2718                         }
2719                         LDAP_FREE(sval);
2720                 } else {
2721                         *errp = ss;
2722                         ldap_contentrule_free(cr);
2723                         return NULL;
2724                 }
2725         }
2726         parse_whsp(&ss);
2727
2728         /*
2729          * Beyond this point we will be liberal an accept the items
2730          * in any order.
2731          */
2732         while (1) {
2733                 kind = get_token(&ss,&sval);
2734                 switch (kind) {
2735                 case TK_EOS:
2736                         *code = LDAP_SCHERR_NORIGHTPAREN;
2737                         *errp = ss;
2738                         ldap_contentrule_free(cr);
2739                         return NULL;
2740                 case TK_RIGHTPAREN:
2741                         return cr;
2742                 case TK_BAREWORD:
2743                         if ( !strcasecmp(sval,"NAME") ) {
2744                                 LDAP_FREE(sval);
2745                                 if ( seen_name ) {
2746                                         *code = LDAP_SCHERR_DUPOPT;
2747                                         *errp = ss;
2748                                         ldap_contentrule_free(cr);
2749                                         return(NULL);
2750                                 }
2751                                 seen_name = 1;
2752                                 cr->cr_names = parse_qdescrs(&ss,code);
2753                                 if ( !cr->cr_names ) {
2754                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2755                                                 *code = LDAP_SCHERR_BADNAME;
2756                                         *errp = ss;
2757                                         ldap_contentrule_free(cr);
2758                                         return NULL;
2759                                 }
2760                         } else if ( !strcasecmp(sval,"DESC") ) {
2761                                 LDAP_FREE(sval);
2762                                 if ( seen_desc ) {
2763                                         *code = LDAP_SCHERR_DUPOPT;
2764                                         *errp = ss;
2765                                         ldap_contentrule_free(cr);
2766                                         return(NULL);
2767                                 }
2768                                 seen_desc = 1;
2769                                 parse_whsp(&ss);
2770                                 kind = get_token(&ss,&sval);
2771                                 if ( kind != TK_QDSTRING ) {
2772                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2773                                         *errp = ss;
2774                                         LDAP_FREE(sval);
2775                                         ldap_contentrule_free(cr);
2776                                         return NULL;
2777                                 }
2778                                 cr->cr_desc = sval;
2779                                 parse_whsp(&ss);
2780                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2781                                 LDAP_FREE(sval);
2782                                 if ( seen_obsolete ) {
2783                                         *code = LDAP_SCHERR_DUPOPT;
2784                                         *errp = ss;
2785                                         ldap_contentrule_free(cr);
2786                                         return(NULL);
2787                                 }
2788                                 seen_obsolete = 1;
2789                                 cr->cr_obsolete = LDAP_SCHEMA_YES;
2790                                 parse_whsp(&ss);
2791                         } else if ( !strcasecmp(sval,"AUX") ) {
2792                                 LDAP_FREE(sval);
2793                                 if ( seen_aux ) {
2794                                         *code = LDAP_SCHERR_DUPOPT;
2795                                         *errp = ss;
2796                                         ldap_contentrule_free(cr);
2797                                         return(NULL);
2798                                 }
2799                                 seen_aux = 1;
2800                                 cr->cr_oc_oids_aux = parse_oids(&ss,code,0);
2801                                 if ( !cr->cr_oc_oids_aux ) {
2802                                         *errp = ss;
2803                                         ldap_contentrule_free(cr);
2804                                         return NULL;
2805                                 }
2806                                 parse_whsp(&ss);
2807                         } else if ( !strcasecmp(sval,"MUST") ) {
2808                                 LDAP_FREE(sval);
2809                                 if ( seen_must ) {
2810                                         *code = LDAP_SCHERR_DUPOPT;
2811                                         *errp = ss;
2812                                         ldap_contentrule_free(cr);
2813                                         return(NULL);
2814                                 }
2815                                 seen_must = 1;
2816                                 cr->cr_at_oids_must = parse_oids(&ss,code,0);
2817                                 if ( !cr->cr_at_oids_must && *code != LDAP_SUCCESS ) {
2818                                         *errp = ss;
2819                                         ldap_contentrule_free(cr);
2820                                         return NULL;
2821                                 }
2822                                 parse_whsp(&ss);
2823                         } else if ( !strcasecmp(sval,"MAY") ) {
2824                                 LDAP_FREE(sval);
2825                                 if ( seen_may ) {
2826                                         *code = LDAP_SCHERR_DUPOPT;
2827                                         *errp = ss;
2828                                         ldap_contentrule_free(cr);
2829                                         return(NULL);
2830                                 }
2831                                 seen_may = 1;
2832                                 cr->cr_at_oids_may = parse_oids(&ss,code,0);
2833                                 if ( !cr->cr_at_oids_may && *code != LDAP_SUCCESS ) {
2834                                         *errp = ss;
2835                                         ldap_contentrule_free(cr);
2836                                         return NULL;
2837                                 }
2838                                 parse_whsp(&ss);
2839                         } else if ( !strcasecmp(sval,"NOT") ) {
2840                                 LDAP_FREE(sval);
2841                                 if ( seen_not ) {
2842                                         *code = LDAP_SCHERR_DUPOPT;
2843                                         *errp = ss;
2844                                         ldap_contentrule_free(cr);
2845                                         return(NULL);
2846                                 }
2847                                 seen_not = 1;
2848                                 cr->cr_at_oids_not = parse_oids(&ss,code,0);
2849                                 if ( !cr->cr_at_oids_not && *code != LDAP_SUCCESS ) {
2850                                         *errp = ss;
2851                                         ldap_contentrule_free(cr);
2852                                         return NULL;
2853                                 }
2854                                 parse_whsp(&ss);
2855                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2856                                 /* Should be parse_qdstrings */
2857                                 ext_vals = parse_qdescrs(&ss, code);
2858                                 if ( !ext_vals ) {
2859                                         *errp = ss;
2860                                         ldap_contentrule_free(cr);
2861                                         return NULL;
2862                                 }
2863                                 if ( add_extension(&cr->cr_extensions,
2864                                                     sval, ext_vals) ) {
2865                                         *code = LDAP_SCHERR_OUTOFMEM;
2866                                         *errp = ss;
2867                                         LDAP_FREE(sval);
2868                                         ldap_contentrule_free(cr);
2869                                         return NULL;
2870                                 }
2871                         } else {
2872                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2873                                 *errp = ss;
2874                                 LDAP_FREE(sval);
2875                                 ldap_contentrule_free(cr);
2876                                 return NULL;
2877                         }
2878                         break;
2879                 default:
2880                         *code = LDAP_SCHERR_UNEXPTOKEN;
2881                         *errp = ss;
2882                         LDAP_FREE(sval);
2883                         ldap_contentrule_free(cr);
2884                         return NULL;
2885                 }
2886         }
2887 }
2888
2889 void
2890 ldap_structurerule_free(LDAPStructureRule * sr)
2891 {
2892         if (sr->sr_names) LDAP_VFREE(sr->sr_names);
2893         if (sr->sr_desc) LDAP_FREE(sr->sr_desc);
2894         if (sr->sr_nameform) LDAP_FREE(sr->sr_nameform);
2895         if (sr->sr_sup_ruleids) LDAP_FREE(sr->sr_sup_ruleids);
2896         free_extensions(sr->sr_extensions);
2897         LDAP_FREE(sr);
2898 }
2899
2900 LDAPStructureRule *
2901 ldap_str2structurerule( LDAP_CONST char * s,
2902         int * code,
2903         LDAP_CONST char ** errp,
2904         LDAP_CONST unsigned flags )
2905 {
2906         int kind, ret;
2907         const char * ss = s;
2908         char * sval;
2909         int seen_name = 0;
2910         int seen_desc = 0;
2911         int seen_obsolete = 0;
2912         int seen_nameform = 0;
2913         LDAPStructureRule * sr;
2914         char ** ext_vals;
2915         const char * savepos;
2916
2917         if ( !s ) {
2918                 *code = LDAP_SCHERR_EMPTY;
2919                 *errp = "";
2920                 return NULL;
2921         }
2922
2923         *errp = s;
2924         sr = LDAP_CALLOC(1,sizeof(LDAPStructureRule));
2925
2926         if ( !sr ) {
2927                 *code = LDAP_SCHERR_OUTOFMEM;
2928                 return NULL;
2929         }
2930
2931         kind = get_token(&ss,&sval);
2932         if ( kind != TK_LEFTPAREN ) {
2933                 *code = LDAP_SCHERR_NOLEFTPAREN;
2934                 LDAP_FREE(sval);
2935                 ldap_structurerule_free(sr);
2936                 return NULL;
2937         }
2938
2939         /*
2940          * Definitions MUST begin with a ruleid.
2941          */
2942         parse_whsp(&ss);
2943         savepos = ss;
2944         ret = ldap_int_parse_ruleid(&ss,code,0,&sr->sr_ruleid);
2945         if ( ret ) {
2946                 *errp = ss;
2947                 ldap_structurerule_free(sr);
2948                 return NULL;
2949         }
2950         parse_whsp(&ss);
2951
2952         /*
2953          * Beyond this point we will be liberal an accept the items
2954          * in any order.
2955          */
2956         while (1) {
2957                 kind = get_token(&ss,&sval);
2958                 switch (kind) {
2959                 case TK_EOS:
2960                         *code = LDAP_SCHERR_NORIGHTPAREN;
2961                         *errp = ss;
2962                         ldap_structurerule_free(sr);
2963                         return NULL;
2964                 case TK_RIGHTPAREN:
2965                         if( !seen_nameform ) {
2966                                 *code = LDAP_SCHERR_MISSING;
2967                                 ldap_structurerule_free(sr);
2968                                 return NULL;
2969                         }
2970                         return sr;
2971                 case TK_BAREWORD:
2972                         if ( !strcasecmp(sval,"NAME") ) {
2973                                 LDAP_FREE(sval);
2974                                 if ( seen_name ) {
2975                                         *code = LDAP_SCHERR_DUPOPT;
2976                                         *errp = ss;
2977                                         ldap_structurerule_free(sr);
2978                                         return(NULL);
2979                                 }
2980                                 seen_name = 1;
2981                                 sr->sr_names = parse_qdescrs(&ss,code);
2982                                 if ( !sr->sr_names ) {
2983                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2984                                                 *code = LDAP_SCHERR_BADNAME;
2985                                         *errp = ss;
2986                                         ldap_structurerule_free(sr);
2987                                         return NULL;
2988                                 }
2989                         } else if ( !strcasecmp(sval,"DESC") ) {
2990                                 LDAP_FREE(sval);
2991                                 if ( seen_desc ) {
2992                                         *code = LDAP_SCHERR_DUPOPT;
2993                                         *errp = ss;
2994                                         ldap_structurerule_free(sr);
2995                                         return(NULL);
2996                                 }
2997                                 seen_desc = 1;
2998                                 parse_whsp(&ss);
2999                                 kind = get_token(&ss,&sval);
3000                                 if ( kind != TK_QDSTRING ) {
3001                                         *code = LDAP_SCHERR_UNEXPTOKEN;
3002                                         *errp = ss;
3003                                         LDAP_FREE(sval);
3004                                         ldap_structurerule_free(sr);
3005                                         return NULL;
3006                                 }
3007                                 sr->sr_desc = sval;
3008                                 parse_whsp(&ss);
3009                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
3010                                 LDAP_FREE(sval);
3011                                 if ( seen_obsolete ) {
3012                                         *code = LDAP_SCHERR_DUPOPT;
3013                                         *errp = ss;
3014                                         ldap_structurerule_free(sr);
3015                                         return(NULL);
3016                                 }
3017                                 seen_obsolete = 1;
3018                                 sr->sr_obsolete = LDAP_SCHEMA_YES;
3019                                 parse_whsp(&ss);
3020                         } else if ( !strcasecmp(sval,"FORM") ) {
3021                                 LDAP_FREE(sval);
3022                                 if ( seen_nameform ) {
3023                                         *code = LDAP_SCHERR_DUPOPT;
3024                                         *errp = ss;
3025                                         ldap_structurerule_free(sr);
3026                                         return(NULL);
3027                                 }
3028                                 seen_nameform = 1;
3029                                 sr->sr_nameform = parse_woid(&ss,code);
3030                                 if ( !sr->sr_nameform ) {
3031                                         *errp = ss;
3032                                         ldap_structurerule_free(sr);
3033                                         return NULL;
3034                                 }
3035                                 parse_whsp(&ss);
3036                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
3037                                 /* Should be parse_qdstrings */
3038                                 ext_vals = parse_qdescrs(&ss, code);
3039                                 if ( !ext_vals ) {
3040                                         *errp = ss;
3041                                         ldap_structurerule_free(sr);
3042                                         return NULL;
3043                                 }
3044                                 if ( add_extension(&sr->sr_extensions,
3045                                                     sval, ext_vals) ) {
3046                                         *code = LDAP_SCHERR_OUTOFMEM;
3047                                         *errp = ss;
3048                                         LDAP_FREE(sval);
3049                                         ldap_structurerule_free(sr);
3050                                         return NULL;
3051                                 }
3052                         } else {
3053                                 *code = LDAP_SCHERR_UNEXPTOKEN;
3054                                 *errp = ss;
3055                                 LDAP_FREE(sval);
3056                                 ldap_structurerule_free(sr);
3057                                 return NULL;
3058                         }
3059                         break;
3060                 default:
3061                         *code = LDAP_SCHERR_UNEXPTOKEN;
3062                         *errp = ss;
3063                         LDAP_FREE(sval);
3064                         ldap_structurerule_free(sr);
3065                         return NULL;
3066                 }
3067         }
3068 }
3069
3070 void
3071 ldap_nameform_free(LDAPNameForm * nf)
3072 {
3073         LDAP_FREE(nf->nf_oid);
3074         if (nf->nf_names) LDAP_VFREE(nf->nf_names);
3075         if (nf->nf_desc) LDAP_FREE(nf->nf_desc);
3076         if (nf->nf_objectclass) LDAP_FREE(nf->nf_objectclass);
3077         if (nf->nf_at_oids_must) LDAP_VFREE(nf->nf_at_oids_must);
3078         if (nf->nf_at_oids_may) LDAP_VFREE(nf->nf_at_oids_may);
3079         free_extensions(nf->nf_extensions);
3080         LDAP_FREE(nf);
3081 }
3082
3083 LDAPNameForm *
3084 ldap_str2nameform( LDAP_CONST char * s,
3085         int * code,
3086         LDAP_CONST char ** errp,
3087         LDAP_CONST unsigned flags )
3088 {
3089         int kind;
3090         const char * ss = s;
3091         char * sval;
3092         int seen_name = 0;
3093         int seen_desc = 0;
3094         int seen_obsolete = 0;
3095         int seen_class = 0;
3096         int seen_must = 0;
3097         int seen_may = 0;
3098         LDAPNameForm * nf;
3099         char ** ext_vals;
3100         const char * savepos;
3101
3102         if ( !s ) {
3103                 *code = LDAP_SCHERR_EMPTY;
3104                 *errp = "";
3105                 return NULL;
3106         }
3107
3108         *errp = s;
3109         nf = LDAP_CALLOC(1,sizeof(LDAPNameForm));
3110
3111         if ( !nf ) {
3112                 *code = LDAP_SCHERR_OUTOFMEM;
3113                 return NULL;
3114         }
3115
3116         kind = get_token(&ss,&sval);
3117         if ( kind != TK_LEFTPAREN ) {
3118                 *code = LDAP_SCHERR_NOLEFTPAREN;
3119                 LDAP_FREE(sval);
3120                 ldap_nameform_free(nf);
3121                 return NULL;
3122         }
3123
3124         /*
3125          * Definitions MUST begin with an OID in the numericoid format.
3126          * However, this routine is used by clients to parse the response
3127          * from servers and very well known servers will provide an OID
3128          * in the wrong format or even no OID at all.  We do our best to
3129          * extract info from those servers.
3130          */
3131         parse_whsp(&ss);
3132         savepos = ss;
3133         nf->nf_oid = ldap_int_parse_numericoid(&ss,code,0);
3134         if ( !nf->nf_oid ) {
3135                 *errp = ss;
3136                 ldap_nameform_free(nf);
3137                 return NULL;
3138         }
3139         parse_whsp(&ss);
3140
3141         /*
3142          * Beyond this point we will be liberal an accept the items
3143          * in any order.
3144          */
3145         while (1) {
3146                 kind = get_token(&ss,&sval);
3147                 switch (kind) {
3148                 case TK_EOS:
3149                         *code = LDAP_SCHERR_NORIGHTPAREN;
3150                         *errp = ss;
3151                         ldap_nameform_free(nf);
3152                         return NULL;
3153                 case TK_RIGHTPAREN:
3154                         if( !seen_class || !seen_must ) {
3155                                 *code = LDAP_SCHERR_MISSING;
3156                                 ldap_nameform_free(nf);
3157                                 return NULL;
3158                         }
3159                         return nf;
3160                 case TK_BAREWORD:
3161                         if ( !strcasecmp(sval,"NAME") ) {
3162                                 LDAP_FREE(sval);
3163                                 if ( seen_name ) {
3164                                         *code = LDAP_SCHERR_DUPOPT;
3165                                         *errp = ss;
3166                                         ldap_nameform_free(nf);
3167                                         return(NULL);
3168                                 }
3169                                 seen_name = 1;
3170                                 nf->nf_names = parse_qdescrs(&ss,code);
3171                                 if ( !nf->nf_names ) {
3172                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
3173                                                 *code = LDAP_SCHERR_BADNAME;
3174                                         *errp = ss;
3175                                         ldap_nameform_free(nf);
3176                                         return NULL;
3177                                 }
3178                         } else if ( !strcasecmp(sval,"DESC") ) {
3179                                 LDAP_FREE(sval);
3180                                 if ( seen_desc ) {
3181                                         *code = LDAP_SCHERR_DUPOPT;
3182                                         *errp = ss;
3183                                         ldap_nameform_free(nf);
3184                                         return(NULL);
3185                                 }
3186                                 seen_desc = 1;
3187                                 parse_whsp(&ss);
3188                                 kind = get_token(&ss,&sval);
3189                                 if ( kind != TK_QDSTRING ) {
3190                                         *code = LDAP_SCHERR_UNEXPTOKEN;
3191                                         *errp = ss;
3192                                         LDAP_FREE(sval);
3193                                         ldap_nameform_free(nf);
3194                                         return NULL;
3195                                 }
3196                                 nf->nf_desc = sval;
3197                                 parse_whsp(&ss);
3198                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
3199                                 LDAP_FREE(sval);
3200                                 if ( seen_obsolete ) {
3201                                         *code = LDAP_SCHERR_DUPOPT;
3202                                         *errp = ss;
3203                                         ldap_nameform_free(nf);
3204                                         return(NULL);
3205                                 }
3206                                 seen_obsolete = 1;
3207                                 nf->nf_obsolete = LDAP_SCHEMA_YES;
3208                                 parse_whsp(&ss);
3209                         } else if ( !strcasecmp(sval,"MUST") ) {
3210                                 LDAP_FREE(sval);
3211                                 if ( seen_must ) {
3212                                         *code = LDAP_SCHERR_DUPOPT;
3213                                         *errp = ss;
3214                                         ldap_nameform_free(nf);
3215                                         return(NULL);
3216                                 }
3217                                 seen_must = 1;
3218                                 nf->nf_at_oids_must = parse_oids(&ss,code,0);
3219                                 if ( !nf->nf_at_oids_must && *code != LDAP_SUCCESS ) {
3220                                         *errp = ss;
3221                                         ldap_nameform_free(nf);
3222                                         return NULL;
3223                                 }
3224                                 parse_whsp(&ss);
3225                         } else if ( !strcasecmp(sval,"MAY") ) {
3226                                 LDAP_FREE(sval);
3227                                 if ( seen_may ) {
3228                                         *code = LDAP_SCHERR_DUPOPT;
3229                                         *errp = ss;
3230                                         ldap_nameform_free(nf);
3231                                         return(NULL);
3232                                 }
3233                                 seen_may = 1;
3234                                 nf->nf_at_oids_may = parse_oids(&ss,code,0);
3235                                 if ( !nf->nf_at_oids_may && *code != LDAP_SUCCESS ) {
3236                                         *errp = ss;
3237                                         ldap_nameform_free(nf);
3238                                         return NULL;
3239                                 }
3240                                 parse_whsp(&ss);
3241                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
3242                                 /* Should be parse_qdstrings */
3243                                 ext_vals = parse_qdescrs(&ss, code);
3244                                 if ( !ext_vals ) {
3245                                         *errp = ss;
3246                                         ldap_nameform_free(nf);
3247                                         return NULL;
3248                                 }
3249                                 if ( add_extension(&nf->nf_extensions,
3250                                                     sval, ext_vals) ) {
3251                                         *code = LDAP_SCHERR_OUTOFMEM;
3252                                         *errp = ss;
3253                                         LDAP_FREE(sval);
3254                                         ldap_nameform_free(nf);
3255                                         return NULL;
3256                                 }
3257                         } else {
3258                                 *code = LDAP_SCHERR_UNEXPTOKEN;
3259                                 *errp = ss;
3260                                 LDAP_FREE(sval);
3261                                 ldap_nameform_free(nf);
3262                                 return NULL;
3263                         }
3264                         break;
3265                 default:
3266                         *code = LDAP_SCHERR_UNEXPTOKEN;
3267                         *errp = ss;
3268                         LDAP_FREE(sval);
3269                         ldap_nameform_free(nf);
3270                         return NULL;
3271                 }
3272         }
3273 }
3274
3275 static char *const err2text[] = {
3276         N_("Success"),
3277         N_("Out of memory"),
3278         N_("Unexpected token"),
3279         N_("Missing opening parenthesis"),
3280         N_("Missing closing parenthesis"),
3281         N_("Expecting digit"),
3282         N_("Expecting a name"),
3283         N_("Bad description"),
3284         N_("Bad superiors"),
3285         N_("Duplicate option"),
3286         N_("Unexpected end of data"),
3287         N_("Missing required field"),
3288         N_("Out of order field")
3289 };
3290
3291 char *
3292 ldap_scherr2str(int code)
3293 {
3294         if ( code < 0 || code >= (int)(sizeof(err2text)/sizeof(char *)) ) {
3295                 return _("Unknown error");
3296         } else {
3297                 return _(err2text[code]);
3298         }
3299 }