mirror of
https://git.openldap.org/openldap/openldap.git
synced 2024-12-27 03:20:22 +08:00
571 lines
13 KiB
C
571 lines
13 KiB
C
/* $OpenLDAP$ */
|
|
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
|
|
*
|
|
* Copyright 1999-2005 The OpenLDAP Foundation.
|
|
* Portions Copyright 1999 Dmitry Kovalev.
|
|
* Portions Copyright 2002 Pierangelo Masarati.
|
|
* 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. Additional significant contributors include
|
|
* Pierangelo Masarati.
|
|
*/
|
|
|
|
#include "portable.h"
|
|
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include "ac/string.h"
|
|
#include "ac/ctype.h"
|
|
#include "ac/stdarg.h"
|
|
|
|
#include "slap.h"
|
|
#include "proto-sql.h"
|
|
#include "lutil.h"
|
|
|
|
#define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
|
|
#define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
|
|
|
|
#define BACKSQL_STR_GROW 256
|
|
|
|
char backsql_def_oc_query[] =
|
|
"SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
|
|
"FROM ldap_oc_mappings";
|
|
char backsql_def_needs_select_oc_query[] =
|
|
"SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
|
|
"expect_return FROM ldap_oc_mappings";
|
|
char backsql_def_at_query[] =
|
|
"SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
|
|
"param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
|
|
"WHERE oc_map_id=?";
|
|
char backsql_def_delentry_stmt[] = "DELETE FROM ldap_entries WHERE id=?";
|
|
char backsql_def_renentry_stmt[] =
|
|
"UPDATE ldap_entries SET dn=?,parent=?,keyval=? WHERE id=?";
|
|
char backsql_def_insentry_stmt[] =
|
|
"INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
|
|
"VALUES (?,?,?,?)";
|
|
char backsql_def_delobjclasses_stmt[] = "DELETE FROM ldap_entry_objclasses "
|
|
"WHERE entry_id=?";
|
|
char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
|
|
char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
|
|
char backsql_id_query[] = "SELECT id,keyval,oc_map_id,dn FROM ldap_entries WHERE ";
|
|
/* better ?||? or cast(?||? as varchar) */
|
|
char backsql_def_concat_func[] = "CONCAT(?,?)";
|
|
|
|
/* TimesTen */
|
|
char backsql_check_dn_ru_query[] = "SELECT dn_ru FROM ldap_entries";
|
|
|
|
struct berbuf *
|
|
backsql_strcat( struct berbuf *dest, ... )
|
|
{
|
|
va_list strs;
|
|
ber_len_t cdlen, cslen, grow;
|
|
char *cstr;
|
|
|
|
assert( dest );
|
|
assert( dest->bb_val.bv_val == NULL
|
|
|| dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n", 0, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
va_start( strs, dest );
|
|
if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
|
|
dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
|
|
sizeof( char ) );
|
|
dest->bb_val.bv_len = 0;
|
|
dest->bb_len = BACKSQL_STR_GROW;
|
|
}
|
|
cdlen = dest->bb_val.bv_len;
|
|
while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
|
|
cslen = strlen( cstr );
|
|
grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
|
|
if ( dest->bb_len - cdlen <= cslen ) {
|
|
char *tmp_dest;
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
|
|
"buflen=%d, cdlen=%d, cslen=%d "
|
|
"-- reallocating dest\n",
|
|
dest->bb_len, cdlen + 1, cslen );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
|
|
( dest->bb_len ) + grow * sizeof( char ) );
|
|
if ( tmp_dest == NULL ) {
|
|
Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
|
|
"could not reallocate string buffer.\n",
|
|
0, 0, 0 );
|
|
return NULL;
|
|
}
|
|
dest->bb_val.bv_val = tmp_dest;
|
|
dest->bb_len += grow;
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
|
|
"new buflen=%d, dest=%p\n",
|
|
dest->bb_len, dest, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
}
|
|
AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
|
|
cdlen += cslen;
|
|
}
|
|
va_end( strs );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest=\"%s\")\n",
|
|
dest->bb_val.bv_val, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
dest->bb_val.bv_len = cdlen;
|
|
|
|
return dest;
|
|
}
|
|
|
|
struct berbuf *
|
|
backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
|
|
{
|
|
va_list strs;
|
|
ber_len_t cdlen;
|
|
|
|
assert( dest );
|
|
assert( fmt );
|
|
assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
|
|
assert( dest->bb_val.bv_val == NULL
|
|
|| dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n", 0, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
va_start( strs, fmt );
|
|
if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
|
|
dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
|
|
sizeof( char ) );
|
|
dest->bb_val.bv_len = 0;
|
|
dest->bb_len = BACKSQL_STR_GROW;
|
|
}
|
|
|
|
cdlen = dest->bb_val.bv_len;
|
|
for ( ; fmt[0]; fmt++ ) {
|
|
ber_len_t cslen, grow;
|
|
char *cstr, cc[ 2 ] = { '\0', '\0' };
|
|
struct berval *cbv;
|
|
|
|
switch ( fmt[ 0 ] ) {
|
|
|
|
/* berval */
|
|
case 'b':
|
|
cbv = va_arg( strs, struct berval * );
|
|
cstr = cbv->bv_val;
|
|
cslen = cbv->bv_len;
|
|
break;
|
|
|
|
/* length + string */
|
|
case 'l':
|
|
cslen = va_arg( strs, ber_len_t );
|
|
cstr = va_arg( strs, char * );
|
|
break;
|
|
|
|
/* string */
|
|
case 's':
|
|
cstr = va_arg( strs, char * );
|
|
cslen = strlen( cstr );
|
|
break;
|
|
|
|
/* char */
|
|
case 'c':
|
|
/*
|
|
* `char' is promoted to `int' when passed through `...'
|
|
*/
|
|
cc[0] = va_arg( strs, int );
|
|
cstr = cc;
|
|
cslen = 1;
|
|
break;
|
|
|
|
default:
|
|
assert( 0 );
|
|
}
|
|
|
|
grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
|
|
if ( dest->bb_len - cdlen <= cslen ) {
|
|
char *tmp_dest;
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
|
|
"buflen=%d, cdlen=%d, cslen=%d "
|
|
"-- reallocating dest\n",
|
|
dest->bb_len, cdlen + 1, cslen );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
|
|
( dest->bb_len ) + grow * sizeof( char ) );
|
|
if ( tmp_dest == NULL ) {
|
|
Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
|
|
"could not reallocate string buffer.\n",
|
|
0, 0, 0 );
|
|
return NULL;
|
|
}
|
|
dest->bb_val.bv_val = tmp_dest;
|
|
dest->bb_len += grow * sizeof( char );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
|
|
"new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
}
|
|
|
|
assert( cstr );
|
|
|
|
AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
|
|
cdlen += cslen;
|
|
}
|
|
|
|
va_end( strs );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest=\"%s\")\n",
|
|
dest->bb_val.bv_val, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
dest->bb_val.bv_len = cdlen;
|
|
|
|
return dest;
|
|
}
|
|
|
|
int
|
|
backsql_entry_addattr(
|
|
Entry *e,
|
|
AttributeDescription *ad,
|
|
struct berval *val,
|
|
void *memctx )
|
|
{
|
|
int rc;
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(\"%s\"): %s=%s\n",
|
|
e->e_name.bv_val, ad->ad_cname->bv_val, val->bv_val );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
rc = attr_merge_normalize_one( e, ad, val, memctx );
|
|
|
|
if ( rc != LDAP_SUCCESS ) {
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(\"%s\"): "
|
|
"failed to merge value \"%s\" for attribute \"%s\"\n",
|
|
e->e_name.bv_val, val->bv_val, ad->ad_cname.bv_val );
|
|
return rc;
|
|
}
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "<==backsql_entry_addattr(\"%s\")\n",
|
|
e->e_name.bv_val, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
return LDAP_SUCCESS;
|
|
}
|
|
|
|
static char *
|
|
backsql_get_table_spec( backsql_info *bi, char **p )
|
|
{
|
|
char *s, *q;
|
|
struct berbuf res = BB_NULL;
|
|
|
|
assert( p );
|
|
assert( *p );
|
|
|
|
s = *p;
|
|
while ( **p && **p != ',' ) {
|
|
(*p)++;
|
|
}
|
|
|
|
if ( **p ) {
|
|
*(*p)++ = '\0';
|
|
}
|
|
|
|
#define BACKSQL_NEXT_WORD { \
|
|
while ( *s && isspace( (unsigned char)*s ) ) s++; \
|
|
if ( !*s ) return res.bb_val.bv_val; \
|
|
q = s; \
|
|
while ( *q && !isspace( (unsigned char)*q ) ) q++; \
|
|
if ( *q ) *q++='\0'; \
|
|
}
|
|
|
|
BACKSQL_NEXT_WORD;
|
|
/* table name */
|
|
backsql_strcat( &res, s, NULL );
|
|
s = q;
|
|
|
|
BACKSQL_NEXT_WORD;
|
|
if ( strcasecmp( s, "AS" ) == 0 ) {
|
|
s = q;
|
|
BACKSQL_NEXT_WORD;
|
|
}
|
|
|
|
/* oracle doesn't understand "AS" :( and other RDBMSes don't need it */
|
|
backsql_strfcat( &res, "lbbsb",
|
|
STRLENOF( " " ), " ",
|
|
&bi->sql_aliasing,
|
|
&bi->sql_aliasing_quote,
|
|
s,
|
|
&bi->sql_aliasing_quote );
|
|
|
|
return res.bb_val.bv_val;
|
|
}
|
|
|
|
int
|
|
backsql_merge_from_clause(
|
|
backsql_info *bi,
|
|
struct berbuf *dest_from,
|
|
struct berval *src_from )
|
|
{
|
|
char *s, *p, *srcc, *pos, e;
|
|
struct berbuf res = BB_NULL;
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
|
|
"dest_from=\"%s\",src_from=\"%s\"\n",
|
|
dest_from ? dest_from->bb_val.bv_val : "<NULL>",
|
|
src_from->bv_val, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
srcc = ch_strdup( src_from->bv_val );
|
|
p = srcc;
|
|
|
|
if ( dest_from != NULL ) {
|
|
res = *dest_from;
|
|
}
|
|
|
|
while ( *p ) {
|
|
s = backsql_get_table_spec( bi, &p );
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
|
|
"p=\"%s\" s=\"%s\"\n", p, s, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
if ( res.bb_val.bv_val == NULL ) {
|
|
backsql_strcat( &res, s, NULL );
|
|
|
|
} else {
|
|
pos = strstr( res.bb_val.bv_val, s );
|
|
if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
|
|
backsql_strfcat( &res, "cs", ',', s );
|
|
}
|
|
}
|
|
|
|
if ( s ) {
|
|
ch_free( s );
|
|
}
|
|
}
|
|
|
|
#ifdef BACKSQL_TRACE
|
|
Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
|
|
#endif /* BACKSQL_TRACE */
|
|
|
|
free( srcc );
|
|
*dest_from = res;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* splits a pattern in components separated by '?'
|
|
* (double ?? are turned into single ? and left in the string)
|
|
* expected contains the number of expected occurrences of '?'
|
|
* (a negative value means parse as many as possible)
|
|
*/
|
|
|
|
int
|
|
backsql_split_pattern(
|
|
const char *_pattern,
|
|
BerVarray *split_pattern,
|
|
int expected )
|
|
{
|
|
char *pattern, *start, *end;
|
|
struct berval bv;
|
|
int rc = 0;
|
|
|
|
#define SPLIT_CHAR '?'
|
|
|
|
assert( _pattern );
|
|
assert( split_pattern );
|
|
|
|
pattern = ch_strdup( _pattern );
|
|
|
|
start = pattern;
|
|
end = strchr( start, SPLIT_CHAR );
|
|
for ( ; start; expected-- ) {
|
|
char *real_end = end;
|
|
ber_len_t real_len;
|
|
|
|
if ( real_end == NULL ) {
|
|
real_end = start + strlen( start );
|
|
|
|
} else if ( real_end[ 1 ] == SPLIT_CHAR ) {
|
|
expected++;
|
|
AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
|
|
end = strchr( real_end + 1, SPLIT_CHAR );
|
|
continue;
|
|
}
|
|
|
|
real_len = real_end - start;
|
|
if ( real_len == 0 ) {
|
|
ber_str2bv( "", 0, 1, &bv );
|
|
} else {
|
|
ber_str2bv( start, real_len, 1, &bv );
|
|
}
|
|
|
|
ber_bvarray_add( split_pattern, &bv );
|
|
|
|
if ( expected == 0 ) {
|
|
if ( end != NULL ) {
|
|
rc = -1;
|
|
goto done;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( end != NULL ) {
|
|
start = end + 1;
|
|
end = strchr( start, SPLIT_CHAR );
|
|
}
|
|
}
|
|
|
|
done:;
|
|
|
|
ch_free( pattern );
|
|
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
backsql_prepare_pattern(
|
|
BerVarray split_pattern,
|
|
BerVarray values,
|
|
struct berval *res )
|
|
{
|
|
int i;
|
|
struct berbuf bb = BB_NULL;
|
|
|
|
assert( res );
|
|
|
|
for ( i = 0; values[i].bv_val; i++ ) {
|
|
if ( split_pattern[i].bv_val == NULL ) {
|
|
ch_free( bb.bb_val.bv_val );
|
|
return -1;
|
|
}
|
|
backsql_strfcat( &bb, "b", &split_pattern[ i ] );
|
|
backsql_strfcat( &bb, "b", &values[ i ] );
|
|
}
|
|
|
|
if ( split_pattern[ i ].bv_val == NULL ) {
|
|
ch_free( bb.bb_val.bv_val );
|
|
return -1;
|
|
}
|
|
|
|
backsql_strfcat( &bb, "b", &split_pattern[ i ] );
|
|
|
|
*res = bb.bb_val;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
backsql_entryUUID(
|
|
backsql_info *bi,
|
|
backsql_entryID *id,
|
|
struct berval *entryUUID,
|
|
void *memctx )
|
|
{
|
|
char uuidbuf[ LDAP_LUTIL_UUIDSTR_BUFSIZE ];
|
|
struct berval uuid;
|
|
#ifdef BACKSQL_ARBITRARY_KEY
|
|
int i;
|
|
ber_len_t l, lmax;
|
|
#endif /* BACKSQL_ARBITRARY_KEY */
|
|
|
|
/* entryUUID is generated as "%08x-%04x-%04x-0000-eaddrXXX"
|
|
* with eid_oc_id as %08x and hi and lo eid_id as %04x-%04x */
|
|
assert( bi );
|
|
assert( id );
|
|
assert( entryUUID );
|
|
|
|
#ifdef BACKSQL_ARBITRARY_KEY
|
|
snprintf( uuidbuf, sizeof( uuidbuf ),
|
|
"%08x-0000-0000-0000-000000000000",
|
|
( id->eid_oc_id & 0xFFFFFFFF ) );
|
|
lmax = id->eid_keyval.bv_len < 12 ? id->eid_keyval.bv_len : 12;
|
|
for ( l = 0, i = 9; l < lmax; l++, i += 2 ) {
|
|
switch ( i ) {
|
|
case STRLENOF( "00000000-0000" ):
|
|
case STRLENOF( "00000000-0000-0000" ):
|
|
case STRLENOF( "00000000-0000-0000-0000" ):
|
|
uuidbuf[ i++ ] = '-';
|
|
/* FALLTHRU */
|
|
|
|
default:
|
|
snprintf( &uuidbuf[ i ], 3, "%2x", id->eid_keyval.bv_val[ l ] );
|
|
break;
|
|
}
|
|
}
|
|
#else /* ! BACKSQL_ARBITRARY_KEY */
|
|
/* note: works only with 32 bit architectures... */
|
|
snprintf( uuidbuf, sizeof( uuidbuf ),
|
|
"%08x-%04x-%04x-0000-000000000000",
|
|
( id->eid_oc_id & 0xFFFFFFFF ),
|
|
( ( id->eid_keyval & 0xFFFF0000 ) >> 020 /* 16 */ ),
|
|
( id->eid_keyval & 0xFFFF ) );
|
|
#endif /* ! BACKSQL_ARBITRARY_KEY */
|
|
|
|
uuid.bv_val = uuidbuf;
|
|
uuid.bv_len = strlen( uuidbuf );
|
|
|
|
ber_dupbv_x( entryUUID, &uuid, memctx );
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
backsql_entryUUID_decode(
|
|
struct berval *entryUUID,
|
|
unsigned long *oc_id,
|
|
#ifdef BACKSQL_ARBITRARY_KEY
|
|
struct berval *keyval
|
|
#else /* ! BACKSQL_ARBITRARY_KEY */
|
|
unsigned long *keyval
|
|
#endif /* ! BACKSQL_ARBITRARY_KEY */
|
|
)
|
|
{
|
|
fprintf( stderr, "==> backsql_entryUUID_decode()\n" );
|
|
|
|
*oc_id = ( entryUUID->bv_val[0] << 030 /* 24 */ )
|
|
+ ( entryUUID->bv_val[1] << 020 /* 16 */ )
|
|
+ ( entryUUID->bv_val[2] << 010 /* 8 */ )
|
|
+ entryUUID->bv_val[3];
|
|
|
|
#ifdef BACKSQL_ARBITRARY_KEY
|
|
/* FIXME */
|
|
#else /* ! BACKSQL_ARBITRARY_KEY */
|
|
*keyval = ( entryUUID->bv_val[4] << 030 /* 24 */ )
|
|
+ ( entryUUID->bv_val[5] << 020 /* 16 */ )
|
|
+ ( entryUUID->bv_val[6] << 010 /* 8 */ )
|
|
+ entryUUID->bv_val[7];
|
|
#endif /* ! BACKSQL_ARBITRARY_KEY */
|
|
|
|
fprintf( stderr, "<== backsql_entryUUID_decode(): oc=%lu id=%lu\n",
|
|
*oc_id, *keyval );
|
|
|
|
return LDAP_SUCCESS;
|
|
}
|
|
|