mirror of
https://git.openldap.org/openldap/openldap.git
synced 2024-12-21 03:10:25 +08:00
437 lines
8.8 KiB
C
437 lines
8.8 KiB
C
/* $OpenLDAP$ */
|
|
/*
|
|
* Copyright 2004-2005 The OpenLDAP Foundation.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted only as authorized by the OpenLDAP
|
|
* Public License.
|
|
*
|
|
* A copy of this license is available in the file LICENSE in the
|
|
* top-level directory of the distribution or, alternatively, at
|
|
* <http://www.OpenLDAP.org/license.html>.
|
|
*/
|
|
|
|
#include <portable.h>
|
|
|
|
#include <ac/string.h>
|
|
#include <ac/ctype.h>
|
|
#include <ac/signal.h>
|
|
#include <ac/errno.h>
|
|
#include <ac/stdlib.h>
|
|
#include <ac/ctype.h>
|
|
#include <ac/time.h>
|
|
#include <ac/unistd.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
/*
|
|
* Schema reader that allows us to define DSA schema (including
|
|
* operational attributes and non-user object classes)
|
|
*
|
|
* A kludge, at best, and in order to avoid including slapd
|
|
* headers we use fprintf() rather than slapd's native logging,
|
|
* which may confuse users...
|
|
*
|
|
*/
|
|
|
|
#include <ldap.h>
|
|
#include <ldap_schema.h>
|
|
|
|
extern int at_add(LDAPAttributeType *at, const char **err);
|
|
extern int oc_add(LDAPObjectClass *oc, int user, const char **err);
|
|
extern int cr_add(LDAPContentRule *cr, int user, const char **err);
|
|
|
|
#define ARGS_STEP 512
|
|
|
|
static char *fp_getline(FILE *fp, int *lineno);
|
|
static void fp_getline_init(int *lineno);
|
|
static int fp_parse_line(int lineno, char *line);
|
|
static char *strtok_quote( char *line, char *sep );
|
|
|
|
static char **cargv = NULL;
|
|
static int cargv_size = 0;
|
|
static int cargc = 0;
|
|
static char *strtok_quote_ptr;
|
|
|
|
int init_module(int argc, char *argv[]);
|
|
|
|
static int dsaschema_parse_at(const char *fname, int lineno, char *line, char **argv)
|
|
{
|
|
LDAPAttributeType *at;
|
|
int code;
|
|
const char *err;
|
|
|
|
at = ldap_str2attributetype(line, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
|
|
if (!at) {
|
|
fprintf(stderr, "%s: line %d: %s before %s\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
if (at->at_oid == NULL) {
|
|
fprintf(stderr, "%s: line %d: attributeType has no OID\n",
|
|
fname, lineno);
|
|
return 1;
|
|
}
|
|
|
|
code = at_add(at, &err);
|
|
if (code) {
|
|
fprintf(stderr, "%s: line %d: %s: \"%s\"\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
ldap_memfree(at);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsaschema_parse_oc(const char *fname, int lineno, char *line, char **argv)
|
|
{
|
|
LDAPObjectClass *oc;
|
|
int code;
|
|
const char *err;
|
|
|
|
oc = ldap_str2objectclass(line, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
|
|
if (!oc) {
|
|
fprintf(stderr, "%s: line %d: %s before %s\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
if (oc->oc_oid == NULL) {
|
|
fprintf(stderr,
|
|
"%s: line %d: objectclass has no OID\n",
|
|
fname, lineno);
|
|
return 1;
|
|
}
|
|
|
|
code = oc_add(oc, 0, &err);
|
|
if (code) {
|
|
fprintf(stderr, "%s: line %d: %s: \"%s\"\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
ldap_memfree(oc);
|
|
return 0;
|
|
}
|
|
|
|
static int dsaschema_parse_cr(const char *fname, int lineno, char *line, char **argv)
|
|
{
|
|
LDAPContentRule *cr;
|
|
int code;
|
|
const char *err;
|
|
|
|
cr = ldap_str2contentrule(line, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
|
|
if (!cr) {
|
|
fprintf(stderr, "%s: line %d: %s before %s\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
if (cr->cr_oid == NULL) {
|
|
fprintf(stderr,
|
|
"%s: line %d: objectclass has no OID\n",
|
|
fname, lineno);
|
|
return 1;
|
|
}
|
|
|
|
code = cr_add(cr, 0, &err);
|
|
if (code) {
|
|
fprintf(stderr, "%s: line %d: %s: \"%s\"\n",
|
|
fname, lineno, ldap_scherr2str(code), err);
|
|
return 1;
|
|
}
|
|
|
|
ldap_memfree(cr);
|
|
return 0;
|
|
}
|
|
|
|
static int dsaschema_read_config(const char *fname, int depth)
|
|
{
|
|
FILE *fp;
|
|
char *line, *savefname, *saveline;
|
|
int savelineno, lineno;
|
|
int rc;
|
|
|
|
if (depth == 0) {
|
|
cargv = calloc(ARGS_STEP + 1, sizeof(*cargv));
|
|
if (cargv == NULL) {
|
|
return 1;
|
|
}
|
|
cargv_size = ARGS_STEP + 1;
|
|
}
|
|
|
|
fp = fopen(fname, "r");
|
|
if (fp == NULL) {
|
|
fprintf(stderr, "could not open config file \"%s\": %s (%d)\n",
|
|
fname, strerror(errno), errno);
|
|
return 1;
|
|
}
|
|
fp_getline_init(&lineno);
|
|
|
|
while ((line = fp_getline(fp, &lineno)) != NULL) {
|
|
/* skip comments and blank lines */
|
|
if (line[0] == '#' || line[0] == '\0') {
|
|
continue;
|
|
}
|
|
|
|
saveline = strdup(line);
|
|
if (saveline == NULL) {
|
|
return 1;
|
|
}
|
|
|
|
if (fp_parse_line(lineno, line) != 0) {
|
|
return 1;
|
|
}
|
|
|
|
if (cargc < 1) {
|
|
continue;
|
|
}
|
|
|
|
if (strcasecmp(cargv[0], "attributetype") == 0 ||
|
|
strcasecmp(cargv[0], "attribute") == 0) {
|
|
if (cargc < 2) {
|
|
fprintf(stderr, "%s: line %d: illegal attribute type format\n",
|
|
fname, lineno);
|
|
return 1;
|
|
} else if (*cargv[1] == '(' /*')'*/) {
|
|
char *p;
|
|
|
|
p = strchr(saveline, '(' /*')'*/);
|
|
rc = dsaschema_parse_at(fname, lineno, p, cargv);
|
|
if (rc != 0)
|
|
return rc;
|
|
} else {
|
|
fprintf(stderr, "%s: line %d: old attribute type format not supported\n",
|
|
fname, lineno);
|
|
}
|
|
} else if (strcasecmp(cargv[0], "ditcontentrule") == 0) {
|
|
char *p;
|
|
p = strchr(saveline, '(' /*')'*/);
|
|
rc = dsaschema_parse_cr(fname, lineno, p, cargv);
|
|
if (rc != 0)
|
|
return rc;
|
|
} else if (strcasecmp(cargv[0], "objectclass") == 0) {
|
|
if (cargc < 2) {
|
|
fprintf(stderr, "%s: line %d: illegal objectclass format\n",
|
|
fname, lineno);
|
|
return 1;
|
|
} else if (*cargv[1] == '(' /*')'*/) {
|
|
char *p;
|
|
|
|
p = strchr(saveline, '(' /*')'*/);
|
|
rc = dsaschema_parse_oc(fname, lineno, p, cargv);
|
|
if (rc != 0)
|
|
return rc;
|
|
} else {
|
|
fprintf(stderr, "%s: line %d: object class format not supported\n",
|
|
fname, lineno);
|
|
}
|
|
} else if (strcasecmp(cargv[0], "include") == 0) {
|
|
if (cargc < 2) {
|
|
fprintf(stderr, "%s: line %d: missing file name in \"include <filename>\" line",
|
|
fname, lineno);
|
|
return 1;
|
|
}
|
|
savefname = strdup(cargv[1]);
|
|
if (savefname == NULL) {
|
|
return 1;
|
|
}
|
|
if (dsaschema_read_config(savefname, depth + 1) != 0) {
|
|
return 1;
|
|
}
|
|
free(savefname);
|
|
lineno = savelineno - 1;
|
|
} else {
|
|
fprintf(stderr, "%s: line %d: unknown directive \"%s\" (ignored)\n",
|
|
fname, lineno, cargv[0]);
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
if (depth == 0)
|
|
free(cargv);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int init_module(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
int rc;
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
rc = dsaschema_read_config(argv[i], 0);
|
|
if (rc != 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
static int
|
|
fp_parse_line(
|
|
int lineno,
|
|
char *line
|
|
)
|
|
{
|
|
char * token;
|
|
|
|
cargc = 0;
|
|
token = strtok_quote( line, " \t" );
|
|
|
|
if ( strtok_quote_ptr ) {
|
|
*strtok_quote_ptr = ' ';
|
|
}
|
|
|
|
if ( strtok_quote_ptr ) {
|
|
*strtok_quote_ptr = '\0';
|
|
}
|
|
|
|
for ( ; token != NULL; token = strtok_quote( NULL, " \t" ) ) {
|
|
if ( cargc == cargv_size - 1 ) {
|
|
char **tmp;
|
|
tmp = realloc( cargv, (cargv_size + ARGS_STEP) *
|
|
sizeof(*cargv) );
|
|
if ( tmp == NULL ) {
|
|
return -1;
|
|
}
|
|
cargv = tmp;
|
|
cargv_size += ARGS_STEP;
|
|
}
|
|
cargv[cargc++] = token;
|
|
}
|
|
cargv[cargc] = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static char *
|
|
strtok_quote( char *line, char *sep )
|
|
{
|
|
int inquote;
|
|
char *tmp;
|
|
static char *next;
|
|
|
|
strtok_quote_ptr = NULL;
|
|
if ( line != NULL ) {
|
|
next = line;
|
|
}
|
|
while ( *next && strchr( sep, *next ) ) {
|
|
next++;
|
|
}
|
|
|
|
if ( *next == '\0' ) {
|
|
next = NULL;
|
|
return( NULL );
|
|
}
|
|
tmp = next;
|
|
|
|
for ( inquote = 0; *next; ) {
|
|
switch ( *next ) {
|
|
case '"':
|
|
if ( inquote ) {
|
|
inquote = 0;
|
|
} else {
|
|
inquote = 1;
|
|
}
|
|
AC_MEMCPY( next, next + 1, strlen( next + 1 ) + 1 );
|
|
break;
|
|
|
|
case '\\':
|
|
if ( next[1] )
|
|
AC_MEMCPY( next,
|
|
next + 1, strlen( next + 1 ) + 1 );
|
|
next++; /* dont parse the escaped character */
|
|
break;
|
|
|
|
default:
|
|
if ( ! inquote ) {
|
|
if ( strchr( sep, *next ) != NULL ) {
|
|
strtok_quote_ptr = next;
|
|
*next++ = '\0';
|
|
return( tmp );
|
|
}
|
|
}
|
|
next++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return( tmp );
|
|
}
|
|
|
|
static char buf[BUFSIZ];
|
|
static char *line;
|
|
static size_t lmax, lcur;
|
|
|
|
#define CATLINE( buf ) \
|
|
do { \
|
|
size_t len = strlen( buf ); \
|
|
while ( lcur + len + 1 > lmax ) { \
|
|
lmax += BUFSIZ; \
|
|
line = (char *) realloc( line, lmax ); \
|
|
} \
|
|
strcpy( line + lcur, buf ); \
|
|
lcur += len; \
|
|
} while( 0 )
|
|
|
|
static char *
|
|
fp_getline( FILE *fp, int *lineno )
|
|
{
|
|
char *p;
|
|
|
|
lcur = 0;
|
|
CATLINE( buf );
|
|
(*lineno)++;
|
|
|
|
/* hack attack - keeps us from having to keep a stack of bufs... */
|
|
if ( strncasecmp( line, "include", 7 ) == 0 ) {
|
|
buf[0] = '\0';
|
|
return( line );
|
|
}
|
|
|
|
while ( fgets( buf, sizeof(buf), fp ) != NULL ) {
|
|
/* trim off \r\n or \n */
|
|
if ( (p = strchr( buf, '\n' )) != NULL ) {
|
|
if( p > buf && p[-1] == '\r' ) --p;
|
|
*p = '\0';
|
|
}
|
|
|
|
/* trim off trailing \ and append the next line */
|
|
if ( line[ 0 ] != '\0'
|
|
&& (p = line + strlen( line ) - 1)[ 0 ] == '\\'
|
|
&& p[ -1 ] != '\\' ) {
|
|
p[ 0 ] = '\0';
|
|
lcur--;
|
|
|
|
} else {
|
|
if ( ! isspace( (unsigned char) buf[0] ) ) {
|
|
return( line );
|
|
}
|
|
|
|
/* change leading whitespace to a space */
|
|
buf[0] = ' ';
|
|
}
|
|
|
|
CATLINE( buf );
|
|
(*lineno)++;
|
|
}
|
|
buf[0] = '\0';
|
|
|
|
return( line[0] ? line : NULL );
|
|
}
|
|
|
|
static void
|
|
fp_getline_init( int *lineno )
|
|
{
|
|
*lineno = -1;
|
|
buf[0] = '\0';
|
|
}
|
|
|