2 * Copyright 1999, Dmitry Kovalev <mit@openldap.org>, All rights reserved.
4 * Redistribution and use in source and binary forms are permitted only
5 * as authorized by the OpenLDAP Public License. A copy of this
6 * license is available at http://www.OpenLDAP.org/license.html or
7 * in file LICENSE in the top-level directory of the distribution.
15 #include <sys/types.h>
16 #include "ac/string.h"
18 #include "ac/stdarg.h"
23 #include "schema-map.h"
26 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
27 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
29 #define BACKSQL_STR_GROW 256
31 char backsql_def_oc_query[] =
32 "SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
33 "FROM ldap_oc_mappings";
34 char backsql_def_needs_select_oc_query[] =
35 "SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
36 "expect_return FROM ldap_oc_mappings";
37 char backsql_def_at_query[] =
38 "SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
39 "param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
41 char backsql_def_delentry_query[] = "DELETE FROM ldap_entries WHERE id=?";
42 char backsql_def_insentry_query[] =
43 "INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
45 char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
46 char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
47 char backsql_id_query[] = "SELECT id,keyval,oc_map_id FROM ldap_entries WHERE ";
48 /* better ?||? or cast(?||? as varchar) */
49 char backsql_def_concat_func[] = "CONCAT(?,?)";
52 char backsql_check_dn_ru_query[] = "SELECT dn_ru from ldap_entries";
55 backsql_strcat( struct berbuf *dest, ... )
58 ber_len_t cdlen, cslen, grow;
62 assert( dest->bb_val.bv_val == NULL
63 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
66 Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n" );
67 #endif /* BACKSQL_TRACE */
69 va_start( strs, dest );
70 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
71 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
73 dest->bb_val.bv_len = 0;
74 dest->bb_len = BACKSQL_STR_GROW;
76 cdlen = dest->bb_val.bv_len;
77 while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
78 cslen = strlen( cstr );
79 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
80 if ( dest->bb_len - cdlen <= cslen ) {
84 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
85 "buflen=%d, cdlen=%d, cslen=%d "
86 "-- reallocating dest\n",
87 dest->bb_len, cdlen + 1, cslen );
88 #endif /* BACKSQL_TRACE */
90 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
91 ( dest->bb_len ) + grow * sizeof( char ) );
92 if ( tmp_dest == NULL ) {
93 Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
94 "could not reallocate string buffer.\n",
98 dest->bb_val.bv_val = tmp_dest;
102 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
103 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
104 #endif /* BACKSQL_TRACE */
106 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
112 Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest='%s')\n",
114 #endif /* BACKSQL_TRACE */
116 dest->bb_val.bv_len = cdlen;
122 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
129 assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
130 assert( dest->bb_val.bv_val == NULL
131 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
134 Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n" );
135 #endif /* BACKSQL_TRACE */
137 va_start( strs, fmt );
138 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
139 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
141 dest->bb_val.bv_len = 0;
142 dest->bb_len = BACKSQL_STR_GROW;
145 cdlen = dest->bb_val.bv_len;
146 for ( ; fmt[0]; fmt++ ) {
147 ber_len_t cslen, grow;
148 char *cstr, cc[ 2 ] = { '\0', '\0' };
151 switch ( fmt[ 0 ] ) {
155 cbv = va_arg( strs, struct berval * );
160 /* length + string */
162 cslen = va_arg( strs, ber_len_t );
163 cstr = va_arg( strs, char * );
168 cstr = va_arg( strs, char * );
169 cslen = strlen( cstr );
175 * `char' is promoted to `int' when passed through `...'
177 cc[0] = va_arg( strs, int );
186 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
187 if ( dest->bb_len - cdlen <= cslen ) {
191 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
192 "buflen=%d, cdlen=%d, cslen=%d "
193 "-- reallocating dest\n",
194 dest->bb_len, cdlen + 1, cslen );
195 #endif /* BACKSQL_TRACE */
197 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
198 ( dest->bb_len ) + grow * sizeof( char ) );
199 if ( tmp_dest == NULL ) {
200 Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
201 "could not reallocate string buffer.\n",
205 dest->bb_val.bv_val = tmp_dest;
206 dest->bb_len += grow * sizeof( char );
209 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
210 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
211 #endif /* BACKSQL_TRACE */
216 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
223 Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest='%s')\n",
225 #endif /* BACKSQL_TRACE */
227 dest->bb_val.bv_len = cdlen;
233 backsql_entry_addattr(
235 struct berval *at_name,
236 struct berval *at_val,
239 AttributeDescription *ad;
244 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
245 "at_name='%s', at_val='%s'\n",
246 at_name->bv_val, at_val->bv_val, 0 );
247 #endif /* BACKSQL_TRACE */
250 rc = slap_bv2ad( at_name, &ad, &text );
251 if ( rc != LDAP_SUCCESS ) {
252 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
253 "failed to find AttributeDescription for '%s'\n",
254 at_name->bv_val, 0, 0 );
258 rc = attr_merge_normalize_one( e, ad, at_val, memctx );
261 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
262 "failed to merge value '%s' for attribute '%s'\n",
263 at_val->bv_val, at_name->bv_val, 0 );
268 Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
269 #endif /* BACKSQL_TRACE */
275 backsql_get_table_spec( char **p )
278 struct berbuf res = BB_NULL;
284 while ( **p && **p != ',' ) {
292 #define BACKSQL_NEXT_WORD { \
293 while ( *s && isspace( (unsigned char)*s ) ) s++; \
294 if ( !*s ) return res.bb_val.bv_val; \
296 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
297 if ( *q ) *q++='\0'; \
302 backsql_strcat( &res, s, NULL );
306 if ( !strcasecmp( s, "as" ) ) {
312 backsql_strcat( &res, " AS ", s, NULL );
313 /* oracle doesn't understand AS :( */
317 backsql_strfcat( &res, "cs", ' ', s );
319 return res.bb_val.bv_val;
323 backsql_merge_from_clause(
324 struct berbuf *dest_from,
325 struct berval *src_from )
327 char *s, *p, *srcc, *pos, e;
328 struct berbuf res = BB_NULL;
331 Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
332 "dest_from='%s',src_from='%s'\n",
333 dest_from ? dest_from->bb_val.bv_val : "<NULL>", src_from, 0 );
334 #endif /* BACKSQL_TRACE */
336 srcc = ch_strdup( src_from->bv_val );
339 if ( dest_from != NULL ) {
344 s = backsql_get_table_spec( &p );
347 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
348 "p='%s' s='%s'\n", p, s, 0 );
349 #endif /* BACKSQL_TRACE */
351 if ( res.bb_val.bv_val == NULL ) {
352 backsql_strcat( &res, s, NULL );
355 pos = strstr( res.bb_val.bv_val, s );
356 if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
357 backsql_strfcat( &res, "cs", ',', s );
367 Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
368 #endif /* BACKSQL_TRACE */
377 * splits a pattern in components separated by '?'
378 * (double ?? are turned into single ? and left in the string)
379 * expected contains the number of expected occurrences of '?'
380 * (a negative value means parse as many as possible)
384 backsql_split_pattern(
385 const char *_pattern,
386 BerVarray *split_pattern,
389 char *pattern, *start, *end;
393 #define SPLIT_CHAR '?'
396 assert( split_pattern );
398 pattern = ch_strdup( _pattern );
401 end = strchr( start, SPLIT_CHAR );
402 for ( ; start; expected-- ) {
403 char *real_end = end;
406 if ( real_end == NULL ) {
407 real_end = start + strlen( start );
409 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
411 AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
412 end = strchr( real_end + 1, SPLIT_CHAR );
416 real_len = real_end - start;
417 if ( real_len == 0 ) {
418 ber_str2bv( "", 0, 1, &bv );
420 ber_str2bv( start, real_len, 1, &bv );
423 ber_bvarray_add( split_pattern, &bv );
425 if ( expected == 0 ) {
435 end = strchr( start, SPLIT_CHAR );
447 backsql_prepare_pattern(
448 BerVarray split_pattern,
453 struct berbuf bb = BB_NULL;
457 for ( i = 0; values[i].bv_val; i++ ) {
458 if ( split_pattern[i].bv_val == NULL ) {
459 ch_free( bb.bb_val.bv_val );
462 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
463 backsql_strfcat( &bb, "b", &values[ i ] );
466 if ( split_pattern[ i ].bv_val == NULL ) {
467 ch_free( bb.bb_val.bv_val );
471 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
478 #endif /* SLAPD_SQL */