2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 * Copyright 1999-2004 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.
26 #include <sys/types.h>
27 #include "ac/string.h"
29 #include "ac/stdarg.h"
34 #include "proto-sql.h"
36 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
37 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
39 #define BACKSQL_STR_GROW 256
41 char backsql_def_oc_query[] =
42 "SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
43 "FROM ldap_oc_mappings";
44 char backsql_def_needs_select_oc_query[] =
45 "SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
46 "expect_return FROM ldap_oc_mappings";
47 char backsql_def_at_query[] =
48 "SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
49 "param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
51 char backsql_def_delentry_query[] = "DELETE FROM ldap_entries WHERE id=?";
52 char backsql_def_insentry_query[] =
53 "INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
55 char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
56 char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
57 char backsql_id_query[] = "SELECT id,keyval,oc_map_id FROM ldap_entries WHERE ";
58 /* better ?||? or cast(?||? as varchar) */
59 char backsql_def_concat_func[] = "CONCAT(?,?)";
62 char backsql_check_dn_ru_query[] = "SELECT dn_ru from ldap_entries";
65 backsql_strcat( struct berbuf *dest, ... )
68 ber_len_t cdlen, cslen, grow;
72 assert( dest->bb_val.bv_val == NULL
73 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
76 Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n" );
77 #endif /* BACKSQL_TRACE */
79 va_start( strs, dest );
80 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
81 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
83 dest->bb_val.bv_len = 0;
84 dest->bb_len = BACKSQL_STR_GROW;
86 cdlen = dest->bb_val.bv_len;
87 while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
88 cslen = strlen( cstr );
89 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
90 if ( dest->bb_len - cdlen <= cslen ) {
94 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
95 "buflen=%d, cdlen=%d, cslen=%d "
96 "-- reallocating dest\n",
97 dest->bb_len, cdlen + 1, cslen );
98 #endif /* BACKSQL_TRACE */
100 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
101 ( dest->bb_len ) + grow * sizeof( char ) );
102 if ( tmp_dest == NULL ) {
103 Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
104 "could not reallocate string buffer.\n",
108 dest->bb_val.bv_val = tmp_dest;
109 dest->bb_len += grow;
112 Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
113 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
114 #endif /* BACKSQL_TRACE */
116 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
122 Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest='%s')\n",
124 #endif /* BACKSQL_TRACE */
126 dest->bb_val.bv_len = cdlen;
132 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
139 assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
140 assert( dest->bb_val.bv_val == NULL
141 || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
144 Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n" );
145 #endif /* BACKSQL_TRACE */
147 va_start( strs, fmt );
148 if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
149 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
151 dest->bb_val.bv_len = 0;
152 dest->bb_len = BACKSQL_STR_GROW;
155 cdlen = dest->bb_val.bv_len;
156 for ( ; fmt[0]; fmt++ ) {
157 ber_len_t cslen, grow;
158 char *cstr, cc[ 2 ] = { '\0', '\0' };
161 switch ( fmt[ 0 ] ) {
165 cbv = va_arg( strs, struct berval * );
170 /* length + string */
172 cslen = va_arg( strs, ber_len_t );
173 cstr = va_arg( strs, char * );
178 cstr = va_arg( strs, char * );
179 cslen = strlen( cstr );
185 * `char' is promoted to `int' when passed through `...'
187 cc[0] = va_arg( strs, int );
196 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
197 if ( dest->bb_len - cdlen <= cslen ) {
201 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
202 "buflen=%d, cdlen=%d, cslen=%d "
203 "-- reallocating dest\n",
204 dest->bb_len, cdlen + 1, cslen );
205 #endif /* BACKSQL_TRACE */
207 tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
208 ( dest->bb_len ) + grow * sizeof( char ) );
209 if ( tmp_dest == NULL ) {
210 Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
211 "could not reallocate string buffer.\n",
215 dest->bb_val.bv_val = tmp_dest;
216 dest->bb_len += grow * sizeof( char );
219 Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
220 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
221 #endif /* BACKSQL_TRACE */
226 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
233 Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest='%s')\n",
235 #endif /* BACKSQL_TRACE */
237 dest->bb_val.bv_len = cdlen;
243 backsql_entry_addattr(
245 struct berval *at_name,
246 struct berval *at_val,
249 AttributeDescription *ad;
254 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
255 "at_name='%s', at_val='%s'\n",
256 at_name->bv_val, at_val->bv_val, 0 );
257 #endif /* BACKSQL_TRACE */
260 rc = slap_bv2ad( at_name, &ad, &text );
261 if ( rc != LDAP_SUCCESS ) {
262 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
263 "failed to find AttributeDescription for '%s'\n",
264 at_name->bv_val, 0, 0 );
268 rc = attr_merge_normalize_one( e, ad, at_val, memctx );
271 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
272 "failed to merge value '%s' for attribute '%s'\n",
273 at_val->bv_val, at_name->bv_val, 0 );
278 Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
279 #endif /* BACKSQL_TRACE */
285 backsql_get_table_spec( char **p )
288 struct berbuf res = BB_NULL;
294 while ( **p && **p != ',' ) {
302 #define BACKSQL_NEXT_WORD { \
303 while ( *s && isspace( (unsigned char)*s ) ) s++; \
304 if ( !*s ) return res.bb_val.bv_val; \
306 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
307 if ( *q ) *q++='\0'; \
312 backsql_strcat( &res, s, NULL );
316 if ( !strcasecmp( s, "as" ) ) {
322 backsql_strcat( &res, " AS ", s, NULL );
323 /* oracle doesn't understand AS :( and other RDBMSes don't need it */
327 backsql_strfcat( &res, "cs", ' ', s );
329 return res.bb_val.bv_val;
333 backsql_merge_from_clause(
334 struct berbuf *dest_from,
335 struct berval *src_from )
337 char *s, *p, *srcc, *pos, e;
338 struct berbuf res = BB_NULL;
341 Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
342 "dest_from='%s',src_from='%s'\n",
343 dest_from ? dest_from->bb_val.bv_val : "<NULL>", src_from, 0 );
344 #endif /* BACKSQL_TRACE */
346 srcc = ch_strdup( src_from->bv_val );
349 if ( dest_from != NULL ) {
354 s = backsql_get_table_spec( &p );
357 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
358 "p='%s' s='%s'\n", p, s, 0 );
359 #endif /* BACKSQL_TRACE */
361 if ( res.bb_val.bv_val == NULL ) {
362 backsql_strcat( &res, s, NULL );
365 pos = strstr( res.bb_val.bv_val, s );
366 if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
367 backsql_strfcat( &res, "cs", ',', s );
377 Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
378 #endif /* BACKSQL_TRACE */
387 * splits a pattern in components separated by '?'
388 * (double ?? are turned into single ? and left in the string)
389 * expected contains the number of expected occurrences of '?'
390 * (a negative value means parse as many as possible)
394 backsql_split_pattern(
395 const char *_pattern,
396 BerVarray *split_pattern,
399 char *pattern, *start, *end;
403 #define SPLIT_CHAR '?'
406 assert( split_pattern );
408 pattern = ch_strdup( _pattern );
411 end = strchr( start, SPLIT_CHAR );
412 for ( ; start; expected-- ) {
413 char *real_end = end;
416 if ( real_end == NULL ) {
417 real_end = start + strlen( start );
419 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
421 AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
422 end = strchr( real_end + 1, SPLIT_CHAR );
426 real_len = real_end - start;
427 if ( real_len == 0 ) {
428 ber_str2bv( "", 0, 1, &bv );
430 ber_str2bv( start, real_len, 1, &bv );
433 ber_bvarray_add( split_pattern, &bv );
435 if ( expected == 0 ) {
445 end = strchr( start, SPLIT_CHAR );
457 backsql_prepare_pattern(
458 BerVarray split_pattern,
463 struct berbuf bb = BB_NULL;
467 for ( i = 0; values[i].bv_val; i++ ) {
468 if ( split_pattern[i].bv_val == NULL ) {
469 ch_free( bb.bb_val.bv_val );
472 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
473 backsql_strfcat( &bb, "b", &values[ i ] );
476 if ( split_pattern[ i ].bv_val == NULL ) {
477 ch_free( bb.bb_val.bv_val );
481 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
488 #endif /* SLAPD_SQL */