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 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include "ac/string.h"
  26 #include "ac/ctype.h"
  27 #include "ac/stdarg.h"
  28
  29 #include "slap.h"
  30 #include "proto-sql.h"
  31 #include "lutil.h"
  32
  33 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
  34 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
  35
  36 #define BACKSQL_STR_GROW 256
  37
  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 "
  47         "WHERE oc_map_id=?";
  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) "
  51         "VALUES (?,?,?,?)";
  52 char backsql_def_delobjclasses_query[] = "DELETE FROM ldap_entry_objclasses "
  53         "WHERE entry_id=?";
  54 char backsql_def_delreferrals_query[] = "DELETE FROM ldap_referrals "
  55         "WHERE entry_id=?";
  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(?,?)";
  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", 0, 0, 0 );
  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",
 115                                 dest->bb_len, dest, 0 );
 116 #endif /* BACKSQL_TRACE */
 117                 }
 118                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 119                 cdlen += cslen;
 120         }
 121         va_end( strs );
 122
 123 #ifdef BACKSQL_TRACE
 124         Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest=\"%s\")\n",
 125                         dest->bb_val.bv_val, 0, 0 );
 126 #endif /* BACKSQL_TRACE */
 127
 128         dest->bb_val.bv_len = cdlen;
 129
 130         return dest;
 131 }
 132
 133 struct berbuf *
 134 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
 135 {
 136         va_list         strs;
 137         ber_len_t       cdlen;
 138
 139         assert( dest );
 140         assert( 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 ) );
 144
 145 #ifdef BACKSQL_TRACE
 146         Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n", 0, 0, 0 );
 147 #endif /* BACKSQL_TRACE */
 148
 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,
 152                                 sizeof( char ) );
 153                 dest->bb_val.bv_len = 0;
 154                 dest->bb_len = BACKSQL_STR_GROW;
 155         }
 156
 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' };
 161                 struct berval   *cbv;
 162
 163                 switch ( fmt[ 0 ] ) {
 164
 165                 /* berval */
 166                 case 'b':
 167                         cbv = va_arg( strs, struct berval * );
 168                         cstr = cbv->bv_val;
 169                         cslen = cbv->bv_len;
 170                         break;
 171
 172                 /* length + string */
 173                 case 'l':
 174                         cslen = va_arg( strs, ber_len_t );
 175                         cstr = va_arg( strs, char * );
 176                         break;
 177
 178                 /* string */
 179                 case 's':
 180                         cstr = va_arg( strs, char * );
 181                         cslen = strlen( cstr );
 182                         break;
 183
 184                 /* char */
 185                 case 'c':
 186                         /*
 187                          * `char' is promoted to `int' when passed through `...'
 188                          */
 189                         cc[0] = va_arg( strs, int );
 190                         cstr = cc;
 191                         cslen = 1;
 192                         break;
 193
 194                 default:
 195                         assert( 0 );
 196                 }
 197
 198                 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
 199                 if ( dest->bb_len - cdlen <= cslen ) {
 200                         char    *tmp_dest;
 201
 202 #ifdef BACKSQL_TRACE
 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 */
 208
 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",
 214                                         0, 0, 0 );
 215                                 return NULL;
 216                         }
 217                         dest->bb_val.bv_val = tmp_dest;
 218                         dest->bb_len += grow * sizeof( char );
 219
 220 #ifdef BACKSQL_TRACE
 221                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 222                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 223 #endif /* BACKSQL_TRACE */
 224                 }
 225
 226                 assert( cstr );
 227
 228                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 229                 cdlen += cslen;
 230         }
 231
 232         va_end( strs );
 233
 234 #ifdef BACKSQL_TRACE
 235         Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest=\"%s\")\n",
 236                         dest->bb_val.bv_val, 0, 0 );
 237 #endif /* BACKSQL_TRACE */
 238
 239         dest->bb_val.bv_len = cdlen;
 240
 241         return dest;
 242 }
 243
 244 int
 245 backsql_entry_addattr(
 246         Entry           *e,
 247         struct berval   *at_name,
 248         struct berval   *at_val,
 249         void            *memctx )
 250 {
 251         AttributeDescription    *ad;
 252         int                     rc;
 253         const char              *text;
 254
 255 #ifdef BACKSQL_TRACE
 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 */
 260
 261         ad = NULL;
 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 );
 267                 return 0;
 268         }
 269
 270         rc = attr_merge_normalize_one( e, ad, at_val, memctx );
 271
 272         if ( rc != 0 ) {
 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 );
 276                 return 0;
 277         }
 278
 279 #ifdef BACKSQL_TRACE
 280         Debug( LDAP_DEBUG_TRACE, "<==backsql_query_addattr()\n", 0, 0, 0 );
 281 #endif /* BACKSQL_TRACE */
 282
 283         return 1;
 284 }
 285
 286 static char *
 287 backsql_get_table_spec( char **p )
 288 {
 289         char            *s, *q;
 290         struct berbuf   res = BB_NULL;
 291
 292         assert( p );
 293         assert( *p );
 294
 295         s = *p;
 296         while ( **p && **p != ',' ) {
 297                 (*p)++;
 298         }
 299
 300         if ( **p ) {
 301                 *(*p)++ = '\0';
 302         }
 303
 304 #define BACKSQL_NEXT_WORD { \
 305                 while ( *s && isspace( (unsigned char)*s ) ) s++; \
 306                 if ( !*s ) return res.bb_val.bv_val; \
 307                 q = s; \
 308                 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
 309                 if ( *q ) *q++='\0'; \
 310         }
 311
 312         BACKSQL_NEXT_WORD;
 313         /* table name */
 314         backsql_strcat( &res, s, NULL );
 315         s = q;
 316
 317         BACKSQL_NEXT_WORD;
 318         if ( strcasecmp( s, "AS" ) == 0 ) {
 319                 s = q;
 320                 BACKSQL_NEXT_WORD;
 321         }
 322
 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 */
 330
 331         return res.bb_val.bv_val;
 332 }
 333
 334 int
 335 backsql_merge_from_clause(
 336         struct berbuf   *dest_from,
 337         struct berval   *src_from )
 338 {
 339         char            *s, *p, *srcc, *pos, e;
 340         struct berbuf   res = BB_NULL;
 341
 342 #ifdef BACKSQL_TRACE
 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 */
 348
 349         srcc = ch_strdup( src_from->bv_val );
 350         p = srcc;
 351
 352         if ( dest_from != NULL ) {
 353                 res = *dest_from;
 354         }
 355
 356         while ( *p ) {
 357                 s = backsql_get_table_spec( &p );
 358
 359 #ifdef BACKSQL_TRACE
 360                 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
 361                         "p=\"%s\" s=\"%s\"\n", p, s, 0 );
 362 #endif /* BACKSQL_TRACE */
 363
 364                 if ( res.bb_val.bv_val == NULL ) {
 365                         backsql_strcat( &res, s, NULL );
 366
 367                 } else {
 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 );
 371                         }
 372                 }
 373
 374                 if ( s ) {
 375                         ch_free( s );
 376                 }
 377         }
 378
 379 #ifdef BACKSQL_TRACE
 380         Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
 381 #endif /* BACKSQL_TRACE */
 382
 383         free( srcc );
 384         *dest_from = res;
 385
 386         return 1;
 387 }
 388
 389 /*
 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)
 394  */
 395
 396 int
 397 backsql_split_pattern(
 398         const char      *_pattern,
 399         BerVarray       *split_pattern,
 400         int             expected )
 401 {
 402         char            *pattern, *start, *end;
 403         struct berval   bv;
 404         int             rc = 0;
 405
 406 #define SPLIT_CHAR      '?'
 407
 408         assert( _pattern );
 409         assert( split_pattern );
 410
 411         pattern = ch_strdup( _pattern );
 412
 413         start = pattern;
 414         end = strchr( start, SPLIT_CHAR );
 415         for ( ; start; expected-- ) {
 416                 char            *real_end = end;
 417                 ber_len_t       real_len;
 418
 419                 if ( real_end == NULL ) {
 420                         real_end = start + strlen( start );
 421
 422                 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
 423                         expected++;
 424                         AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
 425                         end = strchr( real_end + 1, SPLIT_CHAR );
 426                         continue;
 427                 }
 428
 429                 real_len = real_end - start;
 430                 if ( real_len == 0 ) {
 431                         ber_str2bv( "", 0, 1, &bv );
 432                 } else {
 433                         ber_str2bv( start, real_len, 1, &bv );
 434                 }
 435
 436                 ber_bvarray_add( split_pattern, &bv );
 437
 438                 if ( expected == 0 ) {
 439                         if ( end != NULL ) {
 440                                 rc = -1;
 441                                 goto done;
 442                         }
 443                         break;
 444                 }
 445
 446                 if ( end != NULL ) {
 447                         start = end + 1;
 448                         end = strchr( start, SPLIT_CHAR );
 449                 }
 450         }
 451
 452 done:;
 453
 454         ch_free( pattern );
 455
 456         return rc;
 457 }
 458
 459 int
 460 backsql_prepare_pattern(
 461         BerVarray       split_pattern,
 462         BerVarray       values,
 463         struct berval   *res )
 464 {
 465         int             i;
 466         struct berbuf   bb = BB_NULL;
 467
 468         assert( res );
 469
 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 );
 473                         return -1;
 474                 }
 475                 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 476                 backsql_strfcat( &bb, "b", &values[ i ] );
 477         }
 478
 479         if ( split_pattern[ i ].bv_val == NULL ) {
 480                 ch_free( bb.bb_val.bv_val );
 481                 return -1;
 482         }
 483
 484         backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 485
 486         *res = bb.bb_val;
 487
 488         return 0;
 489 }
 490
 491 int
 492 backsql_entryUUID(
 493         backsql_info    *bi,
 494         backsql_entryID *id,
 495         struct berval   *entryUUID,
 496         void            *memctx )
 497 {
 498         char            uuidbuf[ LDAP_LUTIL_UUIDSTR_BUFSIZE ];
 499         struct berval   uuid;
 500 #ifdef BACKSQL_ARBITRARY_KEY
 501         int             i;
 502         ber_len_t       l, lmax;
 503 #endif /* BACKSQL_ARBITRARY_KEY */
 504
 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 */
 507         assert( bi );
 508         assert( id );
 509         assert( entryUUID );
 510
 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 ) {
 517                 switch ( i ) {
 518                 case STRLENOF( "00000000-0000" ):
 519                 case STRLENOF( "00000000-0000-0000" ):
 520                 case STRLENOF( "00000000-0000-0000-0000" ):
 521                         uuidbuf[ i++ ] = '-';
 522                 /* FALLTHRU */
 523
 524                 default:
 525                         snprintf( &uuidbuf[ i ], 3, "%2x", id->eid_keyval.bv_val[ l ] );
 526                         break;
 527                 }
 528         }
 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 */
 537
 538         uuid.bv_val = uuidbuf;
 539         uuid.bv_len = strlen( uuidbuf );
 540
 541         ber_dupbv_x( entryUUID, &uuid, memctx );
 542
 543         return 0;
 544 }
 545
 546 int
 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 */
 555         )
 556 {
 557         fprintf( stderr, "==> backsql_entryUUID_decode()\n" );
 558
 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];
 563
 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 */
 571
 572         fprintf( stderr, "<== backsql_entryUUID_decode(): oc=%lu id=%lu\n",
 573                         *oc_id, *keyval );
 574
 575         return LDAP_SUCCESS;
 576 }
 577