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

   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 Mararati.
   7  * Portions Copyright 2004 Mark Adamson.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted only as authorized by the OpenLDAP
  12  * Public License.
  13  *
  14  * A copy of this license is available in the file LICENSE in the
  15  * top-level directory of the distribution or, alternatively, at
  16  * <http://www.OpenLDAP.org/license.html>.
  17  */
  18 /* ACKNOWLEDGEMENTS:
  19  * This work was initially developed by Dmitry Kovalev for inclusion
  20  * by OpenLDAP Software.  Additional significant contributors include
  21  * Pierangelo Masarati and Mark Adamson.
  22  */
  23 /*
  24  * The following changes have been addressed:
  25  *
  26  * Enhancements:
  27  *   - re-styled code for better readability
  28  *   - upgraded backend API to reflect recent changes
  29  *   - LDAP schema is checked when loading SQL/LDAP mapping
  30  *   - AttributeDescription/ObjectClass pointers used for more efficient
  31  *     mapping lookup
  32  *   - bervals used where string length is required often
  33  *   - atomized write operations by committing at the end of each operation
  34  *     and defaulting connection closure to rollback
  35  *   - added LDAP access control to write operations
  36  *   - fully implemented modrdn (with rdn attrs change, deleteoldrdn,
  37  *     access check, parent/children check and more)
  38  *   - added parent access control, children control to delete operation
  39  *   - added structuralObjectClass operational attribute check and
  40  *     value return on search
  41  *   - added hasSubordinate operational attribute on demand
  42  *   - search limits are appropriately enforced
  43  *   - function backsql_strcat() has been made more efficient
  44  *   - concat function has been made configurable by means of a pattern
  45  *   - added config switches:
  46  *       - fail_if_no_mapping   write operations fail if there is no mapping
  47  *       - has_ldapinfo_dn_ru   overrides autodetect
  48  *       - concat_pattern       a string containing two '?' is used
  49  *                              (note that "?||?" should be more portable
  50  *                              than builtin function "CONCAT(?,?)")
  51  *       - strcast_func         cast of string constants in "SELECT DISTINCT
  52  *                              statements (needed by PostgreSQL)
  53  *       - upper_needs_cast     cast the argument of upper when required
  54  *                              (basically when building dn substring queries)
  55  *   - added noop control
  56  *   - added values return filter control
  57  *   - hasSubordinate can be used in search filters (with limitations)
  58  *   - eliminated oc->name; use oc->oc->soc_cname instead
  59  *
  60  * Todo:
  61  *   - add security checks for SQL statements that can be injected (?)
  62  *   - re-test with previously supported RDBMs
  63  *   - replace dn_ru and so with normalized dn (no need for upper() and so
  64  *     in dn match)
  65  *   - implement a backsql_normalize() function to replace the upper()
  66  *     conversion routines
  67  *   - note that subtree deletion, subtree renaming and so could be easily
  68  *     implemented (rollback and consistency checks are available :)
  69  *   - implement "lastmod" and other operational stuff (ldap_entries table ?)
  70  *   - check how to allow multiple operations with one statement, to remove
  71  *     BACKSQL_REALLOC_STMT from modify.c (a more recent unixODBC lib?)
  72  */
  73 /*
  74  * Improvements submitted by (ITS#3432)
  75  *
  76  * 1. id_query.patch            applied (with changes)
  77  * 2. shortcut.patch            applied (reworked)
  78  * 3. create_hint.patch         applied
  79  * 4. count_query.patch         rejected (conflicts with other features)
  80  * 5. returncodes.patch         applied (with sanity checks)
  81  * 6. connpool.patch            under evaluation
  82  * 7. modoc.patch               under evaluation
  83  * 8. miscfixes.patch           applied (reworked; FIXME: other
  84  *                              operations may need to load the
  85  *                              entire entry for ACL purposes)
  86  *
  87  * original description:
  88
  89          Changes that were made to the SQL backend.
  90
  91 The patches were made against 2.2.18 and can be applied individually,
  92 but would best be applied in the numerical order of the file names.
  93 A synopsis of each patch is given here:
  94
  95
  96 1. Added an option to set SQL query for the "id_query" operation.
  97
  98 2. Added an option to the SQL backend called "use_subtree_shortcut".
  99 When a search is performed, the SQL query includes a WHERE clause
 100 which says the DN must be "LIKE %<searchbase>".  The LIKE operation
 101 can be slow in an RDBM. This shortcut option says that if the
 102 searchbase of the LDAP search is the root DN of the SQL backend,
 103 and thus all objects will match the LIKE operator, do not include
 104 the "LIKE %<searchbase>" clause in the SQL query (it is replaced
 105 instead by the always true "1=1" clause to keep the "AND"'s
 106 working correctly).  This option is off by default, and should be
 107 turned on only if all objects to be found in the RDBM are under the
 108 same root DN. Multiple backends working within the same RDBM table
 109 space would encounter problems. LDAP searches whose searchbase are
 110 not at the root DN will bypass this shortcut and employ the LIKE
 111 clause.
 112
 113 3. Added a "create_hint" column to ldap_oc_mappings table. Allows
 114 taking the value of an attr named in "create_hint" and passing it to
 115 the create_proc procedure.  This is necessary for when an objectClass's
 116 table is partition indexed by some indexing column and thus the value
 117 in that indexing column cannot change after the row is created. The
 118 value for the indexed column is passed into the create_proc, which
 119 uses it to fill in the indexed column as the new row is created.
 120
 121 4. When loading the values of an attribute, the count(*) of the number
 122 of values is fetched first and memory is allocated for the array of
 123 values and normalized values. The old system of loading the values one
 124 by one and running realloc() on the array of values and normalized
 125 values each time was badly fragmenting memory. The array of values and
 126 normalized values would be side by side in memory, and realloc()'ing
 127 them over and over would force them to leapfrog each other through all
 128 of available memory. Attrs with a large number of values could not be
 129 loaded without crashing the slapd daemon.
 130
 131 5. Added code to interpret the value returned by stored procedures
 132 which have expect_return set. Returned value is interpreted as an LDAP
 133 return code. This allows the distinction between the SQL failing to
 134 execute and the SQL running to completion and returning an error code
 135 which can indicate a policy violation.
 136
 137 6. Added RDBM connection pooling. Once an operation is finished the
 138 connection to the RDBM is returned to a pool rather than closing.
 139 Allows the next operation to skip the initialization and authentication
 140 phases of contacting the RDBM. Also, if licensing with ODBC places
 141 a limit on the number of connections, an LDAP thread can block waiting
 142 for another thread to finish, so that no LDAP errors are returned
 143 for having more LDAP connections than allowed RDBM connections. An
 144 RDBM connection which receives an SQL error is marked as "tainted"
 145 so that it will be closed rather than returned to the pool.
 146   Also, RDBM connections must be bound to a given LDAP connection AND
 147 operation number, and NOT just the connection number.  Asynchronous
 148 LDAP clients can have multiple simultaneous LDAP operations which
 149 should not share the same RDBM connection.  A given LDAP operation can
 150 even make multiple SQL operations (e.g. a BIND operation which
 151 requires SASL to perform an LDAP search to convert the SASL ID to an
 152 LDAP DN), so each RDBM connection now has a refcount that must reach
 153 zero before the connection is returned to the free pool.
 154
 155 7. Added ability to change the objectClass of an object. Required
 156 considerable work to copy all attributes out of old object and into
 157 new object.  Does a schema check before proceeding.  Creates a new
 158 object, fills it in, deletes the old object, then changes the
 159 oc_map_id and keyval of the entry in the "ldap_entries" table.
 160
 161 8.  Generic fixes. Includes initializing pointers before they
 162 get used in error branch cases, pointer checks before dereferencing,
 163 resetting a return code to success after a COMPARE op, sealing
 164 memory leaks, and in search.c, changing some of the "1=1" tests to
 165 "2=2", "3=3", etc so that when reading slapd trace output, the
 166 location in the source code where the x=x test was added to the SQL
 167 can be easily distinguished.
 168  */
 169
 170 #ifndef __BACKSQL_H__
 171 #define __BACKSQL_H__
 172
 173 /* former sql-types.h */
 174 #include <sql.h>
 175 #include <sqlext.h>
 176
 177 typedef struct {
 178         SWORD           ncols;
 179         BerVarray       col_names;
 180         UDWORD          *col_prec;
 181         char            **cols;
 182         SQLINTEGER      *value_len;
 183 } BACKSQL_ROW_NTS;
 184
 185 /*
 186  * Better use the standard length of 8192 (as of slap.h)?
 187  *
 188  * NOTE: must be consistent with definition in ldap_entries table
 189  */
 190 /* #define BACKSQL_MAX_DN_LEN   SLAP_LDAPDN_MAXLEN */
 191 #define BACKSQL_MAX_DN_LEN      255
 192
 193 /*
 194  * define to enable very extensive trace logging (debug only)
 195  */
 196 #undef BACKSQL_TRACE
 197
 198 /*
 199  * define to enable varchars as unique keys in user tables
 200  *
 201  * by default integers are used (and recommended)
 202  * for performances.  Integers are used anyway in back-sql
 203  * related tables.
 204  */
 205 #undef BACKSQL_ARBITRARY_KEY
 206
 207 /*
 208  * define to enable experimental support for syncporv overlay
 209  */
 210 #ifdef LDAP_DEVEL
 211 #define BACKSQL_SYNCPROV
 212 #endif /* LDAP_DEVEL */
 213
 214 /*
 215  * define to the appropriate aliasing string
 216  *
 217  * some RDBMSes tolerate (or require) that " AS " is not used
 218  * when aliasing tables/columns
 219  */
 220 #define BACKSQL_ALIASING        "AS "
 221 /* #define      BACKSQL_ALIASING        "" */
 222
 223 /*
 224  * define to the appropriate quoting char
 225  *
 226  * some RDBMSes tolerate/require that the aliases be enclosed
 227  * in quotes.  This is especially true for those that do not
 228  * allow keywords used as aliases.
 229  */
 230 /* #define BACKSQL_ALIASING_QUOTE       '"' */
 231 /* #define BACKSQL_ALIASING_QUOTE       '\'' */
 232
 233 /*
 234  * API
 235  *
 236  * a simple mechanism to allow DN mucking between the LDAP
 237  * and the stored string representation.
 238  */
 239 typedef struct backsql_api {
 240         char                    *ba_name;
 241         int                     (*ba_dn2odbc)( Operation *op, SlapReply *rs, struct berval *dn );
 242         int                     (*ba_odbc2dn)( Operation *op, SlapReply *rs, struct berval *dn );
 243         struct backsql_api *ba_next;
 244 } backsql_api;
 245
 246 /*
 247  * Entry ID structure
 248  */
 249 typedef struct backsql_entryID {
 250         /* #define BACKSQL_ARBITRARY_KEY to allow a non-numeric key.
 251          * It is required by some special applications that use
 252          * strings as keys for the main table.
 253          * In this case, #define BACKSQL_MAX_KEY_LEN consistently
 254          * with the key size definition */
 255 #ifdef BACKSQL_ARBITRARY_KEY
 256         struct berval           eid_id;
 257         struct berval           eid_keyval;
 258 #define BACKSQL_MAX_KEY_LEN     64
 259 #else /* ! BACKSQL_ARBITRARY_KEY */
 260         /* The original numeric key is maintained as default. */
 261         unsigned long           eid_id;
 262         unsigned long           eid_keyval;
 263 #endif /* ! BACKSQL_ARBITRARY_KEY */
 264
 265         unsigned long           eid_oc_id;
 266         struct berval           eid_dn;
 267         struct berval           eid_ndn;
 268         struct backsql_entryID  *eid_next;
 269 } backsql_entryID;
 270
 271 #ifdef BACKSQL_ARBITRARY_KEY
 272 #define BACKSQL_ENTRYID_INIT { BER_BVNULL, BER_BVNULL, 0, BER_BVNULL, BER_BVNULL, NULL }
 273 #else /* ! BACKSQL_ARBITRARY_KEY */
 274 #define BACKSQL_ENTRYID_INIT { 0, 0, 0, BER_BVNULL, BER_BVNULL, NULL }
 275 #endif /* BACKSQL_ARBITRARY_KEY */
 276
 277 /*
 278  * "structural" objectClass mapping structure
 279  */
 280 typedef struct backsql_oc_map_rec {
 281         /*
 282          * Structure of corresponding LDAP objectClass definition
 283          */
 284         ObjectClass             *bom_oc;
 285 #define BACKSQL_OC_NAME(ocmap)  ((ocmap)->bom_oc->soc_cname.bv_val)
 286
 287         struct berval           bom_keytbl;
 288         struct berval           bom_keycol;
 289         /* expected to return keyval of newly created entry */
 290         char                    *bom_create_proc;
 291         /* in case create_proc does not return the keyval of the newly
 292          * created row */
 293         char                    *bom_create_keyval;
 294         /* supposed to expect keyval as parameter and delete
 295          * all the attributes as well */
 296         char                    *bom_delete_proc;
 297         /* flags whether delete_proc is a function (whether back-sql
 298          * should bind first parameter as output for return code) */
 299         int                     bom_expect_return;
 300         unsigned long           bom_id;
 301         Avlnode                 *bom_attrs;
 302         AttributeDescription    *bom_create_hint;
 303 } backsql_oc_map_rec;
 304
 305 /*
 306  * attributeType mapping structure
 307  */
 308 typedef struct backsql_at_map_rec {
 309         /* Description of corresponding LDAP attribute type */
 310         AttributeDescription    *bam_ad;
 311         /* ObjectClass if bam_ad is objectClass */
 312         ObjectClass             *bam_oc;
 313
 314         struct berval   bam_from_tbls;
 315         struct berval   bam_join_where;
 316         struct berval   bam_sel_expr;
 317
 318         /* TimesTen, or, if a uppercase function is defined,
 319          * an uppercased version of bam_sel_expr */
 320         struct berval   bam_sel_expr_u;
 321
 322         /* supposed to expect 2 binded values: entry keyval
 323          * and attr. value to add, like "add_name(?,?,?)" */
 324         char            *bam_add_proc;
 325         /* supposed to expect 2 binded values: entry keyval
 326          * and attr. value to delete */
 327         char            *bam_delete_proc;
 328         /* for optimization purposes attribute load query
 329          * is preconstructed from parts on schemamap load time */
 330         char            *bam_query;
 331         /* following flags are bitmasks (first bit used for add_proc,
 332          * second - for delete_proc) */
 333         /* order of parameters for procedures above;
 334          * 1 means "data then keyval", 0 means "keyval then data" */
 335         int             bam_param_order;
 336         /* flags whether one or more of procedures is a function
 337          * (whether back-sql should bind first parameter as output
 338          * for return code) */
 339         int             bam_expect_return;
 340
 341         /* next mapping for attribute */
 342         struct backsql_at_map_rec       *bam_next;
 343 } backsql_at_map_rec;
 344
 345 #define BACKSQL_AT_MAP_REC_INIT { NULL, NULL, BER_BVC(""), BER_BVC(""), BER_BVNULL, BER_BVNULL, NULL, NULL, NULL, 0, 0, NULL }
 346
 347 /* define to uppercase filters only if the matching rule requires it
 348  * (currently broken) */
 349 /* #define      BACKSQL_UPPERCASE_FILTER */
 350
 351 #define BACKSQL_AT_CANUPPERCASE(at)     ((at)->bam_sel_expr_u.bv_val)
 352
 353 /* defines to support bitmasks above */
 354 #define BACKSQL_ADD     0x1
 355 #define BACKSQL_DEL     0x2
 356
 357 #define BACKSQL_IS_ADD(x)       ( BACKSQL_ADD & (x) )
 358 #define BACKSQL_IS_DEL(x)       ( BACKSQL_DEL & (x) )
 359
 360 #define BACKSQL_NCMP(v1,v2)     ber_bvcmp((v1),(v2))
 361
 362 #define BACKSQL_CONCAT
 363 /*
 364  * berbuf structure: a berval with a buffer size associated
 365  */
 366 typedef struct berbuf {
 367         struct berval   bb_val;
 368         ber_len_t       bb_len;
 369 } BerBuffer;
 370
 371 #define BB_NULL         { { 0, NULL }, 0 }
 372
 373 typedef struct backsql_srch_info {
 374         Operation               *bsi_op;
 375         SlapReply               *bsi_rs;
 376
 377         unsigned                bsi_flags;
 378 #define BSQL_SF_NONE                    0x0000U
 379 #define BSQL_SF_ALL_USER                0x0001U
 380 #define BSQL_SF_ALL_OPER                0x0002U
 381 #define BSQL_SF_ALL_ATTRS               (BSQL_SF_ALL_USER|BSQL_SF_ALL_OPER)
 382 #define BSQL_SF_FILTER_HASSUBORDINATE   0x0010U
 383 #define BSQL_SF_FILTER_ENTRYUUID        0x0020U
 384 #define BSQL_SF_FILTER_ENTRYCSN         0x0040U
 385 #define BSQL_SF_RETURN_ENTRYUUID        (BSQL_SF_FILTER_ENTRYUUID << 8)
 386
 387         struct berval           *bsi_base_ndn;
 388         int                     bsi_use_subtree_shortcut;
 389         backsql_entryID         bsi_base_id;
 390         int                     bsi_scope;
 391 /* BACKSQL_SCOPE_BASE_LIKE can be set by API in ors_scope
 392  * whenever the search base DN contains chars that cannot
 393  * be mapped into the charset used in the RDBMS; so they're
 394  * turned into '%' and an approximate ('LIKE') condition
 395  * is used */
 396 #define BACKSQL_SCOPE_BASE_LIKE         ( LDAP_SCOPE_BASE | 0x1000 )
 397         Filter                  *bsi_filter;
 398         int                     bsi_slimit,
 399                                 bsi_tlimit;
 400         time_t                  bsi_stoptime;
 401
 402         backsql_entryID         *bsi_id_list,
 403                                 **bsi_id_listtail,
 404                                 *bsi_c_eid;
 405         int                     bsi_n_candidates;
 406         int                     bsi_abandon;
 407         int                     bsi_status;
 408
 409         backsql_oc_map_rec      *bsi_oc;
 410         struct berbuf           bsi_sel,
 411                                 bsi_from,
 412                                 bsi_join_where,
 413                                 bsi_flt_where;
 414         ObjectClass             *bsi_filter_oc;
 415         SQLHDBC                 bsi_dbh;
 416         AttributeName           *bsi_attrs;
 417
 418         Entry                   *bsi_e;
 419 } backsql_srch_info;
 420
 421 /*
 422  * Backend private data structure
 423  */
 424 typedef struct {
 425         char            *sql_dbhost;
 426         int             sql_dbport;
 427         char            *sql_dbuser;
 428         char            *sql_dbpasswd;
 429         char            *sql_dbname;
 430
 431         /*
 432          * SQL condition for subtree searches differs in syntax:
 433          * "LIKE CONCAT('%',?)" or "LIKE '%'+?" or "LIKE '%'||?"
 434          * or smtg else
 435          */
 436         struct berval   sql_subtree_cond;
 437         struct berval   sql_children_cond;
 438         char            *sql_oc_query,
 439                         *sql_at_query;
 440         char            *sql_insentry_query,
 441                         *sql_delentry_query,
 442                         *sql_delobjclasses_query,
 443                         *sql_delreferrals_query;
 444         char            *sql_id_query;
 445         char            *sql_has_children_query;
 446
 447         MatchingRule    *sql_caseIgnoreMatch;
 448         MatchingRule    *sql_telephoneNumberMatch;
 449
 450         struct berval   sql_upper_func;
 451         struct berval   sql_upper_func_open;
 452         struct berval   sql_upper_func_close;
 453         BerVarray       sql_concat_func;
 454
 455         struct berval   sql_strcast_func;
 456
 457         unsigned int    sql_flags;
 458 #define BSQLF_SCHEMA_LOADED             0x0001
 459 #define BSQLF_UPPER_NEEDS_CAST          0x0002
 460 #define BSQLF_CREATE_NEEDS_SELECT       0x0004
 461 #define BSQLF_FAIL_IF_NO_MAPPING        0x0008
 462 #define BSQLF_HAS_LDAPINFO_DN_RU        0x0010
 463 #define BSQLF_DONTCHECK_LDAPINFO_DN_RU  0x0020
 464 #define BSQLF_USE_REVERSE_DN            0x0040
 465 #define BSQLF_ALLOW_ORPHANS             0x0080
 466 #define BSQLF_USE_SUBTREE_SHORTCUT      0x0100
 467
 468 #define BACKSQL_SCHEMA_LOADED(si) \
 469         ((si)->sql_flags & BSQLF_SCHEMA_LOADED)
 470 #define BACKSQL_UPPER_NEEDS_CAST(si) \
 471         ((si)->sql_flags & BSQLF_UPPER_NEEDS_CAST)
 472 #define BACKSQL_CREATE_NEEDS_SELECT(si) \
 473         ((si)->sql_flags & BSQLF_CREATE_NEEDS_SELECT)
 474 #define BACKSQL_FAIL_IF_NO_MAPPING(si) \
 475         ((si)->sql_flags & BSQLF_FAIL_IF_NO_MAPPING)
 476 #define BACKSQL_HAS_LDAPINFO_DN_RU(si) \
 477         ((si)->sql_flags & BSQLF_HAS_LDAPINFO_DN_RU)
 478 #define BACKSQL_DONTCHECK_LDAPINFO_DN_RU(si) \
 479         ((si)->sql_flags & BSQLF_DONTCHECK_LDAPINFO_DN_RU)
 480 #define BACKSQL_USE_REVERSE_DN(si) \
 481         ((si)->sql_flags & BSQLF_USE_REVERSE_DN)
 482 #define BACKSQL_CANUPPERCASE(si) \
 483         (!BER_BVISNULL( &(si)->sql_upper_func ))
 484 #define BACKSQL_ALLOW_ORPHANS(si) \
 485         ((si)->sql_flags & BSQLF_ALLOW_ORPHANS)
 486 #define BACKSQL_USE_SUBTREE_SHORTCUT(si) \
 487         ((si)->sql_flags & BSQLF_USE_SUBTREE_SHORTCUT)
 488
 489         Entry           *sql_baseObject;
 490 #ifdef BACKSQL_ARBITRARY_KEY
 491 #define BACKSQL_BASEOBJECT_IDSTR        "baseObject"
 492 #define BACKSQL_BASEOBJECT_KEYVAL       BACKSQL_BASEOBJECT_IDSTR
 493 #define BACKSQL_IS_BASEOBJECT_ID(id)    (bvmatch((id), &backsql_baseObject_bv))
 494 #else /* ! BACKSQL_ARBITRARY_KEY */
 495 #define BACKSQL_BASEOBJECT_ID           0
 496 #define BACKSQL_BASEOBJECT_IDSTR        "0"
 497 #define BACKSQL_BASEOBJECT_KEYVAL       0
 498 #define BACKSQL_IS_BASEOBJECT_ID(id)    (*(id) == BACKSQL_BASEOBJECT_ID)
 499 #endif /* ! BACKSQL_ARBITRARY_KEY */
 500 #define BACKSQL_BASEOBJECT_OC           0
 501
 502         Avlnode         *sql_db_conns;
 503         Avlnode         *sql_oc_by_oc;
 504         Avlnode         *sql_oc_by_id;
 505         ldap_pvt_thread_mutex_t         sql_dbconn_mutex;
 506         ldap_pvt_thread_mutex_t         sql_schema_mutex;
 507         SQLHENV         sql_db_env;
 508
 509         backsql_api     *sql_api;
 510 } backsql_info;
 511
 512 #define BACKSQL_SUCCESS( rc ) \
 513         ( (rc) == SQL_SUCCESS || (rc) == SQL_SUCCESS_WITH_INFO )
 514
 515 #define BACKSQL_AVL_STOP                0
 516 #define BACKSQL_AVL_CONTINUE            1
 517
 518 /* see ldap.h for the meaning of the macros and of the values */
 519 #define BACKSQL_LEGAL_ERROR( rc ) \
 520         ( LDAP_RANGE( (rc), 0x00, 0x0e ) \
 521           || LDAP_ATTR_ERROR( (rc) ) \
 522           || LDAP_NAME_ERROR( (rc) ) \
 523           || LDAP_SECURITY_ERROR( (rc) ) \
 524           || LDAP_SERVICE_ERROR( (rc) ) \
 525           || LDAP_UPDATE_ERROR( (rc) ) )
 526 #define BACKSQL_SANITIZE_ERROR( rc ) \
 527         ( BACKSQL_LEGAL_ERROR( (rc) ) ? (rc) : LDAP_OTHER )
 528
 529 #endif /* __BACKSQL_H__ */
 530