1 /* $OpenLDAP: pkg/ldap/servers/slapd/back-sql/back-sql.h,v 1.49.2.4 2008/02/11 23:26:48 kurt Exp $ */ 2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 3 * 4 * Copyright 1999-2008 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 applied (reworked) 80 * 5. returncodes.patch applied (with sanity checks) 81 * 6. connpool.patch under evaluation 82 * 7. modoc.patch under evaluation (requires 83 * manageDSAit and "manage" 84 * access privileges) 85 * 8. miscfixes.patch applied (reworked; other 86 * operations need to load the 87 * entire entry for ACL purposes; 88 * see ITS#3480, now fixed) 89 * 90 * original description: 91 92 Changes that were made to the SQL backend. 93 94 The patches were made against 2.2.18 and can be applied individually, 95 but would best be applied in the numerical order of the file names. 96 A synopsis of each patch is given here: 97 98 99 1. Added an option to set SQL query for the "id_query" operation. 100 101 2. Added an option to the SQL backend called "use_subtree_shortcut". 102 When a search is performed, the SQL query includes a WHERE clause 103 which says the DN must be "LIKE %<searchbase>". The LIKE operation 104 can be slow in an RDBM. This shortcut option says that if the 105 searchbase of the LDAP search is the root DN of the SQL backend, 106 and thus all objects will match the LIKE operator, do not include 107 the "LIKE %<searchbase>" clause in the SQL query (it is replaced 108 instead by the always true "1=1" clause to keep the "AND"'s 109 working correctly). This option is off by default, and should be 110 turned on only if all objects to be found in the RDBM are under the 111 same root DN. Multiple backends working within the same RDBM table 112 space would encounter problems. LDAP searches whose searchbase are 113 not at the root DN will bypass this shortcut and employ the LIKE 114 clause. 115 116 3. Added a "create_hint" column to ldap_oc_mappings table. Allows 117 taking the value of an attr named in "create_hint" and passing it to 118 the create_proc procedure. This is necessary for when an objectClass's 119 table is partition indexed by some indexing column and thus the value 120 in that indexing column cannot change after the row is created. The 121 value for the indexed column is passed into the create_proc, which 122 uses it to fill in the indexed column as the new row is created. 123 124 4. When loading the values of an attribute, the count(*) of the number 125 of values is fetched first and memory is allocated for the array of 126 values and normalized values. The old system of loading the values one 127 by one and running realloc() on the array of values and normalized 128 values each time was badly fragmenting memory. The array of values and 129 normalized values would be side by side in memory, and realloc()'ing 130 them over and over would force them to leapfrog each other through all 131 of available memory. Attrs with a large number of values could not be 132 loaded without crashing the slapd daemon. 133 134 5. Added code to interpret the value returned by stored procedures 135 which have expect_return set. Returned value is interpreted as an LDAP 136 return code. This allows the distinction between the SQL failing to 137 execute and the SQL running to completion and returning an error code 138 which can indicate a policy violation. 139 140 6. Added RDBM connection pooling. Once an operation is finished the 141 connection to the RDBM is returned to a pool rather than closing. 142 Allows the next operation to skip the initialization and authentication 143 phases of contacting the RDBM. Also, if licensing with ODBC places 144 a limit on the number of connections, an LDAP thread can block waiting 145 for another thread to finish, so that no LDAP errors are returned 146 for having more LDAP connections than allowed RDBM connections. An 147 RDBM connection which receives an SQL error is marked as "tainted" 148 so that it will be closed rather than returned to the pool. 149 Also, RDBM connections must be bound to a given LDAP connection AND 150 operation number, and NOT just the connection number. Asynchronous 151 LDAP clients can have multiple simultaneous LDAP operations which 152 should not share the same RDBM connection. A given LDAP operation can 153 even make multiple SQL operations (e.g. a BIND operation which 154 requires SASL to perform an LDAP search to convert the SASL ID to an 155 LDAP DN), so each RDBM connection now has a refcount that must reach 156 zero before the connection is returned to the free pool. 157 158 7. Added ability to change the objectClass of an object. Required 159 considerable work to copy all attributes out of old object and into 160 new object. Does a schema check before proceeding. Creates a new 161 object, fills it in, deletes the old object, then changes the 162 oc_map_id and keyval of the entry in the "ldap_entries" table. 163 164 8. Generic fixes. Includes initializing pointers before they 165 get used in error branch cases, pointer checks before dereferencing, 166 resetting a return code to success after a COMPARE op, sealing 167 memory leaks, and in search.c, changing some of the "1=1" tests to 168 "2=2", "3=3", etc so that when reading slapd trace output, the 169 location in the source code where the x=x test was added to the SQL 170 can be easily distinguished. 171 */ 172 173 #ifndef __BACKSQL_H__ 174 #define __BACKSQL_H__ 175 176 /* former sql-types.h */ 177 #include <sql.h> 178 #include <sqlext.h> 179 180 typedef struct { 181 SWORD ncols; 182 BerVarray col_names; 183 UDWORD *col_prec; 184 SQLSMALLINT *col_type; 185 char **cols; 186 SQLINTEGER *value_len; 187 } BACKSQL_ROW_NTS; 188 189 /* 190 * Better use the standard length of 8192 (as of slap.h)? 191 * 192 * NOTE: must be consistent with definition in ldap_entries table 193 */ 194 /* #define BACKSQL_MAX_DN_LEN SLAP_LDAPDN_MAXLEN */ 195 #define BACKSQL_MAX_DN_LEN 255 196 197 /* 198 * define to enable very extensive trace logging (debug only) 199 */ 200 #undef BACKSQL_TRACE 201 202 /* 203 * define if using MS SQL and workaround needed (see sql-wrap.c) 204 */ 205 #undef BACKSQL_MSSQL_WORKAROUND 206 207 /* 208 * define to enable values counting for attributes 209 */ 210 #define BACKSQL_COUNTQUERY 211 212 /* 213 * define to enable prettification/validation of values 214 */ 215 #define BACKSQL_PRETTY_VALIDATE 216 217 /* 218 * define to enable varchars as unique keys in user tables 219 * 220 * by default integers are used (and recommended) 221 * for performances. Integers are used anyway in back-sql 222 * related tables. 223 */ 224 #undef BACKSQL_ARBITRARY_KEY 225 226 /* 227 * define to enable support for syncprov overlay 228 */ 229 #define BACKSQL_SYNCPROV 230 231 /* 232 * define to the appropriate aliasing string 233 * 234 * some RDBMSes tolerate (or require) that " AS " is not used 235 * when aliasing tables/columns 236 */ 237 #define BACKSQL_ALIASING "AS " 238 /* #define BACKSQL_ALIASING "" */ 239 240 /* 241 * define to the appropriate quoting char 242 * 243 * some RDBMSes tolerate/require that the aliases be enclosed 244 * in quotes. This is especially true for those that do not 245 * allow keywords used as aliases. 246 */ 247 #define BACKSQL_ALIASING_QUOTE "" 248 /* #define BACKSQL_ALIASING_QUOTE "\"" */ 249 /* #define BACKSQL_ALIASING_QUOTE "'" */ 250 251 /* 252 * API 253 * 254 * a simple mechanism to allow DN mucking between the LDAP 255 * and the stored string representation. 256 */ 257 typedef struct backsql_api { 258 char *ba_name; 259 int (*ba_config)( struct backsql_api *self, int argc, char *argv[] ); 260 int (*ba_destroy)( struct backsql_api *self ); 261 262 int (*ba_dn2odbc)( Operation *op, SlapReply *rs, struct berval *dn ); 263 int (*ba_odbc2dn)( Operation *op, SlapReply *rs, struct berval *dn ); 264 265 void *ba_private; 266 struct backsql_api *ba_next; 267 } backsql_api; 268 269 /* 270 * "structural" objectClass mapping structure 271 */ 272 typedef struct backsql_oc_map_rec { 273 /* 274 * Structure of corresponding LDAP objectClass definition 275 */ 276 ObjectClass *bom_oc; 277 #define BACKSQL_OC_NAME(ocmap) ((ocmap)->bom_oc->soc_cname.bv_val) 278 279 struct berval bom_keytbl; 280 struct berval bom_keycol; 281 /* expected to return keyval of newly created entry */ 282 char *bom_create_proc; 283 /* in case create_proc does not return the keyval of the newly 284 * created row */ 285 char *bom_create_keyval; 286 /* supposed to expect keyval as parameter and delete 287 * all the attributes as well */ 288 char *bom_delete_proc; 289 /* flags whether delete_proc is a function (whether back-sql 290 * should bind first parameter as output for return code) */ 291 int bom_expect_return; 292 unsigned long bom_id; 293 Avlnode *bom_attrs; 294 AttributeDescription *bom_create_hint; 295 } backsql_oc_map_rec; 296 297 /* 298 * attributeType mapping structure 299 */ 300 typedef struct backsql_at_map_rec { 301 /* Description of corresponding LDAP attribute type */ 302 AttributeDescription *bam_ad; 303 AttributeDescription *bam_true_ad; 304 /* ObjectClass if bam_ad is objectClass */ 305 ObjectClass *bam_oc; 306 307 struct berval bam_from_tbls; 308 struct berval bam_join_where; 309 struct berval bam_sel_expr; 310 311 /* TimesTen, or, if a uppercase function is defined, 312 * an uppercased version of bam_sel_expr */ 313 struct berval bam_sel_expr_u; 314 315 /* supposed to expect 2 binded values: entry keyval 316 * and attr. value to add, like "add_name(?,?,?)" */ 317 char *bam_add_proc; 318 /* supposed to expect 2 binded values: entry keyval 319 * and attr. value to delete */ 320 char *bam_delete_proc; 321 /* for optimization purposes attribute load query 322 * is preconstructed from parts on schemamap load time */ 323 char *bam_query; 324 #ifdef BACKSQL_COUNTQUERY 325 char *bam_countquery; 326 #endif /* BACKSQL_COUNTQUERY */ 327 /* following flags are bitmasks (first bit used for add_proc, 328 * second - for delete_proc) */ 329 /* order of parameters for procedures above; 330 * 1 means "data then keyval", 0 means "keyval then data" */ 331 int bam_param_order; 332 /* flags whether one or more of procedures is a function 333 * (whether back-sql should bind first parameter as output 334 * for return code) */ 335 int bam_expect_return; 336 337 /* next mapping for attribute */ 338 struct backsql_at_map_rec *bam_next; 339 } backsql_at_map_rec; 340 341 #define BACKSQL_AT_MAP_REC_INIT { NULL, NULL, BER_BVC(""), BER_BVC(""), BER_BVNULL, BER_BVNULL, NULL, NULL, NULL, 0, 0, NULL } 342 343 /* define to uppercase filters only if the matching rule requires it 344 * (currently broken) */ 345 /* #define BACKSQL_UPPERCASE_FILTER */ 346 347 #define BACKSQL_AT_CANUPPERCASE(at) ( !BER_BVISNULL( &(at)->bam_sel_expr_u ) ) 348 349 /* defines to support bitmasks above */ 350 #define BACKSQL_ADD 0x1 351 #define BACKSQL_DEL 0x2 352 353 #define BACKSQL_IS_ADD(x) ( ( BACKSQL_ADD & (x) ) == BACKSQL_ADD ) 354 #define BACKSQL_IS_DEL(x) ( ( BACKSQL_DEL & (x) ) == BACKSQL_DEL ) 355 356 #define BACKSQL_NCMP(v1,v2) ber_bvcmp((v1),(v2)) 357 358 #define BACKSQL_CONCAT 359 /* 360 * berbuf structure: a berval with a buffer size associated 361 */ 362 typedef struct berbuf { 363 struct berval bb_val; 364 ber_len_t bb_len; 365 } BerBuffer; 366 367 #define BB_NULL { BER_BVNULL, 0 } 368 369 /* 370 * Entry ID structure 371 */ 372 typedef struct backsql_entryID { 373 /* #define BACKSQL_ARBITRARY_KEY to allow a non-numeric key. 374 * It is required by some special applications that use 375 * strings as keys for the main table. 376 * In this case, #define BACKSQL_MAX_KEY_LEN consistently 377 * with the key size definition */ 378 #ifdef BACKSQL_ARBITRARY_KEY 379 struct berval eid_id; 380 struct berval eid_keyval; 381 #define BACKSQL_MAX_KEY_LEN 64 382 #else /* ! BACKSQL_ARBITRARY_KEY */ 383 /* The original numeric key is maintained as default. */ 384 unsigned long eid_id; 385 unsigned long eid_keyval; 386 #endif /* ! BACKSQL_ARBITRARY_KEY */ 387 388 unsigned long eid_oc_id; 389 backsql_oc_map_rec *eid_oc; 390 struct berval eid_dn; 391 struct berval eid_ndn; 392 struct backsql_entryID *eid_next; 393 } backsql_entryID; 394 395 #ifdef BACKSQL_ARBITRARY_KEY 396 #define BACKSQL_ENTRYID_INIT { BER_BVNULL, BER_BVNULL, 0, NULL, BER_BVNULL, BER_BVNULL, NULL } 397 #else /* ! BACKSQL_ARBITRARY_KEY */ 398 #define BACKSQL_ENTRYID_INIT { 0, 0, 0, NULL, BER_BVNULL, BER_BVNULL, NULL } 399 #endif /* BACKSQL_ARBITRARY_KEY */ 400 401 /* the function must collect the entry associated to nbase */ 402 #define BACKSQL_ISF_GET_ID 0x1U 403 #define BACKSQL_ISF_GET_ENTRY ( 0x2U | BACKSQL_ISF_GET_ID ) 404 #define BACKSQL_ISF_GET_OC ( 0x4U | BACKSQL_ISF_GET_ID ) 405 #define BACKSQL_ISF_MATCHED 0x8U 406 #define BACKSQL_IS_GET_ID(f) \ 407 ( ( (f) & BACKSQL_ISF_GET_ID ) == BACKSQL_ISF_GET_ID ) 408 #define BACKSQL_IS_GET_ENTRY(f) \ 409 ( ( (f) & BACKSQL_ISF_GET_ENTRY ) == BACKSQL_ISF_GET_ENTRY ) 410 #define BACKSQL_IS_GET_OC(f) \ 411 ( ( (f) & BACKSQL_ISF_GET_OC ) == BACKSQL_ISF_GET_OC ) 412 #define BACKSQL_IS_MATCHED(f) \ 413 ( ( (f) & BACKSQL_ISF_MATCHED ) == BACKSQL_ISF_MATCHED ) 414 typedef struct backsql_srch_info { 415 Operation *bsi_op; 416 SlapReply *bsi_rs; 417 418 unsigned bsi_flags; 419 #define BSQL_SF_NONE 0x0000U 420 #define BSQL_SF_ALL_USER 0x0001U 421 #define BSQL_SF_ALL_OPER 0x0002U 422 #define BSQL_SF_ALL_ATTRS (BSQL_SF_ALL_USER|BSQL_SF_ALL_OPER) 423 #define BSQL_SF_FILTER_HASSUBORDINATE 0x0010U 424 #define BSQL_SF_FILTER_ENTRYUUID 0x0020U 425 #define BSQL_SF_FILTER_ENTRYCSN 0x0040U 426 #define BSQL_SF_RETURN_ENTRYUUID (BSQL_SF_FILTER_ENTRYUUID << 8) 427 #define BSQL_ISF(bsi, f) ( ( (bsi)->bsi_flags & f ) == f ) 428 #define BSQL_ISF_ALL_USER(bsi) BSQL_ISF(bsi, BSQL_SF_ALL_USER) 429 #define BSQL_ISF_ALL_OPER(bsi) BSQL_ISF(bsi, BSQL_SF_ALL_OPER) 430 #define BSQL_ISF_ALL_ATTRS(bsi) BSQL_ISF(bsi, BSQL_SF_ALL_ATTRS) 431 432 struct berval *bsi_base_ndn; 433 int bsi_use_subtree_shortcut; 434 backsql_entryID bsi_base_id; 435 int bsi_scope; 436 /* BACKSQL_SCOPE_BASE_LIKE can be set by API in ors_scope 437 * whenever the search base DN contains chars that cannot 438 * be mapped into the charset used in the RDBMS; so they're 439 * turned into '%' and an approximate ('LIKE') condition 440 * is used */ 441 #define BACKSQL_SCOPE_BASE_LIKE ( LDAP_SCOPE_BASE | 0x1000 ) 442 Filter *bsi_filter; 443 time_t bsi_stoptime; 444 445 backsql_entryID *bsi_id_list, 446 **bsi_id_listtail, 447 *bsi_c_eid; 448 int bsi_n_candidates; 449 int bsi_status; 450 451 backsql_oc_map_rec *bsi_oc; 452 struct berbuf bsi_sel, 453 bsi_from, 454 bsi_join_where, 455 bsi_flt_where; 456 ObjectClass *bsi_filter_oc; 457 SQLHDBC bsi_dbh; 458 AttributeName *bsi_attrs; 459 460 Entry *bsi_e; 461 } backsql_srch_info; 462 463 /* 464 * Backend private data structure 465 */ 466 typedef struct backsql_info { 467 char *sql_dbhost; 468 int sql_dbport; 469 char *sql_dbuser; 470 char *sql_dbpasswd; 471 char *sql_dbname; 472 473 /* 474 * SQL condition for subtree searches differs in syntax: 475 * "LIKE CONCAT('%',?)" or "LIKE '%'+?" or "LIKE '%'||?" 476 * or smtg else 477 */ 478 struct berval sql_subtree_cond; 479 struct berval sql_children_cond; 480 struct berval sql_dn_match_cond; 481 char *sql_oc_query; 482 char *sql_at_query; 483 char *sql_insentry_stmt; 484 char *sql_delentry_stmt; 485 char *sql_renentry_stmt; 486 char *sql_delobjclasses_stmt; 487 char *sql_id_query; 488 char *sql_has_children_query; 489 char *sql_list_children_query; 490 491 MatchingRule *sql_caseIgnoreMatch; 492 MatchingRule *sql_telephoneNumberMatch; 493 494 struct berval sql_upper_func; 495 struct berval sql_upper_func_open; 496 struct berval sql_upper_func_close; 497 BerVarray sql_concat_func; 498 struct berval sql_strcast_func; 499 500 struct berval sql_aliasing; 501 struct berval sql_aliasing_quote; 502 struct berval sql_dn_oc_aliasing; 503 504 AttributeName *sql_anlist; 505 506 unsigned int sql_flags; 507 #define BSQLF_SCHEMA_LOADED 0x0001 508 #define BSQLF_UPPER_NEEDS_CAST 0x0002 509 #define BSQLF_CREATE_NEEDS_SELECT 0x0004 510 #define BSQLF_FAIL_IF_NO_MAPPING 0x0008 511 #define BSQLF_HAS_LDAPINFO_DN_RU 0x0010 512 #define BSQLF_DONTCHECK_LDAPINFO_DN_RU 0x0020 513 #define BSQLF_USE_REVERSE_DN 0x0040 514 #define BSQLF_ALLOW_ORPHANS 0x0080 515 #define BSQLF_USE_SUBTREE_SHORTCUT 0x0100 516 #define BSQLF_FETCH_ALL_USERATTRS 0x0200 517 #define BSQLF_FETCH_ALL_OPATTRS 0x0400 518 #define BSQLF_FETCH_ALL_ATTRS (BSQLF_FETCH_ALL_USERATTRS|BSQLF_FETCH_ALL_OPATTRS) 519 #define BSQLF_CHECK_SCHEMA 0x0800 520 521 #define BACKSQL_ISF(si, f) \ 522 (((si)->sql_flags & f) == f) 523 524 #define BACKSQL_SCHEMA_LOADED(si) \ 525 BACKSQL_ISF(si, BSQLF_SCHEMA_LOADED) 526 #define BACKSQL_UPPER_NEEDS_CAST(si) \ 527 BACKSQL_ISF(si, BSQLF_UPPER_NEEDS_CAST) 528 #define BACKSQL_CREATE_NEEDS_SELECT(si) \ 529 BACKSQL_ISF(si, BSQLF_CREATE_NEEDS_SELECT) 530 #define BACKSQL_FAIL_IF_NO_MAPPING(si) \ 531 BACKSQL_ISF(si, BSQLF_FAIL_IF_NO_MAPPING) 532 #define BACKSQL_HAS_LDAPINFO_DN_RU(si) \ 533 BACKSQL_ISF(si, BSQLF_HAS_LDAPINFO_DN_RU) 534 #define BACKSQL_DONTCHECK_LDAPINFO_DN_RU(si) \ 535 BACKSQL_ISF(si, BSQLF_DONTCHECK_LDAPINFO_DN_RU) 536 #define BACKSQL_USE_REVERSE_DN(si) \ 537 BACKSQL_ISF(si, BSQLF_USE_REVERSE_DN) 538 #define BACKSQL_CANUPPERCASE(si) \ 539 (!BER_BVISNULL( &(si)->sql_upper_func )) 540 #define BACKSQL_ALLOW_ORPHANS(si) \ 541 BACKSQL_ISF(si, BSQLF_ALLOW_ORPHANS) 542 #define BACKSQL_USE_SUBTREE_SHORTCUT(si) \ 543 BACKSQL_ISF(si, BSQLF_USE_SUBTREE_SHORTCUT) 544 #define BACKSQL_FETCH_ALL_USERATTRS(si) \ 545 BACKSQL_ISF(si, BSQLF_FETCH_ALL_USERATTRS) 546 #define BACKSQL_FETCH_ALL_OPATTRS(si) \ 547 BACKSQL_ISF(si, BSQLF_FETCH_ALL_OPATTRS) 548 #define BACKSQL_FETCH_ALL_ATTRS(si) \ 549 BACKSQL_ISF(si, BSQLF_FETCH_ALL_ATTRS) 550 #define BACKSQL_CHECK_SCHEMA(si) \ 551 BACKSQL_ISF(si, BSQLF_CHECK_SCHEMA) 552 553 Entry *sql_baseObject; 554 #ifdef BACKSQL_ARBITRARY_KEY 555 #define BACKSQL_BASEOBJECT_IDSTR "baseObject" 556 #define BACKSQL_BASEOBJECT_KEYVAL BACKSQL_BASEOBJECT_IDSTR 557 #define BACKSQL_IS_BASEOBJECT_ID(id) (bvmatch((id), &backsql_baseObject_bv)) 558 #else /* ! BACKSQL_ARBITRARY_KEY */ 559 #define BACKSQL_BASEOBJECT_ID 0 560 #define BACKSQL_BASEOBJECT_IDSTR LDAP_XSTRING(BACKSQL_BASEOBJECT_ID) 561 #define BACKSQL_BASEOBJECT_KEYVAL 0 562 #define BACKSQL_IS_BASEOBJECT_ID(id) (*(id) == BACKSQL_BASEOBJECT_ID) 563 #endif /* ! BACKSQL_ARBITRARY_KEY */ 564 #define BACKSQL_BASEOBJECT_OC 0 565 566 Avlnode *sql_db_conns; 567 SQLHDBC sql_dbh; 568 ldap_pvt_thread_mutex_t sql_dbconn_mutex; 569 Avlnode *sql_oc_by_oc; 570 Avlnode *sql_oc_by_id; 571 ldap_pvt_thread_mutex_t sql_schema_mutex; 572 SQLHENV sql_db_env; 573 574 backsql_api *sql_api; 575 } backsql_info; 576 577 #define BACKSQL_SUCCESS( rc ) \ 578 ( (rc) == SQL_SUCCESS || (rc) == SQL_SUCCESS_WITH_INFO ) 579 580 #define BACKSQL_AVL_STOP 0 581 #define BACKSQL_AVL_CONTINUE 1 582 583 /* see ldap.h for the meaning of the macros and of the values */ 584 #define BACKSQL_LEGAL_ERROR( rc ) \ 585 ( LDAP_RANGE( (rc), 0x00, 0x0e ) \ 586 || LDAP_ATTR_ERROR( (rc) ) \ 587 || LDAP_NAME_ERROR( (rc) ) \ 588 || LDAP_SECURITY_ERROR( (rc) ) \ 589 || LDAP_SERVICE_ERROR( (rc) ) \ 590 || LDAP_UPDATE_ERROR( (rc) ) ) 591 #define BACKSQL_SANITIZE_ERROR( rc ) \ 592 ( BACKSQL_LEGAL_ERROR( (rc) ) ? (rc) : LDAP_OTHER ) 593 594 #define BACKSQL_IS_BINARY(ct) \ 595 ( (ct) == SQL_BINARY \ 596 || (ct) == SQL_VARBINARY \ 597 || (ct) == SQL_LONGVARBINARY) 598 599 #endif /* __BACKSQL_H__ */ 600 601