sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-27 14:04:05 +03:00
Code

r9447: Add a new tool to convert openLdap schema files into an ldif

Browse Source 
My first test with nis.schema seem to confirm it works properly

Use a command line like:
oLschema2ldif -I tests/schema/nis.schema -O nis_schema.ldif -b "dc=sambadom,dc=samba,dc=org"
to see how it works.

SSS
(This used to be commit fc373fd4631420c9d8d4087a2c698b08e18372d7)
This commit is contained in:
Simo Sorce 2005-08-21 14:26:03 +00:00 committed by Gerald (Jerry) Carter
parent f975eb06f0
commit 5c16371daa
4 changed files with 604 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
source4/lib/ldb/Makefile.in
View File

@ -61,7 +61,7 @@ OBJS = $(MODULES_OBJ) $(COMMON_OBJ) $(LDB_TDB_OBJ) $(TDB_OBJ) $(TALLOC_OBJ) $(L
LDB_LIB = lib/libldb.a
BINS = bin/ldbadd bin/ldbsearch bin/ldbdel bin/ldbmodify bin/ldbedit bin/ldbrename bin/ldbtest
BINS = bin/ldbadd bin/ldbsearch bin/ldbdel bin/ldbmodify bin/ldbedit bin/ldbrename bin/ldbtest bin/oLschema2ldif
LIBS = $(LDB_LIB)($(OBJS))
@ -102,6 +102,9 @@ bin/ldbrename: tools/ldbrename.o tools/cmdline.o $(LIBS)
bin/ldbtest: tools/ldbtest.o tools/cmdline.o $(LIBS)
$(CC) -o bin/ldbtest tools/ldbtest.o tools/cmdline.o $(LIB_FLAGS)
bin/oLschema2ldif: tools/oLschema2ldif.o tools/cmdline.o $(LIBS)
$(CC) -o bin/oLschema2ldif tools/oLschema2ldif.o tools/cmdline.o $(LIB_FLAGS)
.SUFFIXES: .1 .2 .3 .yo
%.3: %.3.xml

11
source4/lib/ldb/config.mk
View File

@ -202,3 +202,14 @@ REQUIRED_SUBSYSTEMS = \
LIBLDB_CMDLINE
# End BINARY ldbtest
################################################
################################################
# Start BINARY oLschema2ldif
[BINARY::oLschema2ldif]
INSTALLDIR = BINDIR
OBJ_FILES= \
lib/ldb/tools/oLschema2ldif.o
REQUIRED_SUBSYSTEMS = \
LIBLDB_CMDLINE
# End BINARY oLschema2ldif
################################################

12
source4/lib/ldb/tools/cmdline.c
View File

@ -151,13 +151,13 @@ struct ldb_cmdline *ldb_cmdline_process(struct ldb_context *ldb, int argc, const
*ret = options;
/* all utils need some option */
if (ldb) {
if (ret->url == NULL) {
fprintf(stderr, "You must supply a url with -H or with $LDB_URL\n");
if (usage) usage();
goto failed;
}
if (ret->url == NULL) {
fprintf(stderr, "You must supply a url with -H or with $LDB_URL\n");
if (usage) usage();
goto failed;
}
if (strcmp(ret->url, "NONE") != 0) {
if (ldb_connect(ldb, ret->url, 0, ret->options) != 0) {
fprintf(stderr, "Failed to connect to %s - %s\n",
ret->url, ldb_errstring(ldb));

583
source4/lib/ldb/tools/oLschema2ldif.c Normal file
View File

@ -0,0 +1,583 @@
/*
ldb database library
Copyright (C) Simo Sorce 2005
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
** under the LGPL
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Name: ldb
*
* Component: ldbdel
*
* Description: utility to delete records - modelled on ldapdelete
*
* Author: Andrew Tridgell
*/
#include "includes.h"
#include "ldb/include/ldb.h"
#include "ldb/include/ldb_private.h"
#include "ldb/tools/cmdline.h"
#include <stdio.h>
#ifdef _SAMBA_BUILD_
#include "system/filesys.h"
#endif
#define SCHEMA_UNKNOWN 0
#define SCHEMA_NAME 1
#define SCHEMA_SUP 2
#define SCHEMA_STRUCTURAL 3
#define SCHEMA_ABSTRACT 4
#define SCHEMA_AUXILIARY 5
#define SCHEMA_MUST 6
#define SCHEMA_MAY 7
#define SCHEMA_SINGLE_VALUE 8
#define SCHEMA_EQUALITY 9
#define SCHEMA_SUBSTR 10
#define SCHEMA_SYNTAX 11
#define SCHEMA_DESC 12
struct schema_conv {
int count;
int failures;
};
struct token {
int type;
char *value;
};
struct ldb_context *ldb_ctx;
struct ldb_dn *basedn;
static int check_braces(const char *string)
{
int b;
char *c;
b = 0;
if ((c = strchr(string, '(')) == NULL) {
return -1;
}
b++;
c++;
while (b) {
c = strpbrk(c, "()");
if (c == NULL) return 1;
if (*c == '(') b++;
if (*c == ')') b--;
c++;
}
return 0;
}
static char *skip_spaces(char *string) {
return (string + strspn(string, " \t\n"));
}
static int add_multi_string(struct ldb_context *ldb, struct ldb_message *msg, const char *attr, char *values)
{
char *c;
char *s;
int n;
c = skip_spaces(values);
while (*c) {
n = strcspn(c, " \t$");
s = talloc_strndup(msg, c, n);
if (ldb_msg_add_string(ldb, msg, attr, s) != 0) {
return -1;
}
c += n;
c += strspn(c, " \t$");
}
return 0;
}
#define MSG_ADD_STRING(a, v) do { if (ldb_msg_add_string(ldb_ctx, msg, a, v) != 0) goto failed; } while(0)
#define MSG_ADD_M_STRING(a, v) do { if (add_multi_string(ldb_ctx, msg, a, v) != 0) goto failed; } while(0)
static char *get_def_value(TALLOC_CTX *ctx, char **string)
{
char *c = *string;
char *value;
int n;
if (*c == '\'') {
c++;
n = strcspn(c, "\'");
value = talloc_strndup(ctx, c, n);
c += n;
c++; /* skip closing \' */
} else {
n = strcspn(c, " \t\n");
value = talloc_strndup(ctx, c, n);
c += n;
}
*string = c;
return value;
}
static struct token *get_next_schema_token(TALLOC_CTX *ctx, char **string)
{
char *c = skip_spaces(*string);
char *type;
struct token *token;
int n;
token = talloc(ctx, struct token);
n = strcspn(c, " \t\n");
type = talloc_strndup(token, c, n);
c += n;
c = skip_spaces(c);
if (strcasecmp("NAME", type) == 0) {
talloc_free(type);
token->type = SCHEMA_NAME;
/* we do not support aliases so we get only the first name given and skip others */
if (*c == '(') {
char *s = strchr(c, ')');
if (s == NULL) return NULL;
s = skip_spaces(s);
*string = s;
c++;
c = skip_spaces(c);
}
token->value = get_def_value(ctx, &c);
if (*string < c) { /* single name */
c = skip_spaces(c);
*string = c;
}
return token;
}
if (strcasecmp("SUP", type) == 0) {
talloc_free(type);
token->type = SCHEMA_SUP;
token->value = get_def_value(ctx, &c);
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("STRUCTURAL", type) == 0) {
talloc_free(type);
token->type = SCHEMA_STRUCTURAL;
*string = c;
return token;
}
if (strcasecmp("ABSTRACT", type) == 0) {
talloc_free(type);
token->type = SCHEMA_ABSTRACT;
*string = c;
return token;
}
if (strcasecmp("AUXILIARY", type) == 0) {
talloc_free(type);
token->type = SCHEMA_AUXILIARY;
*string = c;
return token;
}
if (strcasecmp("MUST", type) == 0) {
talloc_free(type);
token->type = SCHEMA_MUST;
if (*c == '(') {
c++;
n = strcspn(c, ")");
token->value = talloc_strndup(ctx, c, n);
c += n;
c++;
} else {
token->value = get_def_value(ctx, &c);
}
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("MAY", type) == 0) {
talloc_free(type);
token->type = SCHEMA_MAY;
if (*c == '(') {
c++;
n = strcspn(c, ")");
token->value = talloc_strndup(ctx, c, n);
c += n;
c++;
} else {
token->value = get_def_value(ctx, &c);
}
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("SINGLE-VALUE", type) == 0) {
talloc_free(type);
token->type = SCHEMA_SINGLE_VALUE;
*string = c;
return token;
}
if (strcasecmp("EQUALITY", type) == 0) {
talloc_free(type);
token->type = SCHEMA_EQUALITY;
token->value = get_def_value(ctx, &c);
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("SUBSTR", type) == 0) {
talloc_free(type);
token->type = SCHEMA_SUBSTR;
token->value = get_def_value(ctx, &c);
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("SYNTAX", type) == 0) {
talloc_free(type);
token->type = SCHEMA_SYNTAX;
token->value = get_def_value(ctx, &c);
c = skip_spaces(c);
*string = c;
return token;
}
if (strcasecmp("DESC", type) == 0) {
talloc_free(type);
token->type = SCHEMA_DESC;
token->value = get_def_value(ctx, &c);
c = skip_spaces(c);
*string = c;
return token;
}
token->type = SCHEMA_UNKNOWN;
token->value = type;
if (*c == ')') {
*string = c;
return token;
}
if (*c == '\'') {
c = strchr(++c, '\'');
c++;
} else {
c += strcspn(c, " \t\n");
}
c = skip_spaces(c);
*string = c;
return token;
}
static struct ldb_message *process_entry(TALLOC_CTX *mem_ctx, const char *entry)
{
TALLOC_CTX *ctx;
struct ldb_message *msg;
struct token *token;
char *c, *s;
int n;
ctx = talloc_new(mem_ctx);
msg = ldb_msg_new(ctx);
ldb_msg_add_string(ldb_ctx, msg, "objectClass", "top");
c = talloc_strdup(ctx, entry);
if (!c) return NULL;
c = skip_spaces(c);
switch (*c) {
case 'a':
if (strncmp(c, "attributetype", 13) == 0) {
c += 13;
MSG_ADD_STRING("objectClass", "attributeSchema");
break;
}
goto failed;
case 'o':
if (strncmp(c, "objectclass", 11) == 0) {
c += 11;
MSG_ADD_STRING("objectClass", "classSchema");
break;
}
goto failed;
default:
goto failed;
}
c = strchr(c, '(');
if (c == NULL) goto failed;
c++;
c = skip_spaces(c);
/* get attributeID */
n = strcspn(c, " \t");
s = talloc_strndup(msg, c, n);
MSG_ADD_STRING("attributeID", s);
c += n;
c = skip_spaces(c);
while (*c != ')') {
token = get_next_schema_token(msg, &c);
if (!token) goto failed;
switch (token->type) {
case SCHEMA_NAME:
MSG_ADD_STRING("cn", token->value);
MSG_ADD_STRING("name", token->value);
MSG_ADD_STRING("lDAPDisplayName", token->value);
msg->dn = ldb_dn_string_compose(msg, basedn,
"CN=%s,CN=Schema,CN=Configuration",
token->value);
break;
case SCHEMA_SUP:
MSG_ADD_STRING("subClassOf", token->value);
break;
case SCHEMA_STRUCTURAL:
MSG_ADD_STRING("objectClassCategory", "1");
break;
case SCHEMA_ABSTRACT:
MSG_ADD_STRING("objectClassCategory", "2");
break;
case SCHEMA_AUXILIARY:
MSG_ADD_STRING("objectClassCategory", "3");
break;
case SCHEMA_MUST:
MSG_ADD_M_STRING("mustContain", token->value);
break;
case SCHEMA_MAY:
MSG_ADD_M_STRING("mayContain", token->value);
break;
case SCHEMA_SINGLE_VALUE:
MSG_ADD_STRING("isSingleValued", "TRUE");
break;
case SCHEMA_EQUALITY:
/* TODO */
break;
case SCHEMA_SUBSTR:
/* TODO */
break;
case SCHEMA_SYNTAX:
MSG_ADD_STRING("attributeSyntax", token->value);
break;
case SCHEMA_DESC:
MSG_ADD_STRING("description", token->value);
break;
default:
fprintf(stderr, "Unknown Definition: %s\n", token->value);
}
}
talloc_steal(mem_ctx, msg);
talloc_free(ctx);
return msg;
failed:
talloc_free(ctx);
return NULL;
}
static const struct schema_conv process_file(FILE *in, FILE *out)
{
TALLOC_CTX *ctx;
struct schema_conv ret;
char *entry;
int c, t, line;
struct ldb_ldif ldif;
ldif.changetype = LDB_CHANGETYPE_NONE;
ctx = talloc_new(NULL);
ret.count = 0;
ret.failures = 0;
line = 0;
while ((c = fgetc(in)) != EOF) {
line++;
/* fprintf(stderr, "Parsing line %d\n", line); */
if (c == '#') {
do {
c = fgetc(in);
} while (c != EOF && c != '\n');
continue;
}
if (c == '\n') {
continue;
}
t = 0;
entry = talloc_array(ctx, char, 1024);
if (entry == NULL) exit(-1);
do {
if (c == '\n') {
entry[t] = '\0';
if (check_braces(entry) == 0) {
ret.count++;
ldif.msg = process_entry(ctx, entry);
if (ldif.msg == NULL) {
ret.failures++;
fprintf(stderr, "No valid msg from entry \n[%s]\n at line %d\n", entry, line);
break;
}
ldb_ldif_write_file(ldb_ctx, out, &ldif);
break;
}
line++;
} else {
entry[t] = c;
t++;
}
if ((t % 1023) == 0) {
entry = talloc_realloc(ctx, entry, char, t + 1024);
if (entry == NULL) exit(-1);
}
} while ((c = fgetc(in)) != EOF);
if (c != '\n') {
entry[t] = '\0';
if (check_braces(entry) == 0) {
ret.count++;
ldif.msg = process_entry(ctx, entry);
if (ldif.msg == NULL) {
ret.failures++;
fprintf(stderr, "No valid msg from entry \n[%s]\n at line %d\n", entry, line);
break;
}
ldb_ldif_write_file(ldb_ctx, out, &ldif);
} else {
fprintf(stderr, "malformed entry on line %d\n", line);
ret.failures++;
}
}
if (c == EOF) break;
}
return ret;
}
static void usage(void)
{
printf("Usage: oLschema2ldif <options>\n");
printf("Options:\n");
printf(" -I inputfile inputfile otherwise STDIN\n");
printf(" -O outputfile outputfile otherwise STDOUT\n");
printf(" -o options pass options like modules to activate\n");
printf(" e.g: -o modules:timestamps\n");
printf("\n");
printf("Converts records from an openLdap formatted schema to an ldif schema\n\n");
exit(1);
}
int main(int argc, const char **argv)
{
TALLOC_CTX *ctx;
struct schema_conv ret;
struct ldb_cmdline *options;
FILE *in = stdin;
FILE *out = stdout;
ctx = talloc_new(NULL);
ldb_ctx = ldb_init(ctx);
setenv("LDB_URL", "NONE", 1);
options = ldb_cmdline_process(ldb_ctx, argc, argv, usage);
if (options->basedn == NULL) {
perror("Base DN not specified");
exit(1);
} else {
basedn = ldb_dn_explode(ctx, options->basedn);
if (basedn == NULL) {
perror("Malformed Base DN");
exit(1);
}
}
if (options->input) {
in = fopen(options->input, "r");
if (!in) {
perror(options->input);
exit(1);
}
}
if (options->output) {
out = fopen(options->output, "w");
if (!out) {
perror(options->output);
exit(1);
}
}
ret = process_file(in, out);
fclose(in);
fclose(out);
printf("Converted %d records with %d failures\n", ret.count, ret.failures);
return 0;
}