mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2024-12-27 03:20:22 +08:00
Code Issues Packages Projects Releases Wiki Activity
fd5ded3afb
openldap/servers/slapd/back-sql/schema-map.c

623 lines
17 KiB
C
Raw Normal View History

notices and acknowledgements
2003-12-08 03:19:18 +08:00
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
*
notices and acknowledgements
2003-12-08 03:19:18 +08:00
* Copyright 1999-2003 The OpenLDAP Foundation.
* Portions Copyright 1999 Dmitry Kovalev.
* 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>.
*/
/* ACKNOWLEDGEMENTS:
* This work was initially developed by Dmitry Kovalev for inclusion
* by OpenLDAP Software.
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
*/
#include "portable.h"
wrap sql *.c files with #ifdef SLAPD_SQL to facilate NT builds without -DSLAPD_SQL
2000-03-19 14:18:27 +08:00
#ifdef SLAPD_SQL
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
#include <stdio.h>
#include <sys/types.h>
Add checks for SQL headers in configure.in (need to rerun autoheader and autoconf); #include "ac/string.h" instead of <string.h>
2002-11-10 01:03:07 +08:00
#include "ac/string.h"
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
#include "slap.h"
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
#include "lber_pvt.h"
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
#include "ldap_pvt.h"
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
#include "back-sql.h"
#include "sql-wrap.h"
#include "schema-map.h"
#include "util.h"
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
/*
* Uses the pointer to the ObjectClass structure
*/
static int
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_oc( const void *v_m1, const void *v_m2 )
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
{
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
use SLAP_PTRCMP
2003-04-19 01:16:48 +08:00
return SLAP_PTRCMP( m1->oc, m2->oc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
}
static int
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_oc_id( const void *v_m1, const void *v_m2 )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return ( m1->id < m2->id ? -1 : ( m1->id > m2->id ? 1 : 0 ) );
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
/*
* Uses the pointer to the AttributeDescription structure
*/
static int
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_attr( const void *v_m1, const void *v_m2 )
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
{
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
const backsql_at_map_rec *m1 = v_m1, *m2 = v_m2;
use SLAP_PTRCMP
2003-04-19 01:16:48 +08:00
return SLAP_PTRCMP( m1->ad, m2->ad );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
}
static int
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_make_attr_query(
backsql_oc_map_rec *oc_map,
backsql_at_map_rec *at_map )
changes for 2.0-beta including: - fixes according to new API changes - closing db connection in connection_destroy callback, not unbind - support of new schema code, samples changed accordingly - support for multiple objectclasses (to distinguish from unique objectclass-to-tables mapping) - auto 'ref' attribute support - samples now include illustrations of using these 2 features to make named referrals as described in ldapext-namedref draft more to come: - documentation update - different improvements to be more close to native directory (after beta?)
2000-06-30 05:14:43 +08:00
{
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
struct berbuf bb = BB_NULL;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
backsql_strfcat( &bb, "lblblblbcbl",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
(ber_len_t)sizeof( "SELECT " ) - 1, "SELECT ",
&at_map->sel_expr,
(ber_len_t)sizeof( " AS " ) - 1, " AS ",
&at_map->ad->ad_cname,
(ber_len_t)sizeof( " FROM " ) - 1, " FROM ",
&at_map->from_tbls,
(ber_len_t)sizeof( " WHERE " ) - 1, " WHERE ",
&oc_map->keytbl,
'.',
&oc_map->keycol,
(ber_len_t)sizeof( "=?" ) - 1, "=?" );
if ( at_map->join_where.bv_val != NULL ) {
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
backsql_strfcat( &bb, "lb",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
(ber_len_t)sizeof( " AND ") - 1, " AND ",
&at_map->join_where );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
changes for 2.0-beta including: - fixes according to new API changes - closing db connection in connection_destroy callback, not unbind - support of new schema code, samples changed accordingly - support for multiple objectclasses (to distinguish from unique objectclass-to-tables mapping) - auto 'ref' attribute support - samples now include illustrations of using these 2 features to make named referrals as described in ldapext-namedref draft more to come: - documentation update - different improvements to be more close to native directory (after beta?)
2000-06-30 05:14:43 +08:00
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
at_map->query = bb.bb_val.bv_val;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return 0;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
changes for 2.0-beta including: - fixes according to new API changes - closing db connection in connection_destroy callback, not unbind - support of new schema code, samples changed accordingly - support for multiple objectclasses (to distinguish from unique objectclass-to-tables mapping) - auto 'ref' attribute support - samples now include illustrations of using these 2 features to make named referrals as described in ldapext-namedref draft more to come: - documentation update - different improvements to be more close to native directory (after beta?)
2000-06-30 05:14:43 +08:00
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
static int
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_add_sysmaps( backsql_oc_map_rec *oc_map )
changes for 2.0-beta including: - fixes according to new API changes - closing db connection in connection_destroy callback, not unbind - support of new schema code, samples changed accordingly - support for multiple objectclasses (to distinguish from unique objectclass-to-tables mapping) - auto 'ref' attribute support - samples now include illustrations of using these 2 features to make named referrals as described in ldapext-namedref draft more to come: - documentation update - different improvements to be more close to native directory (after beta?)
2000-06-30 05:14:43 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_at_map_rec *at_map;
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
char s[] = "+9223372036854775807L";
ber_len_t slen;
struct berbuf bb;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
snprintf( s, sizeof( s ), "%ld", oc_map->id );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
slen = strlen( s );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
at_map = (backsql_at_map_rec *)ch_calloc(1,
sizeof( backsql_at_map_rec ) );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
at_map->ad = slap_schema.si_ad_objectClass;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ber_str2bv( "ldap_entry_objclasses.oc_name", 0, 1, &at_map->sel_expr );
ber_str2bv( "ldap_entry_objclasses,ldap_entries", 0, 1,
&at_map->from_tbls );
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
bb.bb_len = at_map->from_tbls.bv_len + 1;
bb.bb_val = at_map->from_tbls;
backsql_merge_from_clause( &bb, &oc_map->keytbl );
at_map->from_tbls = bb.bb_val;
bb.bb_val.bv_val = NULL;
bb.bb_val.bv_len = 0;
bb.bb_len = 0;
backsql_strfcat( &bb, "lbcbll",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
(ber_len_t)sizeof( "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=" ) - 1,
"ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=",
&oc_map->keytbl,
'.',
&oc_map->keycol,
(ber_len_t)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
" and ldap_entries.oc_map_id=",
slen, s );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
at_map->join_where = bb.bb_val;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
at_map->add_proc = NULL;
at_map->delete_proc = NULL;
at_map->param_order = 0;
at_map->expect_return = 0;
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_make_attr_query( oc_map, at_map );
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_insert( &oc_map->attrs, at_map, backsql_cmp_attr, NULL );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
at_map = (backsql_at_map_rec *)ch_calloc( 1,
sizeof( backsql_at_map_rec ) );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
at_map->ad = slap_schema.si_ad_ref;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ber_str2bv( "ldap_referrals.url", 0, 1, &at_map->sel_expr );
ber_str2bv( "ldap_referrals,ldap_entries", 0, 1, &at_map->from_tbls );
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
bb.bb_val.bv_val = NULL;
bb.bb_val.bv_len = 0;
bb.bb_len = at_map->from_tbls.bv_len + 1;
backsql_merge_from_clause( &bb, &oc_map->keytbl );
at_map->from_tbls = bb.bb_val;
bb.bb_val.bv_val = NULL;
bb.bb_val.bv_len = 0;
bb.bb_len = 0;
backsql_strfcat( &bb, "lbcbll",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
(ber_len_t)sizeof( "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=" ) - 1,
"ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=",
&oc_map->keytbl,
'.',
&oc_map->keycol,
(ber_len_t)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
" and ldap_entries.oc_map_id=",
slen, s );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
at_map->join_where = bb.bb_val;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
at_map->add_proc = NULL;
at_map->delete_proc = NULL;
at_map->param_order = 0;
at_map->expect_return = 0;
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_make_attr_query( oc_map, at_map );
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_insert( &oc_map->attrs, at_map, backsql_cmp_attr, NULL );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
return 1;
changes for 2.0-beta including: - fixes according to new API changes - closing db connection in connection_destroy callback, not unbind - support of new schema code, samples changed accordingly - support for multiple objectclasses (to distinguish from unique objectclass-to-tables mapping) - auto 'ref' attribute support - samples now include illustrations of using these 2 features to make named referrals as described in ldapext-namedref draft more to come: - documentation update - different improvements to be more close to native directory (after beta?)
2000-06-30 05:14:43 +08:00
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
int
backsql_load_schema_map( backsql_info *si, SQLHDBC dbh )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
SQLHSTMT oc_sth, at_sth;
RETCODE rc;
BACKSQL_ROW_NTS oc_row, at_row;
unsigned long oc_id;
backsql_oc_map_rec *oc_map;
backsql_at_map_rec *at_map;
Debug( LDAP_DEBUG_TRACE, "==>load_schema_map()\n", 0, 0, 0 );
/*
* TimesTen : See if the ldap_entries.dn_ru field exists in the schema
*/
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
if ( !BACKSQL_DONTCHECK_LDAPINFO_DN_RU( si ) ) {
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
rc = backsql_Prepare( dbh, &oc_sth,
backsql_check_dn_ru_query, 0 );
if ( rc == SQL_SUCCESS ) {
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
/* Yes, the field exists */
si->bsql_flags |= BSQLF_HAS_LDAPINFO_DN_RU;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "ldapinfo.dn_ru field exists "
"in the schema\n", 0, 0, 0 );
} else {
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
/* No such field exists */
si->bsql_flags &= ~BSQLF_HAS_LDAPINFO_DN_RU;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
SQLFreeStmt( oc_sth, SQL_DROP );
}
rc = backsql_Prepare( dbh, &oc_sth, si->oc_query, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"error preparing oc_query: '%s'\n",
si->oc_query, 0, 0 );
backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): at_query '%s'\n",
si->at_query, 0, 0 );
rc = backsql_Prepare( dbh, &at_sth, si->at_query, 0 );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"error preparing at_query: '%s'\n",
si->at_query, 0, 0 );
backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
rc = backsql_BindParamID( at_sth, 1, &oc_id );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"error binding param for at_query: \n", 0, 0, 0 );
backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
rc = SQLExecute( oc_sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"error executing oc_query: \n", 0, 0, 0 );
backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
backsql_BindRowAsStrings( oc_sth, &oc_row );
rc = SQLFetch( oc_sth );
for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( oc_sth ) ) {
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
int colnum;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
oc_map = (backsql_oc_map_rec *)ch_calloc( 1,
sizeof( backsql_oc_map_rec ) );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
oc_map->id = strtol( oc_row.cols[ 0 ], NULL, 0 );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
oc_map->oc = oc_find( oc_row.cols[ 1 ] );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( oc_map->oc == NULL ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"objectClass '%s' is not defined in schema\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
oc_row.cols[ 1 ], 0, 0 );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER; /* undefined objectClass ? */
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ber_str2bv( oc_row.cols[ 2 ], 0, 1, &oc_map->keytbl );
ber_str2bv( oc_row.cols[ 3 ], 0, 1, &oc_map->keycol );
various fixes and improvements
2002-09-03 03:39:31 +08:00
oc_map->create_proc = ( oc_row.value_len[ 4 ] < 0 ) ? NULL
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
: ch_strdup( oc_row.cols[ 4 ] );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
colnum = 5;
if ( BACKSQL_CREATE_NEEDS_SELECT( si ) ) {
colnum = 6;
various fixes and improvements
2002-09-03 03:39:31 +08:00
oc_map->create_keyval = ( oc_row.value_len[ 5 ] < 0 )
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
? NULL : ch_strdup( oc_row.cols[ 5 ] );
}
various fixes and improvements
2002-09-03 03:39:31 +08:00
oc_map->delete_proc = ( oc_row.value_len[ colnum ] < 0 ) ? NULL
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
: ch_strdup( oc_row.cols[ colnum ] );
oc_map->expect_return = strtol( oc_row.cols[ colnum + 1 ],
NULL, 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
/*
* FIXME: first attempt to check for offending
* instructions in {create|delete}_proc
*/
oc_map->attrs = NULL;
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_insert( &si->oc_by_oc, oc_map, backsql_cmp_oc, NULL );
avl_insert( &si->oc_by_id, oc_map, backsql_cmp_oc_id, NULL );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
oc_id = oc_map->id;
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"objectClass '%s': keytbl='%s' keycol='%s'\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
BACKSQL_OC_NAME( oc_map ),
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
oc_map->keytbl.bv_val, oc_map->keycol.bv_val );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( oc_map->create_proc ) {
Debug( LDAP_DEBUG_TRACE, "create_proc='%s'\n",
oc_map->create_proc, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
if ( oc_map->create_keyval ) {
Debug( LDAP_DEBUG_TRACE, "create_keyval='%s'\n",
oc_map->create_keyval, 0, 0 );
}
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( oc_map->delete_proc ) {
Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
oc_map->delete_proc, 0, 0 );
}
Debug( LDAP_DEBUG_TRACE, "expect_return: "
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
"add=%d, del=%d; attributes:\n",
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
BACKSQL_IS_ADD( oc_map->expect_return ),
BACKSQL_IS_DEL( oc_map->expect_return ), 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"autoadding 'objectClass' and 'ref' mappings\n",
0, 0, 0 );
backsql_add_sysmaps( oc_map );
rc = SQLExecute( at_sth );
if ( rc != SQL_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"error executing at_query: \n", 0, 0, 0 );
backsql_PrintErrors( SQL_NULL_HENV, dbh, at_sth, rc );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_OTHER;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
backsql_BindRowAsStrings( at_sth, &at_row );
rc = SQLFetch( at_sth );
for ( ; BACKSQL_SUCCESS(rc); rc = SQLFetch( at_sth ) ) {
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
const char *text = NULL;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
struct berval bv;
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
struct berbuf bb = BB_NULL;
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "********'%s'\n",
at_row.cols[ 0 ], 0, 0 );
Debug( LDAP_DEBUG_TRACE,
"name='%s',sel_expr='%s' from='%s'",
at_row.cols[ 0 ], at_row.cols[ 1 ],
at_row.cols[ 2 ] );
Debug( LDAP_DEBUG_TRACE,
"join_where='%s',add_proc='%s'",
at_row.cols[ 3 ], at_row.cols[ 4 ], 0 );
Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
at_row.cols[ 5 ], 0, 0 );
/* TimesTen */
Debug( LDAP_DEBUG_TRACE, "sel_expr_u='%s'\n",
at_row.cols[ 8 ], 0, 0 );
at_map = (backsql_at_map_rec *)ch_calloc( 1,
sizeof( backsql_at_map_rec ) );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
rc = slap_str2ad( at_row.cols[ 0 ],
&at_map->ad, &text );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"attribute '%s' for objectClass '%s' "
"is not defined in schema: %s\n",
fix typo
2002-10-23 22:10:21 +08:00
at_row.cols[ 0 ],
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
BACKSQL_OC_NAME( oc_map ), text );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_CONSTRAINT_VIOLATION;
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ber_str2bv( at_row.cols[ 1 ], 0, 1, &at_map->sel_expr );
various fixes and improvements
2002-09-03 03:39:31 +08:00
if ( at_row.value_len[ 8 ] < 0 ) {
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
at_map->sel_expr_u.bv_val = NULL;
at_map->sel_expr_u.bv_len = 0;
} else {
ber_str2bv( at_row.cols[ 8 ], 0, 1,
&at_map->sel_expr_u );
}
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ber_str2bv( at_row.cols[ 2 ], 0, 0, &bv );
fix backsql new API; use berbuf instead of berval
2003-04-16 05:55:25 +08:00
backsql_merge_from_clause( &bb, &bv );
at_map->from_tbls = bb.bb_val;
various fixes and improvements
2002-09-03 03:39:31 +08:00
if ( at_row.value_len[ 3 ] < 0 ) {
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
at_map->join_where.bv_val = NULL;
at_map->join_where.bv_len = 0;
} else {
ber_str2bv( at_row.cols[ 3 ], 0, 1,
&at_map->join_where );
}
various fixes and improvements
2002-09-03 03:39:31 +08:00
at_map->add_proc = NULL;
if ( at_row.value_len[ 4 ] > 0 ) {
at_map->add_proc = ch_strdup( at_row.cols[4] );
}
at_map->delete_proc = NULL;
if ( at_row.value_len[ 5 ] > 0 ) {
at_map->delete_proc
= ch_strdup( at_row.cols[ 5 ] );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
at_map->param_order = strtol( at_row.cols[ 6 ],
NULL, 0 );
at_map->expect_return = strtol( at_row.cols[ 7 ],
NULL, 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_make_attr_query( oc_map, at_map );
Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
"preconstructed query '%s'\n",
at_map->query, 0, 0 );
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_insert( &oc_map->attrs, at_map, backsql_cmp_attr, NULL );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
backsql_FreeRow( &at_row );
SQLFreeStmt( at_sth, SQL_CLOSE );
}
backsql_FreeRow( &oc_row );
SQLFreeStmt( at_sth, SQL_DROP );
SQLFreeStmt( oc_sth, SQL_DROP );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
si->bsql_flags |= BSQLF_SCHEMA_LOADED;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "<==load_schema_map()\n", 0, 0, 0 );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return LDAP_SUCCESS;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_oc_map_rec *
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
backsql_oc2oc( backsql_info *si, ObjectClass *oc )
{
backsql_oc_map_rec tmp, *res;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "==>backsql_oc2oc(): "
"searching for objectclass with name='%s'\n",
objclass, 0, 0 );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
tmp.oc = oc;
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
"found name='%s', id=%d\n",
BACKSQL_OC_NAME( res ), res->id, 0 );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
} else {
Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
"not found\n", 0, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return res;
}
backsql_oc_map_rec *
backsql_name2oc( backsql_info *si, struct berval *oc_name )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_oc_map_rec tmp, *res;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "==>oc_with_name(): "
"searching for objectclass with name='%s'\n",
objclass, 0, 0 );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
tmp.oc = oc_bvfind( oc_name );
if ( tmp.oc == NULL ) {
return NULL;
}
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
"found name='%s', id=%d\n",
BACKSQL_OC_NAME( res ), res->id, 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
} else {
Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
"not found\n", 0, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
return res;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_oc_map_rec *
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
backsql_id2oc( backsql_info *si, unsigned long id )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_oc_map_rec tmp, *res;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "==>oc_with_id(): "
"searching for objectclass with id='%d'\n", id, 0, 0 );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
tmp.id = id;
res = (backsql_oc_map_rec *)avl_find( si->oc_by_id, &tmp,
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_oc_id );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
"found name='%s', id=%d\n",
BACKSQL_OC_NAME( res ), res->id, 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
} else {
Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
"not found\n", 0, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
return res;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_at_map_rec *
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
backsql_at_map_rec tmp, *res;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "==>backsql_ad2at(): "
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
"searching for attribute '%s' for objectclass '%s'\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
attr, BACKSQL_OC_NAME( objclass ), 0 );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
tmp.ad = ad;
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
res = (backsql_at_map_rec *)avl_find( objclass->attrs, &tmp,
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_attr );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( res != NULL ) {
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
"found name='%s', sel_expr='%s'\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
res->ad->ad_cname.bv_val, res->sel_expr.bv_val, 0 );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
} else {
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
"not found\n", 0, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
return res;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
/*
* Deprecated
*/
backsql_at_map_rec *
backsql_name2at( backsql_oc_map_rec* objclass, struct berval *attr )
{
backsql_at_map_rec tmp, *res;
const char *text = NULL;
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "==>backsql_name2at(): "
"searching for attribute '%s' for objectclass '%s'\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
attr, BACKSQL_OC_NAME( objclass ), 0 );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( slap_bv2ad( attr, &tmp.ad, &text ) != LDAP_SUCCESS ) {
return NULL;
}
res = (backsql_at_map_rec *)avl_find( objclass->attrs, &tmp,
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_cmp_attr );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#ifdef BACKSQL_TRACE
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==backsql_name2at(): "
"found name='%s', sel_expr='%s'\n",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
res->name, res->sel_expr.bv_val, 0 );
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
} else {
Debug( LDAP_DEBUG_TRACE, "<==backsql_name2at(): "
"not found\n", 0, 0, 0 );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
#endif /* BACKSQL_TRACE */
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
return res;
}
static void
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_free_attr( void *v_at )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_at_map_rec *at = v_at;
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "==>free_attr(): '%s'\n",
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
at->ad->ad_cname.bv_val, 0, 0 );
ch_free( at->sel_expr.bv_val );
if ( at->from_tbls.bv_val != NULL ) {
ch_free( at->from_tbls.bv_val );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
if ( at->join_where.bv_val != NULL ) {
ch_free( at->join_where.bv_val );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
if ( at->add_proc != NULL ) {
ch_free( at->add_proc );
}
if ( at->delete_proc != NULL ) {
ch_free( at->delete_proc );
}
if ( at->query ) {
ch_free( at->query );
}
/* TimesTen */
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
if ( at->sel_expr_u.bv_val ) {
ch_free( at->sel_expr_u.bv_val );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
}
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
ch_free( at );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "<==free_attr()\n", 0, 0, 0 );
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
static void
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_free_oc( void *v_oc )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
backsql_oc_map_rec *oc = v_oc;
CHANGES: - now all write operations appear to work correctly with PostgeSQL 7.0 - all write operations have been made transactional (atomic writes to entries are committed separately only in case of complete^1 success while all other operations are rolled-back by default) - more cleanup and handling of exceptional conditions TODO: - deen to check with different databases and more up to date versions of both unixODBC and PostgreSQL. ^1: attribute add/modify/delete operations silently succeed if the appropriate add/delete proc does not exist for each attribute; this may be correct to hide undesired/unimplemented correspondence between LDAP and SQL databases; however, a more appropriate LDAP behavior would be a failure with LDAP_UNAVAILABLE if a single write operation cannot be executed for such reason
2002-08-17 00:45:24 +08:00
Debug( LDAP_DEBUG_TRACE, "==>free_oc(): '%s'\n",
- added the capability to filter based on hasSubordinate attribute to back-bdb, back-ldbm and back-sql (the latter with limitations); - added handling of ":dn" attributes to extended rfc2254 filters and to matched value filter - altered the behavior of get_mra() when a matching rule is given: now it checks whether it is compatible with the attribute syntax and, in case it is, the given mr is used. In case of no type, the check is delayed when filtering
2002-08-29 18:55:48 +08:00
BACKSQL_OC_NAME( oc ), 0, 0 );
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_free( oc->attrs, backsql_free_attr );
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
ch_free( oc->keytbl.bv_val );
ch_free( oc->keycol.bv_val );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( oc->create_proc != NULL ) {
ch_free( oc->create_proc );
}
Final run of changes to back-sql; IBM db2 support has been tested. Now related ITSes need be audited and possibly closed. Enhancements: - re-styled code for better readability - upgraded backend API to reflect recent changes - LDAP schema is checked when loading SQL/LDAP mapping - AttributeDescription/ObjectClass pointers used for more efficient mapping lookup - bervals used where string length is required often - atomized write operations by committing at the end of each operation and defaulting connection closure to rollback - added LDAP access control to write operations - fully implemented modrdn (with rdn attrs change, deleteoldrdn, access check, parent/children check and more) - added parent access control, children control to delete operation - added structuralObjectClass operational attribute check and value return on search - added hasSubordinate operational attribute on demand - search limits are appropriately enforced - function backsql_strcat() has been made more efficient - concat function has been made configurable by means of a pattern - added config switches: - fail_if_no_mapping write operations fail if there is no mapping - has_ldapinfo_dn_ru overrides autodetect - concat_pattern a string containing two '?' is used (note that "?||?" should be more portable than builtin function "CONCAT(?,?)") - strcast_func cast of string constants in "SELECT DISTINCT statements (needed by PostgreSQL) - upper_needs_cast cast the argument of upper when required (basically when building dn substring queries) Todo: - add security checks for SQL statements that can be injected (?) - re-test with previously supported RDBMs - replace dn_ru and so with normalized dn (no need for upper() and so in dn match) - implement a backsql_normalize() function to replace the upper() conversion routines - note that subtree deletion, subtree renaming and so could be easily implemented (rollback and consistency checks are available :) - implement "lastmod" and other operational stuff (ldap_entries table ?)
2002-08-23 16:54:08 +08:00
if ( oc->create_keyval != NULL ) {
ch_free( oc->create_keyval );
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
if ( oc->delete_proc != NULL ) {
ch_free( oc->delete_proc );
}
ch_free( oc );
Debug( LDAP_DEBUG_TRACE, "<==free_oc()\n", 0, 0, 0 );
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
int
backsql_destroy_schema_map( backsql_info *si )
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
{
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n", 0, 0, 0 );
Remove casts of AVL function pointers.
2002-12-15 06:25:52 +08:00
avl_free( si->oc_by_oc, 0 );
avl_free( si->oc_by_id, backsql_free_oc );
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n", 0, 0, 0 );
return 0;
more back-sql files + rdbms_dependent samples
2000-03-17 03:34:46 +08:00
}
wrap sql *.c files with #ifdef SLAPD_SQL to facilate NT builds without -DSLAPD_SQL
2000-03-19 14:18:27 +08:00
Summary of changes: - filter -> SQL translation bugfixes - several memory leaks fixups - improved configurability: - allows definition of uppercasing function to support CIS matching on databases that do case sensitive compares (this fixes up Oracle issues, example updated) - allows more flexibility in stored procedures interface (different parameter order, optional return codes - see samples, and comments in backsql.h) - synchronize function interfaces to recent changes in prototypes ("const" clauses etc.) made for all backends (those changes led to compile-time errors)
2000-05-27 00:03:32 +08:00
#endif /* SLAPD_SQL */
changes: - re-style according to the style giudelines for better readability - updated to recent frontend/backend API changes - fixed a few quirks about normalization - "optimized" a few memory allocation/string handling functions - fixed a few quirks about add/modify (still have to look ad modrdn) todo: - there is still something broken (at least with PostgreSQL and IBM db2, the two RDBMS O have at hand) when adding - move everything to struct bervals and try to save a few strlen - try some LDAP/SQL syntax relation to use appropriate value bind if possible - ...
2002-08-14 01:12:27 +08:00
Reference in New Issue Copy Permalink