-/*
- * Copyright 1999, Dmitry Kovalev <mit@openldap.org>, All rights reserved.
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1999-2012 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.
*
- * Redistribution and use in source and binary forms are permitted only
- * as authorized by the OpenLDAP Public License. A copy of this
- * license is available at http://www.OpenLDAP.org/license.html or
- * in file LICENSE in the top-level directory of the distribution.
+ * 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"
-#ifdef SLAPD_SQL
-
#include <stdio.h>
#include <sys/types.h>
#include "ac/string.h"
#include "ac/ctype.h"
#include "ac/stdarg.h"
+
#include "slap.h"
-#include "lber_pvt.h"
-#include "ldap_pvt.h"
-#include "back-sql.h"
-#include "schema-map.h"
-#include "util.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[] =
+const 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[] =
+const 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[] =
+const 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_query[] = "DELETE FROM ldap_entries WHERE id=?";
-char backsql_def_insentry_query[] =
+const char backsql_def_delentry_stmt[] = "DELETE FROM ldap_entries WHERE id=?";
+const char backsql_def_renentry_stmt[] =
+ "UPDATE ldap_entries SET dn=?,parent=?,keyval=? WHERE id=?";
+const char backsql_def_insentry_stmt[] =
"INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
"VALUES (?,?,?,?)";
-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 FROM ldap_entries WHERE ";
+const char backsql_def_delobjclasses_stmt[] = "DELETE FROM ldap_entry_objclasses "
+ "WHERE entry_id=?";
+const char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
+const char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
+const 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(?,?)";
+const char backsql_def_concat_func[] = "CONCAT(?,?)";
/* TimesTen */
-char backsql_check_dn_ru_query[] = "SELECT dn_ru from ldap_entries";
+const char backsql_check_dn_ru_query[] = "SELECT dn_ru FROM ldap_entries";
-struct berval *
-backsql_strcat( struct berval *dest, ber_len_t *buflen, ... )
+struct berbuf *
+backsql_strcat_x( struct berbuf *dest, void *memctx, ... )
{
va_list strs;
ber_len_t cdlen, cslen, grow;
char *cstr;
- assert( dest );
- assert( dest->bv_val == NULL
- || dest->bv_len == strlen( dest->bv_val ) );
+ assert( dest != NULL );
+ 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" );
+ Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
- va_start( strs, buflen );
- if ( dest->bv_val == NULL || *buflen == 0 ) {
- dest->bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
- sizeof( char ) );
- dest->bv_len = 0;
- *buflen = BACKSQL_STR_GROW;
+ va_start( strs, memctx );
+ if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
+ dest->bb_val.bv_val = (char *)ber_memalloc_x( BACKSQL_STR_GROW * sizeof( char ), memctx );
+ dest->bb_val.bv_len = 0;
+ dest->bb_len = BACKSQL_STR_GROW;
}
- cdlen = dest->bv_len;
+ cdlen = dest->bb_val.bv_len;
while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
cslen = strlen( cstr );
grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
- if ( *buflen - cdlen <= 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",
- *buflen, cdlen + 1, cslen );
+ dest->bb_len, cdlen + 1, cslen );
#endif /* BACKSQL_TRACE */
- tmp_dest = (char *)ch_realloc( dest->bv_val,
- ( *buflen ) + grow * sizeof( char ) );
+ tmp_dest = (char *)ber_memrealloc_x( dest->bb_val.bv_val,
+ dest->bb_len + grow * sizeof( char ), memctx );
if ( tmp_dest == NULL ) {
Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
"could not reallocate string buffer.\n",
0, 0, 0 );
return NULL;
}
- dest->bv_val = tmp_dest;
- *buflen += grow;
+ 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", *buflen, dest, 0 );
+ "new buflen=%d, dest=%p\n",
+ dest->bb_len, dest, 0 );
#endif /* BACKSQL_TRACE */
}
- AC_MEMCPY( dest->bv_val + cdlen, cstr, cslen + 1 );
+ 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, 0, 0 );
+ Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest=\"%s\")\n",
+ dest->bb_val.bv_val, 0, 0 );
#endif /* BACKSQL_TRACE */
- dest->bv_len = cdlen;
+ dest->bb_val.bv_len = cdlen;
return dest;
}
-struct berval *
-backsql_strfcat( struct berval *dest, ber_len_t *buflen, const char *fmt, ... )
+struct berbuf *
+backsql_strfcat_x( struct berbuf *dest, void *memctx, const char *fmt, ... )
{
va_list strs;
ber_len_t cdlen;
- assert( dest );
- assert( buflen );
- assert( fmt );
- assert( *buflen == 0 || *buflen > dest->bv_len );
- assert( dest->bv_val == NULL
- || dest->bv_len == strlen( dest->bv_val ) );
+ assert( dest != NULL );
+ assert( fmt != NULL );
+ 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" );
+ Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n", 0, 0, 0 );
#endif /* BACKSQL_TRACE */
va_start( strs, fmt );
- if ( dest->bv_val == NULL || *buflen == 0 ) {
- dest->bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
- sizeof( char ) );
- dest->bv_len = 0;
- *buflen = BACKSQL_STR_GROW;
+ if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
+ dest->bb_val.bv_val = (char *)ber_memalloc_x( BACKSQL_STR_GROW * sizeof( char ), memctx );
+ dest->bb_val.bv_len = 0;
+ dest->bb_len = BACKSQL_STR_GROW;
}
- cdlen = dest->bv_len;
+ cdlen = dest->bb_val.bv_len;
for ( ; fmt[0]; fmt++ ) {
ber_len_t cslen, grow;
char *cstr, cc[ 2 ] = { '\0', '\0' };
cslen = va_arg( strs, ber_len_t );
cstr = va_arg( strs, char * );
break;
-
+
/* string */
case 's':
cstr = va_arg( strs, char * );
}
grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
- if ( *buflen - cdlen <= 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",
- *buflen, cdlen + 1, cslen );
+ dest->bb_len, cdlen + 1, cslen );
#endif /* BACKSQL_TRACE */
- tmp_dest = (char *)ch_realloc( dest->bv_val,
- ( *buflen ) + grow * sizeof( char ) );
+ tmp_dest = (char *)ber_memrealloc_x( dest->bb_val.bv_val,
+ ( dest->bb_len ) + grow * sizeof( char ), memctx );
if ( tmp_dest == NULL ) {
Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
"could not reallocate string buffer.\n",
0, 0, 0 );
return NULL;
}
- dest->bv_val = tmp_dest;
- *buflen += grow * sizeof( char );
+ 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", *buflen, dest, 0 );
+ "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
#endif /* BACKSQL_TRACE */
}
- assert( cstr );
+ assert( cstr != NULL );
- AC_MEMCPY( dest->bv_val + cdlen, cstr, cslen + 1 );
+ 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, 0, 0 );
+ Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest=\"%s\")\n",
+ dest->bb_val.bv_val, 0, 0 );
#endif /* BACKSQL_TRACE */
- dest->bv_len = cdlen;
+ dest->bb_val.bv_len = cdlen;
return dest;
}
int
backsql_entry_addattr(
- Entry *e,
- struct berval *at_name,
- struct berval *at_val,
- void *memctx )
+ Entry *e,
+ AttributeDescription *ad,
+ struct berval *val,
+ void *memctx )
{
- AttributeDescription *ad;
int rc;
- const char *text;
#ifdef BACKSQL_TRACE
- Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
- "at_name='%s', at_val='%s'\n",
- at_name->bv_val, at_val->bv_val, 0 );
+ 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 */
- ad = NULL;
- rc = slap_bv2ad( at_name, &ad, &text );
- if ( rc != LDAP_SUCCESS ) {
- Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
- "failed to find AttributeDescription for '%s'\n",
- at_name->bv_val, 0, 0 );
- return 0;
- }
-
- rc = attr_merge_normalize_one( e, ad, at_val, memctx );
+ rc = attr_merge_normalize_one( e, ad, val, memctx );
- if ( rc != 0 ) {
- Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
- "failed to merge value '%s' for attribute '%s'\n",
- at_val->bv_val, at_name->bv_val, 0 );
- return 0;
+ 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_query_addattr()\n", 0, 0, 0 );
+ Debug( LDAP_DEBUG_TRACE, "<==backsql_entry_addattr(\"%s\")\n",
+ e->e_name.bv_val, 0, 0 );
#endif /* BACKSQL_TRACE */
- return 1;
+ return LDAP_SUCCESS;
}
-char *
-backsql_get_table_spec( char **p )
+static char *
+backsql_get_table_spec( backsql_info *bi, char **p )
{
char *s, *q;
- struct berval res = BER_BVNULL;
- ber_len_t res_len = 0;
+ struct berbuf res = BB_NULL;
- assert( p );
- assert( *p );
+ assert( p != NULL );
+ assert( *p != NULL );
s = *p;
while ( **p && **p != ',' ) {
#define BACKSQL_NEXT_WORD { \
while ( *s && isspace( (unsigned char)*s ) ) s++; \
- if ( !*s ) return res.bv_val; \
+ 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, &res_len, s, NULL );
+ backsql_strcat_x( &res, NULL, s, NULL );
s = q;
BACKSQL_NEXT_WORD;
- if ( !strcasecmp( s, "as" ) ) {
+ if ( strcasecmp( s, "AS" ) == 0 ) {
s = q;
BACKSQL_NEXT_WORD;
}
-#if 0
- backsql_strcat( &res, &res_len, " AS ", s, NULL );
- /* oracle doesn't understand AS :( */
-#endif
-
- /* table alias */
- backsql_strfcat( &res, &res_len, "cs", ' ', s );
+ /* oracle doesn't understand "AS" :( and other RDBMSes don't need it */
+ backsql_strfcat_x( &res, NULL, "lbbsb",
+ STRLENOF( " " ), " ",
+ &bi->sql_aliasing,
+ &bi->sql_aliasing_quote,
+ s,
+ &bi->sql_aliasing_quote );
- return res.bv_val;
+ return res.bb_val.bv_val;
}
int
backsql_merge_from_clause(
- struct berval *dest_from,
- ber_len_t *dest_len,
+ backsql_info *bi,
+ struct berbuf *dest_from,
struct berval *src_from )
{
char *s, *p, *srcc, *pos, e;
- struct berval res = { 0 , NULL };
+ 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->bv_val : "<NULL>", src_from, 0 );
+ "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 );
}
while ( *p ) {
- s = backsql_get_table_spec( &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 );
+ "p=\"%s\" s=\"%s\"\n", p, s, 0 );
#endif /* BACKSQL_TRACE */
- if ( res.bv_val == NULL ) {
- backsql_strcat( &res, dest_len, s, NULL );
+ if ( BER_BVISNULL( &res.bb_val ) ) {
+ backsql_strcat_x( &res, NULL, s, NULL );
} else {
- pos = strstr( res.bv_val, s );
- if ( pos == NULL ) {
- backsql_strfcat( &res, dest_len, "cs", ',', s );
- } else if ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) {
- backsql_strfcat( &res, dest_len, "cs", ',', s );
+ pos = strstr( res.bb_val.bv_val, s );
+ if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
+ backsql_strfcat_x( &res, NULL, "cs", ',', s );
}
}
#define SPLIT_CHAR '?'
- assert( _pattern );
- assert( split_pattern );
+ assert( _pattern != NULL );
+ assert( split_pattern != NULL );
pattern = ch_strdup( _pattern );
BerVarray values,
struct berval *res )
{
- ber_len_t len = 0;
int i;
+ struct berbuf bb = BB_NULL;
- res->bv_val = NULL;
- res->bv_len = 0;
+ assert( res != NULL );
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( res, &len, "b", &split_pattern[ i ] );
- backsql_strfcat( res, &len, "b", &values[ i ] );
+ backsql_strfcat_x( &bb, NULL, "b", &split_pattern[ i ] );
+ backsql_strfcat_x( &bb, NULL, "b", &values[ i ] );
}
if ( split_pattern[ i ].bv_val == NULL ) {
+ ch_free( bb.bb_val.bv_val );
return -1;
}
- backsql_strfcat( res, &len, "b", &split_pattern[ i ] );
+ backsql_strfcat_x( &bb, NULL, "b", &split_pattern[ i ] );
+
+ *res = bb.bb_val;
return 0;
}
-#endif /* SLAPD_SQL */
+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 != NULL );
+ assert( id != NULL );
+ assert( entryUUID != NULL );
+
+#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",
+ ( (unsigned)id->eid_oc_id & 0xFFFFFFFF ),
+ ( ( (unsigned)id->eid_keyval & 0xFFFF0000 ) >> 020 /* 16 */ ),
+ ( (unsigned)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 */
+ )
+{
+#if 0
+ fprintf( stderr, "==> backsql_entryUUID_decode()\n" );
+#endif
+
+ *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 */
+
+#if 0
+ fprintf( stderr, "<== backsql_entryUUID_decode(): oc=%lu id=%lu\n",
+ *oc_id, *keyval );
+#endif
+
+ return LDAP_SUCCESS;
+}
projects / openldap / blobdiff