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 typedef enum tk_t {
 963         TK_NOENDQUOTE   = -2,
 964         TK_OUTOFMEM     = -1,
 965         TK_EOS          = 0,
 966         TK_UNEXPCHAR    = 1,
 967         TK_BAREWORD     = 2,
 968         TK_QDSTRING     = 3,
 969         TK_LEFTPAREN    = 4,
 970         TK_RIGHTPAREN   = 5,
 971         TK_DOLLAR       = 6,
 972         TK_QDESCR       = TK_QDSTRING
 973 } tk_t;
 974
 975 static tk_t
 976 get_token( const char ** sp, char ** token_val )
 977 {
 978         tk_t kind;
 979         const char * p;
 980         const char * q;
 981         char * res;
 982
 983         *token_val = NULL;
 984         switch (**sp) {
 985         case '\0':
 986                 kind = TK_EOS;
 987                 (*sp)++;
 988                 break;
 989         case '(':
 990                 kind = TK_LEFTPAREN;
 991                 (*sp)++;
 992                 break;
 993         case ')':
 994                 kind = TK_RIGHTPAREN;
 995                 (*sp)++;
 996                 break;
 997         case '$':
 998                 kind = TK_DOLLAR;
 999                 (*sp)++;
1000                 break;
1001         case '\'':
1002                 kind = TK_QDSTRING;
1003                 (*sp)++;
1004                 p = *sp;
1005                 while ( **sp != '\'' && **sp != '\0' )
1006                         (*sp)++;
1007                 if ( **sp == '\'' ) {
1008                         q = *sp;
1009                         res = LDAP_MALLOC(q-p+1);
1010                         if ( !res ) {
1011                                 kind = TK_OUTOFMEM;
1012                         } else {
1013                                 strncpy(res,p,q-p);
1014                                 res[q-p] = '\0';
1015                                 *token_val = res;
1016                         }
1017                         (*sp)++;
1018                 } else {
1019                         kind = TK_NOENDQUOTE;
1020                 }
1021                 break;
1022         default:
1023                 kind = TK_BAREWORD;
1024                 p = *sp;
1025                 while ( !LDAP_SPACE(**sp) &&
1026                         **sp != '(' &&
1027                         **sp != ')' &&
1028                         **sp != '$' &&
1029                         **sp != '\'' &&
1030                         /* for suggested minimum upper bound on the number
1031                          * of characters <draft-ietf-ldapbis-syntaxes> */
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         tk_t 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         tk_t 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 flags)
1236 {
1237         char * sval;
1238         const char *savepos;
1239         int quoted = 0;
1240         int allow_quoted = ( flags & LDAP_SCHEMA_ALLOW_QUOTED );
1241         int allow_oidmacro = ( flags & LDAP_SCHEMA_ALLOW_OID_MACRO );
1242
1243         *len = 0;
1244         /* Netscape puts the SYNTAX value in quotes (incorrectly) */
1245         if ( allow_quoted && **sp == '\'' ) {
1246                 quoted = 1;
1247                 (*sp)++;
1248         }
1249         savepos = *sp;
1250         sval = ldap_int_parse_numericoid(sp, code, 0);
1251         if ( !sval ) {
1252                 if ( allow_oidmacro
1253                         && *sp == savepos
1254                         && *code == LDAP_SCHERR_NODIGIT )
1255                 {
1256                         if ( get_token(sp, &sval) != TK_BAREWORD ) {
1257                                 if ( sval != NULL ) {
1258                                         LDAP_FREE(sval);
1259                                 }
1260                                 return NULL;
1261                         }
1262                 } else {
1263                         return NULL;
1264                 }
1265         }
1266         if ( **sp == '{' /*}*/ ) {
1267                 (*sp)++;
1268                 *len = atoi(*sp);
1269                 while ( LDAP_DIGIT(**sp) )
1270                         (*sp)++;
1271                 if ( **sp != /*{*/ '}' ) {
1272                         *code = LDAP_SCHERR_UNEXPTOKEN;
1273                         LDAP_FREE(sval);
1274                         return NULL;
1275                 }
1276                 (*sp)++;
1277         }
1278         if ( allow_quoted && quoted ) {
1279                 if ( **sp == '\'' ) {
1280                         (*sp)++;
1281                 } else {
1282                         *code = LDAP_SCHERR_UNEXPTOKEN;
1283                         LDAP_FREE(sval);
1284                         return NULL;
1285                 }
1286         }
1287         return sval;
1288 }
1289
1290 /*
1291  * Next routine will accept a qdstring in place of an oid if
1292  * allow_quoted is set.  This is necessary to interoperate with
1293  * Netscape Directory server that will improperly quote each oid (at
1294  * least those of the descr kind) in the SUP clause.
1295  */
1296
1297 /* Parse a woid or a $-separated list of them enclosed in () */
1298 static char **
1299 parse_oids(const char **sp, int *code, const int allow_quoted)
1300 {
1301         char ** res;
1302         char ** res1;
1303         tk_t kind;
1304         char * sval;
1305         int size;
1306         int pos;
1307
1308         /*
1309          * Strictly speaking, doing this here accepts whsp before the
1310          * ( at the begining of an oidlist, but this is harmless.  Also,
1311          * we are very liberal in what we accept as an OID.  Maybe
1312          * refine later.
1313          */
1314         parse_whsp(sp);
1315         kind = get_token(sp,&sval);
1316         if ( kind == TK_LEFTPAREN ) {
1317                 /* Let's presume there will be at least 2 entries */
1318                 size = 3;
1319                 res = LDAP_CALLOC(3,sizeof(char *));
1320                 if ( !res ) {
1321                         *code = LDAP_SCHERR_OUTOFMEM;
1322                         return NULL;
1323                 }
1324                 pos = 0;
1325                 parse_whsp(sp);
1326                 kind = get_token(sp,&sval);
1327                 if ( kind == TK_BAREWORD ||
1328                      ( allow_quoted && kind == TK_QDSTRING ) ) {
1329                         res[pos++] = sval;
1330                         res[pos] = NULL;
1331                 } else if ( kind == TK_RIGHTPAREN ) {
1332                         /* FIXME: be liberal in what we accept... */
1333                         parse_whsp(sp);
1334                         LDAP_FREE(res);
1335                         return NULL;
1336                 } else {
1337                         *code = LDAP_SCHERR_UNEXPTOKEN;
1338                         LDAP_FREE(sval);
1339                         LDAP_VFREE(res);
1340                         return NULL;
1341                 }
1342                 parse_whsp(sp);
1343                 while (1) {
1344                         kind = get_token(sp,&sval);
1345                         if ( kind == TK_RIGHTPAREN )
1346                                 break;
1347                         if ( kind == TK_DOLLAR ) {
1348                                 parse_whsp(sp);
1349                                 kind = get_token(sp,&sval);
1350                                 if ( kind == TK_BAREWORD ||
1351                                      ( allow_quoted &&
1352                                        kind == TK_QDSTRING ) ) {
1353                                         if ( pos == size-2 ) {
1354                                                 size++;
1355                                                 res1 = LDAP_REALLOC(res,size*sizeof(char *));
1356                                                 if ( !res1 ) {
1357                                                         LDAP_FREE(sval);
1358                                                         LDAP_VFREE(res);
1359                                                         *code = LDAP_SCHERR_OUTOFMEM;
1360                                                         return(NULL);
1361                                                 }
1362                                                 res = res1;
1363                                         }
1364                                         res[pos++] = sval;
1365                                         res[pos] = NULL;
1366                                 } else {
1367                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1368                                         LDAP_FREE(sval);
1369                                         LDAP_VFREE(res);
1370                                         return NULL;
1371                                 }
1372                                 parse_whsp(sp);
1373                         } else {
1374                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1375                                 LDAP_FREE(sval);
1376                                 LDAP_VFREE(res);
1377                                 return NULL;
1378                         }
1379                 }
1380                 parse_whsp(sp);
1381                 return(res);
1382         } else if ( kind == TK_BAREWORD ||
1383                     ( allow_quoted && kind == TK_QDSTRING ) ) {
1384                 res = LDAP_CALLOC(2,sizeof(char *));
1385                 if ( !res ) {
1386                         LDAP_FREE(sval);
1387                         *code = LDAP_SCHERR_OUTOFMEM;
1388                         return NULL;
1389                 }
1390                 res[0] = sval;
1391                 res[1] = NULL;
1392                 parse_whsp(sp);
1393                 return res;
1394         } else {
1395                 LDAP_FREE(sval);
1396                 *code = LDAP_SCHERR_BADNAME;
1397                 return NULL;
1398         }
1399 }
1400
1401 static int
1402 add_extension(LDAPSchemaExtensionItem ***extensions,
1403               char * name, char ** values)
1404 {
1405         int n;
1406         LDAPSchemaExtensionItem **tmp, *ext;
1407
1408         ext = LDAP_CALLOC(1, sizeof(LDAPSchemaExtensionItem));
1409         if ( !ext )
1410                 return 1;
1411         ext->lsei_name = name;
1412         ext->lsei_values = values;
1413
1414         if ( !*extensions ) {
1415                 *extensions =
1416                   LDAP_CALLOC(2, sizeof(LDAPSchemaExtensionItem *));
1417                 if ( !*extensions )
1418                   return 1;
1419                 n = 0;
1420         } else {
1421                 for ( n=0; (*extensions)[n] != NULL; n++ )
1422                         ;
1423                 tmp = LDAP_REALLOC(*extensions,
1424                                    (n+2)*sizeof(LDAPSchemaExtensionItem *));
1425                 if ( !tmp )
1426                         return 1;
1427                 *extensions = tmp;
1428         }
1429         (*extensions)[n] = ext;
1430         (*extensions)[n+1] = NULL;
1431         return 0;
1432 }
1433
1434 static void
1435 free_extensions(LDAPSchemaExtensionItem **extensions)
1436 {
1437         LDAPSchemaExtensionItem **ext;
1438
1439         if ( extensions ) {
1440                 for ( ext = extensions; *ext != NULL; ext++ ) {
1441                         LDAP_FREE((*ext)->lsei_name);
1442                         LDAP_VFREE((*ext)->lsei_values);
1443                         LDAP_FREE(*ext);
1444                 }
1445                 LDAP_FREE(extensions);
1446         }
1447 }
1448
1449 void
1450 ldap_syntax_free( LDAPSyntax * syn )
1451 {
1452         LDAP_FREE(syn->syn_oid);
1453         if (syn->syn_names) LDAP_VFREE(syn->syn_names);
1454         if (syn->syn_desc) LDAP_FREE(syn->syn_desc);
1455         free_extensions(syn->syn_extensions);
1456         LDAP_FREE(syn);
1457 }
1458
1459 LDAPSyntax *
1460 ldap_str2syntax( LDAP_CONST char * s,
1461         int * code,
1462         LDAP_CONST char ** errp,
1463         LDAP_CONST unsigned flags )
1464 {
1465         tk_t kind;
1466         const char * ss = s;
1467         char * sval;
1468         int seen_name = 0;
1469         int seen_desc = 0;
1470         LDAPSyntax * syn;
1471         char ** ext_vals;
1472
1473         if ( !s ) {
1474                 *code = LDAP_SCHERR_EMPTY;
1475                 *errp = "";
1476                 return NULL;
1477         }
1478
1479         *errp = s;
1480         syn = LDAP_CALLOC(1,sizeof(LDAPSyntax));
1481
1482         if ( !syn ) {
1483                 *code = LDAP_SCHERR_OUTOFMEM;
1484                 return NULL;
1485         }
1486
1487         kind = get_token(&ss,&sval);
1488         if ( kind != TK_LEFTPAREN ) {
1489                 LDAP_FREE(sval);
1490                 *code = LDAP_SCHERR_NOLEFTPAREN;
1491                 ldap_syntax_free(syn);
1492                 return NULL;
1493         }
1494
1495         parse_whsp(&ss);
1496         syn->syn_oid = ldap_int_parse_numericoid(&ss,code,0);
1497         if ( !syn->syn_oid ) {
1498                 *errp = ss;
1499                 ldap_syntax_free(syn);
1500                 return NULL;
1501         }
1502         parse_whsp(&ss);
1503
1504         /*
1505          * Beyond this point we will be liberal and accept the items
1506          * in any order.
1507          */
1508         while (1) {
1509                 kind = get_token(&ss,&sval);
1510                 switch (kind) {
1511                 case TK_EOS:
1512                         *code = LDAP_SCHERR_NORIGHTPAREN;
1513                         *errp = ss;
1514                         ldap_syntax_free(syn);
1515                         return NULL;
1516                 case TK_RIGHTPAREN:
1517                         return syn;
1518                 case TK_BAREWORD:
1519                         if ( !strcasecmp(sval,"NAME") ) {
1520                                 LDAP_FREE(sval);
1521                                 if ( seen_name ) {
1522                                         *code = LDAP_SCHERR_DUPOPT;
1523                                         *errp = ss;
1524                                         ldap_syntax_free(syn);
1525                                         return(NULL);
1526                                 }
1527                                 seen_name = 1;
1528                                 syn->syn_names = parse_qdescrs(&ss,code);
1529                                 if ( !syn->syn_names ) {
1530                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1531                                                 *code = LDAP_SCHERR_BADNAME;
1532                                         *errp = ss;
1533                                         ldap_syntax_free(syn);
1534                                         return NULL;
1535                                 }
1536                         } else if ( !strcasecmp(sval,"DESC") ) {
1537                                 LDAP_FREE(sval);
1538                                 if ( seen_desc ) {
1539                                         *code = LDAP_SCHERR_DUPOPT;
1540                                         *errp = ss;
1541                                         ldap_syntax_free(syn);
1542                                         return(NULL);
1543                                 }
1544                                 seen_desc = 1;
1545                                 parse_whsp(&ss);
1546                                 kind = get_token(&ss,&sval);
1547                                 if ( kind != TK_QDSTRING ) {
1548                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1549                                         *errp = ss;
1550                                         LDAP_FREE(sval);
1551                                         ldap_syntax_free(syn);
1552                                         return NULL;
1553                                 }
1554                                 syn->syn_desc = sval;
1555                                 parse_whsp(&ss);
1556                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1557                                 /* Should be parse_qdstrings */
1558                                 ext_vals = parse_qdescrs(&ss, code);
1559                                 if ( !ext_vals ) {
1560                                         *errp = ss;
1561                                         ldap_syntax_free(syn);
1562                                         return NULL;
1563                                 }
1564                                 if ( add_extension(&syn->syn_extensions,
1565                                                     sval, ext_vals) ) {
1566                                         *code = LDAP_SCHERR_OUTOFMEM;
1567                                         *errp = ss;
1568                                         LDAP_FREE(sval);
1569                                         ldap_syntax_free(syn);
1570                                         return NULL;
1571                                 }
1572                         } else {
1573                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1574                                 *errp = ss;
1575                                 LDAP_FREE(sval);
1576                                 ldap_syntax_free(syn);
1577                                 return NULL;
1578                         }
1579                         break;
1580                 default:
1581                         *code = LDAP_SCHERR_UNEXPTOKEN;
1582                         *errp = ss;
1583                         LDAP_FREE(sval);
1584                         ldap_syntax_free(syn);
1585                         return NULL;
1586                 }
1587         }
1588 }
1589
1590 void
1591 ldap_matchingrule_free( LDAPMatchingRule * mr )
1592 {
1593         LDAP_FREE(mr->mr_oid);
1594         if (mr->mr_names) LDAP_VFREE(mr->mr_names);
1595         if (mr->mr_desc) LDAP_FREE(mr->mr_desc);
1596         if (mr->mr_syntax_oid) LDAP_FREE(mr->mr_syntax_oid);
1597         free_extensions(mr->mr_extensions);
1598         LDAP_FREE(mr);
1599 }
1600
1601 LDAPMatchingRule *
1602 ldap_str2matchingrule( LDAP_CONST char * s,
1603         int * code,
1604         LDAP_CONST char ** errp,
1605         LDAP_CONST unsigned flags )
1606 {
1607         tk_t kind;
1608         const char * ss = s;
1609         char * sval;
1610         int seen_name = 0;
1611         int seen_desc = 0;
1612         int seen_obsolete = 0;
1613         int seen_syntax = 0;
1614         LDAPMatchingRule * mr;
1615         char ** ext_vals;
1616         const char * savepos;
1617
1618         if ( !s ) {
1619                 *code = LDAP_SCHERR_EMPTY;
1620                 *errp = "";
1621                 return NULL;
1622         }
1623
1624         *errp = s;
1625         mr = LDAP_CALLOC(1,sizeof(LDAPMatchingRule));
1626
1627         if ( !mr ) {
1628                 *code = LDAP_SCHERR_OUTOFMEM;
1629                 return NULL;
1630         }
1631
1632         kind = get_token(&ss,&sval);
1633         if ( kind != TK_LEFTPAREN ) {
1634                 *code = LDAP_SCHERR_NOLEFTPAREN;
1635                 LDAP_FREE(sval);
1636                 ldap_matchingrule_free(mr);
1637                 return NULL;
1638         }
1639
1640         parse_whsp(&ss);
1641         savepos = ss;
1642         mr->mr_oid = ldap_int_parse_numericoid(&ss,code,flags);
1643         if ( !mr->mr_oid ) {
1644                 if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
1645                         /* Backtracking */
1646                         ss = savepos;
1647                         kind = get_token(&ss,&sval);
1648                         if ( kind == TK_BAREWORD ) {
1649                                 if ( !strcasecmp(sval, "NAME") ||
1650                                      !strcasecmp(sval, "DESC") ||
1651                                      !strcasecmp(sval, "OBSOLETE") ||
1652                                      !strcasecmp(sval, "SYNTAX") ||
1653                                      !strncasecmp(sval, "X-", 2) ) {
1654                                         /* Missing OID, backtrack */
1655                                         ss = savepos;
1656                                 } else {
1657                                         /* Non-numerical OID, ignore */
1658                                 }
1659                         }
1660                         LDAP_FREE(sval);
1661                 } else {
1662                         *errp = ss;
1663                         ldap_matchingrule_free(mr);
1664                         return NULL;
1665                 }
1666         }
1667         parse_whsp(&ss);
1668
1669         /*
1670          * Beyond this point we will be liberal and accept the items
1671          * in any order.
1672          */
1673         while (1) {
1674                 kind = get_token(&ss,&sval);
1675                 switch (kind) {
1676                 case TK_EOS:
1677                         *code = LDAP_SCHERR_NORIGHTPAREN;
1678                         *errp = ss;
1679                         ldap_matchingrule_free(mr);
1680                         return NULL;
1681                 case TK_RIGHTPAREN:
1682                         if( !seen_syntax ) {
1683                                 *code = LDAP_SCHERR_MISSING;
1684                                 ldap_matchingrule_free(mr);
1685                                 return NULL;
1686                         }
1687                         return mr;
1688                 case TK_BAREWORD:
1689                         if ( !strcasecmp(sval,"NAME") ) {
1690                                 LDAP_FREE(sval);
1691                                 if ( seen_name ) {
1692                                         *code = LDAP_SCHERR_DUPOPT;
1693                                         *errp = ss;
1694                                         ldap_matchingrule_free(mr);
1695                                         return(NULL);
1696                                 }
1697                                 seen_name = 1;
1698                                 mr->mr_names = parse_qdescrs(&ss,code);
1699                                 if ( !mr->mr_names ) {
1700                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1701                                                 *code = LDAP_SCHERR_BADNAME;
1702                                         *errp = ss;
1703                                         ldap_matchingrule_free(mr);
1704                                         return NULL;
1705                                 }
1706                         } else if ( !strcasecmp(sval,"DESC") ) {
1707                                 LDAP_FREE(sval);
1708                                 if ( seen_desc ) {
1709                                         *code = LDAP_SCHERR_DUPOPT;
1710                                         *errp = ss;
1711                                         ldap_matchingrule_free(mr);
1712                                         return(NULL);
1713                                 }
1714                                 seen_desc = 1;
1715                                 parse_whsp(&ss);
1716                                 kind = get_token(&ss,&sval);
1717                                 if ( kind != TK_QDSTRING ) {
1718                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1719                                         *errp = ss;
1720                                         LDAP_FREE(sval);
1721                                         ldap_matchingrule_free(mr);
1722                                         return NULL;
1723                                 }
1724                                 mr->mr_desc = sval;
1725                                 parse_whsp(&ss);
1726                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
1727                                 LDAP_FREE(sval);
1728                                 if ( seen_obsolete ) {
1729                                         *code = LDAP_SCHERR_DUPOPT;
1730                                         *errp = ss;
1731                                         ldap_matchingrule_free(mr);
1732                                         return(NULL);
1733                                 }
1734                                 seen_obsolete = 1;
1735                                 mr->mr_obsolete = LDAP_SCHEMA_YES;
1736                                 parse_whsp(&ss);
1737                         } else if ( !strcasecmp(sval,"SYNTAX") ) {
1738                                 LDAP_FREE(sval);
1739                                 if ( seen_syntax ) {
1740                                         *code = LDAP_SCHERR_DUPOPT;
1741                                         *errp = ss;
1742                                         ldap_matchingrule_free(mr);
1743                                         return(NULL);
1744                                 }
1745                                 seen_syntax = 1;
1746                                 parse_whsp(&ss);
1747                                 mr->mr_syntax_oid =
1748                                         ldap_int_parse_numericoid(&ss,code,flags);
1749                                 if ( !mr->mr_syntax_oid ) {
1750                                         *errp = ss;
1751                                         ldap_matchingrule_free(mr);
1752                                         return NULL;
1753                                 }
1754                                 parse_whsp(&ss);
1755                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1756                                 /* Should be parse_qdstrings */
1757                                 ext_vals = parse_qdescrs(&ss, code);
1758                                 if ( !ext_vals ) {
1759                                         *errp = ss;
1760                                         ldap_matchingrule_free(mr);
1761                                         return NULL;
1762                                 }
1763                                 if ( add_extension(&mr->mr_extensions,
1764                                                     sval, ext_vals) ) {
1765                                         *code = LDAP_SCHERR_OUTOFMEM;
1766                                         *errp = ss;
1767                                         LDAP_FREE(sval);
1768                                         ldap_matchingrule_free(mr);
1769                                         return NULL;
1770                                 }
1771                         } else {
1772                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1773                                 *errp = ss;
1774                                 LDAP_FREE(sval);
1775                                 ldap_matchingrule_free(mr);
1776                                 return NULL;
1777                         }
1778                         break;
1779                 default:
1780                         *code = LDAP_SCHERR_UNEXPTOKEN;
1781                         *errp = ss;
1782                         LDAP_FREE(sval);
1783                         ldap_matchingrule_free(mr);
1784                         return NULL;
1785                 }
1786         }
1787 }
1788
1789 void
1790 ldap_matchingruleuse_free( LDAPMatchingRuleUse * mru )
1791 {
1792         LDAP_FREE(mru->mru_oid);
1793         if (mru->mru_names) LDAP_VFREE(mru->mru_names);
1794         if (mru->mru_desc) LDAP_FREE(mru->mru_desc);
1795         if (mru->mru_applies_oids) LDAP_VFREE(mru->mru_applies_oids);
1796         free_extensions(mru->mru_extensions);
1797         LDAP_FREE(mru);
1798 }
1799
1800 LDAPMatchingRuleUse *
1801 ldap_str2matchingruleuse( LDAP_CONST char * s,
1802         int * code,
1803         LDAP_CONST char ** errp,
1804         LDAP_CONST unsigned flags )
1805 {
1806         tk_t kind;
1807         const char * ss = s;
1808         char * sval;
1809         int seen_name = 0;
1810         int seen_desc = 0;
1811         int seen_obsolete = 0;
1812         int seen_applies = 0;
1813         LDAPMatchingRuleUse * mru;
1814         char ** ext_vals;
1815         const char * savepos;
1816
1817         if ( !s ) {
1818                 *code = LDAP_SCHERR_EMPTY;
1819                 *errp = "";
1820                 return NULL;
1821         }
1822
1823         *errp = s;
1824         mru = LDAP_CALLOC(1,sizeof(LDAPMatchingRuleUse));
1825
1826         if ( !mru ) {
1827                 *code = LDAP_SCHERR_OUTOFMEM;
1828                 return NULL;
1829         }
1830
1831         kind = get_token(&ss,&sval);
1832         if ( kind != TK_LEFTPAREN ) {
1833                 *code = LDAP_SCHERR_NOLEFTPAREN;
1834                 LDAP_FREE(sval);
1835                 ldap_matchingruleuse_free(mru);
1836                 return NULL;
1837         }
1838
1839         parse_whsp(&ss);
1840         savepos = ss;
1841         mru->mru_oid = ldap_int_parse_numericoid(&ss,code,flags);
1842         if ( !mru->mru_oid ) {
1843                 if ( flags & LDAP_SCHEMA_ALLOW_NO_OID ) {
1844                         /* Backtracking */
1845                         ss = savepos;
1846                         kind = get_token(&ss,&sval);
1847                         if ( kind == TK_BAREWORD ) {
1848                                 if ( !strcasecmp(sval, "NAME") ||
1849                                      !strcasecmp(sval, "DESC") ||
1850                                      !strcasecmp(sval, "OBSOLETE") ||
1851                                      !strcasecmp(sval, "APPLIES") ||
1852                                      !strncasecmp(sval, "X-", 2) ) {
1853                                         /* Missing OID, backtrack */
1854                                         ss = savepos;
1855                                 } else {
1856                                         /* Non-numerical OID, ignore */
1857                                 }
1858                         }
1859                         LDAP_FREE(sval);
1860                 } else {
1861                         *errp = ss;
1862                         ldap_matchingruleuse_free(mru);
1863                         return NULL;
1864                 }
1865         }
1866         parse_whsp(&ss);
1867
1868         /*
1869          * Beyond this point we will be liberal and accept the items
1870          * in any order.
1871          */
1872         while (1) {
1873                 kind = get_token(&ss,&sval);
1874                 switch (kind) {
1875                 case TK_EOS:
1876                         *code = LDAP_SCHERR_NORIGHTPAREN;
1877                         *errp = ss;
1878                         ldap_matchingruleuse_free(mru);
1879                         return NULL;
1880                 case TK_RIGHTPAREN:
1881                         if( !seen_applies ) {
1882                                 *code = LDAP_SCHERR_MISSING;
1883                                 ldap_matchingruleuse_free(mru);
1884                                 return NULL;
1885                         }
1886                         return mru;
1887                 case TK_BAREWORD:
1888                         if ( !strcasecmp(sval,"NAME") ) {
1889                                 LDAP_FREE(sval);
1890                                 if ( seen_name ) {
1891                                         *code = LDAP_SCHERR_DUPOPT;
1892                                         *errp = ss;
1893                                         ldap_matchingruleuse_free(mru);
1894                                         return(NULL);
1895                                 }
1896                                 seen_name = 1;
1897                                 mru->mru_names = parse_qdescrs(&ss,code);
1898                                 if ( !mru->mru_names ) {
1899                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
1900                                                 *code = LDAP_SCHERR_BADNAME;
1901                                         *errp = ss;
1902                                         ldap_matchingruleuse_free(mru);
1903                                         return NULL;
1904                                 }
1905                         } else if ( !strcasecmp(sval,"DESC") ) {
1906                                 LDAP_FREE(sval);
1907                                 if ( seen_desc ) {
1908                                         *code = LDAP_SCHERR_DUPOPT;
1909                                         *errp = ss;
1910                                         ldap_matchingruleuse_free(mru);
1911                                         return(NULL);
1912                                 }
1913                                 seen_desc = 1;
1914                                 parse_whsp(&ss);
1915                                 kind = get_token(&ss,&sval);
1916                                 if ( kind != TK_QDSTRING ) {
1917                                         *code = LDAP_SCHERR_UNEXPTOKEN;
1918                                         *errp = ss;
1919                                         LDAP_FREE(sval);
1920                                         ldap_matchingruleuse_free(mru);
1921                                         return NULL;
1922                                 }
1923                                 mru->mru_desc = sval;
1924                                 parse_whsp(&ss);
1925                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
1926                                 LDAP_FREE(sval);
1927                                 if ( seen_obsolete ) {
1928                                         *code = LDAP_SCHERR_DUPOPT;
1929                                         *errp = ss;
1930                                         ldap_matchingruleuse_free(mru);
1931                                         return(NULL);
1932                                 }
1933                                 seen_obsolete = 1;
1934                                 mru->mru_obsolete = LDAP_SCHEMA_YES;
1935                                 parse_whsp(&ss);
1936                         } else if ( !strcasecmp(sval,"APPLIES") ) {
1937                                 LDAP_FREE(sval);
1938                                 if ( seen_applies ) {
1939                                         *code = LDAP_SCHERR_DUPOPT;
1940                                         *errp = ss;
1941                                         ldap_matchingruleuse_free(mru);
1942                                         return(NULL);
1943                                 }
1944                                 seen_applies = 1;
1945                                 mru->mru_applies_oids = parse_oids(&ss,
1946                                                              code,
1947                                                              flags);
1948                                 if ( !mru->mru_applies_oids && *code != LDAP_SUCCESS ) {
1949                                         *errp = ss;
1950                                         ldap_matchingruleuse_free(mru);
1951                                         return NULL;
1952                                 }
1953                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
1954                                 /* Should be parse_qdstrings */
1955                                 ext_vals = parse_qdescrs(&ss, code);
1956                                 if ( !ext_vals ) {
1957                                         *errp = ss;
1958                                         ldap_matchingruleuse_free(mru);
1959                                         return NULL;
1960                                 }
1961                                 if ( add_extension(&mru->mru_extensions,
1962                                                     sval, ext_vals) ) {
1963                                         *code = LDAP_SCHERR_OUTOFMEM;
1964                                         *errp = ss;
1965                                         LDAP_FREE(sval);
1966                                         ldap_matchingruleuse_free(mru);
1967                                         return NULL;
1968                                 }
1969                         } else {
1970                                 *code = LDAP_SCHERR_UNEXPTOKEN;
1971                                 *errp = ss;
1972                                 LDAP_FREE(sval);
1973                                 ldap_matchingruleuse_free(mru);
1974                                 return NULL;
1975                         }
1976                         break;
1977                 default:
1978                         *code = LDAP_SCHERR_UNEXPTOKEN;
1979                         *errp = ss;
1980                         LDAP_FREE(sval);
1981                         ldap_matchingruleuse_free(mru);
1982                         return NULL;
1983                 }
1984         }
1985 }
1986
1987 void
1988 ldap_attributetype_free(LDAPAttributeType * at)
1989 {
1990         LDAP_FREE(at->at_oid);
1991         if (at->at_names) LDAP_VFREE(at->at_names);
1992         if (at->at_desc) LDAP_FREE(at->at_desc);
1993         if (at->at_sup_oid) LDAP_FREE(at->at_sup_oid);
1994         if (at->at_equality_oid) LDAP_FREE(at->at_equality_oid);
1995         if (at->at_ordering_oid) LDAP_FREE(at->at_ordering_oid);
1996         if (at->at_substr_oid) LDAP_FREE(at->at_substr_oid);
1997         if (at->at_syntax_oid) LDAP_FREE(at->at_syntax_oid);
1998         free_extensions(at->at_extensions);
1999         LDAP_FREE(at);
2000 }
2001
2002 LDAPAttributeType *
2003 ldap_str2attributetype( LDAP_CONST char * s,
2004         int * code,
2005         LDAP_CONST char ** errp,
2006         LDAP_CONST unsigned flags )
2007 {
2008         tk_t kind;
2009         const char * ss = s;
2010         char * sval;
2011         int seen_name = 0;
2012         int seen_desc = 0;
2013         int seen_obsolete = 0;
2014         int seen_sup = 0;
2015         int seen_equality = 0;
2016         int seen_ordering = 0;
2017         int seen_substr = 0;
2018         int seen_syntax = 0;
2019         int seen_usage = 0;
2020         LDAPAttributeType * at;
2021         char ** ext_vals;
2022         const char * savepos;
2023
2024         if ( !s ) {
2025                 *code = LDAP_SCHERR_EMPTY;
2026                 *errp = "";
2027                 return NULL;
2028         }
2029
2030         *errp = s;
2031         at = LDAP_CALLOC(1,sizeof(LDAPAttributeType));
2032
2033         if ( !at ) {
2034                 *code = LDAP_SCHERR_OUTOFMEM;
2035                 return NULL;
2036         }
2037
2038         kind = get_token(&ss,&sval);
2039         if ( kind != TK_LEFTPAREN ) {
2040                 *code = LDAP_SCHERR_NOLEFTPAREN;
2041                 LDAP_FREE(sval);
2042                 ldap_attributetype_free(at);
2043                 return NULL;
2044         }
2045
2046         /*
2047          * Definitions MUST begin with an OID in the numericoid format.
2048          * However, this routine is used by clients to parse the response
2049          * from servers and very well known servers will provide an OID
2050          * in the wrong format or even no OID at all.  We do our best to
2051          * extract info from those servers.
2052          */
2053         parse_whsp(&ss);
2054         savepos = ss;
2055         at->at_oid = ldap_int_parse_numericoid(&ss,code,0);
2056         if ( !at->at_oid ) {
2057                 if ( ( flags & ( LDAP_SCHEMA_ALLOW_NO_OID
2058                                 | LDAP_SCHEMA_ALLOW_OID_MACRO ) )
2059                             && (ss == savepos) )
2060                 {
2061                         /* Backtracking */
2062                         ss = savepos;
2063                         kind = get_token(&ss,&sval);
2064                         if ( kind == TK_BAREWORD ) {
2065                                 if ( !strcasecmp(sval, "NAME") ||
2066                                      !strcasecmp(sval, "DESC") ||
2067                                      !strcasecmp(sval, "OBSOLETE") ||
2068                                      !strcasecmp(sval, "SUP") ||
2069                                      !strcasecmp(sval, "EQUALITY") ||
2070                                      !strcasecmp(sval, "ORDERING") ||
2071                                      !strcasecmp(sval, "SUBSTR") ||
2072                                      !strcasecmp(sval, "SYNTAX") ||
2073                                      !strcasecmp(sval, "SINGLE-VALUE") ||
2074                                      !strcasecmp(sval, "COLLECTIVE") ||
2075                                      !strcasecmp(sval, "NO-USER-MODIFICATION") ||
2076                                      !strcasecmp(sval, "USAGE") ||
2077                                      !strncasecmp(sval, "X-", 2) )
2078                                 {
2079                                         /* Missing OID, backtrack */
2080                                         ss = savepos;
2081                                 } else if ( flags
2082                                         & LDAP_SCHEMA_ALLOW_OID_MACRO)
2083                                 {
2084                                         /* Non-numerical OID ... */
2085                                         int len = ss-savepos;
2086                                         at->at_oid = LDAP_MALLOC(len+1);
2087                                         strncpy(at->at_oid, savepos, len);
2088                                         at->at_oid[len] = 0;
2089                                 }
2090                         }
2091                         LDAP_FREE(sval);
2092                 } else {
2093                         *errp = ss;
2094                         ldap_attributetype_free(at);
2095                         return NULL;
2096                 }
2097         }
2098         parse_whsp(&ss);
2099
2100         /*
2101          * Beyond this point we will be liberal and accept the items
2102          * in any order.
2103          */
2104         while (1) {
2105                 kind = get_token(&ss,&sval);
2106                 switch (kind) {
2107                 case TK_EOS:
2108                         *code = LDAP_SCHERR_NORIGHTPAREN;
2109                         *errp = ss;
2110                         ldap_attributetype_free(at);
2111                         return NULL;
2112                 case TK_RIGHTPAREN:
2113                         return at;
2114                 case TK_BAREWORD:
2115                         if ( !strcasecmp(sval,"NAME") ) {
2116                                 LDAP_FREE(sval);
2117                                 if ( seen_name ) {
2118                                         *code = LDAP_SCHERR_DUPOPT;
2119                                         *errp = ss;
2120                                         ldap_attributetype_free(at);
2121                                         return(NULL);
2122                                 }
2123                                 seen_name = 1;
2124                                 at->at_names = parse_qdescrs(&ss,code);
2125                                 if ( !at->at_names ) {
2126                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2127                                                 *code = LDAP_SCHERR_BADNAME;
2128                                         *errp = ss;
2129                                         ldap_attributetype_free(at);
2130                                         return NULL;
2131                                 }
2132                         } else if ( !strcasecmp(sval,"DESC") ) {
2133                                 LDAP_FREE(sval);
2134                                 if ( seen_desc ) {
2135                                         *code = LDAP_SCHERR_DUPOPT;
2136                                         *errp = ss;
2137                                         ldap_attributetype_free(at);
2138                                         return(NULL);
2139                                 }
2140                                 seen_desc = 1;
2141                                 parse_whsp(&ss);
2142                                 kind = get_token(&ss,&sval);
2143                                 if ( kind != TK_QDSTRING ) {
2144                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2145                                         *errp = ss;
2146                                         LDAP_FREE(sval);
2147                                         ldap_attributetype_free(at);
2148                                         return NULL;
2149                                 }
2150                                 at->at_desc = sval;
2151                                 parse_whsp(&ss);
2152                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2153                                 LDAP_FREE(sval);
2154                                 if ( seen_obsolete ) {
2155                                         *code = LDAP_SCHERR_DUPOPT;
2156                                         *errp = ss;
2157                                         ldap_attributetype_free(at);
2158                                         return(NULL);
2159                                 }
2160                                 seen_obsolete = 1;
2161                                 at->at_obsolete = LDAP_SCHEMA_YES;
2162                                 parse_whsp(&ss);
2163                         } else if ( !strcasecmp(sval,"SUP") ) {
2164                                 LDAP_FREE(sval);
2165                                 if ( seen_sup ) {
2166                                         *code = LDAP_SCHERR_DUPOPT;
2167                                         *errp = ss;
2168                                         ldap_attributetype_free(at);
2169                                         return(NULL);
2170                                 }
2171                                 seen_sup = 1;
2172                                 at->at_sup_oid = parse_woid(&ss,code);
2173                                 if ( !at->at_sup_oid ) {
2174                                         *errp = ss;
2175                                         ldap_attributetype_free(at);
2176                                         return NULL;
2177                                 }
2178                         } else if ( !strcasecmp(sval,"EQUALITY") ) {
2179                                 LDAP_FREE(sval);
2180                                 if ( seen_equality ) {
2181                                         *code = LDAP_SCHERR_DUPOPT;
2182                                         *errp = ss;
2183                                         ldap_attributetype_free(at);
2184                                         return(NULL);
2185                                 }
2186                                 seen_equality = 1;
2187                                 at->at_equality_oid = parse_woid(&ss,code);
2188                                 if ( !at->at_equality_oid ) {
2189                                         *errp = ss;
2190                                         ldap_attributetype_free(at);
2191                                         return NULL;
2192                                 }
2193                         } else if ( !strcasecmp(sval,"ORDERING") ) {
2194                                 LDAP_FREE(sval);
2195                                 if ( seen_ordering ) {
2196                                         *code = LDAP_SCHERR_DUPOPT;
2197                                         *errp = ss;
2198                                         ldap_attributetype_free(at);
2199                                         return(NULL);
2200                                 }
2201                                 seen_ordering = 1;
2202                                 at->at_ordering_oid = parse_woid(&ss,code);
2203                                 if ( !at->at_ordering_oid ) {
2204                                         *errp = ss;
2205                                         ldap_attributetype_free(at);
2206                                         return NULL;
2207                                 }
2208                         } else if ( !strcasecmp(sval,"SUBSTR") ) {
2209                                 LDAP_FREE(sval);
2210                                 if ( seen_substr ) {
2211                                         *code = LDAP_SCHERR_DUPOPT;
2212                                         *errp = ss;
2213                                         ldap_attributetype_free(at);
2214                                         return(NULL);
2215                                 }
2216                                 seen_substr = 1;
2217                                 at->at_substr_oid = parse_woid(&ss,code);
2218                                 if ( !at->at_substr_oid ) {
2219                                         *errp = ss;
2220                                         ldap_attributetype_free(at);
2221                                         return NULL;
2222                                 }
2223                         } else if ( !strcasecmp(sval,"SYNTAX") ) {
2224                                 LDAP_FREE(sval);
2225                                 if ( seen_syntax ) {
2226                                         *code = LDAP_SCHERR_DUPOPT;
2227                                         *errp = ss;
2228                                         ldap_attributetype_free(at);
2229                                         return(NULL);
2230                                 }
2231                                 seen_syntax = 1;
2232                                 parse_whsp(&ss);
2233                                 savepos = ss;
2234                                 at->at_syntax_oid =
2235                                         parse_noidlen(&ss,
2236                                                       code,
2237                                                       &at->at_syntax_len,
2238                                                       flags);
2239                                 if ( !at->at_syntax_oid ) {
2240                                     if ( flags & LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2241                                         kind = get_token(&ss,&sval);
2242                                         if (kind == TK_BAREWORD)
2243                                         {
2244                                             char *sp = strchr(sval, '{');
2245                                             at->at_syntax_oid = sval;
2246                                             if (sp)
2247                                             {
2248                                                 *sp++ = 0;
2249                                                 at->at_syntax_len = atoi(sp);
2250                                                 while ( LDAP_DIGIT(*sp) )
2251                                                         sp++;
2252                                                 if ( *sp != '}' ) {
2253                                                     *code = LDAP_SCHERR_UNEXPTOKEN;
2254                                                     *errp = ss;
2255                                                     ldap_attributetype_free(at);
2256                                                     return NULL;
2257                                                 }
2258                                             }
2259                                         }
2260                                     } else {
2261                                         *errp = ss;
2262                                         ldap_attributetype_free(at);
2263                                         return NULL;
2264                                     }
2265                                 }
2266                                 parse_whsp(&ss);
2267                         } else if ( !strcasecmp(sval,"SINGLE-VALUE") ) {
2268                                 LDAP_FREE(sval);
2269                                 if ( at->at_single_value ) {
2270                                         *code = LDAP_SCHERR_DUPOPT;
2271                                         *errp = ss;
2272                                         ldap_attributetype_free(at);
2273                                         return(NULL);
2274                                 }
2275                                 at->at_single_value = LDAP_SCHEMA_YES;
2276                                 parse_whsp(&ss);
2277                         } else if ( !strcasecmp(sval,"COLLECTIVE") ) {
2278                                 LDAP_FREE(sval);
2279                                 if ( at->at_collective ) {
2280                                         *code = LDAP_SCHERR_DUPOPT;
2281                                         *errp = ss;
2282                                         ldap_attributetype_free(at);
2283                                         return(NULL);
2284                                 }
2285                                 at->at_collective = LDAP_SCHEMA_YES;
2286                                 parse_whsp(&ss);
2287                         } else if ( !strcasecmp(sval,"NO-USER-MODIFICATION") ) {
2288                                 LDAP_FREE(sval);
2289                                 if ( at->at_no_user_mod ) {
2290                                         *code = LDAP_SCHERR_DUPOPT;
2291                                         *errp = ss;
2292                                         ldap_attributetype_free(at);
2293                                         return(NULL);
2294                                 }
2295                                 at->at_no_user_mod = LDAP_SCHEMA_YES;
2296                                 parse_whsp(&ss);
2297                         } else if ( !strcasecmp(sval,"USAGE") ) {
2298                                 LDAP_FREE(sval);
2299                                 if ( seen_usage ) {
2300                                         *code = LDAP_SCHERR_DUPOPT;
2301                                         *errp = ss;
2302                                         ldap_attributetype_free(at);
2303                                         return(NULL);
2304                                 }
2305                                 seen_usage = 1;
2306                                 parse_whsp(&ss);
2307                                 kind = get_token(&ss,&sval);
2308                                 if ( kind != TK_BAREWORD ) {
2309                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2310                                         *errp = ss;
2311                                         LDAP_FREE(sval);
2312                                         ldap_attributetype_free(at);
2313                                         return NULL;
2314                                 }
2315                                 if ( !strcasecmp(sval,"userApplications") )
2316                                         at->at_usage =
2317                                             LDAP_SCHEMA_USER_APPLICATIONS;
2318                                 else if ( !strcasecmp(sval,"directoryOperation") )
2319                                         at->at_usage =
2320                                             LDAP_SCHEMA_DIRECTORY_OPERATION;
2321                                 else if ( !strcasecmp(sval,"distributedOperation") )
2322                                         at->at_usage =
2323                                             LDAP_SCHEMA_DISTRIBUTED_OPERATION;
2324                                 else if ( !strcasecmp(sval,"dSAOperation") )
2325                                         at->at_usage =
2326                                             LDAP_SCHEMA_DSA_OPERATION;
2327                                 else {
2328                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2329                                         *errp = ss;
2330                                         LDAP_FREE(sval);
2331                                         ldap_attributetype_free(at);
2332                                         return NULL;
2333                                 }
2334                                 LDAP_FREE(sval);
2335                                 parse_whsp(&ss);
2336                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2337                                 /* Should be parse_qdstrings */
2338                                 ext_vals = parse_qdescrs(&ss, code);
2339                                 if ( !ext_vals ) {
2340                                         *errp = ss;
2341                                         ldap_attributetype_free(at);
2342                                         return NULL;
2343                                 }
2344                                 if ( add_extension(&at->at_extensions,
2345                                                     sval, ext_vals) ) {
2346                                         *code = LDAP_SCHERR_OUTOFMEM;
2347                                         *errp = ss;
2348                                         LDAP_FREE(sval);
2349                                         ldap_attributetype_free(at);
2350                                         return NULL;
2351                                 }
2352                         } else {
2353                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2354                                 *errp = ss;
2355                                 LDAP_FREE(sval);
2356                                 ldap_attributetype_free(at);
2357                                 return NULL;
2358                         }
2359                         break;
2360                 default:
2361                         *code = LDAP_SCHERR_UNEXPTOKEN;
2362                         *errp = ss;
2363                         LDAP_FREE(sval);
2364                         ldap_attributetype_free(at);
2365                         return NULL;
2366                 }
2367         }
2368 }
2369
2370 void
2371 ldap_objectclass_free(LDAPObjectClass * oc)
2372 {
2373         LDAP_FREE(oc->oc_oid);
2374         if (oc->oc_names) LDAP_VFREE(oc->oc_names);
2375         if (oc->oc_desc) LDAP_FREE(oc->oc_desc);
2376         if (oc->oc_sup_oids) LDAP_VFREE(oc->oc_sup_oids);
2377         if (oc->oc_at_oids_must) LDAP_VFREE(oc->oc_at_oids_must);
2378         if (oc->oc_at_oids_may) LDAP_VFREE(oc->oc_at_oids_may);
2379         free_extensions(oc->oc_extensions);
2380         LDAP_FREE(oc);
2381 }
2382
2383 LDAPObjectClass *
2384 ldap_str2objectclass( LDAP_CONST char * s,
2385         int * code,
2386         LDAP_CONST char ** errp,
2387         LDAP_CONST unsigned flags )
2388 {
2389         tk_t kind;
2390         const char * ss = s;
2391         char * sval;
2392         int seen_name = 0;
2393         int seen_desc = 0;
2394         int seen_obsolete = 0;
2395         int seen_sup = 0;
2396         int seen_kind = 0;
2397         int seen_must = 0;
2398         int seen_may = 0;
2399         LDAPObjectClass * oc;
2400         char ** ext_vals;
2401         const char * savepos;
2402
2403         if ( !s ) {
2404                 *code = LDAP_SCHERR_EMPTY;
2405                 *errp = "";
2406                 return NULL;
2407         }
2408
2409         *errp = s;
2410         oc = LDAP_CALLOC(1,sizeof(LDAPObjectClass));
2411
2412         if ( !oc ) {
2413                 *code = LDAP_SCHERR_OUTOFMEM;
2414                 return NULL;
2415         }
2416         oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
2417
2418         kind = get_token(&ss,&sval);
2419         if ( kind != TK_LEFTPAREN ) {
2420                 *code = LDAP_SCHERR_NOLEFTPAREN;
2421                 LDAP_FREE(sval);
2422                 ldap_objectclass_free(oc);
2423                 return NULL;
2424         }
2425
2426         /*
2427          * Definitions MUST begin with an OID in the numericoid format.
2428          * However, this routine is used by clients to parse the response
2429          * from servers and very well known servers will provide an OID
2430          * in the wrong format or even no OID at all.  We do our best to
2431          * extract info from those servers.
2432          */
2433         parse_whsp(&ss);
2434         savepos = ss;
2435         oc->oc_oid = ldap_int_parse_numericoid(&ss,code,0);
2436         if ( !oc->oc_oid ) {
2437                 if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
2438                         /* Backtracking */
2439                         ss = savepos;
2440                         kind = get_token(&ss,&sval);
2441                         if ( kind == TK_BAREWORD ) {
2442                                 if ( !strcasecmp(sval, "NAME") ||
2443                                      !strcasecmp(sval, "DESC") ||
2444                                      !strcasecmp(sval, "OBSOLETE") ||
2445                                      !strcasecmp(sval, "SUP") ||
2446                                      !strcasecmp(sval, "ABSTRACT") ||
2447                                      !strcasecmp(sval, "STRUCTURAL") ||
2448                                      !strcasecmp(sval, "AUXILIARY") ||
2449                                      !strcasecmp(sval, "MUST") ||
2450                                      !strcasecmp(sval, "MAY") ||
2451                                      !strncasecmp(sval, "X-", 2) ) {
2452                                         /* Missing OID, backtrack */
2453                                         ss = savepos;
2454                                 } else if ( flags &
2455                                         LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2456                                         /* Non-numerical OID, ignore */
2457                                         int len = ss-savepos;
2458                                         oc->oc_oid = LDAP_MALLOC(len+1);
2459                                         strncpy(oc->oc_oid, savepos, len);
2460                                         oc->oc_oid[len] = 0;
2461                                 }
2462                         }
2463                         LDAP_FREE(sval);
2464                         *code = 0;
2465                 } else {
2466                         *errp = ss;
2467                         ldap_objectclass_free(oc);
2468                         return NULL;
2469                 }
2470         }
2471         parse_whsp(&ss);
2472
2473         /*
2474          * Beyond this point we will be liberal an accept the items
2475          * in any order.
2476          */
2477         while (1) {
2478                 kind = get_token(&ss,&sval);
2479                 switch (kind) {
2480                 case TK_EOS:
2481                         *code = LDAP_SCHERR_NORIGHTPAREN;
2482                         *errp = ss;
2483                         ldap_objectclass_free(oc);
2484                         return NULL;
2485                 case TK_RIGHTPAREN:
2486                         return oc;
2487                 case TK_BAREWORD:
2488                         if ( !strcasecmp(sval,"NAME") ) {
2489                                 LDAP_FREE(sval);
2490                                 if ( seen_name ) {
2491                                         *code = LDAP_SCHERR_DUPOPT;
2492                                         *errp = ss;
2493                                         ldap_objectclass_free(oc);
2494                                         return(NULL);
2495                                 }
2496                                 seen_name = 1;
2497                                 oc->oc_names = parse_qdescrs(&ss,code);
2498                                 if ( !oc->oc_names ) {
2499                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2500                                                 *code = LDAP_SCHERR_BADNAME;
2501                                         *errp = ss;
2502                                         ldap_objectclass_free(oc);
2503                                         return NULL;
2504                                 }
2505                         } else if ( !strcasecmp(sval,"DESC") ) {
2506                                 LDAP_FREE(sval);
2507                                 if ( seen_desc ) {
2508                                         *code = LDAP_SCHERR_DUPOPT;
2509                                         *errp = ss;
2510                                         ldap_objectclass_free(oc);
2511                                         return(NULL);
2512                                 }
2513                                 seen_desc = 1;
2514                                 parse_whsp(&ss);
2515                                 kind = get_token(&ss,&sval);
2516                                 if ( kind != TK_QDSTRING ) {
2517                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2518                                         *errp = ss;
2519                                         LDAP_FREE(sval);
2520                                         ldap_objectclass_free(oc);
2521                                         return NULL;
2522                                 }
2523                                 oc->oc_desc = sval;
2524                                 parse_whsp(&ss);
2525                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2526                                 LDAP_FREE(sval);
2527                                 if ( seen_obsolete ) {
2528                                         *code = LDAP_SCHERR_DUPOPT;
2529                                         *errp = ss;
2530                                         ldap_objectclass_free(oc);
2531                                         return(NULL);
2532                                 }
2533                                 seen_obsolete = 1;
2534                                 oc->oc_obsolete = LDAP_SCHEMA_YES;
2535                                 parse_whsp(&ss);
2536                         } else if ( !strcasecmp(sval,"SUP") ) {
2537                                 LDAP_FREE(sval);
2538                                 if ( seen_sup ) {
2539                                         *code = LDAP_SCHERR_DUPOPT;
2540                                         *errp = ss;
2541                                         ldap_objectclass_free(oc);
2542                                         return(NULL);
2543                                 }
2544                                 seen_sup = 1;
2545                                 oc->oc_sup_oids = parse_oids(&ss,
2546                                                              code,
2547                                                              flags);
2548                                 if ( !oc->oc_sup_oids && *code != LDAP_SUCCESS ) {
2549                                         *errp = ss;
2550                                         ldap_objectclass_free(oc);
2551                                         return NULL;
2552                                 }
2553                                 *code = 0;
2554                         } else if ( !strcasecmp(sval,"ABSTRACT") ) {
2555                                 LDAP_FREE(sval);
2556                                 if ( seen_kind ) {
2557                                         *code = LDAP_SCHERR_DUPOPT;
2558                                         *errp = ss;
2559                                         ldap_objectclass_free(oc);
2560                                         return(NULL);
2561                                 }
2562                                 seen_kind = 1;
2563                                 oc->oc_kind = LDAP_SCHEMA_ABSTRACT;
2564                                 parse_whsp(&ss);
2565                         } else if ( !strcasecmp(sval,"STRUCTURAL") ) {
2566                                 LDAP_FREE(sval);
2567                                 if ( seen_kind ) {
2568                                         *code = LDAP_SCHERR_DUPOPT;
2569                                         *errp = ss;
2570                                         ldap_objectclass_free(oc);
2571                                         return(NULL);
2572                                 }
2573                                 seen_kind = 1;
2574                                 oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;
2575                                 parse_whsp(&ss);
2576                         } else if ( !strcasecmp(sval,"AUXILIARY") ) {
2577                                 LDAP_FREE(sval);
2578                                 if ( seen_kind ) {
2579                                         *code = LDAP_SCHERR_DUPOPT;
2580                                         *errp = ss;
2581                                         ldap_objectclass_free(oc);
2582                                         return(NULL);
2583                                 }
2584                                 seen_kind = 1;
2585                                 oc->oc_kind = LDAP_SCHEMA_AUXILIARY;
2586                                 parse_whsp(&ss);
2587                         } else if ( !strcasecmp(sval,"MUST") ) {
2588                                 LDAP_FREE(sval);
2589                                 if ( seen_must ) {
2590                                         *code = LDAP_SCHERR_DUPOPT;
2591                                         *errp = ss;
2592                                         ldap_objectclass_free(oc);
2593                                         return(NULL);
2594                                 }
2595                                 seen_must = 1;
2596                                 oc->oc_at_oids_must = parse_oids(&ss,code,0);
2597                                 if ( !oc->oc_at_oids_must && *code != LDAP_SUCCESS ) {
2598                                         *errp = ss;
2599                                         ldap_objectclass_free(oc);
2600                                         return NULL;
2601                                 }
2602                                 *code = 0;
2603                                 parse_whsp(&ss);
2604                         } else if ( !strcasecmp(sval,"MAY") ) {
2605                                 LDAP_FREE(sval);
2606                                 if ( seen_may ) {
2607                                         *code = LDAP_SCHERR_DUPOPT;
2608                                         *errp = ss;
2609                                         ldap_objectclass_free(oc);
2610                                         return(NULL);
2611                                 }
2612                                 seen_may = 1;
2613                                 oc->oc_at_oids_may = parse_oids(&ss,code,0);
2614                                 if ( !oc->oc_at_oids_may && *code != LDAP_SUCCESS ) {
2615                                         *errp = ss;
2616                                         ldap_objectclass_free(oc);
2617                                         return NULL;
2618                                 }
2619                                 *code = 0;
2620                                 parse_whsp(&ss);
2621                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2622                                 /* Should be parse_qdstrings */
2623                                 ext_vals = parse_qdescrs(&ss, code);
2624                                 *code = 0;
2625                                 if ( !ext_vals ) {
2626                                         *errp = ss;
2627                                         ldap_objectclass_free(oc);
2628                                         return NULL;
2629                                 }
2630                                 if ( add_extension(&oc->oc_extensions,
2631                                                     sval, ext_vals) ) {
2632                                         *code = LDAP_SCHERR_OUTOFMEM;
2633                                         *errp = ss;
2634                                         LDAP_FREE(sval);
2635                                         ldap_objectclass_free(oc);
2636                                         return NULL;
2637                                 }
2638                         } else {
2639                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2640                                 *errp = ss;
2641                                 LDAP_FREE(sval);
2642                                 ldap_objectclass_free(oc);
2643                                 return NULL;
2644                         }
2645                         break;
2646                 default:
2647                         *code = LDAP_SCHERR_UNEXPTOKEN;
2648                         *errp = ss;
2649                         LDAP_FREE(sval);
2650                         ldap_objectclass_free(oc);
2651                         return NULL;
2652                 }
2653         }
2654 }
2655
2656 void
2657 ldap_contentrule_free(LDAPContentRule * cr)
2658 {
2659         LDAP_FREE(cr->cr_oid);
2660         if (cr->cr_names) LDAP_VFREE(cr->cr_names);
2661         if (cr->cr_desc) LDAP_FREE(cr->cr_desc);
2662         if (cr->cr_oc_oids_aux) LDAP_VFREE(cr->cr_oc_oids_aux);
2663         if (cr->cr_at_oids_must) LDAP_VFREE(cr->cr_at_oids_must);
2664         if (cr->cr_at_oids_may) LDAP_VFREE(cr->cr_at_oids_may);
2665         if (cr->cr_at_oids_not) LDAP_VFREE(cr->cr_at_oids_not);
2666         free_extensions(cr->cr_extensions);
2667         LDAP_FREE(cr);
2668 }
2669
2670 LDAPContentRule *
2671 ldap_str2contentrule( LDAP_CONST char * s,
2672         int * code,
2673         LDAP_CONST char ** errp,
2674         LDAP_CONST unsigned flags )
2675 {
2676         tk_t kind;
2677         const char * ss = s;
2678         char * sval;
2679         int seen_name = 0;
2680         int seen_desc = 0;
2681         int seen_obsolete = 0;
2682         int seen_aux = 0;
2683         int seen_must = 0;
2684         int seen_may = 0;
2685         int seen_not = 0;
2686         LDAPContentRule * cr;
2687         char ** ext_vals;
2688         const char * savepos;
2689
2690         if ( !s ) {
2691                 *code = LDAP_SCHERR_EMPTY;
2692                 *errp = "";
2693                 return NULL;
2694         }
2695
2696         *errp = s;
2697         cr = LDAP_CALLOC(1,sizeof(LDAPContentRule));
2698
2699         if ( !cr ) {
2700                 *code = LDAP_SCHERR_OUTOFMEM;
2701                 return NULL;
2702         }
2703
2704         kind = get_token(&ss,&sval);
2705         if ( kind != TK_LEFTPAREN ) {
2706                 *code = LDAP_SCHERR_NOLEFTPAREN;
2707                 LDAP_FREE(sval);
2708                 ldap_contentrule_free(cr);
2709                 return NULL;
2710         }
2711
2712         /*
2713          * Definitions MUST begin with an OID in the numericoid format.
2714          */
2715         parse_whsp(&ss);
2716         savepos = ss;
2717         cr->cr_oid = ldap_int_parse_numericoid(&ss,code,0);
2718         if ( !cr->cr_oid ) {
2719                 if ( (flags & LDAP_SCHEMA_ALLOW_ALL) && (ss == savepos) ) {
2720                         /* Backtracking */
2721                         ss = savepos;
2722                         kind = get_token(&ss,&sval);
2723                         if ( kind == TK_BAREWORD ) {
2724                                 if ( !strcasecmp(sval, "NAME") ||
2725                                      !strcasecmp(sval, "DESC") ||
2726                                      !strcasecmp(sval, "OBSOLETE") ||
2727                                      !strcasecmp(sval, "AUX") ||
2728                                      !strcasecmp(sval, "MUST") ||
2729                                      !strcasecmp(sval, "MAY") ||
2730                                      !strcasecmp(sval, "NOT") ||
2731                                      !strncasecmp(sval, "X-", 2) ) {
2732                                         /* Missing OID, backtrack */
2733                                         ss = savepos;
2734                                 } else if ( flags &
2735                                         LDAP_SCHEMA_ALLOW_OID_MACRO ) {
2736                                         /* Non-numerical OID, ignore */
2737                                         int len = ss-savepos;
2738                                         cr->cr_oid = LDAP_MALLOC(len+1);
2739                                         strncpy(cr->cr_oid, savepos, len);
2740                                         cr->cr_oid[len] = 0;
2741                                 }
2742                         }
2743                         LDAP_FREE(sval);
2744                 } else {
2745                         *errp = ss;
2746                         ldap_contentrule_free(cr);
2747                         return NULL;
2748                 }
2749         }
2750         parse_whsp(&ss);
2751
2752         /*
2753          * Beyond this point we will be liberal an accept the items
2754          * in any order.
2755          */
2756         while (1) {
2757                 kind = get_token(&ss,&sval);
2758                 switch (kind) {
2759                 case TK_EOS:
2760                         *code = LDAP_SCHERR_NORIGHTPAREN;
2761                         *errp = ss;
2762                         ldap_contentrule_free(cr);
2763                         return NULL;
2764                 case TK_RIGHTPAREN:
2765                         return cr;
2766                 case TK_BAREWORD:
2767                         if ( !strcasecmp(sval,"NAME") ) {
2768                                 LDAP_FREE(sval);
2769                                 if ( seen_name ) {
2770                                         *code = LDAP_SCHERR_DUPOPT;
2771                                         *errp = ss;
2772                                         ldap_contentrule_free(cr);
2773                                         return(NULL);
2774                                 }
2775                                 seen_name = 1;
2776                                 cr->cr_names = parse_qdescrs(&ss,code);
2777                                 if ( !cr->cr_names ) {
2778                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
2779                                                 *code = LDAP_SCHERR_BADNAME;
2780                                         *errp = ss;
2781                                         ldap_contentrule_free(cr);
2782                                         return NULL;
2783                                 }
2784                         } else if ( !strcasecmp(sval,"DESC") ) {
2785                                 LDAP_FREE(sval);
2786                                 if ( seen_desc ) {
2787                                         *code = LDAP_SCHERR_DUPOPT;
2788                                         *errp = ss;
2789                                         ldap_contentrule_free(cr);
2790                                         return(NULL);
2791                                 }
2792                                 seen_desc = 1;
2793                                 parse_whsp(&ss);
2794                                 kind = get_token(&ss,&sval);
2795                                 if ( kind != TK_QDSTRING ) {
2796                                         *code = LDAP_SCHERR_UNEXPTOKEN;
2797                                         *errp = ss;
2798                                         LDAP_FREE(sval);
2799                                         ldap_contentrule_free(cr);
2800                                         return NULL;
2801                                 }
2802                                 cr->cr_desc = sval;
2803                                 parse_whsp(&ss);
2804                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
2805                                 LDAP_FREE(sval);
2806                                 if ( seen_obsolete ) {
2807                                         *code = LDAP_SCHERR_DUPOPT;
2808                                         *errp = ss;
2809                                         ldap_contentrule_free(cr);
2810                                         return(NULL);
2811                                 }
2812                                 seen_obsolete = 1;
2813                                 cr->cr_obsolete = LDAP_SCHEMA_YES;
2814                                 parse_whsp(&ss);
2815                         } else if ( !strcasecmp(sval,"AUX") ) {
2816                                 LDAP_FREE(sval);
2817                                 if ( seen_aux ) {
2818                                         *code = LDAP_SCHERR_DUPOPT;
2819                                         *errp = ss;
2820                                         ldap_contentrule_free(cr);
2821                                         return(NULL);
2822                                 }
2823                                 seen_aux = 1;
2824                                 cr->cr_oc_oids_aux = parse_oids(&ss,code,0);
2825                                 if ( !cr->cr_oc_oids_aux ) {
2826                                         *errp = ss;
2827                                         ldap_contentrule_free(cr);
2828                                         return NULL;
2829                                 }
2830                                 parse_whsp(&ss);
2831                         } else if ( !strcasecmp(sval,"MUST") ) {
2832                                 LDAP_FREE(sval);
2833                                 if ( seen_must ) {
2834                                         *code = LDAP_SCHERR_DUPOPT;
2835                                         *errp = ss;
2836                                         ldap_contentrule_free(cr);
2837                                         return(NULL);
2838                                 }
2839                                 seen_must = 1;
2840                                 cr->cr_at_oids_must = parse_oids(&ss,code,0);
2841                                 if ( !cr->cr_at_oids_must && *code != LDAP_SUCCESS ) {
2842                                         *errp = ss;
2843                                         ldap_contentrule_free(cr);
2844                                         return NULL;
2845                                 }
2846                                 parse_whsp(&ss);
2847                         } else if ( !strcasecmp(sval,"MAY") ) {
2848                                 LDAP_FREE(sval);
2849                                 if ( seen_may ) {
2850                                         *code = LDAP_SCHERR_DUPOPT;
2851                                         *errp = ss;
2852                                         ldap_contentrule_free(cr);
2853                                         return(NULL);
2854                                 }
2855                                 seen_may = 1;
2856                                 cr->cr_at_oids_may = parse_oids(&ss,code,0);
2857                                 if ( !cr->cr_at_oids_may && *code != LDAP_SUCCESS ) {
2858                                         *errp = ss;
2859                                         ldap_contentrule_free(cr);
2860                                         return NULL;
2861                                 }
2862                                 parse_whsp(&ss);
2863                         } else if ( !strcasecmp(sval,"NOT") ) {
2864                                 LDAP_FREE(sval);
2865                                 if ( seen_not ) {
2866                                         *code = LDAP_SCHERR_DUPOPT;
2867                                         *errp = ss;
2868                                         ldap_contentrule_free(cr);
2869                                         return(NULL);
2870                                 }
2871                                 seen_not = 1;
2872                                 cr->cr_at_oids_not = parse_oids(&ss,code,0);
2873                                 if ( !cr->cr_at_oids_not && *code != LDAP_SUCCESS ) {
2874                                         *errp = ss;
2875                                         ldap_contentrule_free(cr);
2876                                         return NULL;
2877                                 }
2878                                 parse_whsp(&ss);
2879                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
2880                                 /* Should be parse_qdstrings */
2881                                 ext_vals = parse_qdescrs(&ss, code);
2882                                 if ( !ext_vals ) {
2883                                         *errp = ss;
2884                                         ldap_contentrule_free(cr);
2885                                         return NULL;
2886                                 }
2887                                 if ( add_extension(&cr->cr_extensions,
2888                                                     sval, ext_vals) ) {
2889                                         *code = LDAP_SCHERR_OUTOFMEM;
2890                                         *errp = ss;
2891                                         LDAP_FREE(sval);
2892                                         ldap_contentrule_free(cr);
2893                                         return NULL;
2894                                 }
2895                         } else {
2896                                 *code = LDAP_SCHERR_UNEXPTOKEN;
2897                                 *errp = ss;
2898                                 LDAP_FREE(sval);
2899                                 ldap_contentrule_free(cr);
2900                                 return NULL;
2901                         }
2902                         break;
2903                 default:
2904                         *code = LDAP_SCHERR_UNEXPTOKEN;
2905                         *errp = ss;
2906                         LDAP_FREE(sval);
2907                         ldap_contentrule_free(cr);
2908                         return NULL;
2909                 }
2910         }
2911 }
2912
2913 void
2914 ldap_structurerule_free(LDAPStructureRule * sr)
2915 {
2916         if (sr->sr_names) LDAP_VFREE(sr->sr_names);
2917         if (sr->sr_desc) LDAP_FREE(sr->sr_desc);
2918         if (sr->sr_nameform) LDAP_FREE(sr->sr_nameform);
2919         if (sr->sr_sup_ruleids) LDAP_FREE(sr->sr_sup_ruleids);
2920         free_extensions(sr->sr_extensions);
2921         LDAP_FREE(sr);
2922 }
2923
2924 LDAPStructureRule *
2925 ldap_str2structurerule( LDAP_CONST char * s,
2926         int * code,
2927         LDAP_CONST char ** errp,
2928         LDAP_CONST unsigned flags )
2929 {
2930         tk_t kind;
2931         int ret;
2932         const char * ss = s;
2933         char * sval;
2934         int seen_name = 0;
2935         int seen_desc = 0;
2936         int seen_obsolete = 0;
2937         int seen_nameform = 0;
2938         LDAPStructureRule * sr;
2939         char ** ext_vals;
2940         const char * savepos;
2941
2942         if ( !s ) {
2943                 *code = LDAP_SCHERR_EMPTY;
2944                 *errp = "";
2945                 return NULL;
2946         }
2947
2948         *errp = s;
2949         sr = LDAP_CALLOC(1,sizeof(LDAPStructureRule));
2950
2951         if ( !sr ) {
2952                 *code = LDAP_SCHERR_OUTOFMEM;
2953                 return NULL;
2954         }
2955
2956         kind = get_token(&ss,&sval);
2957         if ( kind != TK_LEFTPAREN ) {
2958                 *code = LDAP_SCHERR_NOLEFTPAREN;
2959                 LDAP_FREE(sval);
2960                 ldap_structurerule_free(sr);
2961                 return NULL;
2962         }
2963
2964         /*
2965          * Definitions MUST begin with a ruleid.
2966          */
2967         parse_whsp(&ss);
2968         savepos = ss;
2969         ret = ldap_int_parse_ruleid(&ss,code,0,&sr->sr_ruleid);
2970         if ( ret ) {
2971                 *errp = ss;
2972                 ldap_structurerule_free(sr);
2973                 return NULL;
2974         }
2975         parse_whsp(&ss);
2976
2977         /*
2978          * Beyond this point we will be liberal an accept the items
2979          * in any order.
2980          */
2981         while (1) {
2982                 kind = get_token(&ss,&sval);
2983                 switch (kind) {
2984                 case TK_EOS:
2985                         *code = LDAP_SCHERR_NORIGHTPAREN;
2986                         *errp = ss;
2987                         ldap_structurerule_free(sr);
2988                         return NULL;
2989                 case TK_RIGHTPAREN:
2990                         if( !seen_nameform ) {
2991                                 *code = LDAP_SCHERR_MISSING;
2992                                 ldap_structurerule_free(sr);
2993                                 return NULL;
2994                         }
2995                         return sr;
2996                 case TK_BAREWORD:
2997                         if ( !strcasecmp(sval,"NAME") ) {
2998                                 LDAP_FREE(sval);
2999                                 if ( seen_name ) {
3000                                         *code = LDAP_SCHERR_DUPOPT;
3001                                         *errp = ss;
3002                                         ldap_structurerule_free(sr);
3003                                         return(NULL);
3004                                 }
3005                                 seen_name = 1;
3006                                 sr->sr_names = parse_qdescrs(&ss,code);
3007                                 if ( !sr->sr_names ) {
3008                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
3009                                                 *code = LDAP_SCHERR_BADNAME;
3010                                         *errp = ss;
3011                                         ldap_structurerule_free(sr);
3012                                         return NULL;
3013                                 }
3014                         } else if ( !strcasecmp(sval,"DESC") ) {
3015                                 LDAP_FREE(sval);
3016                                 if ( seen_desc ) {
3017                                         *code = LDAP_SCHERR_DUPOPT;
3018                                         *errp = ss;
3019                                         ldap_structurerule_free(sr);
3020                                         return(NULL);
3021                                 }
3022                                 seen_desc = 1;
3023                                 parse_whsp(&ss);
3024                                 kind = get_token(&ss,&sval);
3025                                 if ( kind != TK_QDSTRING ) {
3026                                         *code = LDAP_SCHERR_UNEXPTOKEN;
3027                                         *errp = ss;
3028                                         LDAP_FREE(sval);
3029                                         ldap_structurerule_free(sr);
3030                                         return NULL;
3031                                 }
3032                                 sr->sr_desc = sval;
3033                                 parse_whsp(&ss);
3034                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
3035                                 LDAP_FREE(sval);
3036                                 if ( seen_obsolete ) {
3037                                         *code = LDAP_SCHERR_DUPOPT;
3038                                         *errp = ss;
3039                                         ldap_structurerule_free(sr);
3040                                         return(NULL);
3041                                 }
3042                                 seen_obsolete = 1;
3043                                 sr->sr_obsolete = LDAP_SCHEMA_YES;
3044                                 parse_whsp(&ss);
3045                         } else if ( !strcasecmp(sval,"FORM") ) {
3046                                 LDAP_FREE(sval);
3047                                 if ( seen_nameform ) {
3048                                         *code = LDAP_SCHERR_DUPOPT;
3049                                         *errp = ss;
3050                                         ldap_structurerule_free(sr);
3051                                         return(NULL);
3052                                 }
3053                                 seen_nameform = 1;
3054                                 sr->sr_nameform = parse_woid(&ss,code);
3055                                 if ( !sr->sr_nameform ) {
3056                                         *errp = ss;
3057                                         ldap_structurerule_free(sr);
3058                                         return NULL;
3059                                 }
3060                                 parse_whsp(&ss);
3061                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
3062                                 /* Should be parse_qdstrings */
3063                                 ext_vals = parse_qdescrs(&ss, code);
3064                                 if ( !ext_vals ) {
3065                                         *errp = ss;
3066                                         ldap_structurerule_free(sr);
3067                                         return NULL;
3068                                 }
3069                                 if ( add_extension(&sr->sr_extensions,
3070                                                     sval, ext_vals) ) {
3071                                         *code = LDAP_SCHERR_OUTOFMEM;
3072                                         *errp = ss;
3073                                         LDAP_FREE(sval);
3074                                         ldap_structurerule_free(sr);
3075                                         return NULL;
3076                                 }
3077                         } else {
3078                                 *code = LDAP_SCHERR_UNEXPTOKEN;
3079                                 *errp = ss;
3080                                 LDAP_FREE(sval);
3081                                 ldap_structurerule_free(sr);
3082                                 return NULL;
3083                         }
3084                         break;
3085                 default:
3086                         *code = LDAP_SCHERR_UNEXPTOKEN;
3087                         *errp = ss;
3088                         LDAP_FREE(sval);
3089                         ldap_structurerule_free(sr);
3090                         return NULL;
3091                 }
3092         }
3093 }
3094
3095 void
3096 ldap_nameform_free(LDAPNameForm * nf)
3097 {
3098         LDAP_FREE(nf->nf_oid);
3099         if (nf->nf_names) LDAP_VFREE(nf->nf_names);
3100         if (nf->nf_desc) LDAP_FREE(nf->nf_desc);
3101         if (nf->nf_objectclass) LDAP_FREE(nf->nf_objectclass);
3102         if (nf->nf_at_oids_must) LDAP_VFREE(nf->nf_at_oids_must);
3103         if (nf->nf_at_oids_may) LDAP_VFREE(nf->nf_at_oids_may);
3104         free_extensions(nf->nf_extensions);
3105         LDAP_FREE(nf);
3106 }
3107
3108 LDAPNameForm *
3109 ldap_str2nameform( LDAP_CONST char * s,
3110         int * code,
3111         LDAP_CONST char ** errp,
3112         LDAP_CONST unsigned flags )
3113 {
3114         tk_t kind;
3115         const char * ss = s;
3116         char * sval;
3117         int seen_name = 0;
3118         int seen_desc = 0;
3119         int seen_obsolete = 0;
3120         int seen_class = 0;
3121         int seen_must = 0;
3122         int seen_may = 0;
3123         LDAPNameForm * nf;
3124         char ** ext_vals;
3125         const char * savepos;
3126
3127         if ( !s ) {
3128                 *code = LDAP_SCHERR_EMPTY;
3129                 *errp = "";
3130                 return NULL;
3131         }
3132
3133         *errp = s;
3134         nf = LDAP_CALLOC(1,sizeof(LDAPNameForm));
3135
3136         if ( !nf ) {
3137                 *code = LDAP_SCHERR_OUTOFMEM;
3138                 return NULL;
3139         }
3140
3141         kind = get_token(&ss,&sval);
3142         if ( kind != TK_LEFTPAREN ) {
3143                 *code = LDAP_SCHERR_NOLEFTPAREN;
3144                 LDAP_FREE(sval);
3145                 ldap_nameform_free(nf);
3146                 return NULL;
3147         }
3148
3149         /*
3150          * Definitions MUST begin with an OID in the numericoid format.
3151          * However, this routine is used by clients to parse the response
3152          * from servers and very well known servers will provide an OID
3153          * in the wrong format or even no OID at all.  We do our best to
3154          * extract info from those servers.
3155          */
3156         parse_whsp(&ss);
3157         savepos = ss;
3158         nf->nf_oid = ldap_int_parse_numericoid(&ss,code,0);
3159         if ( !nf->nf_oid ) {
3160                 *errp = ss;
3161                 ldap_nameform_free(nf);
3162                 return NULL;
3163         }
3164         parse_whsp(&ss);
3165
3166         /*
3167          * Beyond this point we will be liberal an accept the items
3168          * in any order.
3169          */
3170         while (1) {
3171                 kind = get_token(&ss,&sval);
3172                 switch (kind) {
3173                 case TK_EOS:
3174                         *code = LDAP_SCHERR_NORIGHTPAREN;
3175                         *errp = ss;
3176                         ldap_nameform_free(nf);
3177                         return NULL;
3178                 case TK_RIGHTPAREN:
3179                         if( !seen_class || !seen_must ) {
3180                                 *code = LDAP_SCHERR_MISSING;
3181                                 ldap_nameform_free(nf);
3182                                 return NULL;
3183                         }
3184                         return nf;
3185                 case TK_BAREWORD:
3186                         if ( !strcasecmp(sval,"NAME") ) {
3187                                 LDAP_FREE(sval);
3188                                 if ( seen_name ) {
3189                                         *code = LDAP_SCHERR_DUPOPT;
3190                                         *errp = ss;
3191                                         ldap_nameform_free(nf);
3192                                         return(NULL);
3193                                 }
3194                                 seen_name = 1;
3195                                 nf->nf_names = parse_qdescrs(&ss,code);
3196                                 if ( !nf->nf_names ) {
3197                                         if ( *code != LDAP_SCHERR_OUTOFMEM )
3198                                                 *code = LDAP_SCHERR_BADNAME;
3199                                         *errp = ss;
3200                                         ldap_nameform_free(nf);
3201                                         return NULL;
3202                                 }
3203                         } else if ( !strcasecmp(sval,"DESC") ) {
3204                                 LDAP_FREE(sval);
3205                                 if ( seen_desc ) {
3206                                         *code = LDAP_SCHERR_DUPOPT;
3207                                         *errp = ss;
3208                                         ldap_nameform_free(nf);
3209                                         return(NULL);
3210                                 }
3211                                 seen_desc = 1;
3212                                 parse_whsp(&ss);
3213                                 kind = get_token(&ss,&sval);
3214                                 if ( kind != TK_QDSTRING ) {
3215                                         *code = LDAP_SCHERR_UNEXPTOKEN;
3216                                         *errp = ss;
3217                                         LDAP_FREE(sval);
3218                                         ldap_nameform_free(nf);
3219                                         return NULL;
3220                                 }
3221                                 nf->nf_desc = sval;
3222                                 parse_whsp(&ss);
3223                         } else if ( !strcasecmp(sval,"OBSOLETE") ) {
3224                                 LDAP_FREE(sval);
3225                                 if ( seen_obsolete ) {
3226                                         *code = LDAP_SCHERR_DUPOPT;
3227                                         *errp = ss;
3228                                         ldap_nameform_free(nf);
3229                                         return(NULL);
3230                                 }
3231                                 seen_obsolete = 1;
3232                                 nf->nf_obsolete = LDAP_SCHEMA_YES;
3233                                 parse_whsp(&ss);
3234                         } else if ( !strcasecmp(sval,"MUST") ) {
3235                                 LDAP_FREE(sval);
3236                                 if ( seen_must ) {
3237                                         *code = LDAP_SCHERR_DUPOPT;
3238                                         *errp = ss;
3239                                         ldap_nameform_free(nf);
3240                                         return(NULL);
3241                                 }
3242                                 seen_must = 1;
3243                                 nf->nf_at_oids_must = parse_oids(&ss,code,0);
3244                                 if ( !nf->nf_at_oids_must && *code != LDAP_SUCCESS ) {
3245                                         *errp = ss;
3246                                         ldap_nameform_free(nf);
3247                                         return NULL;
3248                                 }
3249                                 parse_whsp(&ss);
3250                         } else if ( !strcasecmp(sval,"MAY") ) {
3251                                 LDAP_FREE(sval);
3252                                 if ( seen_may ) {
3253                                         *code = LDAP_SCHERR_DUPOPT;
3254                                         *errp = ss;
3255                                         ldap_nameform_free(nf);
3256                                         return(NULL);
3257                                 }
3258                                 seen_may = 1;
3259                                 nf->nf_at_oids_may = parse_oids(&ss,code,0);
3260                                 if ( !nf->nf_at_oids_may && *code != LDAP_SUCCESS ) {
3261                                         *errp = ss;
3262                                         ldap_nameform_free(nf);
3263                                         return NULL;
3264                                 }
3265                                 parse_whsp(&ss);
3266                         } else if ( sval[0] == 'X' && sval[1] == '-' ) {
3267                                 /* Should be parse_qdstrings */
3268                                 ext_vals = parse_qdescrs(&ss, code);
3269                                 if ( !ext_vals ) {
3270                                         *errp = ss;
3271                                         ldap_nameform_free(nf);
3272                                         return NULL;
3273                                 }
3274                                 if ( add_extension(&nf->nf_extensions,
3275                                                     sval, ext_vals) ) {
3276                                         *code = LDAP_SCHERR_OUTOFMEM;
3277                                         *errp = ss;
3278                                         LDAP_FREE(sval);
3279                                         ldap_nameform_free(nf);
3280                                         return NULL;
3281                                 }
3282                         } else {
3283                                 *code = LDAP_SCHERR_UNEXPTOKEN;
3284                                 *errp = ss;
3285                                 LDAP_FREE(sval);
3286                                 ldap_nameform_free(nf);
3287                                 return NULL;
3288                         }
3289                         break;
3290                 default:
3291                         *code = LDAP_SCHERR_UNEXPTOKEN;
3292                         *errp = ss;
3293                         LDAP_FREE(sval);
3294                         ldap_nameform_free(nf);
3295                         return NULL;
3296                 }
3297         }
3298 }
3299
3300 static char *const err2text[] = {
3301         N_("Success"),
3302         N_("Out of memory"),
3303         N_("Unexpected token"),
3304         N_("Missing opening parenthesis"),
3305         N_("Missing closing parenthesis"),
3306         N_("Expecting digit"),
3307         N_("Expecting a name"),
3308         N_("Bad description"),
3309         N_("Bad superiors"),
3310         N_("Duplicate option"),
3311         N_("Unexpected end of data"),
3312         N_("Missing required field"),
3313         N_("Out of order field")
3314 };
3315
3316 char *
3317 ldap_scherr2str(int code)
3318 {
3319         if ( code < 0 || code >= (int)(sizeof(err2text)/sizeof(char *)) ) {
3320                 return _("Unknown error");
3321         } else {
3322                 return _(err2text[code]);
3323         }
3324 }