#include <ac/socket.h>
#include <ac/errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
#include "slap.h"
#ifdef LDAP_SLAPI
#include "slapi/slapi.h"
#endif
#include "lutil.h"
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif /* HAVE_LIMITS_H */
-#ifndef PATH_MAX
-#define PATH_MAX 4096
-#endif /* ! PATH_MAX */
#include "config.h"
#define ARGS_STEP 512
char *slapd_pid_file = NULL;
char *slapd_args_file = NULL;
-char *strtok_quote_ptr;
-
int use_reverse_lookup = 0;
#ifdef LDAP_SLAPI
static void fp_getline_init(ConfigArgs *c);
static int fp_parse_line(ConfigArgs *c);
-static char *strtok_quote(char *line, char *sep);
-
-int read_config_file(const char *fname, int depth, ConfigArgs *cf);
+static char *strtok_quote(char *line, char *sep, char **quote_ptr);
+static char *strtok_quote_ldif(char **line);
ConfigArgs *
new_config_args( BackendDB *be, const char *fname, int lineno, int argc, char **argv )
c->argc = argc;
c->argv = argv;
c->lineno = lineno;
- snprintf( c->log, sizeof( c->log ), "%s: line %lu", fname, lineno );
+ snprintf( c->log, sizeof( c->log ), "%s: line %d", fname, lineno );
return(c);
}
-int parse_config_table(ConfigTable *Conf, ConfigArgs *c) {
- int i, rc, arg_user, arg_type, iarg;
- long larg;
- ber_len_t barg;
- void *ptr;
+void
+init_config_argv( ConfigArgs *c )
+{
+ c->argv = ch_calloc( ARGS_STEP + 1, sizeof( *c->argv ) );
+ c->argv_size = ARGS_STEP + 1;
+}
+
+ConfigTable *config_find_keyword(ConfigTable *Conf, ConfigArgs *c) {
+ int i;
for(i = 0; Conf[i].name; i++)
if( (Conf[i].length && (!strncasecmp(c->argv[0], Conf[i].name, Conf[i].length))) ||
(!strcasecmp(c->argv[0], Conf[i].name)) ) break;
- if(!Conf[i].name) return(ARG_UNKNOWN);
- arg_type = Conf[i].arg_type;
+ if ( !Conf[i].name ) return NULL;
+ return Conf+i;
+}
+
+int config_check_vals(ConfigTable *Conf, ConfigArgs *c, int check_only ) {
+ int rc, arg_user, arg_type, iarg;
+ long larg;
+ ber_len_t barg;
+
+ arg_type = Conf->arg_type;
if(arg_type == ARG_IGNORED) {
Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> ignored\n",
- c->log, Conf[i].name, 0);
+ c->log, Conf->name, 0);
return(0);
}
- if(Conf[i].min_args && (c->argc < Conf[i].min_args)) {
- Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> missing <%s> argument\n",
- c->log, Conf[i].name, Conf[i].what);
+ if((arg_type & ARG_DN) && c->argc == 1) {
+ c->argc = 2;
+ c->argv[1] = "";
+ }
+ if(Conf->min_args && (c->argc < Conf->min_args)) {
+ sprintf( c->msg, "<%s> missing <%s> argument",
+ c->argv[0], Conf->what );
+ Debug(LDAP_DEBUG_CONFIG, "%s: keyword %s\n", c->log, c->msg, 0 );
return(ARG_BAD_CONF);
}
- if(Conf[i].max_args && (c->argc > Conf[i].max_args)) {
- Debug(LDAP_DEBUG_CONFIG, "%s: extra cruft after <%s> in <%s> line (ignored)\n",
- c->log, Conf[i].what, Conf[i].name);
+ if(Conf->max_args && (c->argc > Conf->max_args)) {
+ char *ignored = " ignored";
+
+ sprintf( c->msg, "<%s> extra cruft after <%s>",
+ c->argv[0], Conf->what );
+
+#ifdef LDAP_DEVEL
+ ignored = "";
+#endif /* LDAP_DEVEL */
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s%s.\n",
+ c->log, c->msg, ignored );
+#ifdef LDAP_DEVEL
+ return(ARG_BAD_CONF);
+#endif /* LDAP_DEVEL */
}
if((arg_type & ARG_DB) && !c->be) {
- Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> allowed only within database declaration\n",
- c->log, Conf[i].name, 0);
+ sprintf( c->msg, "<%s> only allowed within database declaration",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: keyword %s\n",
+ c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
if((arg_type & ARG_PRE_BI) && c->bi) {
- Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> must appear before any backend %sdeclaration\n",
- c->log, Conf[i].name, ((arg_type & ARG_PRE_DB)
- ? "or database " : "") );
+ sprintf( c->msg, "<%s> must occur before any backend %sdeclaration",
+ c->argv[0], (arg_type & ARG_PRE_DB) ? "or database " : "" );
+ Debug(LDAP_DEBUG_CONFIG, "%s: keyword %s\n",
+ c->log, c->msg, 0 );
return(ARG_BAD_CONF);
}
if((arg_type & ARG_PRE_DB) && c->be && c->be != frontendDB) {
- Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> must appear before any database declaration\n",
- c->log, Conf[i].name, 0);
+ sprintf( c->msg, "<%s> must occur before any database declaration",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: keyword %s\n",
+ c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
if((arg_type & ARG_PAREN) && *c->argv[1] != '(' /*')'*/) {
- Debug(LDAP_DEBUG_CONFIG, "%s: old <%s> format not supported\n",
- c->log, Conf[i].name, 0);
+ sprintf( c->msg, "<%s> old format not supported", c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s\n",
+ c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
- if((arg_type & ARGS_POINTER) && !Conf[i].arg_item) {
- Debug(LDAP_DEBUG_CONFIG, "%s: null arg_item for <%s>\n",
- c->log, Conf[i].name, 0);
+ if((arg_type & ARGS_POINTER) && !Conf->arg_item && !(arg_type & ARG_OFFSET)) {
+ sprintf( c->msg, "<%s> invalid config_table, arg_item is NULL",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s\n",
+ c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
c->type = arg_user = (arg_type & ARGS_USERLAND);
int j;
iarg = 0; larg = 0; barg = 0;
switch(arg_type & ARGS_NUMERIC) {
- case ARG_INT: iarg = atoi(c->argv[1]); break;
+ case ARG_INT: iarg = strtol(c->argv[1], NULL, 0); break;
case ARG_LONG: larg = strtol(c->argv[1], NULL, 0); break;
case ARG_BER_LEN_T: barg = (ber_len_t)atol(c->argv[1]); break;
case ARG_ON_OFF:
!strcasecmp(c->argv[1], "false")) {
iarg = 0;
} else {
- Debug(LDAP_DEBUG_CONFIG, "%s: ignoring ", c->log, 0, 0);
- Debug(LDAP_DEBUG_CONFIG, "invalid %s value (%s) in <%s> line\n",
- Conf[i].what, c->argv[1], Conf[i].name);
+ sprintf( c->msg, "<%s> invalid value, ignored",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s\n",
+ c->log, c->msg, 0 );
return(0);
}
break;
}
j = (arg_type & ARG_NONZERO) ? 1 : 0;
- if(iarg < j || larg < j || barg < j ) {
+ if(iarg < j && larg < j && barg < j ) {
larg = larg ? larg : (barg ? barg : iarg);
- Debug(LDAP_DEBUG_CONFIG, "%s: " , c->log, 0, 0);
- Debug(LDAP_DEBUG_CONFIG, "invalid %s value (%ld) in <%s> line\n", Conf[i].what, larg, Conf[i].name);
+ sprintf( c->msg, "<%s> invalid value, ignored",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s\n",
+ c->log, c->msg, 0 );
return(ARG_BAD_CONF);
}
switch(arg_type & ARGS_NUMERIC) {
case ARG_BER_LEN_T: c->value_ber_t = barg; break;
}
} else if(arg_type & ARG_STRING) {
- c->value_string = ch_strdup(c->argv[1]);
+ if ( !check_only )
+ c->value_string = ch_strdup(c->argv[1]);
+ } else if(arg_type & ARG_BERVAL) {
+ if ( !check_only )
+ ber_str2bv( c->argv[1], 0, 1, &c->value_bv );
} else if(arg_type & ARG_DN) {
struct berval bv;
ber_str2bv( c->argv[1], 0, 0, &bv );
rc = dnPrettyNormal( NULL, &bv, &c->value_dn, &c->value_ndn, NULL );
if ( rc != LDAP_SUCCESS ) {
- Debug(LDAP_DEBUG_CONFIG, "%s: " , c->log, 0, 0);
- Debug(LDAP_DEBUG_CONFIG, "%s DN is invalid %d (%s)\n",
- Conf[i].name, rc, ldap_err2string( rc ));
+ sprintf( c->msg, "<%s> invalid DN %d (%s)",
+ c->argv[0], rc, ldap_err2string( rc ));
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s\n" , c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
+ if ( check_only ) {
+ ch_free( c->value_ndn.bv_val );
+ ch_free( c->value_dn.bv_val );
+ }
}
+ return 0;
+}
+
+int config_set_vals(ConfigTable *Conf, ConfigArgs *c) {
+ int rc, arg_type;
+ void *ptr = NULL;
+
+ arg_type = Conf->arg_type;
if(arg_type & ARG_MAGIC) {
if(!c->be) c->be = frontendDB;
- rc = (*((ConfigDriver*)Conf[i].arg_item))(c);
+ c->msg[0] = '\0';
+ rc = (*((ConfigDriver*)Conf->arg_item))(c);
+#if 0
if(c->be == frontendDB) c->be = NULL;
+#endif
if(rc) {
- Debug(LDAP_DEBUG_CONFIG, "%s: handler for <%s> exited with %d!",
- c->log, Conf[i].name, rc);
+ if ( !c->msg[0] ) {
+ sprintf( c->msg, "<%s> handler exited with %d",
+ c->argv[0], rc );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s!\n",
+ c->log, c->msg, 0 );
+ }
return(ARG_BAD_CONF);
}
return(0);
else if (c->bi)
ptr = c->bi->bi_private;
else {
- Debug(LDAP_DEBUG_CONFIG, "%s: offset for <%s> missing base pointer!",
- c->log, Conf[i].name, 0);
+ sprintf( c->msg, "<%s> offset is missing base pointer",
+ c->argv[0] );
+ Debug(LDAP_DEBUG_CONFIG, "%s: %s!\n",
+ c->log, c->msg, 0);
return(ARG_BAD_CONF);
}
- ptr = (void *)((char *)ptr + (int)Conf[i].arg_item);
+ ptr = (void *)((char *)ptr + (long)Conf->arg_item);
} else if (arg_type & ARGS_POINTER) {
- ptr = Conf[i].arg_item;
+ ptr = Conf->arg_item;
}
- if(arg_type & ARGS_POINTER) switch(arg_type & ARGS_POINTER) {
+ if(arg_type & ARGS_POINTER)
+ switch(arg_type & ARGS_POINTER) {
case ARG_ON_OFF:
- case ARG_INT: *(int*)ptr = iarg; break;
- case ARG_LONG: *(long*)ptr = larg; break;
- case ARG_BER_LEN_T: *(ber_len_t*)ptr = barg; break;
+ case ARG_INT: *(int*)ptr = c->value_int; break;
+ case ARG_LONG: *(long*)ptr = c->value_long; break;
+ case ARG_BER_LEN_T: *(ber_len_t*)ptr = c->value_ber_t; break;
case ARG_STRING: {
char *cc = *(char**)ptr;
if(cc) {
- if (arg_type & ARG_UNIQUE) {
+ if ((arg_type & ARG_UNIQUE) && c->op == SLAP_CONFIG_ADD ) {
Debug(LDAP_DEBUG_CONFIG, "%s: already set %s!\n",
- c->log, Conf[i].name, 0 );
+ c->log, Conf->name, 0 );
return(ARG_BAD_CONF);
}
- ch_free(cc); /* potential memory leak */
+ ch_free(cc);
}
*(char **)ptr = c->value_string;
break;
}
+ case ARG_BERVAL:
+ *(struct berval *)ptr = c->value_bv;
+ break;
+ }
+ return(0);
+}
+
+int config_add_vals(ConfigTable *Conf, ConfigArgs *c) {
+ int rc, arg_type;
+
+ arg_type = Conf->arg_type;
+ if(arg_type == ARG_IGNORED) {
+ Debug(LDAP_DEBUG_CONFIG, "%s: keyword <%s> ignored\n",
+ c->log, Conf->name, 0);
+ return(0);
}
- return(arg_user);
+ rc = config_check_vals( Conf, c, 0 );
+ if ( rc ) return rc;
+ return config_set_vals( Conf, c );
+}
+
+int
+config_del_vals(ConfigTable *cf, ConfigArgs *c)
+{
+ int rc = 0;
+
+ /* If there is no handler, just ignore it */
+ if ( cf->arg_type & ARG_MAGIC ) {
+ c->op = LDAP_MOD_DELETE;
+ c->type = cf->arg_type & ARGS_USERLAND;
+ rc = (*((ConfigDriver*)cf->arg_item))(c);
+ }
+ return rc;
}
int
memset(&c->values, 0, sizeof(c->values));
c->rvalue_vals = NULL;
c->rvalue_nvals = NULL;
- c->emit = 1;
+ c->op = SLAP_CONFIG_EMIT;
c->type = cf->arg_type & ARGS_USERLAND;
if ( cf->arg_type & ARG_MAGIC ) {
ptr = c->bi->bi_private;
else
return 1;
- ptr = (void *)((char *)ptr + (int)cf->arg_item);
+ ptr = (void *)((char *)ptr + (long)cf->arg_item);
} else {
ptr = cf->arg_item;
}
if ( *(char **)ptr )
c->value_string = ch_strdup(*(char **)ptr);
break;
+ case ARG_BERVAL:
+ ber_dupbv( &c->value_bv, (struct berval *)ptr ); break;
}
}
if ( cf->arg_type & ARGS_POINTER) {
bv.bv_val = c->log;
switch(cf->arg_type & ARGS_POINTER) {
case ARG_INT: bv.bv_len = sprintf(bv.bv_val, "%d", c->value_int); break;
- case ARG_LONG: bv.bv_len = sprintf(bv.bv_val, "%l", c->value_long); break;
- case ARG_BER_LEN_T: bv.bv_len =sprintf(bv.bv_val, "%l",c->value_ber_t); break;
+ case ARG_LONG: bv.bv_len = sprintf(bv.bv_val, "%ld", c->value_long); break;
+ case ARG_BER_LEN_T: bv.bv_len = sprintf(bv.bv_val, "%ld", c->value_ber_t); break;
case ARG_ON_OFF: bv.bv_len = sprintf(bv.bv_val, "%s",
c->value_int ? "TRUE" : "FALSE"); break;
case ARG_STRING:
return 1;
}
break;
+ case ARG_BERVAL:
+ if ( !BER_BVISEMPTY( &c->value_bv )) {
+ bv = c->value_bv;
+ } else {
+ return 1;
+ }
+ break;
}
if (( cf->arg_type & ARGS_POINTER ) == ARG_STRING )
ber_bvarray_add(&c->rvalue_vals, &bv);
const char *err;
for (i=0; ct[i].name; i++ ) {
+ int freeit = 0;
+
if ( !ct[i].attribute ) continue;
at = ldap_str2attributetype( ct[i].attribute,
&code, &err, LDAP_SCHEMA_ALLOW_ALL );
ct[i].attribute, ldap_scherr2str(code), err );
return code;
}
- code = at_add( at, &err );
- if ( code && code != SLAP_SCHERR_ATTR_DUP ) {
- fprintf( stderr, "init_config_attrs: AttributeType \"%s\": %s, %s\n",
- ct[i].attribute, scherr2str(code), err );
- return code;
+
+ code = at_add( at, 0, NULL, &err );
+ if ( code ) {
+ if ( code == SLAP_SCHERR_ATTR_DUP ) {
+ freeit = 1;
+
+ } else {
+ fprintf( stderr, "init_config_attrs: AttributeType \"%s\": %s, %s\n",
+ ct[i].attribute, scherr2str(code), err );
+ return code;
+ }
}
code = slap_str2ad( at->at_names[0], &ct[i].ad, &err );
+ if ( freeit ) {
+ ldap_attributetype_free( at );
+ } else {
+ ldap_memfree( at );
+ }
if ( code ) {
fprintf( stderr, "init_config_attrs: AttributeType \"%s\": %s\n",
ct[i].attribute, err );
return code;
}
- ldap_memfree( at );
}
return 0;
init_config_ocs( ConfigOCs *ocs ) {
int i;
- for (i=0;ocs[i].def;i++) {
+ for (i=0;ocs[i].co_def;i++) {
LDAPObjectClass *oc;
int code;
const char *err;
- oc = ldap_str2objectclass( ocs[i].def, &code, &err,
+ oc = ldap_str2objectclass( ocs[i].co_def, &code, &err,
LDAP_SCHEMA_ALLOW_ALL );
if ( !oc ) {
fprintf( stderr, "init_config_ocs: objectclass \"%s\": %s, %s\n",
- ocs[i].def, ldap_scherr2str(code), err );
+ ocs[i].co_def, ldap_scherr2str(code), err );
return code;
}
- code = oc_add(oc,0,&err);
+ code = oc_add(oc,0,NULL,&err);
if ( code && code != SLAP_SCHERR_CLASS_DUP ) {
fprintf( stderr, "init_config_ocs: objectclass \"%s\": %s, %s\n",
- ocs[i].def, scherr2str(code), err );
+ ocs[i].co_def, scherr2str(code), err );
return code;
}
- if ( ocs[i].oc ) {
- *ocs[i].oc = oc_find(oc->oc_names[0]);
- }
+ ocs[i].co_oc = oc_find(oc->oc_names[0]);
ldap_memfree(oc);
}
return 0;
}
+/* Split an LDIF line into space-separated tokens. Words may be grouped
+ * by quotes. A quoted string may begin in the middle of a word, but must
+ * end at the end of the word (be followed by whitespace or EOS). Any other
+ * quotes are passed through unchanged. All other characters are passed
+ * through unchanged.
+ */
+static char *
+strtok_quote_ldif( char **line )
+{
+ char *beg, *ptr, *quote=NULL;
+ int inquote=0;
+
+ ptr = *line;
+
+ if ( !ptr || !*ptr )
+ return NULL;
+
+ while( isspace( *ptr )) ptr++;
+
+ if ( *ptr == '"' ) {
+ inquote = 1;
+ ptr++;
+ }
+
+ beg = ptr;
+
+ for (;*ptr;ptr++) {
+ if ( *ptr == '"' ) {
+ if ( inquote && ( !ptr[1] || isspace(ptr[1]))) {
+ *ptr++ = '\0';
+ break;
+ }
+ inquote = 1;
+ quote = ptr;
+ continue;
+ }
+ if ( inquote )
+ continue;
+ if ( isspace( *ptr )) {
+ *ptr++ = '\0';
+ break;
+ }
+ }
+ if ( quote ) {
+ while ( quote < ptr ) {
+ *quote = quote[1];
+ quote++;
+ }
+ }
+ if ( !*ptr ) {
+ *line = NULL;
+ } else {
+ while ( isspace( *ptr )) ptr++;
+ *line = ptr;
+ }
+ return beg;
+}
+
+static void
+config_parse_ldif( ConfigArgs *c )
+{
+ char *next;
+ c->tline = ch_strdup(c->line);
+ next = c->tline;
+
+ while ((c->argv[c->argc] = strtok_quote_ldif( &next )) != NULL) {
+ c->argc++;
+ if ( c->argc >= c->argv_size ) {
+ char **tmp = ch_realloc( c->argv, (c->argv_size + ARGS_STEP) *
+ sizeof( *c->argv ));
+ c->argv = tmp;
+ c->argv_size += ARGS_STEP;
+ }
+ }
+ c->argv[c->argc] = NULL;
+}
+
+int
+config_parse_vals(ConfigTable *ct, ConfigArgs *c, int valx)
+{
+ int rc = 0;
+
+ snprintf( c->log, sizeof( c->log ), "%s: value #%d",
+ ct->ad->ad_cname.bv_val, valx );
+ c->argc = 1;
+ c->argv[0] = ct->ad->ad_cname.bv_val;
+
+ if ( ( ct->arg_type & ARG_QUOTE ) && c->line[ 0 ] != '"' ) {
+ c->argv[c->argc] = c->line;
+ c->argc++;
+ c->argv[c->argc] = NULL;
+ c->tline = NULL;
+ } else {
+ config_parse_ldif( c );
+ }
+ rc = config_check_vals( ct, c, 1 );
+ ch_free( c->tline );
+
+ if ( rc )
+ rc = LDAP_CONSTRAINT_VIOLATION;
+
+ return rc;
+}
+
+int
+config_parse_add(ConfigTable *ct, ConfigArgs *c)
+{
+ int rc = 0;
+
+ snprintf( c->log, sizeof( c->log ), "%s: value #%d",
+ ct->ad->ad_cname.bv_val, c->valx );
+ c->argc = 1;
+ c->argv[0] = ct->ad->ad_cname.bv_val;
+
+ if ( ( ct->arg_type & ARG_QUOTE ) && c->line[ 0 ] != '"' ) {
+ c->argv[c->argc] = c->line;
+ c->argc++;
+ c->argv[c->argc] = NULL;
+ c->tline = NULL;
+ } else {
+ config_parse_ldif( c );
+ }
+ c->op = LDAP_MOD_ADD;
+ rc = config_add_vals( ct, c );
+ ch_free( c->tline );
+
+ return rc;
+}
+
int
-read_config_file(const char *fname, int depth, ConfigArgs *cf)
+read_config_file(const char *fname, int depth, ConfigArgs *cf, ConfigTable *cft)
{
FILE *fp;
+ ConfigTable *ct;
ConfigArgs *c;
int rc;
+ struct stat s;
c = ch_calloc( 1, sizeof( ConfigArgs ) );
if ( c == NULL ) {
c->be = NULL;
}
+ c->valx = -1;
c->fname = fname;
- c->argv = ch_calloc( ARGS_STEP + 1, sizeof( *c->argv ) );
- c->argv_size = ARGS_STEP + 1;
+ init_config_argv( c );
+
+ if ( stat( fname, &s ) != 0 ) {
+ ldap_syslog = 1;
+ Debug(LDAP_DEBUG_ANY,
+ "could not stat config file \"%s\": %s (%d)\n",
+ fname, strerror(errno), errno);
+ return(1);
+ }
+
+ if ( !S_ISREG( s.st_mode ) ) {
+ ldap_syslog = 1;
+ Debug(LDAP_DEBUG_ANY,
+ "regular file expected, got \"%s\"\n",
+ fname, 0, 0 );
+ return(1);
+ }
fp = fopen( fname, "r" );
if ( fp == NULL ) {
fp_getline_init(c);
+ c->tline = NULL;
+
while ( fp_getline( fp, c ) ) {
/* skip comments and blank lines */
if ( c->line[0] == '#' || c->line[0] == '\0' ) {
continue;
}
- snprintf( c->log, sizeof( c->log ), "%s: line %lu",
+ snprintf( c->log, sizeof( c->log ), "%s: line %d",
c->fname, c->lineno );
+ c->argc = 0;
+ ch_free( c->tline );
if ( fp_parse_line( c ) ) {
- goto badline;
+ rc = 1;
+ goto done;
}
if ( c->argc < 1 ) {
- Debug(LDAP_DEBUG_CONFIG, "%s: bad config line (ignored)\n", c->log, 0, 0);
+ Debug( SLAPD_DEBUG_CONFIG_ERROR, "%s: bad config line"
+ SLAPD_CONF_UNKNOWN_IGNORED ".\n",
+ c->log, 0, 0);
+#ifdef SLAPD_CONF_UNKNOWN_BAILOUT
+ rc = 1;
+ goto done;
+#else /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
continue;
+#endif /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
}
- rc = parse_config_table( config_back_cf_table, c );
- if ( !rc ) {
- continue;
- }
- if ( rc & ARGS_USERLAND ) {
- switch(rc) { /* XXX a usertype would be opaque here */
- default:
- Debug(LDAP_DEBUG_CONFIG, "%s: unknown user type <%d>\n",
- c->log, *c->argv, 0);
- goto badline;
- }
+ c->op = SLAP_CONFIG_ADD;
+
+ ct = config_find_keyword( cft, c );
+ if ( ct ) {
+ rc = config_add_vals( ct, c );
+ if ( !rc ) continue;
+
+ if ( rc & ARGS_USERLAND ) {
+ /* XXX a usertype would be opaque here */
+ Debug(LDAP_DEBUG_CONFIG, "%s: unknown user type <%s>\n",
+ c->log, c->argv[0], 0);
+ rc = 1;
+ goto done;
- } else if ( rc == ARG_BAD_CONF || rc != ARG_UNKNOWN ) {
- goto badline;
+ } else if ( rc == ARG_BAD_CONF ) {
+ rc = 1;
+ goto done;
+ }
- } else if ( c->bi && c->bi->bi_config ) { /* XXX to check: could both be/bi_config? oops */
- rc = (*c->bi->bi_config)(c->bi, c->fname, c->lineno, c->argc, c->argv);
+ } else if ( c->bi && !c->be ) {
+ rc = SLAP_CONF_UNKNOWN;
+ if ( c->bi->bi_cf_ocs ) {
+ ct = config_find_keyword( c->bi->bi_cf_ocs->co_table, c );
+ if ( ct ) {
+ rc = config_add_vals( ct, c );
+ }
+ }
+ if ( c->bi->bi_config && rc == SLAP_CONF_UNKNOWN ) {
+ rc = (*c->bi->bi_config)(c->bi, c->fname, c->lineno,
+ c->argc, c->argv);
+ }
if ( rc ) {
switch(rc) {
case SLAP_CONF_UNKNOWN:
- Debug(LDAP_DEBUG_CONFIG, "%s: "
- "unknown directive <%s> inside backend info definition (ignored)\n",
- c->log, *c->argv, 0);
+ Debug( SLAPD_DEBUG_CONFIG_ERROR, "%s: "
+ "unknown directive <%s> inside backend info definition"
+ SLAPD_CONF_UNKNOWN_IGNORED ".\n",
+ c->log, *c->argv, 0);
+#ifndef SLAPD_CONF_UNKNOWN_BAILOUT
continue;
+#endif /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
default:
- goto badline;
+ rc = 1;
+ goto done;
}
}
-
- } else if ( c->be ) {
- if ( c->be->be_cf_table ) {
- rc = parse_config_table( c->be->be_cf_table, c );
-
- if ( !rc ) continue;
- if ( rc != ARG_UNKNOWN ) goto badline;
+ } else if ( c->be ) {
+ rc = SLAP_CONF_UNKNOWN;
+ if ( c->be->be_cf_ocs ) {
+ ct = config_find_keyword( c->be->be_cf_ocs->co_table, c );
+ if ( ct ) {
+ rc = config_add_vals( ct, c );
+ }
}
-
- if ( c->be->be_config ) {
+ if ( c->be->be_config && rc == SLAP_CONF_UNKNOWN ) {
rc = (*c->be->be_config)(c->be, c->fname, c->lineno,
c->argc, c->argv);
- if ( rc ) {
- switch(rc) {
- case SLAP_CONF_UNKNOWN:
- Debug( LDAP_DEBUG_CONFIG, "%s: "
- "unknown directive <%s> inside backend database "
- "definition (ignored)\n",
- c->log, *c->argv, 0);
- continue;
- default:
- goto badline;
- }
+ }
+ if ( rc ) {
+ switch(rc) {
+ case SLAP_CONF_UNKNOWN:
+ Debug( SLAPD_DEBUG_CONFIG_ERROR, "%s: "
+ "unknown directive <%s> inside backend database "
+ "definition" SLAPD_CONF_UNKNOWN_IGNORED ".\n",
+ c->log, *c->argv, 0);
+#ifndef SLAPD_CONF_UNKNOWN_BAILOUT
+ continue;
+#endif /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
+ default:
+ rc = 1;
+ goto done;
}
}
if ( rc ) {
switch(rc) {
case SLAP_CONF_UNKNOWN:
- Debug( LDAP_DEBUG_CONFIG, "%s: "
- "unknown directive <%s> inside global database definition (ignored)\n",
+ Debug( SLAPD_DEBUG_CONFIG_ERROR, "%s: "
+ "unknown directive <%s> inside global database definition"
+ SLAPD_CONF_UNKNOWN_IGNORED ".\n",
c->log, *c->argv, 0);
+#ifndef SLAPD_CONF_UNKNOWN_BAILOUT
continue;
+#endif /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
default:
- goto badline;
+ rc = 1;
+ goto done;
}
}
} else {
- Debug(LDAP_DEBUG_CONFIG, "%s: "
- "unknown directive <%s> outside backend info and database definitions (ignored)\n",
+ Debug( SLAPD_DEBUG_CONFIG_ERROR, "%s: "
+ "unknown directive <%s> outside backend info and database definitions"
+ SLAPD_CONF_UNKNOWN_IGNORED ".\n",
c->log, *c->argv, 0);
+#ifdef SLAPD_CONF_UNKNOWN_BAILOUT
+ rc = 1;
+ goto done;
+#else /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
continue;
-
+#endif /* ! SLAPD_CONF_UNKNOWN_BAILOUT */
}
}
- fclose(fp);
+ rc = 0;
- if ( BER_BVISNULL( &frontendDB->be_schemadn ) ) {
- ber_str2bv( SLAPD_SCHEMA_DN, STRLENOF( SLAPD_SCHEMA_DN ), 1,
- &frontendDB->be_schemadn );
- rc = dnNormalize( 0, NULL, NULL, &frontendDB->be_schemadn, &frontendDB->be_schemandn, NULL );
- if ( rc != LDAP_SUCCESS ) {
- Debug(LDAP_DEBUG_ANY, "%s: "
- "unable to normalize default schema DN \"%s\"\n",
- c->log, frontendDB->be_schemadn.bv_val, 0 );
- /* must not happen */
- assert( 0 );
- }
- }
-
- ch_free(c->argv);
- ch_free(c);
- return(0);
-
-badline:
+done:
+ ch_free(c->tline);
fclose(fp);
ch_free(c->argv);
ch_free(c);
- return(1);
+ return(rc);
}
/* restrictops, allows, disallows, requires, loglevel */
return(0);
}
+/* Mask keywords that represent multiple bits should occur before single
+ * bit keywords in the verbmasks array.
+ */
int
mask_to_verbs(slap_verbmasks *v, slap_mask_t m, BerVarray *bva) {
- int i, j;
- struct berval bv;
+ int i;
if (!m) return 1;
for (i=0; !BER_BVISNULL(&v[i].word); i++) {
if (!v[i].mask) continue;
if (( m & v[i].mask ) == v[i].mask ) {
value_add_one( bva, &v[i].word );
+ m ^= v[i].mask;
+ if ( !m ) break;
}
}
return 0;
}
+int
+slap_verbmasks_init( slap_verbmasks **vp, slap_verbmasks *v )
+{
+ int i;
+
+ assert( *vp == NULL );
+
+ for ( i = 0; !BER_BVISNULL( &v[ i ].word ); i++ )
+ ;
+
+ *vp = ch_calloc( i + 1, sizeof( slap_verbmasks ) );
+
+ for ( i = 0; !BER_BVISNULL( &v[ i ].word ); i++ ) {
+ ber_dupbv( &(*vp)[ i ].word, &v[ i ].word );
+ *((slap_mask_t *)&(*vp)[ i ].mask) = v[ i ].mask;
+ }
+
+ BER_BVZERO( &(*vp)[ i ].word );
+
+ return 0;
+}
+
+int
+slap_verbmasks_destroy( slap_verbmasks *v )
+{
+ int i;
+
+ assert( v != NULL );
+
+ for ( i = 0; !BER_BVISNULL( &v[ i ].word ); i++ ) {
+ ch_free( v[ i ].word.bv_val );
+ }
+
+ ch_free( v );
+
+ return 0;
+}
+
+int
+slap_verbmasks_append(
+ slap_verbmasks **vp,
+ slap_mask_t m,
+ struct berval *v,
+ slap_mask_t *ignore )
+{
+ int i;
+
+ if ( !m ) {
+ return LDAP_OPERATIONS_ERROR;
+ }
+
+ for ( i = 0; !BER_BVISNULL( &(*vp)[ i ].word ); i++ ) {
+ if ( !(*vp)[ i ].mask ) continue;
+
+ if ( ignore != NULL ) {
+ int j;
+
+ for ( j = 0; ignore[ j ] != 0; j++ ) {
+ if ( (*vp)[ i ].mask == ignore[ j ] ) {
+ goto check_next;
+ }
+ }
+ }
+
+ if ( ( m & (*vp)[ i ].mask ) == (*vp)[ i ].mask ) {
+ if ( ber_bvstrcasecmp( v, &(*vp)[ i ].word ) == 0 ) {
+ /* already set; ignore */
+ return LDAP_SUCCESS;
+ }
+ /* conflicts */
+ return LDAP_TYPE_OR_VALUE_EXISTS;
+ }
+
+ if ( m & (*vp)[ i ].mask ) {
+ /* conflicts */
+ return LDAP_CONSTRAINT_VIOLATION;
+ }
+check_next:;
+ }
+
+ *vp = ch_realloc( *vp, sizeof( slap_verbmasks ) * ( i + 2 ) );
+ ber_dupbv( &(*vp)[ i ].word, v );
+ *((slap_mask_t *)&(*vp)[ i ].mask) = m;
+ BER_BVZERO( &(*vp)[ i + 1 ].word );
+
+ return LDAP_SUCCESS;
+}
+
+int
+enum_to_verb(slap_verbmasks *v, slap_mask_t m, struct berval *bv) {
+ int i;
+
+ for (i=0; !BER_BVISNULL(&v[i].word); i++) {
+ if ( m == v[i].mask ) {
+ if ( bv != NULL ) {
+ *bv = v[i].word;
+ }
+ return i;
+ }
+ }
+ return -1;
+}
+
static slap_verbmasks tlskey[] = {
- { BER_BVC("no"), SB_TLS_OFF },
- { BER_BVC("yes"), SB_TLS_ON },
+ { BER_BVC("no"), SB_TLS_OFF },
+ { BER_BVC("yes"), SB_TLS_ON },
{ BER_BVC("critical"), SB_TLS_CRITICAL },
{ BER_BVNULL, 0 }
};
static slap_verbmasks methkey[] = {
+ { BER_BVC("none"), LDAP_AUTH_NONE },
{ BER_BVC("simple"), LDAP_AUTH_SIMPLE },
#ifdef HAVE_CYRUS_SASL
{ BER_BVC("sasl"), LDAP_AUTH_SASL },
typedef struct cf_aux_table {
struct berval key;
int off;
- int quote;
+ char type;
+ char quote;
slap_verbmasks *aux;
} cf_aux_table;
static cf_aux_table bindkey[] = {
- { BER_BVC("starttls="), offsetof(slap_bindconf, sb_tls), 0, tlskey },
- { BER_BVC("bindmethod="), offsetof(slap_bindconf, sb_method), 0, methkey },
- { BER_BVC("binddn="), offsetof(slap_bindconf, sb_binddn), 1, NULL },
- { BER_BVC("credentials="), offsetof(slap_bindconf, sb_cred), 1, NULL },
- { BER_BVC("saslmech="), offsetof(slap_bindconf, sb_saslmech), 0, NULL },
- { BER_BVC("secprops="), offsetof(slap_bindconf, sb_secprops), 0, NULL },
- { BER_BVC("realm="), offsetof(slap_bindconf, sb_realm), 0, NULL },
- { BER_BVC("authcID="), offsetof(slap_bindconf, sb_authcId), 0, NULL },
- { BER_BVC("authzID="), offsetof(slap_bindconf, sb_authzId), 1, NULL },
- { BER_BVNULL, 0, 0, NULL }
+ { BER_BVC("starttls="), offsetof(slap_bindconf, sb_tls), 'd', 0, tlskey },
+ { BER_BVC("bindmethod="), offsetof(slap_bindconf, sb_method), 'd', 0, methkey },
+ { BER_BVC("binddn="), offsetof(slap_bindconf, sb_binddn), 'b', 1, NULL },
+ { BER_BVC("credentials="), offsetof(slap_bindconf, sb_cred), 'b', 1, NULL },
+ { BER_BVC("saslmech="), offsetof(slap_bindconf, sb_saslmech), 'b', 0, NULL },
+ { BER_BVC("secprops="), offsetof(slap_bindconf, sb_secprops), 's', 0, NULL },
+ { BER_BVC("realm="), offsetof(slap_bindconf, sb_realm), 'b', 0, NULL },
+ { BER_BVC("authcID="), offsetof(slap_bindconf, sb_authcId), 'b', 0, NULL },
+ { BER_BVC("authzID="), offsetof(slap_bindconf, sb_authzId), 'b', 1, NULL },
+ { BER_BVNULL, 0, 0, 0, NULL }
};
int bindconf_parse( const char *word, slap_bindconf *bc ) {
- int i, rc = 0;
- char **cptr;
+ int rc = 0;
cf_aux_table *tab;
for (tab = bindkey; !BER_BVISNULL(&tab->key); tab++) {
if ( !strncasecmp( word, tab->key.bv_val, tab->key.bv_len )) {
- cptr = (char **)((char *)bc + tab->off);
- if ( tab->aux ) {
- int j;
+ char **cptr;
+ int *iptr, j;
+ struct berval *bptr;
+ const char *val = word + tab->key.bv_len;
+
+ switch ( tab->type ) {
+ case 's':
+ cptr = (char **)((char *)bc + tab->off);
+ *cptr = ch_strdup( val );
+ break;
+
+ case 'b':
+ bptr = (struct berval *)((char *)bc + tab->off);
+ ber_str2bv( val, 0, 1, bptr );
+ break;
+
+ case 'd':
+ assert( tab->aux != NULL );
+ iptr = (int *)((char *)bc + tab->off);
+
rc = 1;
- for (j=0; !BER_BVISNULL(&tab->aux[j].word); j++) {
- if (!strcasecmp(word+tab->key.bv_len, tab->aux[j].word.bv_val)) {
- int *ptr = (int *)cptr;
- *ptr = tab->aux[j].mask;
+ for ( j = 0; !BER_BVISNULL( &tab->aux[j].word ); j++ ) {
+ if ( !strcasecmp( val, tab->aux[j].word.bv_val ) ) {
+ *iptr = tab->aux[j].mask;
rc = 0;
}
}
- if (rc ) {
- Debug(LDAP_DEBUG_ANY, "invalid bind config value %s\n",
- word, 0, 0 );
- }
- return rc;
+ break;
+ }
+
+ if ( rc ) {
+ Debug( LDAP_DEBUG_ANY, "invalid bind config value %s\n",
+ word, 0, 0 );
}
- *cptr = ch_strdup(word+tab->key.bv_len);
- return 0;
+
+ return rc;
}
}
+
return rc;
}
int bindconf_unparse( slap_bindconf *bc, struct berval *bv ) {
char buf[BUFSIZ], *ptr;
cf_aux_table *tab;
- char **cptr;
struct berval tmp;
ptr = buf;
for (tab = bindkey; !BER_BVISNULL(&tab->key); tab++) {
+ char **cptr;
+ int *iptr, i;
+ struct berval *bptr;
+
cptr = (char **)((char *)bc + tab->off);
- if ( tab->aux ) {
- int *ip = (int *)cptr, i;
- for ( i=0; !BER_BVISNULL(&tab->aux[i].word); i++ ) {
- if ( *ip == tab->aux[i].mask ) {
+
+ switch ( tab->type ) {
+ case 'b':
+ bptr = (struct berval *)((char *)bc + tab->off);
+ cptr = &bptr->bv_val;
+ case 's':
+ if ( *cptr ) {
+ *ptr++ = ' ';
+ ptr = lutil_strcopy( ptr, tab->key.bv_val );
+ if ( tab->quote ) *ptr++ = '"';
+ ptr = lutil_strcopy( ptr, *cptr );
+ if ( tab->quote ) *ptr++ = '"';
+ }
+ break;
+
+ case 'd':
+ assert( tab->aux != NULL );
+ iptr = (int *)((char *)bc + tab->off);
+
+ for ( i = 0; !BER_BVISNULL( &tab->aux[i].word ); i++ ) {
+ if ( *iptr == tab->aux[i].mask ) {
*ptr++ = ' ';
ptr = lutil_strcopy( ptr, tab->key.bv_val );
ptr = lutil_strcopy( ptr, tab->aux[i].word.bv_val );
break;
}
}
- } else if ( *cptr ) {
- *ptr++ = ' ';
- ptr = lutil_strcopy( ptr, tab->key.bv_val );
- if ( tab->quote ) *ptr++ = '"';
- ptr = lutil_strcopy( ptr, *cptr );
- if ( tab->quote ) *ptr++ = '"';
+ break;
}
}
tmp.bv_val = buf;
}
void bindconf_free( slap_bindconf *bc ) {
- if ( bc->sb_binddn ) {
- ch_free( bc->sb_binddn );
+ if ( !BER_BVISNULL( &bc->sb_binddn ) ) {
+ ch_free( bc->sb_binddn.bv_val );
+ BER_BVZERO( &bc->sb_binddn );
}
- if ( bc->sb_cred ) {
- ch_free( bc->sb_cred );
+ if ( !BER_BVISNULL( &bc->sb_cred ) ) {
+ ch_free( bc->sb_cred.bv_val );
+ BER_BVZERO( &bc->sb_cred );
}
- if ( bc->sb_saslmech ) {
- ch_free( bc->sb_saslmech );
+ if ( !BER_BVISNULL( &bc->sb_saslmech ) ) {
+ ch_free( bc->sb_saslmech.bv_val );
+ BER_BVZERO( &bc->sb_saslmech );
}
if ( bc->sb_secprops ) {
ch_free( bc->sb_secprops );
+ bc->sb_secprops = NULL;
}
- if ( bc->sb_realm ) {
- ch_free( bc->sb_realm );
+ if ( !BER_BVISNULL( &bc->sb_realm ) ) {
+ ch_free( bc->sb_realm.bv_val );
+ BER_BVZERO( &bc->sb_realm );
}
- if ( bc->sb_authcId ) {
- ch_free( bc->sb_authcId );
+ if ( !BER_BVISNULL( &bc->sb_authcId ) ) {
+ ch_free( bc->sb_authcId.bv_val );
+ BER_BVZERO( &bc->sb_authcId );
}
- if ( bc->sb_authzId ) {
- ch_free( bc->sb_authzId );
+ if ( !BER_BVISNULL( &bc->sb_authzId ) ) {
+ ch_free( bc->sb_authzId.bv_val );
+ BER_BVZERO( &bc->sb_authzId );
}
}
static char *
-strtok_quote( char *line, char *sep )
+strtok_quote( char *line, char *sep, char **quote_ptr )
{
int inquote;
char *tmp;
static char *next;
- strtok_quote_ptr = NULL;
+ *quote_ptr = NULL;
if ( line != NULL ) {
next = line;
}
default:
if ( ! inquote ) {
if ( strchr( sep, *next ) != NULL ) {
- strtok_quote_ptr = next;
+ *quote_ptr = next;
*next++ = '\0';
return( tmp );
}
fp_parse_line(ConfigArgs *c)
{
char *token;
- char *tline = ch_strdup(c->line);
- char *hide[] = { "rootpw", "replica", "bindpw", "pseudorootpw", "dbpasswd", '\0' };
- int i;
-
- c->argc = 0;
- token = strtok_quote(tline, " \t");
+ static char *const hide[] = {
+ "rootpw", "replica", "syncrepl", /* in slapd */
+ "acl-bind", "acl-method", "idassert-bind", /* in back-ldap */
+ "acl-passwd", "bindpw", /* in back-<ldap/meta> */
+ "pseudorootpw", /* in back-meta */
+ "dbpasswd", /* in back-sql */
+ NULL
+ };
+ char *quote_ptr;
+ int i = (int)(sizeof(hide)/sizeof(hide[0])) - 1;
+
+ c->tline = ch_strdup(c->line);
+ token = strtok_quote(c->tline, " \t", "e_ptr);
if(token) for(i = 0; hide[i]; i++) if(!strcasecmp(token, hide[i])) break;
- if(strtok_quote_ptr) *strtok_quote_ptr = ' ';
- Debug(LDAP_DEBUG_CONFIG, "line %lu (%s%s)\n", c->lineno, hide[i] ? hide[i] : c->line, hide[i] ? " ***" : "");
- if(strtok_quote_ptr) *strtok_quote_ptr = '\0';
+ if(quote_ptr) *quote_ptr = ' ';
+ Debug(LDAP_DEBUG_CONFIG, "line %d (%s%s)\n", c->lineno,
+ hide[i] ? hide[i] : c->line, hide[i] ? " ***" : "");
+ if(quote_ptr) *quote_ptr = '\0';
- for(; token; token = strtok_quote(NULL, " \t")) {
- if(c->argc == c->argv_size - 1) {
+ for(;; token = strtok_quote(NULL, " \t", "e_ptr)) {
+ if(c->argc >= c->argv_size) {
char **tmp;
tmp = ch_realloc(c->argv, (c->argv_size + ARGS_STEP) * sizeof(*c->argv));
if(!tmp) {
- Debug(LDAP_DEBUG_ANY, "line %lu: out of memory\n", c->lineno, 0, 0);
+ Debug(LDAP_DEBUG_ANY, "line %d: out of memory\n", c->lineno, 0, 0);
return -1;
}
c->argv = tmp;
c->argv_size += ARGS_STEP;
}
+ if(token == NULL)
+ break;
c->argv[c->argc++] = token;
}
c->argv[c->argc] = NULL;
free( str );
return( *out );
}
+
+int config_generic_wrapper( Backend *be, const char *fname, int lineno,
+ int argc, char **argv )
+{
+ ConfigArgs c = { 0 };
+ ConfigTable *ct;
+ int rc;
+
+ c.be = be;
+ c.fname = fname;
+ c.lineno = lineno;
+ c.argc = argc;
+ c.argv = argv;
+ c.valx = -1;
+ sprintf( c.log, "%s: line %d", fname, lineno );
+
+ rc = SLAP_CONF_UNKNOWN;
+ ct = config_find_keyword( be->be_cf_ocs->co_table, &c );
+ if ( ct )
+ rc = config_add_vals( ct, &c );
+ return rc;
+}