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-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * Portions Copyright 2002 Pierangelo Masarati.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in the file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by Dmitry Kovalev for inclusion
  19  * by OpenLDAP Software.  Additional significant contributors include
  20  * Pierangelo Masarati.
  21  */
  22
  23 #include "portable.h"
  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
  31 #include "slap.h"
  32 #include "proto-sql.h"
  33 #include "lutil.h"
  34
  35 #define BACKSQL_MAX(a,b) ((a)>(b)?(a):(b))
  36 #define BACKSQL_MIN(a,b) ((a)<(b)?(a):(b))
  37
  38 #define BACKSQL_STR_GROW 256
  39
  40 char backsql_def_oc_query[] =
  41         "SELECT id,name,keytbl,keycol,create_proc,delete_proc,expect_return "
  42         "FROM ldap_oc_mappings";
  43 char backsql_def_needs_select_oc_query[] =
  44         "SELECT id,name,keytbl,keycol,create_proc,create_keyval,delete_proc,"
  45         "expect_return FROM ldap_oc_mappings";
  46 char backsql_def_at_query[] =
  47         "SELECT name,sel_expr,from_tbls,join_where,add_proc,delete_proc,"
  48         "param_order,expect_return,sel_expr_u FROM ldap_attr_mappings "
  49         "WHERE oc_map_id=?";
  50 char backsql_def_delentry_stmt[] = "DELETE FROM ldap_entries WHERE id=?";
  51 char backsql_def_renentry_stmt[] =
  52         "UPDATE ldap_entries SET dn=?,parent=?,keyval=? WHERE id=?";
  53 char backsql_def_insentry_stmt[] =
  54         "INSERT INTO ldap_entries (dn,oc_map_id,parent,keyval) "
  55         "VALUES (?,?,?,?)";
  56 char backsql_def_delobjclasses_stmt[] = "DELETE FROM ldap_entry_objclasses "
  57         "WHERE entry_id=?";
  58 char backsql_def_delreferrals_stmt[] = "DELETE FROM ldap_referrals "
  59         "WHERE entry_id=?";
  60 char backsql_def_subtree_cond[] = "ldap_entries.dn LIKE CONCAT('%',?)";
  61 char backsql_def_upper_subtree_cond[] = "(ldap_entries.dn) LIKE CONCAT('%',?)";
  62 char backsql_id_query[] = "SELECT id,keyval,oc_map_id,dn FROM ldap_entries WHERE ";
  63 /* better ?||? or cast(?||? as varchar) */
  64 char backsql_def_concat_func[] = "CONCAT(?,?)";
  65
  66 /* TimesTen */
  67 char backsql_check_dn_ru_query[] = "SELECT dn_ru FROM ldap_entries";
  68
  69 struct berbuf *
  70 backsql_strcat( struct berbuf *dest, ... )
  71 {
  72         va_list         strs;
  73         ber_len_t       cdlen, cslen, grow;
  74         char            *cstr;
  75
  76         assert( dest );
  77         assert( dest->bb_val.bv_val == NULL
  78                         || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
  79
  80 #ifdef BACKSQL_TRACE
  81         Debug( LDAP_DEBUG_TRACE, "==>backsql_strcat()\n", 0, 0, 0 );
  82 #endif /* BACKSQL_TRACE */
  83
  84         va_start( strs, dest );
  85         if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
  86                 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
  87                                 sizeof( char ) );
  88                 dest->bb_val.bv_len = 0;
  89                 dest->bb_len = BACKSQL_STR_GROW;
  90         }
  91         cdlen = dest->bb_val.bv_len;
  92         while ( ( cstr = va_arg( strs, char * ) ) != NULL ) {
  93                 cslen = strlen( cstr );
  94                 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
  95                 if ( dest->bb_len - cdlen <= cslen ) {
  96                         char    *tmp_dest;
  97
  98 #ifdef BACKSQL_TRACE
  99                         Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
 100                                 "buflen=%d, cdlen=%d, cslen=%d "
 101                                 "-- reallocating dest\n",
 102                                 dest->bb_len, cdlen + 1, cslen );
 103 #endif /* BACKSQL_TRACE */
 104
 105                         tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
 106                                         ( dest->bb_len ) + grow * sizeof( char ) );
 107                         if ( tmp_dest == NULL ) {
 108                                 Debug( LDAP_DEBUG_ANY, "backsql_strcat(): "
 109                                         "could not reallocate string buffer.\n",
 110                                         0, 0, 0 );
 111                                 return NULL;
 112                         }
 113                         dest->bb_val.bv_val = tmp_dest;
 114                         dest->bb_len += grow;
 115
 116 #ifdef BACKSQL_TRACE
 117                         Debug( LDAP_DEBUG_TRACE, "backsql_strcat(): "
 118                                 "new buflen=%d, dest=%p\n",
 119                                 dest->bb_len, dest, 0 );
 120 #endif /* BACKSQL_TRACE */
 121                 }
 122                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 123                 cdlen += cslen;
 124         }
 125         va_end( strs );
 126
 127 #ifdef BACKSQL_TRACE
 128         Debug( LDAP_DEBUG_TRACE, "<==backsql_strcat() (dest=\"%s\")\n",
 129                         dest->bb_val.bv_val, 0, 0 );
 130 #endif /* BACKSQL_TRACE */
 131
 132         dest->bb_val.bv_len = cdlen;
 133
 134         return dest;
 135 }
 136
 137 struct berbuf *
 138 backsql_strfcat( struct berbuf *dest, const char *fmt, ... )
 139 {
 140         va_list         strs;
 141         ber_len_t       cdlen;
 142
 143         assert( dest );
 144         assert( fmt );
 145         assert( dest->bb_len == 0 || dest->bb_len > dest->bb_val.bv_len );
 146         assert( dest->bb_val.bv_val == NULL
 147                         || dest->bb_val.bv_len == strlen( dest->bb_val.bv_val ) );
 148
 149 #ifdef BACKSQL_TRACE
 150         Debug( LDAP_DEBUG_TRACE, "==>backsql_strfcat()\n", 0, 0, 0 );
 151 #endif /* BACKSQL_TRACE */
 152
 153         va_start( strs, fmt );
 154         if ( dest->bb_val.bv_val == NULL || dest->bb_len == 0 ) {
 155                 dest->bb_val.bv_val = (char *)ch_calloc( BACKSQL_STR_GROW,
 156                                 sizeof( char ) );
 157                 dest->bb_val.bv_len = 0;
 158                 dest->bb_len = BACKSQL_STR_GROW;
 159         }
 160
 161         cdlen = dest->bb_val.bv_len;
 162         for ( ; fmt[0]; fmt++ ) {
 163                 ber_len_t       cslen, grow;
 164                 char            *cstr, cc[ 2 ] = { '\0', '\0' };
 165                 struct berval   *cbv;
 166
 167                 switch ( fmt[ 0 ] ) {
 168
 169                 /* berval */
 170                 case 'b':
 171                         cbv = va_arg( strs, struct berval * );
 172                         cstr = cbv->bv_val;
 173                         cslen = cbv->bv_len;
 174                         break;
 175
 176                 /* length + string */
 177                 case 'l':
 178                         cslen = va_arg( strs, ber_len_t );
 179                         cstr = va_arg( strs, char * );
 180                         break;
 181
 182                 /* string */
 183                 case 's':
 184                         cstr = va_arg( strs, char * );
 185                         cslen = strlen( cstr );
 186                         break;
 187
 188                 /* char */
 189                 case 'c':
 190                         /*
 191                          * `char' is promoted to `int' when passed through `...'
 192                          */
 193                         cc[0] = va_arg( strs, int );
 194                         cstr = cc;
 195                         cslen = 1;
 196                         break;
 197
 198                 default:
 199                         assert( 0 );
 200                 }
 201
 202                 grow = BACKSQL_MAX( BACKSQL_STR_GROW, cslen );
 203                 if ( dest->bb_len - cdlen <= cslen ) {
 204                         char    *tmp_dest;
 205
 206 #ifdef BACKSQL_TRACE
 207                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 208                                 "buflen=%d, cdlen=%d, cslen=%d "
 209                                 "-- reallocating dest\n",
 210                                 dest->bb_len, cdlen + 1, cslen );
 211 #endif /* BACKSQL_TRACE */
 212
 213                         tmp_dest = (char *)ch_realloc( dest->bb_val.bv_val,
 214                                         ( dest->bb_len ) + grow * sizeof( char ) );
 215                         if ( tmp_dest == NULL ) {
 216                                 Debug( LDAP_DEBUG_ANY, "backsql_strfcat(): "
 217                                         "could not reallocate string buffer.\n",
 218                                         0, 0, 0 );
 219                                 return NULL;
 220                         }
 221                         dest->bb_val.bv_val = tmp_dest;
 222                         dest->bb_len += grow * sizeof( char );
 223
 224 #ifdef BACKSQL_TRACE
 225                         Debug( LDAP_DEBUG_TRACE, "backsql_strfcat(): "
 226                                 "new buflen=%d, dest=%p\n", dest->bb_len, dest, 0 );
 227 #endif /* BACKSQL_TRACE */
 228                 }
 229
 230                 assert( cstr );
 231
 232                 AC_MEMCPY( dest->bb_val.bv_val + cdlen, cstr, cslen + 1 );
 233                 cdlen += cslen;
 234         }
 235
 236         va_end( strs );
 237
 238 #ifdef BACKSQL_TRACE
 239         Debug( LDAP_DEBUG_TRACE, "<==backsql_strfcat() (dest=\"%s\")\n",
 240                         dest->bb_val.bv_val, 0, 0 );
 241 #endif /* BACKSQL_TRACE */
 242
 243         dest->bb_val.bv_len = cdlen;
 244
 245         return dest;
 246 }
 247
 248 int
 249 backsql_entry_addattr(
 250         Entry                   *e,
 251         AttributeDescription    *ad,
 252         struct berval           *val,
 253         void                    *memctx )
 254 {
 255         int                     rc;
 256
 257 #ifdef BACKSQL_TRACE
 258         Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(\"%s\"): %s=%s\n",
 259                 e->e_name.bv_val, ad->ad_cname->bv_val, val->bv_val );
 260 #endif /* BACKSQL_TRACE */
 261
 262         rc = attr_merge_normalize_one( e, ad, val, memctx );
 263
 264         if ( rc != LDAP_SUCCESS ) {
 265                 Debug( LDAP_DEBUG_TRACE, "backsql_entry_addattr(\"%s\"): "
 266                         "failed to merge value \"%s\" for attribute \"%s\"\n",
 267                         e->e_name.bv_val, val->bv_val, ad->ad_cname.bv_val );
 268                 return rc;
 269         }
 270
 271 #ifdef BACKSQL_TRACE
 272         Debug( LDAP_DEBUG_TRACE, "<==backsql_entry_addattr(\"%s\")\n",
 273                 e->e_name.bv_val, 0, 0 );
 274 #endif /* BACKSQL_TRACE */
 275
 276         return LDAP_SUCCESS;
 277 }
 278
 279 static char *
 280 backsql_get_table_spec( char **p )
 281 {
 282         char            *s, *q;
 283         struct berbuf   res = BB_NULL;
 284
 285         assert( p );
 286         assert( *p );
 287
 288         s = *p;
 289         while ( **p && **p != ',' ) {
 290                 (*p)++;
 291         }
 292
 293         if ( **p ) {
 294                 *(*p)++ = '\0';
 295         }
 296
 297 #define BACKSQL_NEXT_WORD { \
 298                 while ( *s && isspace( (unsigned char)*s ) ) s++; \
 299                 if ( !*s ) return res.bb_val.bv_val; \
 300                 q = s; \
 301                 while ( *q && !isspace( (unsigned char)*q ) ) q++; \
 302                 if ( *q ) *q++='\0'; \
 303         }
 304
 305         BACKSQL_NEXT_WORD;
 306         /* table name */
 307         backsql_strcat( &res, s, NULL );
 308         s = q;
 309
 310         BACKSQL_NEXT_WORD;
 311         if ( strcasecmp( s, "AS" ) == 0 ) {
 312                 s = q;
 313                 BACKSQL_NEXT_WORD;
 314         }
 315
 316         /* oracle doesn't understand "AS" :( and other RDBMSes don't need it */
 317 #ifdef BACKSQL_ALIASING_QUOTE
 318         backsql_strfcat( &res, "scsc", " " BACKSQL_ALIASING,
 319                         BACKSQL_ALIASING_QUOTE, s, BACKSQL_ALIASING_QUOTE );
 320 #else /* ! BACKSQL_ALIASING */
 321         backsql_strcat( &res, " " BACKSQL_ALIASING, s, NULL );
 322 #endif /* ! BACKSQL_ALIASING */
 323
 324         return res.bb_val.bv_val;
 325 }
 326
 327 int
 328 backsql_merge_from_clause(
 329         struct berbuf   *dest_from,
 330         struct berval   *src_from )
 331 {
 332         char            *s, *p, *srcc, *pos, e;
 333         struct berbuf   res = BB_NULL;
 334
 335 #ifdef BACKSQL_TRACE
 336         Debug( LDAP_DEBUG_TRACE, "==>backsql_merge_from_clause(): "
 337                 "dest_from=\"%s\",src_from=\"%s\"\n",
 338                 dest_from ? dest_from->bb_val.bv_val : "<NULL>",
 339                 src_from->bv_val, 0 );
 340 #endif /* BACKSQL_TRACE */
 341
 342         srcc = ch_strdup( src_from->bv_val );
 343         p = srcc;
 344
 345         if ( dest_from != NULL ) {
 346                 res = *dest_from;
 347         }
 348
 349         while ( *p ) {
 350                 s = backsql_get_table_spec( &p );
 351
 352 #ifdef BACKSQL_TRACE
 353                 Debug( LDAP_DEBUG_TRACE, "backsql_merge_from_clause(): "
 354                         "p=\"%s\" s=\"%s\"\n", p, s, 0 );
 355 #endif /* BACKSQL_TRACE */
 356
 357                 if ( res.bb_val.bv_val == NULL ) {
 358                         backsql_strcat( &res, s, NULL );
 359
 360                 } else {
 361                         pos = strstr( res.bb_val.bv_val, s );
 362                         if ( pos == NULL || ( ( e = pos[ strlen( s ) ] ) != '\0' && e != ',' ) ) {
 363                                 backsql_strfcat( &res, "cs", ',', s );
 364                         }
 365                 }
 366
 367                 if ( s ) {
 368                         ch_free( s );
 369                 }
 370         }
 371
 372 #ifdef BACKSQL_TRACE
 373         Debug( LDAP_DEBUG_TRACE, "<==backsql_merge_from_clause()\n", 0, 0, 0 );
 374 #endif /* BACKSQL_TRACE */
 375
 376         free( srcc );
 377         *dest_from = res;
 378
 379         return 1;
 380 }
 381
 382 /*
 383  * splits a pattern in components separated by '?'
 384  * (double ?? are turned into single ? and left in the string)
 385  * expected contains the number of expected occurrences of '?'
 386  * (a negative value means parse as many as possible)
 387  */
 388
 389 int
 390 backsql_split_pattern(
 391         const char      *_pattern,
 392         BerVarray       *split_pattern,
 393         int             expected )
 394 {
 395         char            *pattern, *start, *end;
 396         struct berval   bv;
 397         int             rc = 0;
 398
 399 #define SPLIT_CHAR      '?'
 400
 401         assert( _pattern );
 402         assert( split_pattern );
 403
 404         pattern = ch_strdup( _pattern );
 405
 406         start = pattern;
 407         end = strchr( start, SPLIT_CHAR );
 408         for ( ; start; expected-- ) {
 409                 char            *real_end = end;
 410                 ber_len_t       real_len;
 411
 412                 if ( real_end == NULL ) {
 413                         real_end = start + strlen( start );
 414
 415                 } else if ( real_end[ 1 ] == SPLIT_CHAR ) {
 416                         expected++;
 417                         AC_MEMCPY( real_end, real_end + 1, strlen( real_end ) );
 418                         end = strchr( real_end + 1, SPLIT_CHAR );
 419                         continue;
 420                 }
 421
 422                 real_len = real_end - start;
 423                 if ( real_len == 0 ) {
 424                         ber_str2bv( "", 0, 1, &bv );
 425                 } else {
 426                         ber_str2bv( start, real_len, 1, &bv );
 427                 }
 428
 429                 ber_bvarray_add( split_pattern, &bv );
 430
 431                 if ( expected == 0 ) {
 432                         if ( end != NULL ) {
 433                                 rc = -1;
 434                                 goto done;
 435                         }
 436                         break;
 437                 }
 438
 439                 if ( end != NULL ) {
 440                         start = end + 1;
 441                         end = strchr( start, SPLIT_CHAR );
 442                 }
 443         }
 444
 445 done:;
 446
 447         ch_free( pattern );
 448
 449         return rc;
 450 }
 451
 452 int
 453 backsql_prepare_pattern(
 454         BerVarray       split_pattern,
 455         BerVarray       values,
 456         struct berval   *res )
 457 {
 458         int             i;
 459         struct berbuf   bb = BB_NULL;
 460
 461         assert( res );
 462
 463         for ( i = 0; values[i].bv_val; i++ ) {
 464                 if ( split_pattern[i].bv_val == NULL ) {
 465                         ch_free( bb.bb_val.bv_val );
 466                         return -1;
 467                 }
 468                 backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 469                 backsql_strfcat( &bb, "b", &values[ i ] );
 470         }
 471
 472         if ( split_pattern[ i ].bv_val == NULL ) {
 473                 ch_free( bb.bb_val.bv_val );
 474                 return -1;
 475         }
 476
 477         backsql_strfcat( &bb, "b", &split_pattern[ i ] );
 478
 479         *res = bb.bb_val;
 480
 481         return 0;
 482 }
 483
 484 int
 485 backsql_entryUUID(
 486         backsql_info    *bi,
 487         backsql_entryID *id,
 488         struct berval   *entryUUID,
 489         void            *memctx )
 490 {
 491         char            uuidbuf[ LDAP_LUTIL_UUIDSTR_BUFSIZE ];
 492         struct berval   uuid;
 493 #ifdef BACKSQL_ARBITRARY_KEY
 494         int             i;
 495         ber_len_t       l, lmax;
 496 #endif /* BACKSQL_ARBITRARY_KEY */
 497
 498         /* entryUUID is generated as "%08x-%04x-%04x-0000-eaddrXXX"
 499          * with eid_oc_id as %08x and hi and lo eid_id as %04x-%04x */
 500         assert( bi );
 501         assert( id );
 502         assert( entryUUID );
 503
 504 #ifdef BACKSQL_ARBITRARY_KEY
 505         snprintf( uuidbuf, sizeof( uuidbuf ),
 506                         "%08x-0000-0000-0000-000000000000",
 507                         ( id->eid_oc_id & 0xFFFFFFFF ) );
 508         lmax = id->eid_keyval.bv_len < 12 ? id->eid_keyval.bv_len : 12;
 509         for ( l = 0, i = 9; l < lmax; l++, i += 2 ) {
 510                 switch ( i ) {
 511                 case STRLENOF( "00000000-0000" ):
 512                 case STRLENOF( "00000000-0000-0000" ):
 513                 case STRLENOF( "00000000-0000-0000-0000" ):
 514                         uuidbuf[ i++ ] = '-';
 515                 /* FALLTHRU */
 516
 517                 default:
 518                         snprintf( &uuidbuf[ i ], 3, "%2x", id->eid_keyval.bv_val[ l ] );
 519                         break;
 520                 }
 521         }
 522 #else /* ! BACKSQL_ARBITRARY_KEY */
 523         /* note: works only with 32 bit architectures... */
 524         snprintf( uuidbuf, sizeof( uuidbuf ),
 525                         "%08x-%04x-%04x-0000-000000000000",
 526                         ( id->eid_oc_id & 0xFFFFFFFF ),
 527                         ( ( id->eid_keyval & 0xFFFF0000 ) >> 020 /* 16 */ ),
 528                         ( id->eid_keyval & 0xFFFF ) );
 529 #endif /* ! BACKSQL_ARBITRARY_KEY */
 530
 531         uuid.bv_val = uuidbuf;
 532         uuid.bv_len = strlen( uuidbuf );
 533
 534         ber_dupbv_x( entryUUID, &uuid, memctx );
 535
 536         return 0;
 537 }
 538
 539 int
 540 backsql_entryUUID_decode(
 541         struct berval   *entryUUID,
 542         unsigned long   *oc_id,
 543 #ifdef BACKSQL_ARBITRARY_KEY
 544         struct berval   *keyval
 545 #else /* ! BACKSQL_ARBITRARY_KEY */
 546         unsigned long   *keyval
 547 #endif /* ! BACKSQL_ARBITRARY_KEY */
 548         )
 549 {
 550         fprintf( stderr, "==> backsql_entryUUID_decode()\n" );
 551
 552         *oc_id = ( entryUUID->bv_val[0] << 030 /* 24 */ )
 553                 + ( entryUUID->bv_val[1] << 020 /* 16 */ )
 554                 + ( entryUUID->bv_val[2] << 010 /* 8 */ )
 555                 + entryUUID->bv_val[3];
 556
 557 #ifdef BACKSQL_ARBITRARY_KEY
 558         /* FIXME */
 559 #else /* ! BACKSQL_ARBITRARY_KEY */
 560         *keyval = ( entryUUID->bv_val[4] << 030 /* 24 */ )
 561                 + ( entryUUID->bv_val[5] << 020 /* 16 */ )
 562                 + ( entryUUID->bv_val[6] << 010 /* 8 */ )
 563                 + entryUUID->bv_val[7];
 564 #endif /* ! BACKSQL_ARBITRARY_KEY */
 565
 566         fprintf( stderr, "<== backsql_entryUUID_decode(): oc=%lu id=%lu\n",
 567                         *oc_id, *keyval );
 568
 569         return LDAP_SUCCESS;
 570 }
 571