2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1999-2005 The OpenLDAP Foundation.
5 * Portions Copyright 1999 Dmitry Kovalev.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted only as authorized by the OpenLDAP
12 * A copy of this license is available in the file LICENSE in the
13 * top-level directory of the distribution or, alternatively, at
14 * <http://www.OpenLDAP.org/license.html>.
17 * This work was initially developed by Dmitry Kovalev for inclusion
18 * by OpenLDAP Software.
24 #include <sys/types.h>
25 #include "ac/string.h"
27 #include "ac/stdarg.h"
30 #include "proto-sql.h"
33 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
34 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
36 #define BACKSQL_STR_GROW 256
38 char backsql_def_oc_query[] =
39 "SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
40 "FROM ldap_oc_mappings";
41 char backsql_def_needs_select_oc_query[] =
42 "SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
43 "expect_return FROM ldap_oc_mappings";
44 char backsql_def_at_query[] =
45 "SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
46 "param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
48 char backsql_def_delentry_query[] = "DELETE FROM ldap_entries WHERE id=?";
49 char backsql_def_insentry_query[] =
50 "INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
52 char backsql_def_delobjclasses_query[] = "DELETE FROM ldap_entry_objclasses "
54 char backsql_def_delreferrals_query[] = "DELETE FROM ldap_referrals "
56 char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
57 char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
58 char backsql_id_query[] = "SELECT id,keyval,oc_map_id,dn FROM ldap_entries WHERE ";
59 /* better ?||? or cast(?||? as varchar) */
60 char backsql_def_concat_func[] = "CONCAT(?,?)";
63 char backsql_check_dn_ru_query[] = "SELECT dn_ru FROM ldap_entries";
66 backsql_strcat( struct berbuf *dest, ... )
69 ber_len_t cdlen, cslen, grow;
73 assert( dest->bb_val.bv_val == NULL
74 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
77 Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n", 0, 0, 0 );
78 #endif /* BACKSQL_TRACE */
80 va_start( strs, dest );
81 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
82 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
84 dest->bb_val.bv_len = 0;
85 dest->bb_len = BACKSQL_STR_GROW;
87 cdlen = dest->bb_val.bv_len;
88 while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
89 cslen = strlen( cstr );
90 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
91 if ( dest->bb_len - cdlen <= cslen ) {
95 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
96 "buflen=%d, cdlen=%d, cslen=%d "
97 "-- reallocating dest\n",
98 dest->bb_len, cdlen + 1, cslen );
99 #endif /* BACKSQL_TRACE */
101 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
102 ( dest->bb_len ) + grow * sizeof( char ) );
103 if ( tmp_dest == NULL ) {
104 Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
105 "could not reallocate string buffer.\n",
109 dest->bb_val.bv_val = tmp_dest;
110 dest->bb_len += grow;
113 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
114 "new buflen=%d, dest=%p\n",
115 dest->bb_len, dest, 0 );
116 #endif /* BACKSQL_TRACE */
118 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
124 Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest=\"%s\")\n",
125 dest->bb_val.bv_val, 0, 0 );
126 #endif /* BACKSQL_TRACE */
128 dest->bb_val.bv_len = cdlen;
134 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
141 assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
142 assert( dest->bb_val.bv_val == NULL
143 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
146 Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n", 0, 0, 0 );
147 #endif /* BACKSQL_TRACE */
149 va_start( strs, fmt );
150 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
151 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
153 dest->bb_val.bv_len = 0;
154 dest->bb_len = BACKSQL_STR_GROW;
157 cdlen = dest->bb_val.bv_len;
158 for ( ; fmt[0]; fmt++ ) {
159 ber_len_t cslen, grow;
160 char *cstr, cc[ 2 ] = { '\0', '\0' };
163 switch ( fmt[ 0 ] ) {
167 cbv = va_arg( strs, struct berval * );
172 /* length + string */
174 cslen = va_arg( strs, ber_len_t );
175 cstr = va_arg( strs, char * );
180 cstr = va_arg( strs, char * );
181 cslen = strlen( cstr );
187 * `char' is promoted to `int' when passed through `...'
189 cc[0] = va_arg( strs, int );
198 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
199 if ( dest->bb_len - cdlen <= cslen ) {
203 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
204 "buflen=%d, cdlen=%d, cslen=%d "
205 "-- reallocating dest\n",
206 dest->bb_len, cdlen + 1, cslen );
207 #endif /* BACKSQL_TRACE */
209 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
210 ( dest->bb_len ) + grow * sizeof( char ) );
211 if ( tmp_dest == NULL ) {
212 Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
213 "could not reallocate string buffer.\n",
217 dest->bb_val.bv_val = tmp_dest;
218 dest->bb_len += grow * sizeof( char );
221 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
222 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
223 #endif /* BACKSQL_TRACE */
228 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
235 Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest=\"%s\")\n",
236 dest->bb_val.bv_val, 0, 0 );
237 #endif /* BACKSQL_TRACE */
239 dest->bb_val.bv_len = cdlen;
245 backsql_entry_addattr(
247 struct berval *at_name,
248 struct berval *at_val,
251 AttributeDescription *ad;
256 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
257 "at_name=\"%s\", at_val=\"%s\"\n",
258 at_name->bv_val, at_val->bv_val, 0 );
259 #endif /* BACKSQL_TRACE */
262 rc = slap_bv2ad( at_name, &ad, &text );
263 if ( rc != LDAP_SUCCESS ) {
264 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
265 "failed to find AttributeDescription for \"%s\"\n",
266 at_name->bv_val, 0, 0 );
270 rc = attr_merge_normalize_one( e, ad, at_val, memctx );
273 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
274 "failed to merge value \"%s\" for attribute \"%s\"\n",
275 at_val->bv_val, at_name->bv_val, 0 );
280 Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
281 #endif /* BACKSQL_TRACE */
287 backsql_get_table_spec( char **p )
290 struct berbuf res = BB_NULL;
296 while ( **p && **p != ',' ) {
304 #define BACKSQL_NEXT_WORD { \
305 while ( *s && isspace( (unsigned char)*s ) ) s++; \
306 if ( !*s ) return res.bb_val.bv_val; \
308 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
309 if ( *q ) *q++='\0'; \
314 backsql_strcat( &res, s, NULL );
318 if ( strcasecmp( s, "AS" ) == 0 ) {
323 /* oracle doesn't understand "AS" :( and other RDBMSes don't need it */
324 #ifdef BACKSQL_ALIASING_QUOTE
325 backsql_strfcat( &res, "scsc", " " BACKSQL_ALIASING,
326 BACKSQL_ALIASING_QUOTE, s, BACKSQL_ALIASING_QUOTE );
327 #else /* ! BACKSQL_ALIASING */
328 backsql_strcat( &res, " " BACKSQL_ALIASING, s, NULL );
329 #endif /* ! BACKSQL_ALIASING */
331 return res.bb_val.bv_val;
335 backsql_merge_from_clause(
336 struct berbuf *dest_from,
337 struct berval *src_from )
339 char *s, *p, *srcc, *pos, e;
340 struct berbuf res = BB_NULL;
343 Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
344 "dest_from=\"%s\",src_from=\"%s\"\n",
345 dest_from ? dest_from->bb_val.bv_val : "<NULL>",
346 src_from->bv_val, 0 );
347 #endif /* BACKSQL_TRACE */
349 srcc = ch_strdup( src_from->bv_val );
352 if ( dest_from != NULL ) {
357 s = backsql_get_table_spec( &p );
360 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
361 "p=\"%s\" s=\"%s\"\n", p, s, 0 );
362 #endif /* BACKSQL_TRACE */
364 if ( res.bb_val.bv_val == NULL ) {
365 backsql_strcat( &res, s, NULL );
368 pos = strstr( res.bb_val.bv_val, s );
369 if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
370 backsql_strfcat( &res, "cs", ',', s );
380 Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
381 #endif /* BACKSQL_TRACE */
390 * splits a pattern in components separated by '?'
391 * (double ?? are turned into single ? and left in the string)
392 * expected contains the number of expected occurrences of '?'
393 * (a negative value means parse as many as possible)
397 backsql_split_pattern(
398 const char *_pattern,
399 BerVarray *split_pattern,
402 char *pattern, *start, *end;
406 #define SPLIT_CHAR '?'
409 assert( split_pattern );
411 pattern = ch_strdup( _pattern );
414 end = strchr( start, SPLIT_CHAR );
415 for ( ; start; expected-- ) {
416 char *real_end = end;
419 if ( real_end == NULL ) {
420 real_end = start + strlen( start );
422 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
424 AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
425 end = strchr( real_end + 1, SPLIT_CHAR );
429 real_len = real_end - start;
430 if ( real_len == 0 ) {
431 ber_str2bv( "", 0, 1, &bv );
433 ber_str2bv( start, real_len, 1, &bv );
436 ber_bvarray_add( split_pattern, &bv );
438 if ( expected == 0 ) {
448 end = strchr( start, SPLIT_CHAR );
460 backsql_prepare_pattern(
461 BerVarray split_pattern,
466 struct berbuf bb = BB_NULL;
470 for ( i = 0; values[i].bv_val; i++ ) {
471 if ( split_pattern[i].bv_val == NULL ) {
472 ch_free( bb.bb_val.bv_val );
475 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
476 backsql_strfcat( &bb, "b", &values[ i ] );
479 if ( split_pattern[ i ].bv_val == NULL ) {
480 ch_free( bb.bb_val.bv_val );
484 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
495 struct berval *entryUUID,
498 char uuidbuf[ LDAP_LUTIL_UUIDSTR_BUFSIZE ];
500 #ifdef BACKSQL_ARBITRARY_KEY
503 #endif /* BACKSQL_ARBITRARY_KEY */
505 /* entryUUID is generated as "%08x-%04x-%04x-0000-eaddrXXX"
506 * with eid_oc_id as %08x and hi and lo eid_id as %04x-%04x */
511 #ifdef BACKSQL_ARBITRARY_KEY
512 snprintf( uuidbuf, sizeof( uuidbuf ),
513 "%08x-0000-0000-0000-000000000000",
514 ( id->eid_oc_id & 0xFFFFFFFF ) );
515 lmax = id->eid_keyval.bv_len < 12 ? id->eid_keyval.bv_len : 12;
516 for ( l = 0, i = 9; l < lmax; l++, i += 2 ) {
518 case STRLENOF( "00000000-0000" ):
519 case STRLENOF( "00000000-0000-0000" ):
520 case STRLENOF( "00000000-0000-0000-0000" ):
521 uuidbuf[ i++ ] = '-';
525 snprintf( &uuidbuf[ i ], 3, "%2x", id->eid_keyval.bv_val[ l ] );
529 #else /* ! BACKSQL_ARBITRARY_KEY */
530 /* note: works only with 32 bit architectures... */
531 snprintf( uuidbuf, sizeof( uuidbuf ),
532 "%08x-%04x-%04x-0000-000000000000",
533 ( id->eid_oc_id & 0xFFFFFFFF ),
534 ( ( id->eid_keyval & 0xFFFF0000 ) >> 16 ),
535 ( id->eid_keyval & 0xFFFF ) );
536 #endif /* ! BACKSQL_ARBITRARY_KEY */
538 uuid.bv_val = uuidbuf;
539 uuid.bv_len = strlen( uuidbuf );
541 ber_dupbv_x( entryUUID, &uuid, memctx );
547 backsql_entryUUID_decode(
548 struct berval *entryUUID,
549 unsigned long *oc_id,
550 #ifdef BACKSQL_ARBITRARY_KEY
551 struct berval *keyval
552 #else /* ! BACKSQL_ARBITRARY_KEY */
553 unsigned long *keyval
554 #endif /* ! BACKSQL_ARBITRARY_KEY */
557 fprintf( stderr, "==> backsql_entryUUID_decode()\n" );
559 *oc_id = ( entryUUID->bv_val[0] << 3 )
560 + ( entryUUID->bv_val[1] << 2 )
561 + ( entryUUID->bv_val[2] << 1 )
562 + entryUUID->bv_val[3];
564 #ifdef BACKSQL_ARBITRARY_KEY
565 #else /* ! BACKSQL_ARBITRARY_KEY */
566 *keyval = ( entryUUID->bv_val[4] << 3 )
567 + ( entryUUID->bv_val[5] << 2 )
568 + ( entryUUID->bv_val[6] << 1 )
569 + entryUUID->bv_val[7];
570 #endif /* ! BACKSQL_ARBITRARY_KEY */
572 fprintf( stderr, "<== backsql_entryUUID_decode(): oc=%lu id=%lu\n",