git.sur5r.net Git - openldap/blob - servers/slapd/back-sql/util.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2004 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  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>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by Dmitry Kovalev for inclusion
  18  * by OpenLDAP Software.
  19  */
  20
  21 #include "portable.h"
  22
  23 #ifdef SLAPD_SQL
  24
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include "ac/string.h"
  28 #include "ac/ctype.h"
  29 #include "ac/stdarg.h"
  30 #include "slap.h"
  31 #include "lber_pvt.h"
  32 #include "ldap_pvt.h"
  33 #include "back-sql.h"
  34 #include "schema-map.h"
  35 #include "util.h"
  36
  37 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
  38 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
  39
  40 #define BACKSQL_STR_GROW 256
  41
  42 char backsql_def_oc_query[] =
  43         "SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
  44         "FROM ldap_oc_mappings";
  45 char backsql_def_needs_select_oc_query[] =
  46         "SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
  47         "expect_return FROM ldap_oc_mappings";
  48 char backsql_def_at_query[] =
  49         "SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
  50         "param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
  51         "WHERE oc_map_id=?";
  52 char backsql_def_delentry_query[] = "DELETE FROM ldap_entries WHERE id=?";
  53 char backsql_def_insentry_query[] =
  54         "INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
  55         "VALUES (?,?,?,?)";
  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 FROM ldap_entries WHERE ";
  59 /* better ?||? or cast(?||? as varchar) */
  60 char backsql_def_concat_func[] = "CONCAT(?,?)";
  61
  62 /* TimesTen */
  63 char backsql_check_dn_ru_query[] = "SELECT dn_ru from ldap_entries";
  64
  65 struct berbuf *
  66 backsql_strcat( struct berbuf *dest, ... )
  67 {
  68         va_list         strs;
  69         ber_len_t       cdlen, cslen, grow;
  70         char            *cstr;
  71
  72         assert( dest );
  73         assert( dest->bb_val.bv_val == NULL
  74                         || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
  75
  76 #ifdef BACKSQL_TRACE
  77         Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n" );
  78 #endif /* BACKSQL_TRACE */
  79
  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,
  83                                 sizeof( char ) );
  84                 dest->bb_val.bv_len = 0;
  85                 dest->bb_len = BACKSQL_STR_GROW;
  86         }
  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 ) {
  92                         char    *tmp_dest;
  93
  94 #ifdef BACKSQL_TRACE
  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 */
 100
 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",
 106                                         0, 0, 0 );
 107                                 return NULL;
 108                         }
 109                         dest->bb_val.bv_val = tmp_dest;
 110                         dest->bb_len += grow;
 111
 112 #ifdef BACKSQL_TRACE
 113                         Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
 114                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 115 #endif /* BACKSQL_TRACE */
 116                 }
 117                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 118                 cdlen += cslen;
 119         }
 120         va_end( strs );
 121
 122 #ifdef BACKSQL_TRACE
 123         Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest='%s')\n",
 124                         dest, 0, 0 );
 125 #endif /* BACKSQL_TRACE */
 126
 127         dest->bb_val.bv_len = cdlen;
 128
 129         return dest;
 130 }
 131
 132 struct berbuf *
 133 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
 134 {
 135         va_list         strs;
 136         ber_len_t       cdlen;
 137
 138         assert( dest );
 139         assert( fmt );
 140         assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
 141         assert( dest->bb_val.bv_val == NULL
 142                         || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
 143
 144 #ifdef BACKSQL_TRACE
 145         Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n" );
 146 #endif /* BACKSQL_TRACE */
 147
 148         va_start( strs, fmt );
 149         if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
 150                 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
 151                                 sizeof( char ) );
 152                 dest->bb_val.bv_len = 0;
 153                 dest->bb_len = BACKSQL_STR_GROW;
 154         }
 155
 156         cdlen = dest->bb_val.bv_len;
 157         for ( ; fmt[0]; fmt++ ) {
 158                 ber_len_t       cslen, grow;
 159                 char            *cstr, cc[ 2 ] = { '\0', '\0' };
 160                 struct berval   *cbv;
 161
 162                 switch ( fmt[ 0 ] ) {
 163
 164                 /* berval */
 165                 case 'b':
 166                         cbv = va_arg( strs, struct berval * );
 167                         cstr = cbv->bv_val;
 168                         cslen = cbv->bv_len;
 169                         break;
 170
 171                 /* length + string */
 172                 case 'l':
 173                         cslen = va_arg( strs, ber_len_t );
 174                         cstr = va_arg( strs, char * );
 175                         break;
 176
 177                 /* string */
 178                 case 's':
 179                         cstr = va_arg( strs, char * );
 180                         cslen = strlen( cstr );
 181                         break;
 182
 183                 /* char */
 184                 case 'c':
 185                         /*
 186                          * `char' is promoted to `int' when passed through `...'
 187                          */
 188                         cc[0] = va_arg( strs, int );
 189                         cstr = cc;
 190                         cslen = 1;
 191                         break;
 192
 193                 default:
 194                         assert( 0 );
 195                 }
 196
 197                 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
 198                 if ( dest->bb_len - cdlen <= cslen ) {
 199                         char    *tmp_dest;
 200
 201 #ifdef BACKSQL_TRACE
 202                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 203                                 "buflen=%d, cdlen=%d, cslen=%d "
 204                                 "-- reallocating dest\n",
 205                                 dest->bb_len, cdlen + 1, cslen );
 206 #endif /* BACKSQL_TRACE */
 207
 208                         tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
 209                                         ( dest->bb_len ) + grow * sizeof( char ) );
 210                         if ( tmp_dest == NULL ) {
 211                                 Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
 212                                         "could not reallocate string buffer.\n",
 213                                         0, 0, 0 );
 214                                 return NULL;
 215                         }
 216                         dest->bb_val.bv_val = tmp_dest;
 217                         dest->bb_len += grow * sizeof( char );
 218
 219 #ifdef BACKSQL_TRACE
 220                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 221                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 222 #endif /* BACKSQL_TRACE */
 223                 }
 224
 225                 assert( cstr );
 226
 227                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 228                 cdlen += cslen;
 229         }
 230
 231         va_end( strs );
 232
 233 #ifdef BACKSQL_TRACE
 234         Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest='%s')\n",
 235                         dest, 0, 0 );
 236 #endif /* BACKSQL_TRACE */
 237
 238         dest->bb_val.bv_len = cdlen;
 239
 240         return dest;
 241 }
 242
 243 int
 244 backsql_entry_addattr(
 245         Entry           *e,
 246         struct berval   *at_name,
 247         struct berval   *at_val,
 248         void            *memctx )
 249 {
 250         AttributeDescription    *ad;
 251         int                     rc;
 252         const char              *text;
 253
 254 #ifdef BACKSQL_TRACE
 255         Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
 256                 "at_name='%s', at_val='%s'\n",
 257                 at_name->bv_val, at_val->bv_val, 0 );
 258 #endif /* BACKSQL_TRACE */
 259
 260         ad = NULL;
 261         rc = slap_bv2ad( at_name, &ad, &text );
 262         if ( rc != LDAP_SUCCESS ) {
 263                 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
 264                         "failed to find AttributeDescription for '%s'\n",
 265                         at_name->bv_val, 0, 0 );
 266                 return 0;
 267         }
 268
 269         rc = attr_merge_normalize_one( e, ad, at_val, memctx );
 270
 271         if ( rc != 0 ) {
 272                 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(): "
 273                         "failed to merge value '%s' for attribute '%s'\n",
 274                         at_val->bv_val, at_name->bv_val, 0 );
 275                 return 0;
 276         }
 277
 278 #ifdef BACKSQL_TRACE
 279         Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
 280 #endif /* BACKSQL_TRACE */
 281
 282         return 1;
 283 }
 284
 285 char *
 286 backsql_get_table_spec( char **p )
 287 {
 288         char            *s, *q;
 289         struct berbuf   res = BB_NULL;
 290
 291         assert( p );
 292         assert( *p );
 293
 294         s = *p;
 295         while ( **p && **p != ',' ) {
 296                 (*p)++;
 297         }
 298
 299         if ( **p ) {
 300                 *(*p)++ = '\0';
 301         }
 302
 303 #define BACKSQL_NEXT_WORD { \
 304                 while ( *s && isspace( (unsigned char)*s ) ) s++; \
 305                 if ( !*s ) return res.bb_val.bv_val; \
 306                 q = s; \
 307                 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
 308                 if ( *q ) *q++='\0'; \
 309         }
 310
 311         BACKSQL_NEXT_WORD;
 312         /* table name */
 313         backsql_strcat( &res, s, NULL );
 314         s = q;
 315
 316         BACKSQL_NEXT_WORD;
 317         if ( !strcasecmp( s, "as" ) ) {
 318                 s = q;
 319                 BACKSQL_NEXT_WORD;
 320         }
 321
 322 #if 0
 323         backsql_strcat( &res, " AS ", s, NULL );
 324         /* oracle doesn't understand AS :( */
 325 #endif
 326
 327         /* table alias */
 328         backsql_strfcat( &res, "cs", ' ', s );
 329
 330         return res.bb_val.bv_val;
 331 }
 332
 333 int
 334 backsql_merge_from_clause(
 335         struct berbuf   *dest_from,
 336         struct berval   *src_from )
 337 {
 338         char            *s, *p, *srcc, *pos, e;
 339         struct berbuf   res = BB_NULL;
 340
 341 #ifdef BACKSQL_TRACE
 342         Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
 343                 "dest_from='%s',src_from='%s'\n",
 344                 dest_from ? dest_from->bb_val.bv_val : "<NULL>", src_from, 0 );
 345 #endif /* BACKSQL_TRACE */
 346
 347         srcc = ch_strdup( src_from->bv_val );
 348         p = srcc;
 349
 350         if ( dest_from != NULL ) {
 351                 res = *dest_from;
 352         }
 353
 354         while ( *p ) {
 355                 s = backsql_get_table_spec( &p );
 356
 357 #ifdef BACKSQL_TRACE
 358                 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
 359                         "p='%s' s='%s'\n", p, s, 0 );
 360 #endif /* BACKSQL_TRACE */
 361
 362                 if ( res.bb_val.bv_val == NULL ) {
 363                         backsql_strcat( &res, s, NULL );
 364
 365                 } else {
 366                         pos = strstr( res.bb_val.bv_val, s );
 367                         if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
 368                                 backsql_strfcat( &res, "cs", ',', s );
 369                         }
 370                 }
 371
 372                 if ( s ) {
 373                         ch_free( s );
 374                 }
 375         }
 376
 377 #ifdef BACKSQL_TRACE
 378         Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
 379 #endif /* BACKSQL_TRACE */
 380
 381         free( srcc );
 382         *dest_from = res;
 383
 384         return 1;
 385 }
 386
 387 /*
 388  * splits a pattern in components separated by '?'
 389  * (double ?? are turned into single ? and left in the string)
 390  * expected contains the number of expected occurrences of '?'
 391  * (a negative value means parse as many as possible)
 392  */
 393
 394 int
 395 backsql_split_pattern(
 396         const char      *_pattern,
 397         BerVarray       *split_pattern,
 398         int             expected )
 399 {
 400         char            *pattern, *start, *end;
 401         struct berval   bv;
 402         int             rc = 0;
 403
 404 #define SPLIT_CHAR      '?'
 405
 406         assert( _pattern );
 407         assert( split_pattern );
 408
 409         pattern = ch_strdup( _pattern );
 410
 411         start = pattern;
 412         end = strchr( start, SPLIT_CHAR );
 413         for ( ; start; expected-- ) {
 414                 char            *real_end = end;
 415                 ber_len_t       real_len;
 416
 417                 if ( real_end == NULL ) {
 418                         real_end = start + strlen( start );
 419
 420                 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
 421                         expected++;
 422                         AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
 423                         end = strchr( real_end + 1, SPLIT_CHAR );
 424                         continue;
 425                 }
 426
 427                 real_len = real_end - start;
 428                 if ( real_len == 0 ) {
 429                         ber_str2bv( "", 0, 1, &bv );
 430                 } else {
 431                         ber_str2bv( start, real_len, 1, &bv );
 432                 }
 433
 434                 ber_bvarray_add( split_pattern, &bv );
 435
 436                 if ( expected == 0 ) {
 437                         if ( end != NULL ) {
 438                                 rc = -1;
 439                                 goto done;
 440                         }
 441                         break;
 442                 }
 443
 444                 if ( end != NULL ) {
 445                         start = end + 1;
 446                         end = strchr( start, SPLIT_CHAR );
 447                 }
 448         }
 449
 450 done:;
 451
 452         ch_free( pattern );
 453
 454         return rc;
 455 }
 456
 457 int
 458 backsql_prepare_pattern(
 459         BerVarray       split_pattern,
 460         BerVarray       values,
 461         struct berval   *res )
 462 {
 463         int             i;
 464         struct berbuf   bb = BB_NULL;
 465
 466         assert( res );
 467
 468         for ( i = 0; values[i].bv_val; i++ ) {
 469                 if ( split_pattern[i].bv_val == NULL ) {
 470                         ch_free( bb.bb_val.bv_val );
 471                         return -1;
 472                 }
 473                 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 474                 backsql_strfcat( &bb, "b", &values[ i ] );
 475         }
 476
 477         if ( split_pattern[ i ].bv_val == NULL ) {
 478                 ch_free( bb.bb_val.bv_val );
 479                 return -1;
 480         }
 481
 482         backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 483
 484         *res = bb.bb_val;
 485
 486         return 0;
 487 }
 488
 489 #endif /* SLAPD_SQL */
 490