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, 0, NULL, NULL, &err);
if (code) {
fprintf(stderr, "%s: line %d: %s: \"%s\"\n",
fname, lineno, ldap_scherr2str(code), err);
return 1;
}
ldap_memfree(at);
return 0;
}
int
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 );
at_usage();
return 1;
}
if ( at->at_oid == NULL ) {
fprintf( stderr,
"%s: line %d: attributeType has no OID\n",
fname, lineno );
at_usage();
return 1;
}
/* operational attributes should be defined internally */
if ( at->at_usage ) {
fprintf( stderr, "%s: line %d: attribute type \"%s\" is operational\n",
fname, lineno, at->at_oid );
return 1;
}
code = at_add(at,&err);
if ( code ) {
fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
fname, lineno, scherr2str(code), err);
return 1;
}
ldap_memfree(at);
return 0;
}
/* backport register_at() from HEAD, to allow building with OL <= 2.3 */
static int
register_at( char *def, AttributeDescription **rad, int dupok )
{
LDAPAttributeType *at;
int code, freeit = 0;
const char *err;
AttributeDescription *ad = NULL;
at = ldap_str2attributetype( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
if ( !at ) {
Debug( LDAP_DEBUG_ANY,
"register_at: AttributeType \"%s\": %s, %s\n",
def, ldap_scherr2str(code), err );
return code;
}
code = at_add( at, 0, NULL, &err );
if ( code ) {
if ( code == SLAP_SCHERR_ATTR_DUP && dupok ) {
freeit = 1;
} else {
ldap_attributetype_free( at );
Debug( LDAP_DEBUG_ANY,
"register_at: AttributeType \"%s\": %s, %s\n",
def, scherr2str(code), err );
return code;
}
}
code = slap_str2ad( at->at_names[0], &ad, &err );
if ( freeit || code ) {
ldap_attributetype_free( at );
} else {
ldap_memfree( at );
}
if ( code ) {
Debug( LDAP_DEBUG_ANY, "register_at: AttributeType \"%s\": %s\n",
def, err, 0 );
}
if ( rad ) *rad = ad;
return code;
}
LDAPAttrType::LDAPAttrType (string at_item, int flags ) {
DEBUG(LDAP_DEBUG_CONSTRUCT,
"LDAPAttrType::LDAPAttrType( )" << endl);
LDAPAttributeType *a;
int ret;
const char *errp;
a = ldap_str2attributetype (at_item.c_str(), &ret, &errp, flags);
if (a) {
this->setNames( a->at_names );
this->setDesc( a->at_desc );
this->setOid( a->at_oid );
this->setSingle( a->at_single_value );
this->setUsage( a->at_usage );
this->setSuperiorOid( a->at_sup_oid );
this->setEqualityOid( a->at_equality_oid );
this->setOrderingOid( a->at_ordering_oid );
this->setSubstringOid( a->at_substr_oid );
this->setSyntaxOid( a->at_syntax_oid );
}
// else? -> error
}
int
parse_at(
struct config_args_s *c,
AttributeType **sat,
AttributeType *prev )
{
LDAPAttributeType *at;
int code;
const char *err;
char *line = strchr( c->line, '(' );
at = ldap_str2attributetype( line, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
if ( !at ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s: %s before %s",
c->argv[0], ldap_scherr2str(code), err );
Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
"%s %s\n", c->log, c->cr_msg );
at_usage();
return 1;
}
if ( at->at_oid == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s: OID is missing",
c->argv[0] );
Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
"%s %s\n", c->log, c->cr_msg );
at_usage();
code = 1;
goto done;
}
/* operational attributes should be defined internally */
if ( at->at_usage ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s: \"%s\" is operational",
c->argv[0], at->at_oid );
Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
"%s %s\n", c->log, c->cr_msg );
code = 1;
goto done;
}
code = at_add( at, 1, sat, prev, &err);
if ( code ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s: %s: \"%s\"",
c->argv[0], scherr2str(code), err);
Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
"%s %s\n", c->log, c->cr_msg );
code = 1;
goto done;
}
done:;
if ( code ) {
ldap_attributetype_free( at );
} else {
ldap_memfree( at );
}
return code;
}
static LdapAttribute *
worker_gda_ldap_get_attr_info (WorkerLdapAttrInfoData *data, GError **error)
{
LdapAttribute *retval = NULL;
if (data->cdata->attributes_hash)
return g_hash_table_lookup (data->cdata->attributes_hash, data->attribute);
/* initialize known types */
data->cdata->attributes_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
(GDestroyNotify) ldap_attribute_free);
if (data->cdata->attributes_cache_file) {
/* try to load from cache file, which must contain one line per attribute:
* <syntax oid>,0|1,<attribute name>
*/
gchar *fdata;
if (g_file_get_contents (data->cdata->attributes_cache_file, &fdata, NULL, NULL)) {
gchar *start, *ptr;
gchar **array;
start = fdata;
while (1) {
gboolean done = FALSE;
for (ptr = start; *ptr && (*ptr != '\n'); ptr++);
if (*ptr == '\n')
*ptr = 0;
else
done = TRUE;
if (*start && (*start != '#')) {
array = g_strsplit (start, ",", 3);
if (array[0] && array[1] && array[2]) {
LdapAttribute *lat;
lat = g_new (LdapAttribute, 1);
lat->name = g_strdup (array[2]);
lat->type = gda_ldap_get_type_info (array[0]);
lat->single_value = (*array[1] == '0' ? FALSE : TRUE);
g_hash_table_insert (data->cdata->attributes_hash,
lat->name, lat);
/*g_print ("CACHE ADDED [%s][%p][%d] for OID %s\n",
lat->name, lat->type, lat->single_value,
array[0]);*/
}
g_strfreev (array);
}
if (done)
break;
else
start = ptr+1;
}
g_free (fdata);
return g_hash_table_lookup (data->cdata->attributes_hash, data->attribute);
}
}
GString *string = NULL;
LDAPMessage *msg, *entry;
int res;
gchar *subschema = NULL;
char *subschemasubentry[] = {"subschemaSubentry", NULL};
char *schema_attrs[] = {"attributeTypes", NULL};
/* look for subschema */
if (! gda_ldap_ensure_bound (data->cnc, NULL))
return NULL;
gda_ldap_execution_slowdown (data->cnc);
res = ldap_search_ext_s (data->cdata->handle, "", LDAP_SCOPE_BASE,
"(objectclass=*)",
subschemasubentry, 0,
NULL, NULL, NULL, 0,
&msg);
if (res != LDAP_SUCCESS) {
gda_ldap_may_unbind (data->cnc);
return NULL;
}
if ((entry = ldap_first_entry (data->cdata->handle, msg))) {
char *attr;
BerElement *ber;
if ((attr = ldap_first_attribute (data->cdata->handle, entry, &ber))) {
BerValue **bvals;
if ((bvals = ldap_get_values_len (data->cdata->handle, entry, attr))) {
subschema = g_strdup (bvals[0]->bv_val);
ldap_value_free_len (bvals);
}
ldap_memfree (attr);
}
if (ber)
ber_free (ber, 0);
}
ldap_msgfree (msg);
if (! subschema) {
gda_ldap_may_unbind (data->cnc);
return NULL;
}
/* look for attributeTypes */
gda_ldap_execution_slowdown (data->cnc);
res = ldap_search_ext_s (data->cdata->handle, subschema, LDAP_SCOPE_BASE,
"(objectclass=*)",
schema_attrs, 0,
NULL, NULL, NULL, 0,
&msg);
g_free (subschema);
if (res != LDAP_SUCCESS) {
gda_ldap_may_unbind (data->cnc);
return NULL;
}
if (data->cdata->attributes_cache_file)
string = g_string_new ("# Cache file. This file can safely be removed, in this case\n"
"# it will be automatically recreated.\n"
"# DO NOT MODIFY\n");
for (entry = ldap_first_entry (data->cdata->handle, msg);
entry;
entry = ldap_next_entry (data->cdata->handle, msg)) {
char *attr;
BerElement *ber;
for (attr = ldap_first_attribute (data->cdata->handle, msg, &ber);
attr;
attr = ldap_next_attribute (data->cdata->handle, msg, ber)) {
if (strcasecmp(attr, "attributeTypes")) {
ldap_memfree (attr);
continue;
}
BerValue **bvals;
bvals = ldap_get_values_len (data->cdata->handle, entry, attr);
if (bvals) {
gint i;
for (i = 0; bvals[i]; i++) {
LDAPAttributeType *at;
const char *errp;
int retcode;
at = ldap_str2attributetype (bvals[i]->bv_val, &retcode,
&errp,
LDAP_SCHEMA_ALLOW_ALL);
if (at && at->at_names && at->at_syntax_oid &&
at->at_names[0] && *(at->at_names[0])) {
LdapAttribute *lat;
lat = g_new (LdapAttribute, 1);
lat->name = g_strdup (at->at_names [0]);
lat->type = gda_ldap_get_type_info (at->at_syntax_oid);
lat->single_value = (at->at_single_value == 0 ? FALSE : TRUE);
g_hash_table_insert (data->cdata->attributes_hash,
lat->name, lat);
/*g_print ("ADDED [%s][%p][%d] for OID %s\n",
lat->name, lat->type, lat->single_value,
at->at_syntax_oid);*/
if (string)
g_string_append_printf (string, "%s,%d,%s\n",
at->at_syntax_oid,
lat->single_value,
lat->name);
}
if (at)
ldap_memfree (at);
}
ldap_value_free_len (bvals);
}
ldap_memfree (attr);
}
if (ber)
ber_free (ber, 0);
}
ldap_msgfree (msg);
if (string) {
if (! g_file_set_contents (data->cdata->attributes_cache_file, string->str, -1, NULL)) {
gchar *dirname;
dirname = g_path_get_dirname (data->cdata->attributes_cache_file);
g_mkdir_with_parents (dirname, 0700);
g_free (dirname);
g_file_set_contents (data->cdata->attributes_cache_file, string->str, -1, NULL);
}
g_string_free (string, TRUE);
}
gda_ldap_may_unbind (data->cnc);
retval = g_hash_table_lookup (data->cdata->attributes_hash, data->attribute);
return retval;
}
