| | 1 | /** Connect(load) driver |
| | 2 | |
| | 3 | Copyright (C) 1995 by Ke Jin <kejin@empress.com> |
| | 4 | |
| | 5 | This program is free software; you can redistribute it and/or modify |
| | 6 | it under the terms of the GNU General Public License as published by |
| | 7 | the Free Software Foundation; either version 2 of the License, or |
| | 8 | (at your option) any later version. |
| | 9 | |
| | 10 | This program is distributed in the hope that it will be useful, |
| | 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 13 | GNU General Public License for more details. |
| | 14 | **/ |
| | 15 | |
| | 16 | #include <../iodbc/iodbc.h> |
| | 17 | |
| | 18 | #include <../iodbc/isql.h> |
| | 19 | #include <../iodbc/isqlext.h> |
| | 20 | |
| | 21 | #include <../iodbc/dlproc.h> |
| | 22 | |
| | 23 | #include <../iodbc/herr.h> |
| | 24 | #include <../iodbc/henv.h> |
| | 25 | #include <../iodbc/hdbc.h> |
| | 26 | #include <../iodbc/hstmt.h> |
| | 27 | |
| | 28 | #include <../iodbc/itrace.h> |
| | 29 | |
| | 30 | extern char* _iodbcdm_getkeyvalbydsn(); |
| | 31 | extern char* _iodbcdm_getkeyvalinstr(); |
| | 32 | extern RETCODE _iodbcdm_driverunload(); |
| | 33 | |
| | 34 | /* |
| | 35 | * Following id string is a copyright mark. Removing(i.e. use |
| | 36 | * souce code of this package without it or make it not appear |
| | 37 | * in the final object file) or modifing it without permission |
| | 38 | * from original author(kejin@empress.com) are copyright |
| | 39 | * violation. |
| | 40 | */ |
| | 41 | static char sccsid[] |
| | 42 | = "@(#)iODBC driver manager " "2.12" ", Copyright(c) 1995 by Ke Jin"; |
| | 43 | |
| | 44 | static RETCODE _iodbcdm_driverload( |
| | 45 | char FAR* path, |
| | 46 | HDBC hdbc ) |
| | 47 | /* - Load driver share library( or increase its reference count |
| | 48 | * if it has already been loaded by another active connection) |
| | 49 | * - Call driver's SQLAllocEnv() (for the first reference only) |
| | 50 | * - Call driver's SQLAllocConnect() |
| | 51 | * - Call driver's SQLSetConnectOption() (set login time out) |
| | 52 | * - Increase the bookkeeping reference count |
| | 53 | */ |
| | 54 | { |
| | 55 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 56 | GENV_t FAR* genv; |
| | 57 | ENV_t FAR* penv = NULL; |
| | 58 | HDLL hdll; |
| | 59 | HPROC hproc; |
| | 60 | RETCODE retcode = SQL_SUCCESS; |
| | 61 | int sqlstat = en_00000; |
| | 62 | |
| | 63 | if( path == NULL || path[0] == '\0' ) |
| | 64 | { |
| | 65 | PUSHSQLERR ( pdbc->herr, en_IM002 ); |
| | 66 | |
| | 67 | return SQL_ERROR; |
| | 68 | } |
| | 69 | |
| | 70 | if( hdbc == SQL_NULL_HDBC |
| | 71 | || pdbc->genv == SQL_NULL_HENV ) |
| | 72 | { |
| | 73 | return SQL_INVALID_HANDLE; |
| | 74 | } |
| | 75 | |
| | 76 | genv = (GENV_t FAR*)pdbc->genv; |
| | 77 | |
| | 78 | hdll = _iodbcdm_dllopen( (char FAR*) path ); |
| | 79 | /* This will either load the |
| | 80 | * driver dll or increase its |
| | 81 | * reference count */ |
| | 82 | |
| | 83 | if( hdll == SQL_NULL_HDLL ) |
| | 84 | { |
| | 85 | PUSHSYSERR ( pdbc->herr, _iodbcdm_dllerror() ); |
| | 86 | PUSHSQLERR ( pdbc->herr, en_IM003 ); |
| | 87 | return SQL_ERROR; |
| | 88 | } |
| | 89 | |
| | 90 | penv = (ENV_t FAR*)(pdbc->henv); |
| | 91 | |
| | 92 | if( penv != NULL ) |
| | 93 | { |
| | 94 | if( penv->hdll != hdll ) |
| | 95 | { |
| | 96 | _iodbcdm_driverunload(hdbc); |
| | 97 | } |
| | 98 | else |
| | 99 | { |
| | 100 | _iodbcdm_dllclose( hdll ); |
| | 101 | /* this will not unload the driver |
| | 102 | * but only decrease its internal |
| | 103 | * reference count |
| | 104 | */ |
| | 105 | } |
| | 106 | } |
| | 107 | |
| | 108 | if(penv == NULL ) |
| | 109 | { |
| | 110 | /* find out whether this dll has already |
| | 111 | * been loaded on another connection */ |
| | 112 | for( penv = (ENV_t FAR*)genv->henv; |
| | 113 | penv != NULL; |
| | 114 | penv = (ENV_t FAR*)penv->next ) |
| | 115 | { |
| | 116 | if( penv->hdll == hdll ) |
| | 117 | { |
| | 118 | _iodbcdm_dllclose( hdll ); |
| | 119 | /* this will not unload the driver |
| | 120 | * but only decrease its internal |
| | 121 | * reference count |
| | 122 | */ |
| | 123 | break; |
| | 124 | } |
| | 125 | } |
| | 126 | |
| | 127 | if( penv == NULL ) |
| | 128 | /* no connection attaching with this dll */ |
| | 129 | { |
| | 130 | int i; |
| | 131 | |
| | 132 | /* create a new dll env instance */ |
| | 133 | penv = (ENV_t FAR*)MEM_ALLOC ( sizeof(ENV_t) ); |
| | 134 | |
| | 135 | if( penv == NULL ) |
| | 136 | { |
| | 137 | _iodbcdm_dllclose(hdll); |
| | 138 | |
| | 139 | PUSHSQLERR ( pdbc->herr, en_S1001 ); |
| | 140 | |
| | 141 | return SQL_ERROR; |
| | 142 | } |
| | 143 | |
| | 144 | for( i = 0; i< SQL_EXT_API_LAST + 1; i++) |
| | 145 | { |
| | 146 | (penv->dllproc_tab)[i] = SQL_NULL_HPROC; |
| | 147 | } |
| | 148 | |
| | 149 | pdbc->henv = penv; |
| | 150 | penv->hdll = hdll; |
| | 151 | |
| | 152 | /* call driver's SQLAllocHandle() or SQLAllocEnv() */ |
| | 153 | #if (ODBCVER >= 0x0300) |
| | 154 | hproc = _iodbcdm_getproc( hdbc, en_AllocHandle ); |
| | 155 | |
| | 156 | if( hproc ) |
| | 157 | { |
| | 158 | CALL_DRIVER ( hdbc, retcode, hproc, en_AllocHandle, |
| | 159 | ( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(penv->dhenv) ) |
| | 160 | } |
| | 161 | else /* try driver's SQLAllocEnv() */ |
| | 162 | #endif |
| | 163 | { |
| | 164 | hproc = _iodbcdm_getproc( hdbc, en_AllocEnv ); |
| | 165 | |
| | 166 | if( hproc == SQL_NULL_HPROC) |
| | 167 | { |
| | 168 | sqlstat = en_IM004; |
| | 169 | } |
| | 170 | else |
| | 171 | { |
| | 172 | CALL_DRIVER ( hdbc, retcode, hproc, |
| | 173 | en_AllocEnv, (&(penv->dhenv)) ) |
| | 174 | } |
| | 175 | } |
| | 176 | |
| | 177 | if( retcode == SQL_ERROR ) |
| | 178 | { |
| | 179 | sqlstat = en_IM004; |
| | 180 | } |
| | 181 | |
| | 182 | if( sqlstat != en_00000 ) |
| | 183 | { |
| | 184 | _iodbcdm_dllclose ( hdll ); |
| | 185 | MEM_FREE ( penv ); |
| | 186 | PUSHSQLERR ( pdbc->herr, en_IM004 ); |
| | 187 | |
| | 188 | return SQL_ERROR; |
| | 189 | } |
| | 190 | |
| | 191 | /* insert into dll env list */ |
| | 192 | penv->next = (ENV_t FAR*)genv->henv; |
| | 193 | genv->henv = penv; |
| | 194 | |
| | 195 | /* initiate this new env entry */ |
| | 196 | penv->refcount = 0; /* we will increase it after |
| | 197 | * driver's SQLAllocConnect() |
| | 198 | * success |
| | 199 | */ |
| | 200 | } |
| | 201 | |
| | 202 | pdbc->henv = penv; |
| | 203 | |
| | 204 | if( pdbc->dhdbc == SQL_NULL_HDBC ) |
| | 205 | { |
| | 206 | #if (ODBCVER >= 0x0300) |
| | 207 | hproc = _iodbcdm_getproc( hdbc, en_AllocHandle ); |
| | 208 | |
| | 209 | if( hproc ) |
| | 210 | { |
| | 211 | CALL_DRIVER( hdbc, retcode, hproc, en_AllocHandle, |
| | 212 | (SQL_HANDLE_DBC, penv->dhenv, &(pdbc->dhdbc)) ) |
| | 213 | } |
| | 214 | else |
| | 215 | #endif |
| | 216 | { |
| | 217 | hproc = _iodbcdm_getproc( hdbc, en_AllocConnect ); |
| | 218 | |
| | 219 | if( hproc == SQL_NULL_HPROC ) |
| | 220 | { |
| | 221 | sqlstat = en_IM005; |
| | 222 | } |
| | 223 | else |
| | 224 | { |
| | 225 | CALL_DRIVER ( hdbc, retcode, hproc, |
| | 226 | en_AllocConnect, (penv->dhenv, &(pdbc->dhdbc)) ) |
| | 227 | } |
| | 228 | } |
| | 229 | |
| | 230 | if( retcode == SQL_ERROR ) |
| | 231 | { |
| | 232 | sqlstat = en_IM005; |
| | 233 | } |
| | 234 | |
| | 235 | if( sqlstat != en_00000 ) |
| | 236 | { |
| | 237 | _iodbcdm_driverunload(hdbc); |
| | 238 | |
| | 239 | pdbc->dhdbc = SQL_NULL_HDBC; |
| | 240 | PUSHSQLERR ( pdbc->herr, en_IM005 ); |
| | 241 | |
| | 242 | return SQL_ERROR; |
| | 243 | } |
| | 244 | } |
| | 245 | |
| | 246 | pdbc->henv = penv; |
| | 247 | penv->refcount ++; /* bookkeeping reference count on this driver */ |
| | 248 | } |
| | 249 | |
| | 250 | /* driver's login timeout option must been set before |
| | 251 | * its SQLConnect() call */ |
| | 252 | if( pdbc->login_timeout != 0UL ) |
| | 253 | { |
| | 254 | hproc = _iodbcdm_getproc( hdbc, en_SetConnectOption ); |
| | 255 | |
| | 256 | if( hproc == SQL_NULL_HPROC ) |
| | 257 | { |
| | 258 | sqlstat = en_IM004; |
| | 259 | } |
| | 260 | else |
| | 261 | { |
| | 262 | CALL_DRIVER ( hdbc, retcode, hproc, |
| | 263 | en_SetConnectOption, ( |
| | 264 | pdbc->dhdbc, |
| | 265 | SQL_LOGIN_TIMEOUT, |
| | 266 | pdbc->login_timeout ) ) |
| | 267 | |
| | 268 | if( retcode == SQL_ERROR ) |
| | 269 | { |
| | 270 | PUSHSQLERR ( pdbc->herr, en_IM006 ); |
| | 271 | |
| | 272 | return SQL_SUCCESS_WITH_INFO; |
| | 273 | } |
| | 274 | } |
| | 275 | } |
| | 276 | |
| | 277 | return SQL_SUCCESS; |
| | 278 | } |
| | 279 | |
| | 280 | RETCODE _iodbcdm_driverunload( HDBC hdbc ) |
| | 281 | /* - Call driver's SQLFreeConnect() |
| | 282 | * - Call driver's SQLFreeEnv() ( for the last reference only) |
| | 283 | * - Unload the share library( or decrease its reference |
| | 284 | * count if it is not the last referenct ) |
| | 285 | * - decrease bookkeeping reference count |
| | 286 | * - state transition to allocated |
| | 287 | */ |
| | 288 | { |
| | 289 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 290 | ENV_t FAR* penv; |
| | 291 | ENV_t FAR* tpenv; |
| | 292 | GENV_t FAR* genv; |
| | 293 | HPROC hproc; |
| | 294 | RETCODE retcode = SQL_SUCCESS; |
| | 295 | int sqlstat = en_00000; |
| | 296 | |
| | 297 | if( hdbc == SQL_NULL_HDBC ) |
| | 298 | { |
| | 299 | return SQL_INVALID_HANDLE; |
| | 300 | } |
| | 301 | |
| | 302 | /* no pointer check will be performed in this function */ |
| | 303 | penv = (ENV_t FAR*)pdbc->henv; |
| | 304 | genv = (GENV_t FAR*)pdbc->genv; |
| | 305 | |
| | 306 | if( penv == NULL |
| | 307 | || penv->hdll == SQL_NULL_HDLL ) |
| | 308 | { |
| | 309 | return SQL_SUCCESS; |
| | 310 | } |
| | 311 | |
| | 312 | #if (ODBCVER >= 0x0300) |
| | 313 | hproc = _iodbcdm_getproc( hdbc, en_FreeHandle ); |
| | 314 | |
| | 315 | if( hproc ) |
| | 316 | { |
| | 317 | CALL_DRIVER ( hdbc, retcode, hproc, en_FreeHandle, |
| | 318 | ( SQL_HANDLE_DBC, pdbc->dhdbc ) ) |
| | 319 | } |
| | 320 | else |
| | 321 | #endif |
| | 322 | { |
| | 323 | hproc = _iodbcdm_getproc( hdbc, en_FreeConnect ); |
| | 324 | |
| | 325 | if( hproc != SQL_NULL_HPROC ) |
| | 326 | { |
| | 327 | CALL_DRIVER ( hdbc, retcode, hproc, |
| | 328 | en_FreeConnect, ( pdbc->dhdbc ) ) |
| | 329 | |
| | 330 | pdbc->dhdbc = SQL_NULL_HDBC; |
| | 331 | } |
| | 332 | } |
| | 333 | |
| | 334 | penv->refcount --; |
| | 335 | |
| | 336 | if( ! penv->refcount ) |
| | 337 | /* no other connections still attaching with this driver */ |
| | 338 | { |
| | 339 | #if (ODBCVER >= 0x0300) |
| | 340 | hproc = _iodbcdm_getproc( hdbc, en_FreeHandle ); |
| | 341 | |
| | 342 | if( hproc ) |
| | 343 | { |
| | 344 | CALL_DRIVER ( hdbc, retcode, hproc, en_FreeHandle, |
| | 345 | ( SQL_HANDLE_ENV, penv->dhenv ) ) |
| | 346 | } |
| | 347 | else |
| | 348 | #endif |
| | 349 | { |
| | 350 | hproc = _iodbcdm_getproc( hdbc, en_FreeEnv ); |
| | 351 | |
| | 352 | if( hproc != SQL_NULL_HPROC ) |
| | 353 | { |
| | 354 | CALL_DRIVER ( hdbc, retcode, hproc, en_FreeEnv, |
| | 355 | ( penv->dhenv ) ) |
| | 356 | |
| | 357 | penv->dhenv = SQL_NULL_HENV; |
| | 358 | } |
| | 359 | } |
| | 360 | |
| | 361 | _iodbcdm_dllclose ( penv->hdll ); |
| | 362 | |
| | 363 | penv->hdll = SQL_NULL_HDLL; |
| | 364 | |
| | 365 | for( tpenv = (ENV_t FAR*)genv->henv; |
| | 366 | tpenv != NULL; |
| | 367 | tpenv = (ENV_t FAR*)penv->next ) |
| | 368 | { |
| | 369 | if( tpenv == penv ) |
| | 370 | { |
| | 371 | genv->henv = penv->next; |
| | 372 | break; |
| | 373 | } |
| | 374 | |
| | 375 | if( tpenv->next == penv ) |
| | 376 | { |
| | 377 | tpenv->next = penv->next; |
| | 378 | break; |
| | 379 | } |
| | 380 | } |
| | 381 | |
| | 382 | MEM_FREE( penv ); |
| | 383 | } |
| | 384 | |
| | 385 | pdbc->henv = SQL_NULL_HENV; |
| | 386 | pdbc->hstmt= SQL_NULL_HSTMT; |
| | 387 | /* pdbc->herr = SQL_NULL_HERR; |
| | 388 | -- delay to DM's SQLFreeConnect() */ |
| | 389 | pdbc->dhdbc= SQL_NULL_HDBC; |
| | 390 | pdbc->state= en_dbc_allocated; |
| | 391 | |
| | 392 | /* set connect options to default values */ |
| | 393 | /********** |
| | 394 | pdbc->access_mode = SQL_MODE_DEFAULT; |
| | 395 | pdbc->autocommit = SQL_AUTOCOMMIT_DEFAULT; |
| | 396 | pdbc->login_timeout = 0UL; |
| | 397 | **********/ |
| | 398 | pdbc->odbc_cursors = SQL_CUR_DEFAULT; |
| | 399 | pdbc->packet_size = 0UL; |
| | 400 | pdbc->quiet_mode = (UDWORD)NULL; |
| | 401 | pdbc->txn_isolation = SQL_TXN_READ_UNCOMMITTED; |
| | 402 | |
| | 403 | if( pdbc->current_qualifier != NULL ) |
| | 404 | { |
| | 405 | MEM_FREE ( pdbc->current_qualifier ); |
| | 406 | pdbc->current_qualifier = NULL; |
| | 407 | } |
| | 408 | |
| | 409 | return SQL_SUCCESS; |
| | 410 | } |
| | 411 | |
| | 412 | static RETCODE _iodbcdm_dbcdelayset( HDBC hdbc ) |
| | 413 | { |
| | 414 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 415 | ENV_t FAR* penv; |
| | 416 | HPROC hproc; |
| | 417 | RETCODE retcode = SQL_SUCCESS; |
| | 418 | RETCODE ret; |
| | 419 | |
| | 420 | penv = pdbc->henv; |
| | 421 | |
| | 422 | hproc = _iodbcdm_getproc( hdbc, en_SetConnectOption ); |
| | 423 | |
| | 424 | if( hproc == SQL_NULL_HPROC ) |
| | 425 | { |
| | 426 | PUSHSQLERR ( pdbc->herr, en_IM006 ); |
| | 427 | |
| | 428 | return SQL_SUCCESS_WITH_INFO; |
| | 429 | } |
| | 430 | |
| | 431 | if( pdbc->access_mode != SQL_MODE_DEFAULT ) |
| | 432 | { |
| | 433 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 434 | en_SetConnectOption, ( |
| | 435 | SQL_ACCESS_MODE, |
| | 436 | pdbc->access_mode) ) |
| | 437 | |
| | 438 | retcode |= ret; |
| | 439 | } |
| | 440 | |
| | 441 | if( pdbc->autocommit != SQL_AUTOCOMMIT_DEFAULT ) |
| | 442 | { |
| | 443 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 444 | en_SetConnectOption, ( |
| | 445 | pdbc->dhdbc, |
| | 446 | SQL_AUTOCOMMIT, |
| | 447 | pdbc->autocommit ) ) |
| | 448 | |
| | 449 | retcode |= ret; |
| | 450 | } |
| | 451 | |
| | 452 | if( pdbc->current_qualifier != NULL ) |
| | 453 | { |
| | 454 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 455 | en_SetConnectOption, ( |
| | 456 | pdbc->dhdbc, |
| | 457 | SQL_CURRENT_QUALIFIER, |
| | 458 | pdbc->current_qualifier ) ) |
| | 459 | |
| | 460 | retcode |= ret; |
| | 461 | } |
| | 462 | |
| | 463 | if( pdbc->packet_size != 0UL ) |
| | 464 | { |
| | 465 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 466 | en_SetConnectOption, ( |
| | 467 | pdbc->dhdbc, |
| | 468 | SQL_PACKET_SIZE, |
| | 469 | pdbc->packet_size ) ) |
| | 470 | |
| | 471 | retcode |= ret; |
| | 472 | } |
| | 473 | |
| | 474 | if( pdbc->quiet_mode != (UDWORD)NULL ) |
| | 475 | { |
| | 476 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 477 | en_SetConnectOption, ( |
| | 478 | pdbc->dhdbc, |
| | 479 | SQL_QUIET_MODE, |
| | 480 | pdbc->quiet_mode ) ) |
| | 481 | |
| | 482 | retcode |= ret; |
| | 483 | } |
| | 484 | |
| | 485 | if( pdbc->txn_isolation != SQL_TXN_READ_UNCOMMITTED ) |
| | 486 | { |
| | 487 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 488 | en_SetConnectOption, ( |
| | 489 | pdbc->dhdbc, |
| | 490 | SQL_TXN_ISOLATION, |
| | 491 | pdbc->txn_isolation ) ) |
| | 492 | } |
| | 493 | |
| | 494 | /* check error code for driver's SQLSetConnectOption() call */ |
| | 495 | if( retcode != SQL_SUCCESS |
| | 496 | && retcode != SQL_SUCCESS_WITH_INFO ) |
| | 497 | { |
| | 498 | PUSHSQLERR ( pdbc->herr, en_IM006 ); |
| | 499 | |
| | 500 | retcode = SQL_ERROR; |
| | 501 | } |
| | 502 | |
| | 503 | /* get cursor behavior on transaction commit or rollback */ |
| | 504 | hproc = _iodbcdm_getproc( hdbc, en_GetInfo ); |
| | 505 | |
| | 506 | if( hproc == SQL_NULL_HPROC ) |
| | 507 | { |
| | 508 | PUSHSQLERR ( pdbc->herr, en_01000 ); |
| | 509 | |
| | 510 | return retcode; |
| | 511 | } |
| | 512 | |
| | 513 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 514 | en_GetInfo, ( |
| | 515 | pdbc->dhdbc, |
| | 516 | SQL_CURSOR_COMMIT_BEHAVIOR, |
| | 517 | (PTR)&(pdbc->cb_commit), |
| | 518 | sizeof(pdbc->cb_commit), |
| | 519 | NULL ) ) |
| | 520 | |
| | 521 | retcode |= ret; |
| | 522 | |
| | 523 | CALL_DRIVER ( hdbc, ret, hproc, |
| | 524 | en_GetInfo, ( |
| | 525 | pdbc->dhdbc, |
| | 526 | SQL_CURSOR_ROLLBACK_BEHAVIOR, |
| | 527 | (PTR)&(pdbc->cb_rollback), |
| | 528 | sizeof(pdbc->cb_rollback), |
| | 529 | NULL ) ) |
| | 530 | |
| | 531 | retcode |= ret; |
| | 532 | |
| | 533 | if( retcode != SQL_SUCCESS |
| | 534 | && retcode != SQL_SUCCESS_WITH_INFO ) |
| | 535 | { |
| | 536 | return SQL_ERROR; |
| | 537 | } |
| | 538 | |
| | 539 | return retcode; |
| | 540 | } |
| | 541 | |
| | 542 | static RETCODE _iodbcdm_settracing( HDBC hdbc, char* dsn, int dsnlen ) |
| | 543 | { |
| | 544 | char buf[256]; |
| | 545 | char* ptr; |
| | 546 | RETCODE setopterr = SQL_SUCCESS; |
| | 547 | |
| | 548 | /* Get Driver's DLL path from specificed or default dsn section */ |
| | 549 | ptr = _iodbcdm_getkeyvalbydsn( dsn, dsnlen, "TraceFile", |
| | 550 | (char FAR*)buf, sizeof(buf)); |
| | 551 | |
| | 552 | if( ptr == NULL || ptr[0] == '\0' ) |
| | 553 | { |
| | 554 | ptr = (char FAR*)(SQL_OPT_TRACE_FILE_DEFAULT); |
| | 555 | } |
| | 556 | |
| | 557 | setopterr |= SQLSetConnectOption( hdbc, |
| | 558 | SQL_OPT_TRACEFILE, (UDWORD)(ptr)); |
| | 559 | |
| | 560 | ptr = _iodbcdm_getkeyvalbydsn( dsn, dsnlen, "Trace", |
| | 561 | (char FAR*)buf, sizeof(buf)); |
| | 562 | |
| | 563 | if( ptr != NULL ) |
| | 564 | { |
| | 565 | UDWORD opt = (UDWORD)(-1L); |
| | 566 | |
| | 567 | if( STREQ(ptr, "ON") |
| | 568 | || STREQ(ptr, "On") |
| | 569 | || STREQ(ptr, "on") |
| | 570 | || STREQ(ptr, "1" ) ) |
| | 571 | { |
| | 572 | opt = SQL_OPT_TRACE_ON; |
| | 573 | } |
| | 574 | |
| | 575 | if( STREQ(ptr, "OFF") |
| | 576 | || STREQ(ptr, "Off") |
| | 577 | || STREQ(ptr, "off") |
| | 578 | || STREQ(ptr, "0" ) ) |
| | 579 | { |
| | 580 | opt = SQL_OPT_TRACE_OFF; |
| | 581 | } |
| | 582 | |
| | 583 | if( opt != (UDWORD)(-1L) ) |
| | 584 | { |
| | 585 | setopterr |= SQLSetConnectOption( hdbc, |
| | 586 | SQL_OPT_TRACE, opt); |
| | 587 | } |
| | 588 | } |
| | 589 | |
| | 590 | return setopterr; |
| | 591 | } |
| | 592 | |
| | 593 | RETCODE SQL_API SQLConnect ( |
| | 594 | HDBC hdbc, |
| | 595 | UCHAR FAR* szDSN, |
| | 596 | SWORD cbDSN, |
| | 597 | UCHAR FAR* szUID, |
| | 598 | SWORD cbUID, |
| | 599 | UCHAR FAR* szAuthStr, |
| | 600 | SWORD cbAuthStr) |
| | 601 | { |
| | 602 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 603 | RETCODE retcode = SQL_SUCCESS; |
| | 604 | RETCODE setopterr = SQL_SUCCESS; |
| | 605 | char driver[1024] = { '\0' }; /* MS SDK Guide |
| | 606 | * specifies driver |
| | 607 | * path can't longer |
| | 608 | * than 255. */ |
| | 609 | char *ptr; |
| | 610 | HPROC hproc; |
| | 611 | |
| | 612 | if( hdbc == SQL_NULL_HDBC ) |
| | 613 | { |
| | 614 | return SQL_INVALID_HANDLE; |
| | 615 | } |
| | 616 | |
| | 617 | /* check arguments */ |
| | 618 | if( ( cbDSN < 0 && cbDSN != SQL_NTS ) |
| | 619 | || ( cbUID < 0 && cbUID != SQL_NTS ) |
| | 620 | || ( cbAuthStr < 0 && cbAuthStr != SQL_NTS ) |
| | 621 | || ( cbDSN > SQL_MAX_DSN_LENGTH ) ) |
| | 622 | { |
| | 623 | PUSHSQLERR ( pdbc->herr, en_S1090 ); |
| | 624 | |
| | 625 | return SQL_ERROR; |
| | 626 | } |
| | 627 | |
| | 628 | if( szDSN == NULL || cbDSN == 0 ) |
| | 629 | { |
| | 630 | PUSHSQLERR ( pdbc->herr, en_IM002 ); |
| | 631 | |
| | 632 | return SQL_ERROR; |
| | 633 | } |
| | 634 | |
| | 635 | /* check state */ |
| | 636 | if( pdbc->state != en_dbc_allocated ) |
| | 637 | { |
| | 638 | PUSHSQLERR ( pdbc->herr, en_08002 ); |
| | 639 | |
| | 640 | return SQL_ERROR; |
| | 641 | } |
| | 642 | |
| | 643 | setopterr |= _iodbcdm_settracing( hdbc, |
| | 644 | (char*)szDSN, cbDSN ); |
| | 645 | |
| | 646 | ptr = _iodbcdm_getkeyvalbydsn( szDSN, cbDSN, "Driver", |
| | 647 | (char FAR*)driver, sizeof(driver)); |
| | 648 | |
| | 649 | if( ptr == NULL ) |
| | 650 | /* No specified or default dsn section or |
| | 651 | * no driver specification in this dsn section */ |
| | 652 | { |
| | 653 | PUSHSQLERR ( pdbc->herr, en_IM002 ); |
| | 654 | |
| | 655 | return SQL_ERROR; |
| | 656 | } |
| | 657 | |
| | 658 | retcode = _iodbcdm_driverload( driver, hdbc ); |
| | 659 | |
| | 660 | switch( retcode ) |
| | 661 | { |
| | 662 | case SQL_SUCCESS: |
| | 663 | break; |
| | 664 | |
| | 665 | case SQL_SUCCESS_WITH_INFO: |
| | 666 | setopterr = SQL_ERROR; |
| | 667 | /* unsuccessed in calling driver's |
| | 668 | * SQLSetConnectOption() to set login |
| | 669 | * timeout. |
| | 670 | */ |
| | 671 | break; |
| | 672 | |
| | 673 | default: |
| | 674 | return retcode; |
| | 675 | } |
| | 676 | |
| | 677 | hproc = _iodbcdm_getproc( hdbc, en_Connect ); |
| | 678 | |
| | 679 | if( hproc == SQL_NULL_HPROC ) |
| | 680 | { |
| | 681 | _iodbcdm_driverunload( hdbc ); |
| | 682 | |
| | 683 | PUSHSQLERR ( pdbc->herr, en_IM001 ); |
| | 684 | |
| | 685 | return SQL_ERROR; |
| | 686 | } |
| | 687 | |
| | 688 | CALL_DRIVER ( hdbc, retcode, hproc, en_Connect, ( |
| | 689 | pdbc->dhdbc, |
| | 690 | szDSN, cbDSN, |
| | 691 | szUID, cbUID, |
| | 692 | szAuthStr, cbAuthStr ) ) |
| | 693 | |
| | 694 | #if 0 |
| | 695 | retcode = hproc(pdbc->dhdbc, |
| | 696 | szDSN, cbDSN, |
| | 697 | szUID, cbUID, |
| | 698 | szAuthStr, cbAuthStr ); |
| | 699 | #endif |
| | 700 | |
| | 701 | if( retcode != SQL_SUCCESS |
| | 702 | && retcode != SQL_SUCCESS_WITH_INFO ) |
| | 703 | { |
| | 704 | /* not unload driver for retrive error |
| | 705 | * messge from driver */ |
| | 706 | /********* |
| | 707 | _iodbcdm_driverunload( hdbc ); |
| | 708 | **********/ |
| | 709 | |
| | 710 | return retcode; |
| | 711 | } |
| | 712 | |
| | 713 | /* state transition */ |
| | 714 | pdbc->state = en_dbc_connected; |
| | 715 | |
| | 716 | /* do delaid option setting */ |
| | 717 | setopterr |= _iodbcdm_dbcdelayset( hdbc ); |
| | 718 | |
| | 719 | if( setopterr != SQL_SUCCESS ) |
| | 720 | { |
| | 721 | return SQL_SUCCESS_WITH_INFO; |
| | 722 | } |
| | 723 | |
| | 724 | return retcode; |
| | 725 | } |
| | 726 | |
| | 727 | RETCODE SQL_API SQLDriverConnect ( |
| | 728 | HDBC hdbc, |
| | 729 | HWND hwnd, |
| | 730 | UCHAR FAR* szConnStrIn, |
| | 731 | SWORD cbConnStrIn, |
| | 732 | UCHAR FAR* szConnStrOut, |
| | 733 | SWORD cbConnStrOutMax, |
| | 734 | SWORD FAR* pcbConnStrOut, |
| | 735 | UWORD fDriverCompletion ) |
| | 736 | { |
| | 737 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 738 | HDLL hdll; |
| | 739 | char FAR* drv; |
| | 740 | char drvbuf[1024]; |
| | 741 | char FAR* dsn; |
| | 742 | char dsnbuf[SQL_MAX_DSN_LENGTH + 1]; |
| | 743 | UCHAR cnstr2drv[1024]; |
| | 744 | |
| | 745 | HPROC hproc, dialproc; |
| | 746 | |
| | 747 | int sqlstat = en_00000; |
| | 748 | RETCODE retcode = SQL_SUCCESS; |
| | 749 | RETCODE setopterr = SQL_SUCCESS; |
| | 750 | |
| | 751 | if( hdbc == SQL_NULL_HDBC ) |
| | 752 | { |
| | 753 | return SQL_INVALID_HANDLE; |
| | 754 | } |
| | 755 | |
| | 756 | /* check arguments */ |
| | 757 | if( ( cbConnStrIn < 0 && cbConnStrIn != SQL_NTS ) |
| | 758 | || cbConnStrOutMax < 0 ) |
| | 759 | { |
| | 760 | PUSHSQLERR (pdbc->herr, en_S1090 ); |
| | 761 | |
| | 762 | return SQL_ERROR; |
| | 763 | } |
| | 764 | |
| | 765 | /* check state */ |
| | 766 | if( pdbc->state != en_dbc_allocated ) |
| | 767 | { |
| | 768 | PUSHSQLERR (pdbc->herr, en_08002 ); |
| | 769 | |
| | 770 | return SQL_ERROR; |
| | 771 | } |
| | 772 | |
| | 773 | drv = _iodbcdm_getkeyvalinstr(szConnStrIn, cbConnStrIn, |
| | 774 | "DRIVER", drvbuf, sizeof(drvbuf)); |
| | 775 | |
| | 776 | dsn = _iodbcdm_getkeyvalinstr(szConnStrIn, cbConnStrIn, |
| | 777 | "DSN", dsnbuf, sizeof(dsnbuf)); |
| | 778 | |
| | 779 | switch( fDriverCompletion ) |
| | 780 | { |
| | 781 | case SQL_DRIVER_NOPROMPT: |
| | 782 | break; |
| | 783 | |
| | 784 | case SQL_DRIVER_COMPLETE: |
| | 785 | case SQL_DRIVER_COMPLETE_REQUIRED: |
| | 786 | if( dsn != NULL ) |
| | 787 | { |
| | 788 | break; |
| | 789 | } |
| | 790 | /* fall to next case */ |
| | 791 | case SQL_DRIVER_PROMPT: |
| | 792 | /* Get data source dialog box function from |
| | 793 | * current executable */ |
| | 794 | hdll = _iodbcdm_dllopen((char FAR*)NULL); |
| | 795 | dialproc = _iodbcdm_dllproc( hdll, |
| | 796 | "_iodbcdm_drvconn_dialbox"); |
| | 797 | |
| | 798 | if( dialproc == SQL_NULL_HPROC ) |
| | 799 | { |
| | 800 | sqlstat = en_IM008; |
| | 801 | break; |
| | 802 | } |
| | 803 | |
| | 804 | retcode = dialproc( |
| | 805 | hwnd, /* window or display handle */ |
| | 806 | dsnbuf, /* input/output dsn buf */ |
| | 807 | sizeof(dsnbuf), /* buf size */ |
| | 808 | &sqlstat); /* error code */ |
| | 809 | |
| | 810 | if( retcode != SQL_SUCCESS ) |
| | 811 | { |
| | 812 | break; |
| | 813 | } |
| | 814 | |
| | 815 | if( cbConnStrIn == SQL_NTS ) |
| | 816 | { |
| | 817 | cbConnStrIn = STRLEN(szConnStrIn ); |
| | 818 | } |
| | 819 | |
| | 820 | dsn = dsnbuf; |
| | 821 | |
| | 822 | if( dsn[0] == '\0' ) |
| | 823 | { |
| | 824 | dsn = "default"; |
| | 825 | } |
| | 826 | |
| | 827 | if( cbConnStrIn > sizeof(cnstr2drv) |
| | 828 | - STRLEN(dsn) - STRLEN("DSN=;") -1 ) |
| | 829 | { |
| | 830 | sqlstat = en_S1001; /* a lazy way to avoid |
| | 831 | * using heap memory */ |
| | 832 | break; |
| | 833 | } |
| | 834 | |
| | 835 | sprintf( (char FAR *)cnstr2drv, "DSN=%s;", dsn); |
| | 836 | cbConnStrIn += STRLEN(cnstr2drv); |
| | 837 | STRNCAT( cnstr2drv, szConnStrIn, cbConnStrIn ); |
| | 838 | szConnStrIn = cnstr2drv; |
| | 839 | break; |
| | 840 | |
| | 841 | default: |
| | 842 | sqlstat = en_S1110; |
| | 843 | break; |
| | 844 | } |
| | 845 | |
| | 846 | if( sqlstat != en_00000 ) |
| | 847 | { |
| | 848 | PUSHSQLERR( pdbc->herr, sqlstat ); |
| | 849 | |
| | 850 | return SQL_ERROR; |
| | 851 | } |
| | 852 | |
| | 853 | if( dsn == NULL || dsn[0] == '\0' ) |
| | 854 | { |
| | 855 | dsn = "default"; |
| | 856 | } |
| | 857 | else /* if you want tracing, you must use a DSN */ |
| | 858 | { |
| | 859 | setopterr |= _iodbcdm_settracing( hdbc, |
| | 860 | (char*)dsn, SQL_NTS ); |
| | 861 | } |
| | 862 | |
| | 863 | if( drv == NULL || drv[0] == '\0' ) |
| | 864 | { |
| | 865 | drv = _iodbcdm_getkeyvalbydsn( dsn, SQL_NTS, "Driver", |
| | 866 | drvbuf, sizeof(drvbuf)); |
| | 867 | } |
| | 868 | |
| | 869 | if( drv == NULL ) |
| | 870 | { |
| | 871 | PUSHSQLERR( pdbc->herr, en_IM002 ); |
| | 872 | |
| | 873 | return SQL_ERROR; |
| | 874 | } |
| | 875 | |
| | 876 | retcode = _iodbcdm_driverload( drv, hdbc ); |
| | 877 | |
| | 878 | switch( retcode ) |
| | 879 | { |
| | 880 | case SQL_SUCCESS: |
| | 881 | break; |
| | 882 | |
| | 883 | case SQL_SUCCESS_WITH_INFO: |
| | 884 | setopterr = SQL_ERROR; |
| | 885 | /* unsuccessed in calling driver's |
| | 886 | * SQLSetConnectOption() to set login |
| | 887 | * timeout. |
| | 888 | */ |
| | 889 | break; |
| | 890 | |
| | 891 | default: |
| | 892 | return retcode; |
| | 893 | } |
| | 894 | |
| | 895 | hproc = _iodbcdm_getproc( hdbc, en_DriverConnect ); |
| | 896 | |
| | 897 | if( hproc == SQL_NULL_HPROC ) |
| | 898 | { |
| | 899 | _iodbcdm_driverunload( hdbc ); |
| | 900 | |
| | 901 | PUSHSQLERR ( pdbc->herr, en_IM001 ); |
| | 902 | |
| | 903 | return SQL_ERROR; |
| | 904 | } |
| | 905 | |
| | 906 | CALL_DRIVER ( hdbc, retcode, hproc, en_DriverConnect, ( |
| | 907 | pdbc->dhdbc, hwnd, |
| | 908 | szConnStrIn, cbConnStrIn, |
| | 909 | szConnStrOut, cbConnStrOutMax, |
| | 910 | pcbConnStrOut, fDriverCompletion ) ) |
| | 911 | |
| | 912 | #if 0 |
| | 913 | retcode = hproc(pdbc->dhdbc, hwnd, |
| | 914 | szConnStrIn, cbConnStrIn, |
| | 915 | szConnStrOut, cbConnStrOutMax, |
| | 916 | pcbConnStrOut, fDriverCompletion ); |
| | 917 | #endif |
| | 918 | |
| | 919 | if( retcode != SQL_SUCCESS |
| | 920 | && retcode != SQL_SUCCESS_WITH_INFO ) |
| | 921 | { |
| | 922 | /* don't unload driver here for retrive |
| | 923 | * error message from driver */ |
| | 924 | /******** |
| | 925 | _iodbcdm_driverunload( hdbc ); |
| | 926 | *********/ |
| | 927 | |
| | 928 | return retcode; |
| | 929 | } |
| | 930 | |
| | 931 | /* state transition */ |
| | 932 | pdbc->state = en_dbc_connected; |
| | 933 | |
| | 934 | /* do delaid option setting */ |
| | 935 | setopterr |= _iodbcdm_dbcdelayset( hdbc ); |
| | 936 | |
| | 937 | if( setopterr != SQL_SUCCESS ) |
| | 938 | { |
| | 939 | return SQL_SUCCESS_WITH_INFO; |
| | 940 | } |
| | 941 | |
| | 942 | return retcode; |
| | 943 | } |
| | 944 | |
| | 945 | RETCODE SQL_API SQLBrowseConnect ( |
| | 946 | HDBC hdbc, |
| | 947 | HWND hwnd, |
| | 948 | UCHAR FAR* szConnStrIn, |
| | 949 | SWORD cbConnStrIn, |
| | 950 | UCHAR FAR* szConnStrOut, |
| | 951 | SWORD cbConnStrOutMax, |
| | 952 | SWORD FAR* pcbConnStrOut ) |
| | 953 | { |
| | 954 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 955 | HDLL hdll; |
| | 956 | char FAR* drv; |
| | 957 | char drvbuf[1024]; |
| | 958 | char FAR* dsn; |
| | 959 | char dsnbuf[SQL_MAX_DSN_LENGTH + 1]; |
| | 960 | UCHAR cnstr2drv[1024]; |
| | 961 | |
| | 962 | HPROC hproc, dialproc; |
| | 963 | |
| | 964 | int sqlstat = en_00000; |
| | 965 | RETCODE retcode = SQL_SUCCESS; |
| | 966 | RETCODE setopterr = SQL_SUCCESS; |
| | 967 | |
| | 968 | if( hdbc == SQL_NULL_HDBC ) |
| | 969 | { |
| | 970 | return SQL_INVALID_HANDLE; |
| | 971 | } |
| | 972 | |
| | 973 | /* check arguments */ |
| | 974 | if( ( cbConnStrIn < 0 && cbConnStrIn != SQL_NTS ) |
| | 975 | || cbConnStrOutMax < 0 ) |
| | 976 | { |
| | 977 | PUSHSQLERR (pdbc->herr, en_S1090 ); |
| | 978 | |
| | 979 | return SQL_ERROR; |
| | 980 | } |
| | 981 | |
| | 982 | if( pdbc->state == en_dbc_allocated ) |
| | 983 | { |
| | 984 | drv = _iodbcdm_getkeyvalinstr(szConnStrIn, cbConnStrIn, |
| | 985 | "DRIVER", drvbuf, sizeof(drvbuf)); |
| | 986 | |
| | 987 | dsn = _iodbcdm_getkeyvalinstr(szConnStrIn, cbConnStrIn, |
| | 988 | "DSN", dsnbuf, sizeof(dsnbuf)); |
| | 989 | |
| | 990 | if( dsn == NULL || dsn[0] == '\0' ) |
| | 991 | { |
| | 992 | dsn = "default"; |
| | 993 | } |
| | 994 | else /* if you want tracing, you must use a DSN */ |
| | 995 | { |
| | 996 | setopterr |= _iodbcdm_settracing( hdbc, |
| | 997 | (char*)dsn, SQL_NTS ); |
| | 998 | } |
| | 999 | |
| | 1000 | if( drv == NULL || drv[0] == '\0' ) |
| | 1001 | { |
| | 1002 | drv = _iodbcdm_getkeyvalbydsn( dsn, SQL_NTS, "Driver", |
| | 1003 | drvbuf, sizeof(drvbuf)); |
| | 1004 | } |
| | 1005 | |
| | 1006 | if( drv == NULL ) |
| | 1007 | { |
| | 1008 | PUSHSQLERR( pdbc->herr, en_IM002 ); |
| | 1009 | |
| | 1010 | return SQL_ERROR; |
| | 1011 | } |
| | 1012 | |
| | 1013 | retcode = _iodbcdm_driverload( drv, hdbc ); |
| | 1014 | |
| | 1015 | switch( retcode ) |
| | 1016 | { |
| | 1017 | case SQL_SUCCESS: |
| | 1018 | break; |
| | 1019 | |
| | 1020 | case SQL_SUCCESS_WITH_INFO: |
| | 1021 | setopterr = SQL_ERROR; |
| | 1022 | /* unsuccessed in calling driver's |
| | 1023 | * SQLSetConnectOption() to set login |
| | 1024 | * timeout. |
| | 1025 | */ |
| | 1026 | break; |
| | 1027 | |
| | 1028 | default: |
| | 1029 | return retcode; |
| | 1030 | } |
| | 1031 | } |
| | 1032 | else if( pdbc->state != en_dbc_needdata ) |
| | 1033 | { |
| | 1034 | PUSHSQLERR ( pdbc->herr, en_08002 ); |
| | 1035 | |
| | 1036 | return SQL_ERROR; |
| | 1037 | } |
| | 1038 | |
| | 1039 | hproc = _iodbcdm_getproc( hdbc, en_BrowseConnect); |
| | 1040 | |
| | 1041 | if( hproc == SQL_NULL_HPROC ) |
| | 1042 | { |
| | 1043 | _iodbcdm_driverunload( hdbc ); |
| | 1044 | |
| | 1045 | pdbc->state = en_dbc_allocated; |
| | 1046 | |
| | 1047 | PUSHSQLERR( pdbc->herr, en_IM001 ); |
| | 1048 | |
| | 1049 | return SQL_ERROR; |
| | 1050 | } |
| | 1051 | |
| | 1052 | CALL_DRIVER ( hdbc, retcode, hproc, en_BrowseConnect, ( |
| | 1053 | pdbc->dhdbc, hwnd, |
| | 1054 | szConnStrIn, cbConnStrIn, |
| | 1055 | szConnStrOut, cbConnStrOutMax, |
| | 1056 | pcbConnStrOut ) ) |
| | 1057 | |
| | 1058 | #if 0 |
| | 1059 | retcode = hproc(pdbc->dhdbc, hwnd, |
| | 1060 | szConnStrIn, cbConnStrIn, |
| | 1061 | szConnStrOut, cbConnStrOutMax, |
| | 1062 | pcbConnStrOut ); |
| | 1063 | #endif |
| | 1064 | |
| | 1065 | switch( retcode ) |
| | 1066 | { |
| | 1067 | case SQL_SUCCESS: |
| | 1068 | case SQL_SUCCESS_WITH_INFO: |
| | 1069 | pdbc->state = en_dbc_connected; |
| | 1070 | setopterr |= _iodbcdm_dbcdelayset( hdbc ); |
| | 1071 | if( setopterr != SQL_SUCCESS ) |
| | 1072 | { |
| | 1073 | retcode = SQL_SUCCESS_WITH_INFO; |
| | 1074 | } |
| | 1075 | break; |
| | 1076 | |
| | 1077 | case SQL_NEED_DATA: |
| | 1078 | pdbc->state = en_dbc_needdata; |
| | 1079 | break; |
| | 1080 | |
| | 1081 | case SQL_ERROR: |
| | 1082 | pdbc->state = en_dbc_allocated; |
| | 1083 | /* but the driver will not unloaded |
| | 1084 | * to allow application retrive err |
| | 1085 | * message from driver |
| | 1086 | */ |
| | 1087 | break; |
| | 1088 | |
| | 1089 | default: |
| | 1090 | break; |
| | 1091 | } |
| | 1092 | |
| | 1093 | return retcode; |
| | 1094 | } |
| | 1095 | |
| | 1096 | RETCODE SQL_API SQLDisconnect ( HDBC hdbc ) |
| | 1097 | { |
| | 1098 | DBC_t FAR* pdbc = (DBC_t*)hdbc; |
| | 1099 | STMT_t FAR* pstmt; |
| | 1100 | RETCODE retcode; |
| | 1101 | HPROC hproc; |
| | 1102 | |
| | 1103 | int sqlstat = en_00000; |
| | 1104 | |
| | 1105 | if( hdbc == SQL_NULL_HDBC ) |
| | 1106 | { |
| | 1107 | return SQL_INVALID_HANDLE; |
| | 1108 | } |
| | 1109 | |
| | 1110 | /* check hdbc state */ |
| | 1111 | if ( pdbc->state == en_dbc_allocated ) |
| | 1112 | { |
| | 1113 | sqlstat = en_08003; |
| | 1114 | } |
| | 1115 | |
| | 1116 | /* check stmt(s) state */ |
| | 1117 | for( pstmt = (STMT_t FAR*)pdbc->hstmt; |
| | 1118 | pstmt != NULL && sqlstat == en_00000; |
| | 1119 | pstmt = (STMT_t FAR*)pstmt->next ) |
| | 1120 | { |
| | 1121 | if( pstmt->state >= en_stmt_needdata |
| | 1122 | || pstmt->asyn_on != en_NullProc ) |
| | 1123 | /* In this case one need to call |
| | 1124 | * SQLCancel() first */ |
| | 1125 | { |
| | 1126 | sqlstat = en_S1010; |
| | 1127 | } |
| | 1128 | } |
| | 1129 | |
| | 1130 | if( sqlstat == en_00000 ) |
| | 1131 | { |
| | 1132 | hproc = _iodbcdm_getproc( hdbc, en_Disconnect ); |
| | 1133 | |
| | 1134 | if( hproc == SQL_NULL_HPROC ) |
| | 1135 | { |
| | 1136 | sqlstat = en_IM001; |
| | 1137 | } |
| | 1138 | } |
| | 1139 | |
| | 1140 | if( sqlstat != en_00000 ) |
| | 1141 | { |
| | 1142 | PUSHSQLERR ( pdbc->herr, sqlstat ); |
| | 1143 | |
| | 1144 | return SQL_ERROR; |
| | 1145 | } |
| | 1146 | |
| | 1147 | CALL_DRIVER ( hdbc, retcode, hproc, en_Disconnect, ( |
| | 1148 | pdbc->dhdbc ) ) |
| | 1149 | |
| | 1150 | #if 0 |
| | 1151 | retcode = hproc( pdbc->dhdbc ); |
| | 1152 | #endif |
| | 1153 | |
| | 1154 | if( retcode == SQL_SUCCESS |
| | 1155 | || retcode == SQL_SUCCESS_WITH_INFO ) |
| | 1156 | { |
| | 1157 | /* diff from MS specs. We disallow |
| | 1158 | * driver SQLDisconnect() return |
| | 1159 | * SQL_SUCCESS_WITH_INFO and post |
| | 1160 | * error message. |
| | 1161 | */ |
| | 1162 | retcode = SQL_SUCCESS; |
| | 1163 | } |
| | 1164 | else |
| | 1165 | { |
| | 1166 | return retcode; |
| | 1167 | } |
| | 1168 | |
| | 1169 | /* free all statement handle(s) on this connection */ |
| | 1170 | for(;pdbc->hstmt;) |
| | 1171 | { |
| | 1172 | _iodbcdm_dropstmt( pdbc->hstmt ); |
| | 1173 | } |
| | 1174 | |
| | 1175 | #if 0 |
| | 1176 | retcode = _iodbcdm_driverunload( hdbc ); |
| | 1177 | #endif |
| | 1178 | |
| | 1179 | /* state transition */ |
| | 1180 | if( retcode == SQL_SUCCESS ) |
| | 1181 | { |
| | 1182 | pdbc->state = en_dbc_allocated; |
| | 1183 | } |
| | 1184 | |
| | 1185 | return retcode; |
| | 1186 | } |
| | 1187 | |
| | 1188 | RETCODE SQL_API SQLNativeSql( |
| | 1189 | HDBC hdbc, |
| | 1190 | UCHAR FAR* szSqlStrIn, |
| | 1191 | SDWORD cbSqlStrIn, |
| | 1192 | UCHAR FAR* szSqlStr, |
| | 1193 | SDWORD cbSqlStrMax, |
| | 1194 | SDWORD FAR* pcbSqlStr ) |
| | 1195 | { |
| | 1196 | DBC_t FAR* pdbc = (DBC_t FAR*)hdbc; |
| | 1197 | HPROC hproc; |
| | 1198 | int sqlstat = en_00000; |
| | 1199 | RETCODE retcode; |
| | 1200 | |
| | 1201 | if( hdbc == SQL_NULL_HDBC ) |
| | 1202 | { |
| | 1203 | return SQL_INVALID_HANDLE; |
| | 1204 | } |
| | 1205 | |
| | 1206 | /* check argument */ |
| | 1207 | if( szSqlStrIn == NULL ) |
| | 1208 | { |
| | 1209 | sqlstat = en_S1009; |
| | 1210 | } |
| | 1211 | else if( cbSqlStrIn < 0 |
| | 1212 | && cbSqlStrIn != SQL_NTS ) |
| | 1213 | { |
| | 1214 | sqlstat = en_S1090; |
| | 1215 | } |
| | 1216 | |
| | 1217 | if( sqlstat != en_00000 ) |
| | 1218 | { |
| | 1219 | PUSHSQLERR ( pdbc->herr, sqlstat ); |
| | 1220 | |
| | 1221 | return SQL_ERROR; |
| | 1222 | } |
| | 1223 | |
| | 1224 | /* check state */ |
| | 1225 | if( pdbc->state <= en_dbc_needdata ) |
| | 1226 | { |
| | 1227 | PUSHSQLERR ( pdbc->herr, en_08003 ); |
| | 1228 | |
| | 1229 | return SQL_ERROR; |
| | 1230 | } |
| | 1231 | |
| | 1232 | /* call driver */ |
| | 1233 | hproc = _iodbcdm_getproc( hdbc, en_NativeSql ); |
| | 1234 | |
| | 1235 | if( hproc == SQL_NULL_HPROC ) |
| | 1236 | { |
| | 1237 | PUSHSQLERR ( pdbc->herr, en_IM001 ); |
| | 1238 | |
| | 1239 | return SQL_ERROR; |
| | 1240 | } |
| | 1241 | |
| | 1242 | CALL_DRIVER ( hdbc, retcode, hproc, en_NativeSql, ( |
| | 1243 | pdbc->dhdbc, |
| | 1244 | szSqlStrIn, |
| | 1245 | cbSqlStrIn, |
| | 1246 | szSqlStr, |
| | 1247 | cbSqlStrMax, |
| | 1248 | pcbSqlStr ) ) |
| | 1249 | |
| | 1250 | #if 0 |
| | 1251 | retcode = hproc(pdbc->dhdbc, |
| | 1252 | szSqlStrIn, |
| | 1253 | cbSqlStrIn, |
| | 1254 | szSqlStr, |
| | 1255 | cbSqlStrMax, |
| | 1256 | pcbSqlStr ); |
| | 1257 | #endif |
| | 1258 | |
| | 1259 | return retcode; |
| | 1260 | } |
projects / wxWidgets.git / blame_incremental