src/iodbc/connect.c

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