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

   1 /*
   2  *       Copyright 1999, Dmitry Kovalev <mit@openldap.org>, All rights reserved.
   3  *
   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.
   8  */
   9
  10 #include "portable.h"
  11
  12 #ifdef SLAPD_SQL
  13
  14 #include <stdio.h>
  15 #include <sys/types.h>
  16 #include "ac/string.h"
  17 #include "ac/ctype.h"
  18 #include "ac/stdarg.h"
  19 #include "slap.h"
  20 #include "lber_pvt.h"
  21 #include "ldap_pvt.h"
  22 #include "back-sql.h"
  23 #include "schema-map.h"
  24 #include "util.h"
  25
  26 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
  27 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
  28
  29 #define BACKSQL_STR_GROW 256
  30
  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 "
  40         "WHERE oc_map_id=?";
  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) "
  44         "VALUES (?,?,?,?)";
  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(?,?)";
  50
  51 /* TimesTen */
  52 char backsql_check_dn_ru_query[] = "SELECT dn_ru from ldap_entries";
  53
  54 struct berbuf *
  55 backsql_strcat( struct berbuf *dest, ... )
  56 {
  57         va_list         strs;
  58         ber_len_t       cdlen, cslen, grow;
  59         char            *cstr;
  60
  61         assert( dest );
  62         assert( dest->bb_val.bv_val == NULL
  63                         || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
  64
  65 #ifdef BACKSQL_TRACE
  66         Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n" );
  67 #endif /* BACKSQL_TRACE */
  68
  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,
  72                                 sizeof( char ) );
  73                 dest->bb_val.bv_len = 0;
  74                 dest->bb_len = BACKSQL_STR_GROW;
  75         }
  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 ) {
  81                         char    *tmp_dest;
  82
  83 #ifdef BACKSQL_TRACE
  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 */
  89
  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",
  95                                         0, 0, 0 );
  96                                 return NULL;
  97                         }
  98                         dest->bb_val.bv_val = tmp_dest;
  99                         dest->bb_len += grow;
 100
 101 #ifdef BACKSQL_TRACE
 102                         Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
 103                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 104 #endif /* BACKSQL_TRACE */
 105                 }
 106                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 107                 cdlen += cslen;
 108         }
 109         va_end( strs );
 110
 111 #ifdef BACKSQL_TRACE
 112         Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest='%s')\n",
 113                         dest, 0, 0 );
 114 #endif /* BACKSQL_TRACE */
 115
 116         dest->bb_val.bv_len = cdlen;
 117
 118         return dest;
 119 }
 120
 121 struct berbuf *
 122 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
 123 {
 124         va_list         strs;
 125         ber_len_t       cdlen;
 126
 127         assert( dest );
 128         assert( 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 ) );
 132
 133 #ifdef BACKSQL_TRACE
 134         Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n" );
 135 #endif /* BACKSQL_TRACE */
 136
 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,
 140                                 sizeof( char ) );
 141                 dest->bb_val.bv_len = 0;
 142                 dest->bb_len = BACKSQL_STR_GROW;
 143         }
 144
 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' };
 149                 struct berval   *cbv;
 150
 151                 switch ( fmt[ 0 ] ) {
 152
 153                 /* berval */
 154                 case 'b':
 155                         cbv = va_arg( strs, struct berval * );
 156                         cstr = cbv->bv_val;
 157                         cslen = cbv->bv_len;
 158                         break;
 159
 160                 /* length + string */
 161                 case 'l':
 162                         cslen = va_arg( strs, ber_len_t );
 163                         cstr = va_arg( strs, char * );
 164                         break;
 165
 166                 /* string */
 167                 case 's':
 168                         cstr = va_arg( strs, char * );
 169                         cslen = strlen( cstr );
 170                         break;
 171
 172                 /* char */
 173                 case 'c':
 174                         /*
 175                          * `char' is promoted to `int' when passed through `...'
 176                          */
 177                         cc[0] = va_arg( strs, int );
 178                         cstr = cc;
 179                         cslen = 1;
 180                         break;
 181
 182                 default:
 183                         assert( 0 );
 184                 }
 185
 186                 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
 187                 if ( dest->bb_len - cdlen <= cslen ) {
 188                         char    *tmp_dest;
 189
 190 #ifdef BACKSQL_TRACE
 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 */
 196
 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",
 202                                         0, 0, 0 );
 203                                 return NULL;
 204                         }
 205                         dest->bb_val.bv_val = tmp_dest;
 206                         dest->bb_len += grow * sizeof( char );
 207
 208 #ifdef BACKSQL_TRACE
 209                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 210                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 211 #endif /* BACKSQL_TRACE */
 212                 }
 213
 214                 assert( cstr );
 215
 216                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 217                 cdlen += cslen;
 218         }
 219
 220         va_end( strs );
 221
 222 #ifdef BACKSQL_TRACE
 223         Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest='%s')\n",
 224                         dest, 0, 0 );
 225 #endif /* BACKSQL_TRACE */
 226
 227         dest->bb_val.bv_len = cdlen;
 228
 229         return dest;
 230 }
 231
 232 int
 233 backsql_entry_addattr(
 234         Entry           *e,
 235         struct berval   *at_name,
 236         struct berval   *at_val,
 237         void            *memctx )
 238 {
 239         AttributeDescription    *ad;
 240         int                     rc;
 241         const char              *text;
 242
 243 #ifdef BACKSQL_TRACE
 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 */
 248
 249         ad = NULL;
 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 );
 255                 return 0;
 256         }
 257
 258         rc = attr_merge_normalize_one( e, ad, at_val, memctx );
 259
 260         if ( rc != 0 ) {
 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 );
 264                 return 0;
 265         }
 266
 267 #ifdef BACKSQL_TRACE
 268         Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
 269 #endif /* BACKSQL_TRACE */
 270
 271         return 1;
 272 }
 273
 274 char *
 275 backsql_get_table_spec( char **p )
 276 {
 277         char            *s, *q;
 278         struct berbuf   res = BB_NULL;
 279
 280         assert( p );
 281         assert( *p );
 282
 283         s = *p;
 284         while ( **p && **p != ',' ) {
 285                 (*p)++;
 286         }
 287
 288         if ( **p ) {
 289                 *(*p)++ = '\0';
 290         }
 291
 292 #define BACKSQL_NEXT_WORD { \
 293                 while ( *s && isspace( (unsigned char)*s ) ) s++; \
 294                 if ( !*s ) return res.bb_val.bv_val; \
 295                 q = s; \
 296                 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
 297                 if ( *q ) *q++='\0'; \
 298         }
 299
 300         BACKSQL_NEXT_WORD;
 301         /* table name */
 302         backsql_strcat( &res, s, NULL );
 303         s = q;
 304
 305         BACKSQL_NEXT_WORD;
 306         if ( !strcasecmp( s, "as" ) ) {
 307                 s = q;
 308                 BACKSQL_NEXT_WORD;
 309         }
 310
 311 #if 0
 312         backsql_strcat( &res, " AS ", s, NULL );
 313         /* oracle doesn't understand AS :( */
 314 #endif
 315
 316         /* table alias */
 317         backsql_strfcat( &res, "cs", ' ', s );
 318
 319         return res.bb_val.bv_val;
 320 }
 321
 322 int
 323 backsql_merge_from_clause(
 324         struct berbuf   *dest_from,
 325         struct berval   *src_from )
 326 {
 327         char            *s, *p, *srcc, *pos, e;
 328         struct berbuf   res = BB_NULL;
 329
 330 #ifdef BACKSQL_TRACE
 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 */
 335
 336         srcc = ch_strdup( src_from->bv_val );
 337         p = srcc;
 338
 339         if ( dest_from != NULL ) {
 340                 res = *dest_from;
 341         }
 342
 343         while ( *p ) {
 344                 s = backsql_get_table_spec( &p );
 345
 346 #ifdef BACKSQL_TRACE
 347                 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
 348                         "p='%s' s='%s'\n", p, s, 0 );
 349 #endif /* BACKSQL_TRACE */
 350
 351                 if ( res.bb_val.bv_val == NULL ) {
 352                         backsql_strcat( &res, s, NULL );
 353
 354                 } else {
 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 );
 358                         }
 359                 }
 360
 361                 if ( s ) {
 362                         ch_free( s );
 363                 }
 364         }
 365
 366 #ifdef BACKSQL_TRACE
 367         Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
 368 #endif /* BACKSQL_TRACE */
 369
 370         free( srcc );
 371         *dest_from = res;
 372
 373         return 1;
 374 }
 375
 376 /*
 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)
 381  */
 382
 383 int
 384 backsql_split_pattern(
 385         const char      *_pattern,
 386         BerVarray       *split_pattern,
 387         int             expected )
 388 {
 389         char            *pattern, *start, *end;
 390         struct berval   bv;
 391         int             rc = 0;
 392
 393 #define SPLIT_CHAR      '?'
 394
 395         assert( _pattern );
 396         assert( split_pattern );
 397
 398         pattern = ch_strdup( _pattern );
 399
 400         start = pattern;
 401         end = strchr( start, SPLIT_CHAR );
 402         for ( ; start; expected-- ) {
 403                 char            *real_end = end;
 404                 ber_len_t       real_len;
 405
 406                 if ( real_end == NULL ) {
 407                         real_end = start + strlen( start );
 408
 409                 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
 410                         expected++;
 411                         AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
 412                         end = strchr( real_end + 1, SPLIT_CHAR );
 413                         continue;
 414                 }
 415
 416                 real_len = real_end - start;
 417                 if ( real_len == 0 ) {
 418                         ber_str2bv( "", 0, 1, &bv );
 419                 } else {
 420                         ber_str2bv( start, real_len, 1, &bv );
 421                 }
 422
 423                 ber_bvarray_add( split_pattern, &bv );
 424
 425                 if ( expected == 0 ) {
 426                         if ( end != NULL ) {
 427                                 rc = -1;
 428                                 goto done;
 429                         }
 430                         break;
 431                 }
 432
 433                 if ( end != NULL ) {
 434                         start = end + 1;
 435                         end = strchr( start, SPLIT_CHAR );
 436                 }
 437         }
 438
 439 done:;
 440
 441         ch_free( pattern );
 442
 443         return rc;
 444 }
 445
 446 int
 447 backsql_prepare_pattern(
 448         BerVarray       split_pattern,
 449         BerVarray       values,
 450         struct berval   *res )
 451 {
 452         int             i;
 453         struct berbuf   bb = BB_NULL;
 454
 455         assert( res );
 456
 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 );
 460                         return -1;
 461                 }
 462                 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 463                 backsql_strfcat( &bb, "b", &values[ i ] );
 464         }
 465
 466         if ( split_pattern[ i ].bv_val == NULL ) {
 467                 ch_free( bb.bb_val.bv_val );
 468                 return -1;
 469         }
 470
 471         backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 472
 473         *res = bb.bb_val;
 474
 475         return 0;
 476 }
 477
 478 #endif /* SLAPD_SQL */
 479