git.sur5r.net Git - openldap/blob - servers/slapd/back-sql/sql-wrap.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 "ac/string.h"
  25 #include <sys/types.h>
  26
  27 #include "slap.h"
  28 #include "proto-sql.h"
  29
  30 #define MAX_ATTR_LEN 16384
  31
  32 typedef struct backsql_db_conn {
  33         unsigned long   ldap_cid;
  34         SQLHDBC         dbh;
  35 } backsql_db_conn;
  36
  37 void
  38 backsql_PrintErrors( SQLHENV henv, SQLHDBC hdbc, SQLHSTMT sth, int rc )
  39 {
  40         SQLCHAR msg[SQL_MAX_MESSAGE_LENGTH];            /* msg. buffer    */
  41         SQLCHAR state[SQL_SQLSTATE_SIZE];               /* statement buf. */
  42         SDWORD  iSqlCode;                               /* return code    */
  43         SWORD   len = SQL_MAX_MESSAGE_LENGTH - 1;       /* return length  */
  44
  45         Debug( LDAP_DEBUG_TRACE, "Return code: %d\n", rc, 0, 0 );
  46
  47         for ( ; rc = SQLError( henv, hdbc, sth, state, &iSqlCode, msg,
  48                         SQL_MAX_MESSAGE_LENGTH - 1, &len ), BACKSQL_SUCCESS( rc ); ) {
  49                 Debug( LDAP_DEBUG_TRACE,
  50                                 "   Native error code: %d\n"
  51                                 "   SQL engine state:  %s\n"
  52                                 "   Message:           %s\n",
  53                                 (int)iSqlCode, state, msg );
  54         }
  55 }
  56
  57 RETCODE
  58 backsql_Prepare( SQLHDBC dbh, SQLHSTMT *sth, char *query, int timeout )
  59 {
  60         RETCODE         rc;
  61         char            drv_name[ 30 ];
  62         SWORD           len;
  63
  64         rc = SQLAllocStmt( dbh, sth );
  65         if ( rc != SQL_SUCCESS ) {
  66                 return rc;
  67         }
  68
  69 #ifdef BACKSQL_TRACE
  70         Debug( LDAP_DEBUG_TRACE, "==>backsql_Prepare()\n", 0, 0, 0 );
  71 #endif /* BACKSQL_TRACE */
  72
  73         SQLGetInfo( dbh, SQL_DRIVER_NAME, drv_name, sizeof( drv_name ), &len );
  74
  75 #ifdef BACKSQL_TRACE
  76         Debug( LDAP_DEBUG_TRACE, "backsql_Prepare(): driver name=\"%s\"\n",
  77                         drv_name, 0, 0 );
  78 #endif /* BACKSQL_TRACE */
  79
  80         ldap_pvt_str2upper( drv_name );
  81         if ( !strncmp( drv_name, "SQLSRV32.DLL", sizeof( drv_name ) ) ) {
  82                 /*
  83                  * stupid default result set in MS SQL Server
  84                  * does not support multiple active statements
  85                  * on the same connection -- so we are trying
  86                  * to make it not to use default result set...
  87                  */
  88                 Debug( LDAP_DEBUG_TRACE, "_SQLprepare(): "
  89                         "enabling MS SQL Server default result "
  90                         "set workaround\n", 0, 0, 0 );
  91                 rc = SQLSetStmtOption( *sth, SQL_CONCURRENCY,
  92                                 SQL_CONCUR_ROWVER );
  93                 if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO ) {
  94                         Debug( LDAP_DEBUG_TRACE, "backsql_Prepare(): "
  95                                 "SQLSetStmtOption(SQL_CONCURRENCY,"
  96                                 "SQL_CONCUR_ROWVER) failed:\n",
  97                                 0, 0, 0 );
  98                         backsql_PrintErrors( SQL_NULL_HENV, dbh, *sth, rc );
  99                         SQLFreeStmt( *sth, SQL_DROP );
 100                         return rc;
 101                 }
 102         }
 103
 104         if ( timeout > 0 ) {
 105                 Debug( LDAP_DEBUG_TRACE, "_SQLprepare(): "
 106                         "setting query timeout to %d sec.\n",
 107                         timeout, 0, 0 );
 108                 rc = SQLSetStmtOption( *sth, SQL_QUERY_TIMEOUT, timeout );
 109                 if ( rc != SQL_SUCCESS ) {
 110                         backsql_PrintErrors( SQL_NULL_HENV, dbh, *sth, rc );
 111                         SQLFreeStmt( *sth, SQL_DROP );
 112                         return rc;
 113                 }
 114         }
 115
 116 #ifdef BACKSQL_TRACE
 117         Debug( LDAP_DEBUG_TRACE, "<==backsql_Prepare() calling SQLPrepare()\n",
 118                         0, 0, 0 );
 119 #endif /* BACKSQL_TRACE */
 120
 121         return SQLPrepare( *sth, query, SQL_NTS );
 122 }
 123
 124 RETCODE
 125 backsql_BindRowAsStrings( SQLHSTMT sth, BACKSQL_ROW_NTS *row )
 126 {
 127         RETCODE         rc;
 128         SQLCHAR         colname[ 64 ];
 129         SQLSMALLINT     name_len, col_type, col_scale, col_null;
 130         UDWORD          col_prec;
 131         int             i;
 132
 133         if ( row == NULL ) {
 134                 return SQL_ERROR;
 135         }
 136
 137 #ifdef BACKSQL_TRACE
 138         Debug( LDAP_DEBUG_TRACE, "==> backsql_BindRowAsStrings()\n", 0, 0, 0 );
 139 #endif /* BACKSQL_TRACE */
 140
 141         rc = SQLNumResultCols( sth, &row->ncols );
 142         if ( rc != SQL_SUCCESS ) {
 143 #ifdef BACKSQL_TRACE
 144                 Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings(): "
 145                         "SQLNumResultCols() failed:\n", 0, 0, 0 );
 146 #endif /* BACKSQL_TRACE */
 147
 148                 backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC, sth, rc );
 149
 150         } else {
 151 #ifdef BACKSQL_TRACE
 152                 Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
 153                         "ncols=%d\n", (int)row->ncols, 0, 0 );
 154 #endif /* BACKSQL_TRACE */
 155
 156                 row->col_names = (BerVarray)ch_calloc( row->ncols + 1,
 157                                 sizeof( struct berval ) );
 158                 row->cols = (char **)ch_calloc( row->ncols + 1,
 159                                 sizeof( char * ) );
 160                 row->col_prec = (UDWORD *)ch_calloc( row->ncols,
 161                                 sizeof( UDWORD ) );
 162                 row->value_len = (SQLINTEGER *)ch_calloc( row->ncols,
 163                                 sizeof( SQLINTEGER ) );
 164                 for ( i = 1; i <= row->ncols; i++ ) {
 165                         rc = SQLDescribeCol( sth, (SQLSMALLINT)i, &colname[ 0 ],
 166                                         (SQLUINTEGER)( sizeof( colname ) - 1 ),
 167                                         &name_len, &col_type,
 168                                         &col_prec, &col_scale, &col_null );
 169                         ber_str2bv( colname, 0, 1, &row->col_names[ i - 1 ] );
 170 #ifdef BACKSQL_TRACE
 171                         Debug( LDAP_DEBUG_TRACE, "backsql_BindRowAsStrings: "
 172                                 "col_name=%s, col_prec[%d]=%d\n",
 173                                 colname, (int)i, (int)col_prec );
 174 #endif /* BACKSQL_TRACE */
 175                         if ( col_type == SQL_LONGVARCHAR
 176                                         || col_type == SQL_LONGVARBINARY) {
 177 #if 0
 178                                 row->cols[ i - 1 ] = NULL;
 179                                 row->col_prec[ i - 1 ] = -1;
 180
 181                                 /*
 182                                  * such fields must be handled
 183                                  * in some other way since they return 2G
 184                                  * as their precision (at least it does so
 185                                  * with MS SQL Server w/native driver)
 186                                  * for now, we just set fixed precision
 187                                  * for such fields - dirty hack, but...
 188                                  * no time to deal with SQLGetData()
 189                                  */
 190 #endif
 191                                 col_prec = MAX_ATTR_LEN;
 192                                 row->cols[ i - 1 ] = (char *)ch_calloc( col_prec + 1, sizeof( char ) );
 193                                 row->col_prec[ i - 1 ] = col_prec;
 194                                 rc = SQLBindCol( sth, (SQLUSMALLINT)i,
 195                                                 SQL_C_CHAR,
 196                                                 (SQLPOINTER)row->cols[ i - 1 ],
 197                                                 col_prec + 1,
 198                                                 &row->value_len[ i - 1 ] );
 199                         } else {
 200                                 row->cols[ i - 1 ] = (char *)ch_calloc( col_prec + 1, sizeof( char ) );
 201                                 row->col_prec[ i - 1 ] = col_prec;
 202                                 rc = SQLBindCol( sth, (SQLUSMALLINT)i,
 203                                                 SQL_C_CHAR,
 204                                                 (SQLPOINTER)row->cols[ i - 1 ],
 205                                                 col_prec + 1,
 206                                                 &row->value_len[ i - 1 ] );
 207                         }
 208                 }
 209
 210                 row->col_names[ i - 1 ].bv_val = NULL;
 211                 row->col_names[ i - 1 ].bv_len = 0;
 212                 row->cols[ i - 1 ] = NULL;
 213         }
 214
 215 #ifdef BACKSQL_TRACE
 216         Debug( LDAP_DEBUG_TRACE, "<== backsql_BindRowAsStrings()\n", 0, 0, 0 );
 217 #endif /* BACKSQL_TRACE */
 218
 219         return rc;
 220 }
 221
 222 RETCODE
 223 backsql_FreeRow( BACKSQL_ROW_NTS *row )
 224 {
 225         if ( row->cols == NULL ) {
 226                 return SQL_ERROR;
 227         }
 228
 229         ber_bvarray_free( row->col_names );
 230         ldap_charray_free( row->cols );
 231         free( row->col_prec );
 232         free( row->value_len );
 233
 234         return SQL_SUCCESS;
 235 }
 236
 237 static int
 238 backsql_cmp_connid( const void *v_c1, const void *v_c2 )
 239 {
 240         const backsql_db_conn *c1 = v_c1, *c2 = v_c2;
 241         if ( c1->ldap_cid > c2->ldap_cid ) {
 242                 return 1;
 243         }
 244
 245         if ( c1->ldap_cid < c2->ldap_cid ) {
 246                 return -1;
 247         }
 248
 249         return 0;
 250 }
 251
 252 static int
 253 backsql_close_db_conn( backsql_db_conn *conn )
 254 {
 255         Debug( LDAP_DEBUG_TRACE, "==>backsql_close_db_conn()\n", 0, 0, 0 );
 256
 257         /*
 258          * Default transact is SQL_ROLLBACK; commit is required only
 259          * by write operations, and it is explicitly performed after
 260          * each atomic operation succeeds.
 261          */
 262
 263         /* TimesTen */
 264         SQLTransact( SQL_NULL_HENV, conn->dbh, SQL_ROLLBACK );
 265         SQLDisconnect( conn->dbh );
 266         SQLFreeConnect( conn->dbh );
 267         Debug( LDAP_DEBUG_TRACE, "<==backsql_close_db_conn()\n", 0, 0, 0 );
 268         return 1;
 269 }
 270
 271 int
 272 backsql_init_db_env( backsql_info *bi )
 273 {
 274         RETCODE         rc;
 275         int             ret = SQL_SUCCESS;
 276
 277         Debug( LDAP_DEBUG_TRACE, "==>backsql_init_db_env()\n", 0, 0, 0 );
 278         rc = SQLAllocEnv( &bi->sql_db_env );
 279         if ( rc != SQL_SUCCESS ) {
 280                 Debug( LDAP_DEBUG_TRACE, "init_db_env: SQLAllocEnv failed:\n",
 281                                 0, 0, 0 );
 282                 backsql_PrintErrors( SQL_NULL_HENV, SQL_NULL_HDBC,
 283                                 SQL_NULL_HENV, rc );
 284                 ret = SQL_ERROR;
 285         }
 286         Debug( LDAP_DEBUG_TRACE, "<==backsql_init_db_env()=%d\n", ret, 0, 0 );
 287         return ret;
 288 }
 289
 290 int
 291 backsql_free_db_env( backsql_info *bi )
 292 {
 293         Debug( LDAP_DEBUG_TRACE, "==>backsql_free_db_env()\n", 0, 0, 0 );
 294
 295 #ifdef BACKSQL_TRACE
 296         Debug( LDAP_DEBUG_TRACE, "free_db_env(): delete AVL tree here!!!\n",
 297                         0, 0, 0 );
 298 #endif /* BACKSQL_TRACE */
 299
 300         /*
 301          * stop, if frontend waits for all threads to shutdown
 302          * before calling this -- then what are we going to delete??
 303          * everything is already deleted...
 304          */
 305         Debug( LDAP_DEBUG_TRACE, "<==backsql_free_db_env()\n", 0, 0, 0 );
 306         return SQL_SUCCESS;
 307 }
 308
 309 static int
 310 backsql_open_db_conn( backsql_info *bi, unsigned long ldap_cid, backsql_db_conn **pdbc )
 311 {
 312         /* TimesTen */
 313         char                    DBMSName[ 32 ];
 314         backsql_db_conn         *dbc;
 315         int                     rc;
 316
 317         assert( pdbc );
 318         *pdbc = NULL;
 319
 320         Debug( LDAP_DEBUG_TRACE, "==>backsql_open_db_conn()\n", 0, 0, 0 );
 321         dbc = (backsql_db_conn *)ch_calloc( 1, sizeof( backsql_db_conn ) );
 322         dbc->ldap_cid = ldap_cid;
 323         rc = SQLAllocConnect( bi->sql_db_env, &dbc->dbh );
 324         if ( !BACKSQL_SUCCESS( rc ) ) {
 325                 Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn: "
 326                         "SQLAllocConnect() failed:\n", 0, 0, 0 );
 327                 backsql_PrintErrors( bi->sql_db_env, SQL_NULL_HDBC,
 328                                 SQL_NULL_HENV, rc );
 329                 return LDAP_UNAVAILABLE;
 330         }
 331
 332         rc = SQLConnect( dbc->dbh,
 333                         (SQLCHAR*)bi->sql_dbname, SQL_NTS,
 334                         (SQLCHAR*)bi->sql_dbuser, SQL_NTS,
 335                         (SQLCHAR*)bi->sql_dbpasswd, SQL_NTS );
 336         if ( rc != SQL_SUCCESS ) {
 337                 Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn: "
 338                         "SQLConnect() to database \"%s\" as user \"%s\" "
 339                         "%s:\n", bi->sql_dbname, bi->sql_dbuser,
 340                         rc == SQL_SUCCESS_WITH_INFO ?
 341                         "succeeded with info" : "failed" );
 342                 backsql_PrintErrors( bi->sql_db_env, dbc->dbh, SQL_NULL_HENV, rc );
 343                 if ( rc != SQL_SUCCESS_WITH_INFO ) {
 344                         return LDAP_UNAVAILABLE;
 345                 }
 346         }
 347
 348         /*
 349          * TimesTen : Turn off autocommit.  We must explicitly
 350          * commit any transactions.
 351          */
 352         SQLSetConnectOption( dbc->dbh, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF );
 353
 354         /*
 355          * See if this connection is to TimesTen.  If it is,
 356          * remember that fact for later use.
 357          */
 358         /* Assume until proven otherwise */
 359         bi->sql_flags &= ~BSQLF_USE_REVERSE_DN;
 360         DBMSName[ 0 ] = '\0';
 361         rc = SQLGetInfo( dbc->dbh, SQL_DBMS_NAME, (PTR)&DBMSName,
 362                         sizeof( DBMSName ), NULL );
 363         if ( rc == SQL_SUCCESS ) {
 364                 if ( strcmp( DBMSName, "TimesTen" ) == 0 ||
 365                                 strcmp( DBMSName, "Front-Tier" ) == 0 ) {
 366                         Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn: "
 367                                 "TimesTen database!\n", 0, 0, 0 );
 368                         bi->sql_flags |= BSQLF_USE_REVERSE_DN;
 369                 }
 370         } else {
 371                 Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn: "
 372                         "SQLGetInfo() failed:\n", 0, 0, 0 );
 373                 backsql_PrintErrors( bi->sql_db_env, dbc->dbh, SQL_NULL_HENV, rc );
 374                 return rc;
 375         }
 376         /* end TimesTen */
 377
 378         Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn(): "
 379                 "connected, adding to tree\n", 0, 0, 0 );
 380         ldap_pvt_thread_mutex_lock( &bi->sql_dbconn_mutex );
 381         if ( avl_insert( &bi->sql_db_conns, dbc, backsql_cmp_connid, avl_dup_error ) ) {
 382                 Debug( LDAP_DEBUG_TRACE, "backsql_open_db_conn: "
 383                         "duplicate connection ID\n", 0, 0, 0 );
 384                 return LDAP_OTHER;
 385         }
 386         ldap_pvt_thread_mutex_unlock( &bi->sql_dbconn_mutex );
 387         Debug( LDAP_DEBUG_TRACE, "<==backsql_open_db_conn()\n", 0, 0, 0 );
 388
 389         *pdbc = dbc;
 390
 391         return LDAP_SUCCESS;
 392 }
 393
 394 int
 395 backsql_free_db_conn( Operation *op )
 396 {
 397         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
 398         backsql_db_conn         tmp = { 0 },
 399                                 *conn;
 400
 401         Debug( LDAP_DEBUG_TRACE, "==>backsql_free_db_conn()\n", 0, 0, 0 );
 402         tmp.ldap_cid = op->o_connid;
 403         ldap_pvt_thread_mutex_lock( &bi->sql_dbconn_mutex );
 404         conn = avl_delete( &bi->sql_db_conns, &tmp, backsql_cmp_connid );
 405         ldap_pvt_thread_mutex_unlock( &bi->sql_dbconn_mutex );
 406
 407         /*
 408          * we have one thread per connection, as I understand -- so we can
 409          * get this out of critical section
 410          */
 411         if ( conn != NULL ) {
 412                 Debug( LDAP_DEBUG_TRACE, "backsql_free_db_conn(): "
 413                         "closing db connection\n", 0, 0, 0 );
 414                 backsql_close_db_conn( conn );
 415         }
 416         Debug( LDAP_DEBUG_TRACE, "<==backsql_free_db_conn()\n", 0, 0, 0 );
 417         return SQL_SUCCESS;
 418 }
 419
 420 int
 421 backsql_get_db_conn( Operation *op, SQLHDBC *dbh )
 422 {
 423         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
 424         backsql_db_conn         *dbc,
 425                                 tmp = { 0 };
 426         int                     rc = LDAP_SUCCESS;
 427
 428         Debug( LDAP_DEBUG_TRACE, "==>backsql_get_db_conn()\n", 0, 0, 0 );
 429
 430         assert( dbh );
 431         *dbh = SQL_NULL_HDBC;
 432
 433         tmp.ldap_cid = op->o_connid;
 434
 435         /*
 436          * we have one thread per connection, as I understand --
 437          * so we do not need locking here
 438          */
 439         dbc = avl_find( bi->sql_db_conns, &tmp, backsql_cmp_connid );
 440         if ( !dbc ) {
 441                 rc = backsql_open_db_conn( bi, op->o_connid, &dbc );
 442                 if ( rc != LDAP_SUCCESS) {
 443                         Debug( LDAP_DEBUG_TRACE, "backsql_get_db_conn(): "
 444                                 "could not get connection handle "
 445                                 "-- returning NULL\n", 0, 0, 0 );
 446                         return rc;
 447                 }
 448         }
 449
 450         ldap_pvt_thread_mutex_lock( &bi->sql_schema_mutex );
 451         if ( !BACKSQL_SCHEMA_LOADED( bi ) ) {
 452                 Debug( LDAP_DEBUG_TRACE, "backsql_get_db_conn(): "
 453                         "first call -- reading schema map\n", 0, 0, 0 );
 454                 rc = backsql_load_schema_map( bi, dbc->dbh );
 455                 if ( rc != LDAP_SUCCESS ) {
 456                         ldap_pvt_thread_mutex_unlock( &bi->sql_schema_mutex );
 457                         backsql_free_db_conn( op );
 458                         return rc;
 459                 }
 460         }
 461         ldap_pvt_thread_mutex_unlock( &bi->sql_schema_mutex );
 462
 463         *dbh = dbc->dbh;
 464
 465         Debug( LDAP_DEBUG_TRACE, "<==backsql_get_db_conn()\n", 0, 0, 0 );
 466
 467         return LDAP_SUCCESS;
 468 }
 469