git.sur5r.net Git - openldap/blob - servers/slapd/back-sql/init.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
  29 #include "slap.h"
  30 #include "proto-sql.h"
  31
  32 int
  33 sql_back_initialize(
  34         BackendInfo     *bi )
  35 {
  36         static char *controls[] = {
  37                 LDAP_CONTROL_ASSERT,
  38                 LDAP_CONTROL_MANAGEDSAIT,
  39 #if 0 /* needs improvements */
  40                 LDAP_CONTROL_NOOP,
  41 #endif
  42 #ifdef LDAP_CONTROL_VALUESRETURNFILTER
  43                 LDAP_CONTROL_VALUESRETURNFILTER,
  44 #endif /* LDAP_CONTROL_VALUESRETURNFILTER */
  45                 NULL
  46         };
  47
  48         bi->bi_controls = controls;
  49
  50         bi->bi_flags |=
  51 #if 0
  52                 SLAP_BFLAG_INCREMENT |
  53 #endif
  54                 SLAP_BFLAG_REFERRALS;
  55
  56         Debug( LDAP_DEBUG_TRACE,"==>sql_back_initialize()\n", 0, 0, 0 );
  57
  58         bi->bi_db_init = backsql_db_init;
  59         bi->bi_db_config = backsql_db_config;
  60         bi->bi_db_open = backsql_db_open;
  61         bi->bi_db_close = backsql_db_close;
  62         bi->bi_db_destroy = backsql_db_destroy;
  63
  64         bi->bi_op_abandon = 0;
  65         bi->bi_op_compare = backsql_compare;
  66         bi->bi_op_bind = backsql_bind;
  67         bi->bi_op_unbind = 0;
  68         bi->bi_op_search = backsql_search;
  69         bi->bi_op_modify = backsql_modify;
  70         bi->bi_op_modrdn = backsql_modrdn;
  71         bi->bi_op_add = backsql_add;
  72         bi->bi_op_delete = backsql_delete;
  73
  74         bi->bi_chk_referrals = 0;
  75         bi->bi_operational = backsql_operational;
  76         bi->bi_entry_get_rw = backsql_entry_get;
  77
  78         bi->bi_connection_init = 0;
  79         bi->bi_connection_destroy = backsql_connection_destroy;
  80
  81         Debug( LDAP_DEBUG_TRACE,"<==sql_back_initialize()\n", 0, 0, 0 );
  82         return 0;
  83 }
  84
  85 int
  86 backsql_destroy(
  87         BackendInfo     *bi )
  88 {
  89         Debug( LDAP_DEBUG_TRACE, "==>backsql_destroy()\n", 0, 0, 0 );
  90         Debug( LDAP_DEBUG_TRACE, "<==backsql_destroy()\n", 0, 0, 0 );
  91         return 0;
  92 }
  93
  94 int
  95 backsql_db_init(
  96         BackendDB       *bd )
  97 {
  98         backsql_info    *bi;
  99
 100         Debug( LDAP_DEBUG_TRACE, "==>backsql_db_init()\n", 0, 0, 0 );
 101         bi = (backsql_info *)ch_calloc( 1, sizeof( backsql_info ) );
 102         memset( bi, '\0', sizeof( backsql_info ) );
 103         ldap_pvt_thread_mutex_init( &bi->sql_dbconn_mutex );
 104         ldap_pvt_thread_mutex_init( &bi->sql_schema_mutex );
 105         backsql_init_db_env( bi );
 106
 107         bd->be_private = bi;
 108         Debug( LDAP_DEBUG_TRACE, "<==backsql_db_init()\n", 0, 0, 0 );
 109         return 0;
 110 }
 111
 112 int
 113 backsql_db_destroy(
 114         BackendDB       *bd )
 115 {
 116         backsql_info    *bi = (backsql_info*)bd->be_private;
 117
 118         Debug( LDAP_DEBUG_TRACE, "==>backsql_db_destroy()\n", 0, 0, 0 );
 119         ldap_pvt_thread_mutex_lock( &bi->sql_dbconn_mutex );
 120         backsql_free_db_env( bi );
 121         ldap_pvt_thread_mutex_unlock( &bi->sql_dbconn_mutex );
 122         ldap_pvt_thread_mutex_destroy( &bi->sql_dbconn_mutex );
 123         ldap_pvt_thread_mutex_lock( &bi->sql_schema_mutex );
 124         backsql_destroy_schema_map( bi );
 125         ldap_pvt_thread_mutex_unlock( &bi->sql_schema_mutex );
 126         ldap_pvt_thread_mutex_destroy( &bi->sql_schema_mutex );
 127         free( bi->sql_dbname );
 128         free( bi->sql_dbuser );
 129         if ( bi->sql_dbpasswd ) {
 130                 free( bi->sql_dbpasswd );
 131         }
 132         if ( bi->sql_dbhost ) {
 133                 free( bi->sql_dbhost );
 134         }
 135         if ( bi->sql_upper_func.bv_val ) {
 136                 free( bi->sql_upper_func.bv_val );
 137                 free( bi->sql_upper_func_open.bv_val );
 138                 free( bi->sql_upper_func_close.bv_val );
 139         }
 140
 141         free( bi->sql_subtree_cond.bv_val );
 142         free( bi->sql_oc_query );
 143         free( bi->sql_at_query );
 144         free( bi->sql_insentry_stmt );
 145         free( bi->sql_delentry_stmt );
 146         free( bi->sql_renentry_stmt );
 147         free( bi->sql_delobjclasses_stmt );
 148         free( bi->sql_delreferrals_stmt );
 149
 150         if ( bi->sql_anlist ) {
 151                 int     i;
 152
 153                 for ( i = 0; !BER_BVISNULL( &bi->sql_anlist[i].an_name ); i++ )
 154                 {
 155                         ch_free( bi->sql_anlist[i].an_name.bv_val );
 156                 }
 157                 ch_free( bi->sql_anlist );
 158         }
 159
 160         if ( bi->sql_baseObject ) {
 161                 entry_free( bi->sql_baseObject );
 162         }
 163
 164         free( bi );
 165
 166         Debug( LDAP_DEBUG_TRACE, "<==backsql_db_destroy()\n", 0, 0, 0 );
 167         return 0;
 168 }
 169
 170 int
 171 backsql_db_open(
 172         BackendDB       *bd )
 173 {
 174         backsql_info    *bi = (backsql_info*)bd->be_private;
 175         SQLHDBC         dbh = SQL_NULL_HDBC;
 176         struct berbuf   bb = BB_NULL;
 177
 178         char            opbuf[ OPERATION_BUFFER_SIZE ];
 179         Operation*      op = (Operation *)opbuf;
 180
 181         Debug( LDAP_DEBUG_TRACE, "==>backsql_db_open(): "
 182                 "testing RDBMS connection\n", 0, 0, 0 );
 183         if ( bi->sql_dbname == NULL ) {
 184                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 185                         "datasource name not specified "
 186                         "(use \"dbname\" directive in slapd.conf)\n", 0, 0, 0 );
 187                 return 1;
 188         }
 189
 190         if ( bi->sql_concat_func == NULL ) {
 191                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 192                         "concat func not specified (use \"concat_pattern\" "
 193                         "directive in slapd.conf)\n", 0, 0, 0 );
 194
 195                 if ( backsql_split_pattern( backsql_def_concat_func,
 196                                 &bi->sql_concat_func, 2 ) ) {
 197                         Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 198                                 "unable to parse pattern \"%s\"",
 199                                 backsql_def_concat_func, 0, 0 );
 200                         return 1;
 201                 }
 202         }
 203
 204         /*
 205          * Prepare cast string as required
 206          */
 207         if ( bi->sql_upper_func.bv_val ) {
 208                 char buf[1024];
 209
 210                 if ( BACKSQL_UPPER_NEEDS_CAST( bi ) ) {
 211                         snprintf( buf, sizeof( buf ),
 212                                 "%s(cast (" /* ? as varchar(%d))) */ ,
 213                                 bi->sql_upper_func.bv_val );
 214                         ber_str2bv( buf, 0, 1, &bi->sql_upper_func_open );
 215
 216                         snprintf( buf, sizeof( buf ),
 217                                 /* (cast(? */ " as varchar(%d)))",
 218                                 BACKSQL_MAX_DN_LEN );
 219                         ber_str2bv( buf, 0, 1, &bi->sql_upper_func_close );
 220
 221                 } else {
 222                         snprintf( buf, sizeof( buf ), "%s(" /* ?) */ ,
 223                                         bi->sql_upper_func.bv_val );
 224                         ber_str2bv( buf, 0, 1, &bi->sql_upper_func_open );
 225
 226                         ber_str2bv( /* (? */ ")", 0, 1, &bi->sql_upper_func_close );
 227                 }
 228         }
 229
 230         /* normalize filter values only if necessary */
 231         bi->sql_caseIgnoreMatch = mr_find( "caseIgnoreMatch" );
 232         assert( bi->sql_caseIgnoreMatch );
 233
 234         bi->sql_telephoneNumberMatch = mr_find( "telephoneNumberMatch" );
 235         assert( bi->sql_telephoneNumberMatch );
 236
 237         if ( bi->sql_dbuser == NULL ) {
 238                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 239                         "user name not specified "
 240                         "(use \"dbuser\" directive in slapd.conf)\n", 0, 0, 0 );
 241                 return 1;
 242         }
 243
 244         if ( bi->sql_subtree_cond.bv_val == NULL ) {
 245                 /*
 246                  * Prepare concat function for subtree search condition
 247                  */
 248                 struct berval   concat;
 249                 struct berval   values[] = {
 250                         BER_BVC( "'%'" ),
 251                         BER_BVC( "?" ),
 252                         BER_BVNULL
 253                 };
 254                 struct berbuf   bb = BB_NULL;
 255
 256                 if ( backsql_prepare_pattern( bi->sql_concat_func, values,
 257                                 &concat ) ) {
 258                         Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 259                                 "unable to prepare CONCAT pattern", 0, 0, 0 );
 260                         return 1;
 261                 }
 262
 263                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 264                         "subtree search SQL condition not specified "
 265                         "(use \"subtree_cond\" directive in slapd.conf)\n",
 266                         0, 0, 0);
 267
 268                 if ( bi->sql_upper_func.bv_val ) {
 269
 270                         /*
 271                          * UPPER(ldap_entries.dn) LIKE UPPER(CONCAT('%',?))
 272                          */
 273
 274                         backsql_strfcat( &bb, "blbbb",
 275                                         &bi->sql_upper_func,
 276                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE " ),
 277                                                 "(ldap_entries.dn) LIKE ",
 278                                         &bi->sql_upper_func_open,
 279                                         &concat,
 280                                         &bi->sql_upper_func_close );
 281
 282                 } else {
 283
 284                         /*
 285                          * ldap_entries.dn LIKE CONCAT('%',?)
 286                          */
 287
 288                         backsql_strfcat( &bb, "lb",
 289                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE " ),
 290                                                 "ldap_entries.dn LIKE ",
 291                                         &concat );
 292                 }
 293
 294                 bi->sql_subtree_cond = bb.bb_val;
 295
 296                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 297                         "setting \"%s\" as default\n",
 298                         bi->sql_subtree_cond.bv_val, 0, 0 );
 299         }
 300
 301         if ( bi->sql_children_cond.bv_val == NULL ) {
 302                 struct berbuf   bb = BB_NULL;
 303
 304                 if ( bi->sql_upper_func.bv_val ) {
 305
 306                         /*
 307                          * UPPER(ldap_entries.dn) LIKE UPPER(CONCAT('%,',?))
 308                          */
 309
 310                         backsql_strfcat( &bb, "blbl",
 311                                         &bi->sql_upper_func,
 312                                         (ber_len_t)STRLENOF( "(ldap_entries.dn)=" ),
 313                                                 "(ldap_entries.dn)=",
 314                                         &bi->sql_upper_func,
 315                                         (ber_len_t)STRLENOF( "(?)" ), "(?)" );
 316
 317                 } else {
 318
 319                         /*
 320                          * ldap_entries.dn LIKE CONCAT('%,',?)
 321                          */
 322
 323                         backsql_strfcat( &bb, "l",
 324                                         (ber_len_t)STRLENOF( "ldap_entries.dn=?" ),
 325                                                 "ldap_entries.dn=?");
 326                 }
 327
 328                 bi->sql_children_cond = bb.bb_val;
 329
 330                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 331                         "setting \"%s\" as default\n",
 332                         bi->sql_children_cond.bv_val, 0, 0 );
 333         }
 334
 335         if ( bi->sql_oc_query == NULL ) {
 336                 if ( BACKSQL_CREATE_NEEDS_SELECT( bi ) ) {
 337                         bi->sql_oc_query =
 338                                 ch_strdup( backsql_def_needs_select_oc_query );
 339
 340                 } else {
 341                         bi->sql_oc_query = ch_strdup( backsql_def_oc_query );
 342                 }
 343
 344                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 345                         "objectclass mapping SQL statement not specified "
 346                         "(use \"oc_query\" directive in slapd.conf)\n",
 347                         0, 0, 0 );
 348                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 349                         "setting \"%s\" by default\n", bi->sql_oc_query, 0, 0 );
 350         }
 351
 352         if ( bi->sql_at_query == NULL ) {
 353                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 354                         "attribute mapping SQL statement not specified "
 355                         "(use \"at_query\" directive in slapd.conf)\n",
 356                         0, 0, 0 );
 357                 Debug(LDAP_DEBUG_TRACE, "backsql_db_open(): "
 358                         "setting \"%s\" by default\n",
 359                         backsql_def_at_query, 0, 0 );
 360                 bi->sql_at_query = ch_strdup( backsql_def_at_query );
 361         }
 362
 363         if ( bi->sql_insentry_stmt == NULL ) {
 364                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 365                         "entry insertion SQL statement not specified "
 366                         "(use \"insentry_stmt\" directive in slapd.conf)\n",
 367                         0, 0, 0 );
 368                 Debug(LDAP_DEBUG_TRACE, "backsql_db_open(): "
 369                         "setting \"%s\" by default\n",
 370                         backsql_def_insentry_stmt, 0, 0 );
 371                 bi->sql_insentry_stmt = ch_strdup( backsql_def_insentry_stmt );
 372         }
 373
 374         if ( bi->sql_delentry_stmt == NULL ) {
 375                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 376                         "entry deletion SQL statement not specified "
 377                         "(use \"delentry_stmt\" directive in slapd.conf)\n",
 378                         0, 0, 0 );
 379                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 380                         "setting \"%s\" by default\n",
 381                         backsql_def_delentry_stmt, 0, 0 );
 382                 bi->sql_delentry_stmt = ch_strdup( backsql_def_delentry_stmt );
 383         }
 384
 385         if ( bi->sql_renentry_stmt == NULL ) {
 386                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 387                         "entry deletion SQL statement not specified "
 388                         "(use \"renentry_stmt\" directive in slapd.conf)\n",
 389                         0, 0, 0 );
 390                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 391                         "setting \"%s\" by default\n",
 392                         backsql_def_renentry_stmt, 0, 0 );
 393                 bi->sql_renentry_stmt = ch_strdup( backsql_def_renentry_stmt );
 394         }
 395
 396         if ( bi->sql_delobjclasses_stmt == NULL ) {
 397                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 398                         "objclasses deletion SQL statement not specified "
 399                         "(use \"delobjclasses_stmt\" directive in slapd.conf)\n",
 400                         0, 0, 0 );
 401                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 402                         "setting \"%s\" by default\n",
 403                         backsql_def_delobjclasses_stmt, 0, 0 );
 404                 bi->sql_delobjclasses_stmt = ch_strdup( backsql_def_delobjclasses_stmt );
 405         }
 406
 407         if ( bi->sql_delreferrals_stmt == NULL ) {
 408                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 409                         "referrals deletion SQL statement not specified "
 410                         "(use \"delreferrals_stmt\" directive in slapd.conf)\n",
 411                         0, 0, 0 );
 412                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 413                         "setting \"%s\" by default\n",
 414                         backsql_def_delreferrals_stmt, 0, 0 );
 415                 bi->sql_delreferrals_stmt = ch_strdup( backsql_def_delreferrals_stmt );
 416         }
 417
 418         op->o_hdr = (Opheader *)&op[ 1 ];
 419         op->o_connid = (unsigned long)(-1);
 420         op->o_bd = bd;
 421         if ( backsql_get_db_conn( op, &dbh ) != LDAP_SUCCESS ) {
 422                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 423                         "connection failed, exiting\n", 0, 0, 0 );
 424                 return 1;
 425         }
 426
 427         /*
 428          * Prepare ID selection query
 429          */
 430         if ( bi->sql_id_query == NULL ) {
 431                 /* no custom id_query provided */
 432                 if ( bi->sql_upper_func.bv_val == NULL ) {
 433                         backsql_strcat( &bb, backsql_id_query, "dn=?", NULL );
 434
 435                 } else {
 436                         if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
 437                                 backsql_strcat( &bb, backsql_id_query,
 438                                                 "dn_ru=?", NULL );
 439                         } else {
 440                                 if ( BACKSQL_USE_REVERSE_DN( bi ) ) {
 441                                         backsql_strfcat( &bb, "sbl",
 442                                                         backsql_id_query,
 443                                                         &bi->sql_upper_func,
 444                                                         (ber_len_t)STRLENOF( "(dn)=?" ), "(dn)=?" );
 445                                 } else {
 446                                         backsql_strfcat( &bb, "sblbcb",
 447                                                         backsql_id_query,
 448                                                         &bi->sql_upper_func,
 449                                                         (ber_len_t)STRLENOF( "(dn)=" ), "(dn)=",
 450                                                         &bi->sql_upper_func_open,
 451                                                         '?',
 452                                                         &bi->sql_upper_func_close );
 453                                 }
 454                         }
 455                 }
 456                 bi->sql_id_query = bb.bb_val.bv_val;
 457         }
 458
 459         /*
 460          * Prepare children ID selection query
 461          */
 462         bi->sql_has_children_query = NULL;
 463
 464         bb.bb_val.bv_val = NULL;
 465         bb.bb_val.bv_len = 0;
 466         bb.bb_len = 0;
 467         backsql_strfcat( &bb, "sb",
 468                         "SELECT COUNT(distinct subordinates.id) FROM ldap_entries,ldap_entries subordinates WHERE subordinates.parent=ldap_entries.id AND ",
 469
 470                         &bi->sql_children_cond );
 471         bi->sql_has_children_query = bb.bb_val.bv_val;
 472
 473         backsql_free_db_conn( op );
 474         if ( !BACKSQL_SCHEMA_LOADED( bi ) ) {
 475                 Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "
 476                         "test failed, schema map not loaded - exiting\n",
 477                         0, 0, 0 );
 478                 return 1;
 479         }
 480
 481         /* should never happen! */
 482         assert( bd->be_nsuffix != NULL );
 483
 484         if ( BER_BVISNULL( &bd->be_nsuffix[ 1 ] ) ) {
 485                 /* enable if only one suffix is defined */
 486                 bi->sql_flags |= BSQLF_USE_SUBTREE_SHORTCUT;
 487         }
 488
 489         Debug( LDAP_DEBUG_TRACE, "<==backsql_db_open(): "
 490                 "test succeeded, schema map loaded\n", 0, 0, 0 );
 491         return 0;
 492 }
 493
 494 int
 495 backsql_db_close(
 496         BackendDB       *bd )
 497 {
 498         Debug( LDAP_DEBUG_TRACE, "==>backsql_db_close()\n", 0, 0, 0 );
 499         Debug( LDAP_DEBUG_TRACE, "<==backsql_db_close()\n", 0, 0, 0 );
 500         return 0;
 501 }
 502
 503 int
 504 backsql_connection_destroy( Backend *bd, Connection *c )
 505 {
 506         char            opbuf[ OPERATION_BUFFER_SIZE ];
 507         Operation*      op = (Operation *)opbuf;
 508
 509         op->o_hdr = (Opheader *)&op[ 1 ];
 510         op->o_connid = c->c_connid;
 511         op->o_bd = bd;
 512
 513         Debug( LDAP_DEBUG_TRACE, "==>backsql_connection_destroy()\n", 0, 0, 0 );
 514         backsql_free_db_conn( op );
 515         Debug( LDAP_DEBUG_TRACE, "<==backsql_connection_destroy()\n", 0, 0, 0 );
 516
 517         return 0;
 518 }
 519
 520 #if SLAPD_SQL == SLAPD_MOD_DYNAMIC
 521
 522 /* conditionally define the init_module() function */
 523 SLAP_BACKEND_INIT_MODULE( sql )
 524
 525 #endif /* SLAPD_SQL == SLAPD_MOD_DYNAMIC */
 526