Diff for /servers/slapd/schemaparse.c between versions 1.12.8.4 and 1.12.8.5

version 1.12.8.4, 1999/09/10 20:25:31 version 1.12.8.5, 2000/06/13 17:57:30
Line 1 Line 1
 /* schemaparse.c - routines to parse config file objectclass definitions */  /* schemaparse.c - routines to parse config file objectclass definitions */
 /* $OpenLDAP: pkg/ldap/servers/slapd/schemaparse.c,v 1.20 1999/09/08 17:06:34 kdz Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/schemaparse.c,v 1.34 2000/06/07 03:17:30 kurt Exp $ */
 /*  /*
  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */   */
   
Line 18 Line 18
   
 int     global_schemacheck = 1; /* schemacheck on is default */  int     global_schemacheck = 1; /* schemacheck on is default */
   
 static void             oc_usage_old(void) LDAP_GCCATTR((noreturn));  
 static void             oc_usage(void)     LDAP_GCCATTR((noreturn));  static void             oc_usage(void)     LDAP_GCCATTR((noreturn));
 static void             at_usage(void)     LDAP_GCCATTR((noreturn));  static void             at_usage(void)     LDAP_GCCATTR((noreturn));
   
 static char *const err2text[] = {  static char *const err2text[] = {
         "",          "Success",
         "Out of memory",          "Out of memory",
         "Objectclass not found",          "ObjectClass not found",
         "Attribute type not found",          "AttributeType not found",
         "Duplicate objectclass",          "Duplicate objectClass",
         "Duplicate attributetype",          "Duplicate attributeType",
         "Duplicate syntax",          "Duplicate ldapSyntax",
         "Duplicate matchingrule",          "Duplicate matchingRule",
         "OID or name required",          "OID or name required",
         "Syntax or superior required",          "SYNTAX or SUPerior required",
         "Matchingrule not found",          "MatchingRule not found",
         "Syntax not found",          "Syntax not found",
         "Syntax required"          "Syntax required"
 };  };
Line 41  static char *const err2text[] = { Line 40  static char *const err2text[] = {
 char *  char *
 scherr2str(int code)  scherr2str(int code)
 {  {
         if ( code < 1 || code >= (sizeof(err2text)/sizeof(char *)) ) {          if ( code < 0 || code >= (sizeof(err2text)/sizeof(char *)) ) {
                 return "Unknown error";                  return "Unknown error";
         } else {          } else {
                 return err2text[code];                  return err2text[code];
         }          }
 }  }
   
 void  
 parse_oc_old(  
     Backend     *be,  
     const char  *fname,  
     int         lineno,  
     int         argc,  
     char        **argv  
 )  
 {  
         int             i;  
         char            last;  
         LDAP_OBJECT_CLASS       *oc;  
         int             code;  
         const char      *err;  
         char            **namep;  
   
         oc = (LDAP_OBJECT_CLASS *) ch_calloc( 1, sizeof(LDAP_OBJECT_CLASS) );  
         oc->oc_names = ch_calloc( 2, sizeof(char *) );  
         oc->oc_names[0] = ch_strdup( argv[1] );  
         oc->oc_names[1] = NULL;  
         if ( strcasecmp( oc->oc_names[0], "top" ) ) {  
                 oc->oc_kind = LDAP_SCHEMA_STRUCTURAL;  
         }  
         for ( i = 2; i < argc; i++ ) {  
                 /* required attributes */  
                 if ( strcasecmp( argv[i], "requires" ) == 0 ) {  
                         do {  
                                 i++;  
                                 if ( i < argc ) {  
                                         char **s = str2charray( argv[i], "," );  
                                         last = argv[i][strlen( argv[i] ) - 1];  
                                         charray_merge( &oc->oc_at_oids_must, s );  
                                         charray_free( s );  
                                 }  
                         } while ( i < argc && last == ',' );  
   
                 /* optional attributes */  
                 } else if ( strcasecmp( argv[i], "allows" ) == 0 ) {  
                         do {  
                                 i++;  
                                 if ( i < argc ) {  
                                         char **s = str2charray( argv[i], "," );  
                                         last = argv[i][strlen( argv[i] ) - 1];  
                                           
                                         charray_merge( &oc->oc_at_oids_may, s );  
                                         charray_free( s );  
                                 }  
                         } while ( i < argc && last == ',' );  
   
                 } else {  
                         fprintf( stderr,  
             "%s: line %d: expecting \"requires\" or \"allows\" got \"%s\"\n",  
                             fname, lineno, argv[i] );  
                         oc_usage_old();  
                 }  
         }  
   
         /*  
          * There was no requirement in the old schema that all attributes  
          * types were defined before use and they would just default to  
          * SYNTAX_CIS.  To support this, we need to make attribute types  
          * out of thin air.  
          */  
         if ( oc->oc_at_oids_must ) {  
                 namep = oc->oc_at_oids_must;  
                 while ( *namep ) {  
                         code = at_fake_if_needed( *namep );  
                         if ( code ) {  
                                 fprintf( stderr, "%s: line %d: %s %s\n",  
                                          fname, lineno, scherr2str(code), *namep);  
                                 exit( EXIT_FAILURE );  
                         }  
                         namep++;  
                 }  
         }  
         if ( oc->oc_at_oids_may ) {  
                 namep = oc->oc_at_oids_may;  
                 while ( *namep ) {  
                         code = at_fake_if_needed( *namep );  
                         if ( code ) {  
                                 fprintf( stderr, "%s: line %d: %s %s\n",  
                                          fname, lineno, scherr2str(code), *namep);  
                                 exit( EXIT_FAILURE );  
                         }  
                         namep++;  
                 }  
         }  
           
         code = oc_add(oc,&err);  
         if ( code ) {  
                 fprintf( stderr, "%s: line %d: %s %s\n",  
                          fname, lineno, scherr2str(code), err);  
                 exit( EXIT_FAILURE );  
         }  
         ldap_memfree(oc);  
 }  
   
 /* OID Macros */  /* OID Macros */
   
Line 173  static char * Line 76  static char *
 find_oidm(char *oid)  find_oidm(char *oid)
 {  {
         OidMacro *om;          OidMacro *om;
         char *new;  
         int pos, suflen;  
   
         /* OID macros must start alpha */          /* OID macros must start alpha */
         if ( !isdigit( *oid ) )          if ( isdigit( *oid ) )  {
         {                  return oid;
             for (om = om_list; om; om=om->next)          }
             {  
                 if ((pos = dscompare(om->name, oid, ':')))      for (om = om_list; om; om=om->som_next) {
                 {                  char **names = om->som_names;
                         suflen = strlen(oid + pos);  
                         new = ch_calloc(1, om->oidlen + suflen + 1);                  if( names == NULL ) {
                         strcpy(new, om->oid);                          continue;
                         if (suflen)                  }
                         {  
                                 suflen = om->oidlen;                  for( ; *names != NULL ; names++ ) {
                                 new[suflen++] = '.';                          int pos = dscompare(*names, oid, ':');
                                 strcpy(new+suflen, oid+pos+1);  
                           if( pos ) {
                                   int suflen = strlen(oid + pos);
                                   char *new = ch_calloc(1,
                                           om->som_oid.bv_len + suflen + 1);
                                   strcpy(new, om->som_oid.bv_val);
   
                                   if( suflen ) {
                                           suflen = om->som_oid.bv_len;
                                           new[suflen++] = '.';
                                           strcpy(new+suflen, oid+pos+1);
                                   }
                                   return new;
                         }                          }
                         return new;  
                 }                  }
             }  
             return NULL;  
         }          }
         return oid;          return NULL;
 }  }
   
 void  void
Line 208  parse_oidm( Line 118  parse_oidm(
     char        **argv      char        **argv
 )  )
 {  {
           char *oid;
         OidMacro *om;          OidMacro *om;
   
         if (argc != 3)          if (argc != 3) {
         {                  fprintf( stderr, "%s: line %d: too many arguments\n",
 usage:          fprintf( stderr, "ObjectIdentifier <name> <oid>\n");                          fname, lineno );
   usage:  fprintf( stderr, "\tObjectIdentifier <name> <oid>\n");
                 exit( EXIT_FAILURE );                  exit( EXIT_FAILURE );
         }          }
   
           oid = find_oidm( argv[1] );
           if( oid != NULL ) {
                   fprintf( stderr,
                           "%s: line %d: "
                           "ObjectIdentifier \"%s\" previously defined \"%s\"",
                           fname, lineno, argv[1], oid );
                   exit( EXIT_FAILURE );
           }
   
         om = (OidMacro *) ch_malloc( sizeof(OidMacro) );          om = (OidMacro *) ch_malloc( sizeof(OidMacro) );
         om->name = ch_strdup( argv[1] );  
         om->oid = find_oidm( argv[2] );          om->som_names = NULL;
         if (!om->oid)          charray_add( &om->som_names, argv[1] );
         {          om->som_oid.bv_val = find_oidm( argv[2] );
   
           if (!om->som_oid.bv_val) {
                 fprintf( stderr, "%s: line %d: OID %s not recognized\n",                  fprintf( stderr, "%s: line %d: OID %s not recognized\n",
                         fname, lineno, argv[2] );                          fname, lineno, argv[2] );
                 goto usage;                  goto usage;
         }          }
         if (om->oid == argv[2])  
                 om->oid = ch_strdup( argv[2] );          if (om->som_oid.bv_val == argv[2]) {
         om->oidlen = strlen( om->oid );                  om->som_oid.bv_val = ch_strdup( argv[2] );
         om->next = om_list;          }
   
           om->som_oid.bv_len = strlen( om->som_oid.bv_val );
           om->som_next = om_list;
         om_list = om;          om_list = om;
 }  }
   
Line 244  parse_oc( Line 171  parse_oc(
         const char      *err;          const char      *err;
         char            *oid = NULL;          char            *oid = NULL;
   
         /* Kludge for OIDmacros. If the numericOid field starts nonnumeric          oc = ldap_str2objectclass(line,&code,&err,LDAP_SCHEMA_ALLOW_ALL);
          * look for and expand a macro. The macro's place in the input line  
          * will be replaced with a field of '0's to keep ldap_str2objectclass  
          * happy. The actual oid will be swapped into place afterward.  
          */  
         if ( !isdigit( *argv[2] ))  
         {  
                 oid = find_oidm(argv[2]);  
                 if (!oid)  
                 {  
                         fprintf(stderr, "%s: line %d: OID %s not recognized\n",  
                                 fname, lineno, argv[2]);  
                         exit( EXIT_FAILURE );  
                 }  
                 if (oid != argv[2])  
                         memset(strstr(line, argv[2]), '0', strlen(argv[2]));  
                 else  
                         oid = NULL;  
         }  
         oc = ldap_str2objectclass(line,&code,&err);  
         if ( !oc ) {          if ( !oc ) {
                 fprintf( stderr, "%s: line %d: %s before %s\n",                  fprintf( stderr, "%s: line %d: %s before %s\n",
                          fname, lineno, ldap_scherr2str(code), err );                           fname, lineno, ldap_scherr2str(code), err );
                 oc_usage();                  oc_usage();
         }          }
         if (oid)          if ( oc->oc_oid ) {
         {                  if ( !isdigit( oc->oc_oid[0] )) {
                 ldap_memfree(oc->oc_oid);                          /* Expand OID macros */
                 oc->oc_oid = oid;                          oid = find_oidm( oc->oc_oid );
                           if ( !oid ) {
                                   fprintf(stderr,
                                           "%s: line %d: OID %s not recognized\n",
                                           fname, lineno, oc->oc_oid);
                                   exit( EXIT_FAILURE );
                           }
                           if ( oid != oc->oc_oid ) {
                                   ldap_memfree( oc->oc_oid );
                                   oc->oc_oid = oid;
                           }
                   }
         }          }
           /* oc->oc_oid == NULL will be an error someday */
         code = oc_add(oc,&err);          code = oc_add(oc,&err);
         if ( code ) {          if ( code ) {
                 fprintf( stderr, "%s: line %d: %s %s\n",                  fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
                          fname, lineno, scherr2str(code), err);                           fname, lineno, scherr2str(code), err);
                 exit( EXIT_FAILURE );                  exit( EXIT_FAILURE );
         }          }
Line 286  parse_oc( Line 206  parse_oc(
 static void  static void
 oc_usage( void )  oc_usage( void )
 {  {
         fprintf( stderr, "ObjectClassDescription = \"(\" whsp\n");          fprintf( stderr,
         fprintf( stderr, "  numericoid whsp      ; ObjectClass identifier\n");                  "ObjectClassDescription = \"(\" whsp\n"
         fprintf( stderr, "  [ \"NAME\" qdescrs ]\n");                  "  numericoid whsp                 ; ObjectClass identifier\n"
         fprintf( stderr, "  [ \"DESC\" qdstring ]\n");                  "  [ \"NAME\" qdescrs ]\n"
         fprintf( stderr, "  [ \"OBSOLETE\" whsp ]\n");                  "  [ \"DESC\" qdstring ]\n"
         fprintf( stderr, "  [ \"SUP\" oids ]       ; Superior ObjectClasses\n");                  "  [ \"OBSOLETE\" whsp ]\n"
         fprintf( stderr, "  [ ( \"ABSTRACT\" / \"STRUCTURAL\" / \"AUXILIARY\" ) whsp ]\n");                  "  [ \"SUP\" oids ]                ; Superior ObjectClasses\n"
         fprintf( stderr, "                       ; default structural\n");                  "  [ ( \"ABSTRACT\" / \"STRUCTURAL\" / \"AUXILIARY\" ) whsp ]\n"
         fprintf( stderr, "  [ \"MUST\" oids ]      ; AttributeTypes\n");                  "                                  ; default structural\n"
         fprintf( stderr, "  [ \"MAY\" oids ]       ; AttributeTypes\n");                  "  [ \"MUST\" oids ]               ; AttributeTypes\n"
         fprintf( stderr, "whsp \")\"\n");                  "  [ \"MAY\" oids ]                ; AttributeTypes\n"
                   "  whsp \")\"\n" );
         exit( EXIT_FAILURE );          exit( EXIT_FAILURE );
 }  }
   
 static void  
 oc_usage_old( void )  
 {  
         fprintf( stderr, "<oc clause> ::= objectclass <ocname>\n" );  
         fprintf( stderr, "                [ requires <attrlist> ]\n" );  
         fprintf( stderr, "                [ allows <attrlist> ]\n" );  
         exit( EXIT_FAILURE );  
 }  
   
 static void  static void
 at_usage( void )  at_usage( void )
 {  {
         fprintf( stderr, "AttributeTypeDescription = \"(\" whsp\n");          fprintf( stderr,
         fprintf( stderr, "  numericoid whsp      ; AttributeType identifier\n");                  "AttributeTypeDescription = \"(\" whsp\n"
         fprintf( stderr, "  [ \"NAME\" qdescrs ]             ; name used in AttributeType\n");                  "  numericoid whsp      ; AttributeType identifier\n"
         fprintf( stderr, "  [ \"DESC\" qdstring ]            ; description\n");                  "  [ \"NAME\" qdescrs ]             ; name used in AttributeType\n"
         fprintf( stderr, "  [ \"OBSOLETE\" whsp ]\n");                  "  [ \"DESC\" qdstring ]            ; description\n"
         fprintf( stderr, "  [ \"SUP\" woid ]                 ; derived from this other\n");                  "  [ \"OBSOLETE\" whsp ]\n"
         fprintf( stderr, "                                 ; AttributeType\n");                  "  [ \"SUP\" woid ]                 ; derived from this other\n"
         fprintf( stderr, "  [ \"EQUALITY\" woid ]            ; Matching Rule name\n");                  "                                   ; AttributeType\n"
         fprintf( stderr, "  [ \"ORDERING\" woid ]            ; Matching Rule name\n");                  "  [ \"EQUALITY\" woid ]            ; Matching Rule name\n"
         fprintf( stderr, "  [ \"SUBSTR\" woid ]              ; Matching Rule name\n");                  "  [ \"ORDERING\" woid ]            ; Matching Rule name\n"
         fprintf( stderr, "  [ \"SYNTAX\" whsp noidlen whsp ] ; see section 4.3\n");                  "  [ \"SUBSTR\" woid ]              ; Matching Rule name\n"
         fprintf( stderr, "  [ \"SINGLE-VALUE\" whsp ]        ; default multi-valued\n");                  "  [ \"SYNTAX\" whsp noidlen whsp ] ; see section 4.3\n"
         fprintf( stderr, "  [ \"COLLECTIVE\" whsp ]          ; default not collective\n");                  "  [ \"SINGLE-VALUE\" whsp ]        ; default multi-valued\n"
         fprintf( stderr, "  [ \"NO-USER-MODIFICATION\" whsp ]; default user modifiable\n");                  "  [ \"COLLECTIVE\" whsp ]          ; default not collective\n"
         fprintf( stderr, "  [ \"USAGE\" whsp AttributeUsage ]; default userApplications\n");                  "  [ \"NO-USER-MODIFICATION\" whsp ]; default user modifiable\n"
         fprintf( stderr, "                                 ; userApplications\n");                  "  [ \"USAGE\" whsp AttributeUsage ]; default userApplications\n"
         fprintf( stderr, "                                 ; directoryOperation\n");                  "                                   ; userApplications\n"
         fprintf( stderr, "                                 ; distributedOperation\n");                  "                                   ; directoryOperation\n"
         fprintf( stderr, "                                 ; dSAOperation\n");                  "                                   ; distributedOperation\n"
         fprintf( stderr, "whsp \")\"\n");                  "                                   ; dSAOperation\n"
                   "  whsp \")\"\n");
         exit( EXIT_FAILURE );          exit( EXIT_FAILURE );
 }  }
   
Line 349  parse_at( Line 263  parse_at(
         char            *oid = NULL;          char            *oid = NULL;
         char            *soid = NULL;          char            *soid = NULL;
   
         /* Kludge for OIDmacros. If the numericOid field starts nonnumeric          /* Kludge for OIDmacros for syntaxes. If the syntax field starts
          * look for and expand a macro. The macro's place in the input line           * nonnumeric, look for and expand a macro. The macro's place in
          * will be replaced with a field of '0's to keep ldap_str2attr           * the input line will be replaced with a field of '0's to keep
          * happy. The actual oid will be swapped into place afterward.           * ldap_str2attributetype happy. The actual oid will be swapped
          */           * into place afterwards.
         if ( !isdigit( *argv[2] ))           */
         {  
                 oid = find_oidm(argv[2]);  
                 if (!oid)  
                 {  
                         fprintf(stderr, "%s: line %d: OID %s not recognized\n",  
                                 fname, lineno, argv[2]);  
                         exit( EXIT_FAILURE );  
                 }  
                 if (oid != argv[2])  
                         memset(strstr(line, argv[2]), '0', strlen(argv[2]));  
                 else  
                         oid = NULL;  
         }  
         for (; argv[3]; argv++)          for (; argv[3]; argv++)
         {          {
                 if (!strcasecmp(argv[3], "syntax") &&                  if (!strcasecmp(argv[3], "syntax") &&
Line 387  parse_at( Line 288  parse_at(
                         break;                          break;
                 }                  }
         }          }
         at = ldap_str2attributetype(line,&code,&err);          at = ldap_str2attributetype(line,&code,&err,LDAP_SCHEMA_ALLOW_ALL);
         if ( !at ) {          if ( !at ) {
                 fprintf( stderr, "%s: line %d: %s before %s\n",                  fprintf( stderr, "%s: line %d: %s before %s\n",
                          fname, lineno, ldap_scherr2str(code), err );                           fname, lineno, ldap_scherr2str(code), err );
                 at_usage();                  at_usage();
         }          }
         if (oid)          if ( at->at_oid ) {
         {                  if ( !isdigit( at->at_oid[0] )) {
                 ldap_memfree(at->at_oid);                          /* Expand OID macros */
                 at->at_oid = oid;                          oid = find_oidm( at->at_oid );
                           if ( !oid ) {
                                   fprintf(stderr,
                                           "%s: line %d: OID %s not recognized\n",
                                           fname, lineno, at->at_oid);
                                   exit( EXIT_FAILURE );
                           }
                           if ( oid != at->at_oid ) {
                                   ldap_memfree( at->at_oid );
                                   at->at_oid = oid;
                           }
                   }
         }          }
           /* at->at_oid == NULL will be an error someday */
         if (soid)          if (soid)
         {          {
                 ldap_memfree(at->at_syntax_oid);                  ldap_memfree(at->at_syntax_oid);
Line 405  parse_at( Line 318  parse_at(
         }          }
         code = at_add(at,&err);          code = at_add(at,&err);
         if ( code ) {          if ( code ) {
                 fprintf( stderr, "%s: line %d: %s %s\n",                  fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
                          fname, lineno, scherr2str(code), err);                           fname, lineno, scherr2str(code), err);
                 exit( EXIT_FAILURE );                  exit( EXIT_FAILURE );
         }          }

Removed from v.1.12.8.4  
changed lines
  Added in v.1.12.8.5


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org