LCOV - code coverage report
Current view: top level - clients/odbc/driver - SQLDriverConnect.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 189 0.0 %
Date: 2021-10-13 02:24:04 Functions: 0 4 0.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : /*
      10             :  * This code was created by Peter Harvey (mostly during Christmas 98/99).
      11             :  * This code is LGPL. Please ensure that this message remains in future
      12             :  * distributions and uses of this code (thats about all I get out of it).
      13             :  * - Peter Harvey pharvey@codebydesign.com
      14             :  *
      15             :  * This file has been modified for the MonetDB project.  See the file
      16             :  * Copyright in this directory for more information.
      17             :  */
      18             : 
      19             : /**********************************************************************
      20             :  * SQLDriverConnect()
      21             :  * CLI Compliance: ODBC (Microsoft)
      22             :  *
      23             :  * Author: Martin van Dinther, Sjoerd Mullender
      24             :  * Date  : 30 aug 2002
      25             :  *
      26             :  **********************************************************************/
      27             : 
      28             : #include "ODBCGlobal.h"
      29             : #include "ODBCDbc.h"
      30             : #include "ODBCUtil.h"
      31             : #ifdef HAVE_STRINGS_H
      32             : #include <strings.h>              /* for strcasecmp */
      33             : #else
      34             : #include <string.h>
      35             : #endif
      36             : 
      37             : int
      38           0 : ODBCGetKeyAttr(const SQLCHAR **conn, SQLSMALLINT *nconn, char **key, char **attr)
      39             : {
      40             :         const SQLCHAR *p;
      41             :         size_t len;
      42             : 
      43           0 :         *key = *attr = NULL;
      44             : 
      45           0 :         p = *conn;
      46           0 :         if (!**conn)
      47             :                 return 0;
      48           0 :         while (*nconn > 0 && **conn && **conn != '=' && **conn != ';') {
      49           0 :                 (*conn)++;
      50           0 :                 (*nconn)--;
      51             :         }
      52           0 :         if (*nconn == 0 || !**conn || **conn == ';')
      53             :                 return 0;
      54           0 :         len = *conn - p;
      55           0 :         *key = (char *) malloc(len + 1);
      56           0 :         if (*key == NULL)
      57             :                 return -1;
      58           0 :         strcpy_len(*key, (char *) p, len + 1);
      59           0 :         (*conn)++;
      60           0 :         (*nconn)--;
      61             :         p = *conn;
      62             : 
      63           0 :         if (*nconn > 0 && **conn == '{' && strcasecmp(*key, "DRIVER") == 0) {
      64           0 :                 (*conn)++;
      65           0 :                 (*nconn)--;
      66             :                 p++;
      67           0 :                 while (*nconn > 0 && **conn && **conn != '}') {
      68           0 :                         (*conn)++;
      69           0 :                         (*nconn)--;
      70             :                 }
      71           0 :                 len = *conn - p;
      72           0 :                 *attr = (char *) malloc(len + 1);
      73           0 :                 if (*attr == NULL) {
      74           0 :                         free(*key);
      75           0 :                         *key = NULL;
      76           0 :                         return -1;
      77             :                 }
      78           0 :                 strcpy_len(*attr, (char *) p, len + 1);
      79           0 :                 (*conn)++;
      80           0 :                 (*nconn)--;
      81             :                 /* should check that *nconn == 0 || **conn == ';' */
      82             :         } else {
      83           0 :                 while (*nconn > 0 && **conn && **conn != ';') {
      84           0 :                         (*conn)++;
      85           0 :                         (*nconn)--;
      86             :                 }
      87           0 :                 len = *conn - p;
      88           0 :                 *attr = (char *) malloc(len + 1);
      89           0 :                 if (*attr == NULL) {
      90           0 :                         free(*key);
      91           0 :                         *key = NULL;
      92           0 :                         return -1;
      93             :                 }
      94           0 :                 strcpy_len(*attr, (char *) p, len + 1);
      95             :         }
      96           0 :         if (*nconn > 0 && **conn) {
      97           0 :                 (*conn)++;
      98           0 :                 (*nconn)--;
      99             :         }
     100             :         return 1;
     101             : }
     102             : 
     103             : SQLRETURN
     104           0 : ODBCConnectionString(SQLRETURN rc,
     105             :                      ODBCDbc *dbc,
     106             :                      SQLCHAR *OutConnectionString,
     107             :                      SQLSMALLINT BufferLength,
     108             :                      SQLSMALLINT *StringLength2Ptr,
     109             :                      const char *dsn,
     110             :                      const char *uid,
     111             :                      const char *pwd,
     112             :                      const char *host,
     113             :                      int port,
     114             :                      const char *database)
     115             : {
     116             :         int n;
     117             : #ifdef ODBCDEBUG
     118             :         SQLCHAR *buf = OutConnectionString;
     119           0 :         int buflen = BufferLength;
     120             : #endif
     121             : 
     122           0 :         if (OutConnectionString == NULL)
     123             :                 BufferLength = -1;
     124           0 :         if (BufferLength > 0) {
     125           0 :                 n = snprintf((char *) OutConnectionString, BufferLength,
     126             :                              "DSN=%s;", dsn ? dsn : "DEFAULT");
     127             :                 /* some snprintf's return -1 if buffer too small */
     128           0 :                 if (n < 0)
     129           0 :                         n = BufferLength + 1;   /* make sure it becomes < 0 */
     130           0 :                 BufferLength -= n;
     131           0 :                 OutConnectionString += n;
     132             :         } else {
     133             :                 BufferLength = -1;
     134             :         }
     135           0 :         if (uid) {
     136           0 :                 if (BufferLength > 0) {
     137           0 :                         n = snprintf((char *) OutConnectionString,
     138             :                                      BufferLength, "UID=%s;", uid);
     139           0 :                         if (n < 0)
     140           0 :                                 n = BufferLength + 1;
     141           0 :                         BufferLength -= n;
     142           0 :                         OutConnectionString += n;
     143             :                 } else {
     144             :                         BufferLength = -1;
     145             :                 }
     146             :         }
     147           0 :         if (pwd) {
     148           0 :                 if (BufferLength > 0) {
     149           0 :                         n = snprintf((char *) OutConnectionString,
     150             :                                      BufferLength, "PWD=%s;", pwd);
     151           0 :                         if (n < 0)
     152           0 :                                 n = BufferLength + 1;
     153           0 :                         BufferLength -= n;
     154           0 :                         OutConnectionString += n;
     155             :                 } else {
     156             :                         BufferLength = -1;
     157             :                 }
     158             :         }
     159           0 :         if (host) {
     160           0 :                 if (BufferLength > 0) {
     161           0 :                         n = snprintf((char *) OutConnectionString,
     162             :                                      BufferLength, "HOST=%s;", host);
     163           0 :                         if (n < 0)
     164           0 :                                 n = BufferLength + 1;
     165           0 :                         BufferLength -= n;
     166           0 :                         OutConnectionString += n;
     167             :                 } else {
     168             :                         BufferLength = -1;
     169             :                 }
     170             :         }
     171           0 :         if (port) {
     172             :                 char portbuf[10];
     173             : 
     174           0 :                 if (BufferLength > 0) {
     175           0 :                         n = snprintf((char *) OutConnectionString,
     176             :                                      BufferLength, "PORT=%d;", port);
     177           0 :                         if (n < 0)
     178           0 :                                 n = BufferLength + 1;
     179           0 :                         BufferLength -= n;
     180           0 :                         OutConnectionString += n;
     181             :                 } else {
     182             :                         BufferLength = -1;
     183             :                 }
     184           0 :                 port = snprintf(portbuf, sizeof(portbuf), "%d", port);
     185             :         }
     186           0 :         if (database) {
     187           0 :                 if (BufferLength > 0) {
     188           0 :                         n = snprintf((char *) OutConnectionString,
     189             :                                      BufferLength,
     190             :                                      "DATABASE=%s;", database);
     191           0 :                         if (n < 0)
     192           0 :                                 n = BufferLength + 1;
     193           0 :                         BufferLength -= n;
     194           0 :                         OutConnectionString += n;
     195             :                 } else {
     196             :                         BufferLength = -1;
     197             :                 }
     198             :         }
     199             : #ifdef ODBCDEBUG
     200           0 :         if (ODBCdebug && getenv("ODBCDEBUG") == NULL) {
     201           0 :                 if (BufferLength > 0) {
     202           0 :                         n = snprintf((char *) OutConnectionString,
     203             :                                      BufferLength,
     204             :                                      "LOGFILE=%s;", ODBCdebug);
     205           0 :                         if (n < 0)
     206           0 :                                 n = BufferLength + 1;
     207           0 :                         BufferLength -= n;
     208             :                         OutConnectionString += n;
     209             :                 } else {
     210             :                         BufferLength = -1;
     211             :                 }
     212             :         }
     213             : #endif
     214             : 
     215             :         /* calculate how much space was needed */
     216           0 :         if (StringLength2Ptr)
     217           0 :                 *StringLength2Ptr = (SQLSMALLINT)
     218           0 :                         (strlen(dsn ? dsn : "DEFAULT") + 5 +
     219           0 :                          (uid ? strlen(uid) + 5 : 0) +
     220           0 :                          (pwd ? strlen(pwd) + 5 : 0) +
     221           0 :                          (host ? strlen(host) + 6 : 0) +
     222           0 :                          (port ? port + 6 : 0) +
     223           0 :                          (database ? strlen(database) + 10 : 0)
     224             : #ifdef ODBCDEBUG
     225           0 :                          + (ODBCdebug && getenv("ODBCDEBUG") == NULL ? strlen(ODBCdebug) + 9 : 0)
     226             : #endif
     227             :                                 );
     228             : 
     229             : #ifdef ODBCDEBUG
     230           0 :         ODBCLOG("ConnectionString: \"%.*s\" %d\n", buf ? buflen : 6, buf ? (char *) buf : "(null)", buflen);
     231             : #endif
     232             : 
     233             :         /* if it didn't fit, say so */
     234           0 :         if (BufferLength < 0) {
     235             :                 /* String data, right-truncated */
     236           0 :                 addDbcError(dbc, "01004", NULL, 0);
     237           0 :                 return SQL_SUCCESS_WITH_INFO;
     238             :         }
     239             :         return rc;
     240             : }
     241             : 
     242             : #ifdef ODBCDEBUG
     243             : static char *
     244           0 : translateDriverCompletion(SQLUSMALLINT DriverCompletion)
     245             : {
     246           0 :         switch (DriverCompletion) {
     247             :         case SQL_DRIVER_PROMPT:
     248             :                 return "SQL_DRIVER_PROMPT";
     249           0 :         case SQL_DRIVER_COMPLETE:
     250           0 :                 return "SQL_DRIVER_COMPLETE";
     251           0 :         case SQL_DRIVER_COMPLETE_REQUIRED:
     252           0 :                 return "SQL_DRIVER_COMPLETE_REQUIRED";
     253           0 :         case SQL_DRIVER_NOPROMPT:
     254           0 :                 return "SQL_DRIVER_NOPROMPT";
     255           0 :         default:
     256           0 :                 return "unknown";
     257             :         }
     258             : }
     259             : #endif
     260             : 
     261             : static SQLRETURN
     262           0 : MNDBDriverConnect(ODBCDbc *dbc,
     263             :                   SQLHWND WindowHandle,
     264             :                   const SQLCHAR *InConnectionString,
     265             :                   SQLSMALLINT StringLength1,
     266             :                   SQLCHAR *OutConnectionString,
     267             :                   SQLSMALLINT BufferLength,
     268             :                   SQLSMALLINT *StringLength2Ptr,
     269             :                   SQLUSMALLINT DriverCompletion,
     270             :                   int tryOnly)
     271             : {
     272             :         char *key, *attr;
     273             :         char *dsn = 0, *uid = 0, *pwd = 0, *host = 0, *database = 0;
     274             :         int port = 0;
     275             :         SQLRETURN rc;
     276             :         int n;
     277             : 
     278             :         (void) WindowHandle;            /* Stefan: unused!? */
     279             : 
     280             :         /* check connection state, should not be connected */
     281           0 :         if (dbc->Connected) {
     282             :                 /* Connection name in use */
     283           0 :                 addDbcError(dbc, "08002", NULL, 0);
     284           0 :                 return SQL_ERROR;
     285             :         }
     286             :         assert(!dbc->Connected);
     287             : 
     288           0 :         fixODBCstring(InConnectionString, StringLength1, SQLSMALLINT,
     289             :                       addDbcError, dbc, return SQL_ERROR);
     290             : 
     291             : #ifdef ODBCDEBUG
     292           0 :         ODBCLOG("\"%.*s\" %s\n", StringLength1,
     293             :                 (char *) InConnectionString,
     294             :                 translateDriverCompletion(DriverCompletion));
     295             : #endif
     296             : 
     297             :         /* check input arguments */
     298           0 :         switch (DriverCompletion) {
     299             :         case SQL_DRIVER_PROMPT:
     300             :         case SQL_DRIVER_COMPLETE:
     301             :         case SQL_DRIVER_COMPLETE_REQUIRED:
     302             :         case SQL_DRIVER_NOPROMPT:
     303             :                 break;
     304           0 :         default:
     305             :                 /* Invalid attribute/option identifier */
     306           0 :                 addDbcError(dbc, "HY092", NULL, 0);
     307           0 :                 return SQL_ERROR;
     308             :         }
     309             : 
     310           0 :         while ((n = ODBCGetKeyAttr(&InConnectionString, &StringLength1, &key, &attr)) > 0) {
     311           0 :                 if (strcasecmp(key, "dsn") == 0 && dsn == NULL)
     312           0 :                         dsn = attr;
     313           0 :                 else if (strcasecmp(key, "uid") == 0 && uid == NULL)
     314           0 :                         uid = attr;
     315           0 :                 else if (strcasecmp(key, "pwd") == 0 && pwd == NULL)
     316           0 :                         pwd = attr;
     317           0 :                 else if (strcasecmp(key, "host") == 0 && host == NULL)
     318           0 :                         host = attr;
     319           0 :                 else if (strcasecmp(key, "database") == 0 && database == NULL)
     320           0 :                         database = attr;
     321           0 :                 else if (strcasecmp(key, "port") == 0 && port == 0) {
     322           0 :                         port = atoi(attr);
     323           0 :                         free(attr);
     324             : #ifdef ODBCDEBUG
     325           0 :                 } else if (strcasecmp(key, "logfile") == 0 &&
     326           0 :                            getenv("ODBCDEBUG") == NULL) {
     327           0 :                         if (ODBCdebug)
     328           0 :                                 free((void *) ODBCdebug); /* discard const */
     329           0 :                         ODBCdebug = attr;
     330             : #endif
     331             :                 } else
     332           0 :                         free(attr);
     333           0 :                 free(key);
     334             :         }
     335             : 
     336           0 :         if (n < 0) {
     337             :                 /* Memory allocation error */
     338           0 :                 addDbcError(dbc, "HY001", NULL, 0);
     339             :                 rc = SQL_ERROR;
     340           0 :         } else if (dsn && strlen(dsn) > SQL_MAX_DSN_LENGTH) {
     341             :                 /* Data source name too long */
     342           0 :                 addDbcError(dbc, "IM010", NULL, 0);
     343           0 :                 rc = SQL_ERROR;
     344           0 :         } else if (tryOnly) {
     345             :                 rc = SQL_SUCCESS;
     346             :         } else {
     347           0 :                 rc = MNDBConnect(dbc, (SQLCHAR *) dsn, SQL_NTS,
     348             :                                  (SQLCHAR *) uid, SQL_NTS,
     349             :                                  (SQLCHAR *) pwd, SQL_NTS,
     350             :                                  host, port, database);
     351             :         }
     352             : 
     353           0 :         if (SQL_SUCCEEDED(rc)) {
     354           0 :                 rc = ODBCConnectionString(rc, dbc, OutConnectionString,
     355             :                                           BufferLength, StringLength2Ptr,
     356             :                                           dsn, uid, pwd, host, port, database);
     357             :         }
     358             : 
     359           0 :         if (dsn)
     360           0 :                 free(dsn);
     361           0 :         if (uid)
     362           0 :                 free(uid);
     363           0 :         if (pwd)
     364           0 :                 free(pwd);
     365           0 :         if (host)
     366           0 :                 free(host);
     367           0 :         if (database)
     368           0 :                 free(database);
     369             :         return rc;
     370             : }
     371             : 
     372             : SQLRETURN SQL_API
     373             : SQLDriverConnect(SQLHDBC ConnectionHandle,
     374             :                  SQLHWND WindowHandle,
     375             :                  SQLCHAR *InConnectionString,
     376             :                  SQLSMALLINT StringLength1,
     377             :                  SQLCHAR *OutConnectionString,
     378             :                  SQLSMALLINT BufferLength,
     379             :                  SQLSMALLINT *StringLength2Ptr,
     380             :                  SQLUSMALLINT DriverCompletion)
     381             : {
     382             :         ODBCDbc *dbc = (ODBCDbc *) ConnectionHandle;
     383             : 
     384             : #ifdef ODBCDEBUG
     385           0 :         ODBCLOG("SQLDriverConnect %p ", ConnectionHandle);
     386             : #endif
     387             : 
     388           0 :         if (!isValidDbc(dbc))
     389             :                 return SQL_INVALID_HANDLE;
     390             : 
     391           0 :         clearDbcErrors(dbc);
     392             : 
     393           0 :         return MNDBDriverConnect(dbc,
     394             :                                  WindowHandle,
     395             :                                  InConnectionString,
     396             :                                  StringLength1,
     397             :                                  OutConnectionString,
     398             :                                  BufferLength,
     399             :                                  StringLength2Ptr,
     400             :                                  DriverCompletion,
     401             :                                  0);
     402             : }
     403             : 
     404             : SQLRETURN SQL_API
     405             : SQLDriverConnectA(SQLHDBC ConnectionHandle,
     406             :                   SQLHWND WindowHandle,
     407             :                   SQLCHAR *InConnectionString,
     408             :                   SQLSMALLINT StringLength1,
     409             :                   SQLCHAR *OutConnectionString,
     410             :                   SQLSMALLINT BufferLength,
     411             :                   SQLSMALLINT *StringLength2Ptr,
     412             :                   SQLUSMALLINT DriverCompletion)
     413             : {
     414           0 :         return SQLDriverConnect(ConnectionHandle,
     415             :                                 WindowHandle,
     416             :                                 InConnectionString,
     417             :                                 StringLength1,
     418             :                                 OutConnectionString,
     419             :                                 BufferLength,
     420             :                                 StringLength2Ptr,
     421             :                                 DriverCompletion);
     422             : }
     423             : 
     424             : SQLRETURN SQL_API
     425             : SQLDriverConnectW(SQLHDBC ConnectionHandle,
     426             :                   SQLHWND WindowHandle,
     427             :                   SQLWCHAR *InConnectionString,
     428             :                   SQLSMALLINT StringLength1,
     429             :                   SQLWCHAR *OutConnectionString,
     430             :                   SQLSMALLINT BufferLength,
     431             :                   SQLSMALLINT *StringLength2Ptr,
     432             :                   SQLUSMALLINT DriverCompletion)
     433             : {
     434             :         ODBCDbc *dbc = (ODBCDbc *) ConnectionHandle;
     435             :         SQLCHAR *in = NULL, *out;
     436             :         SQLSMALLINT n;
     437             :         SQLRETURN rc;
     438             : 
     439             : #ifdef ODBCDEBUG
     440           0 :         ODBCLOG("SQLDriverConnectW %p ", ConnectionHandle);
     441             : #endif
     442             : 
     443           0 :         if (!isValidDbc(dbc))
     444             :                 return SQL_INVALID_HANDLE;
     445             : 
     446           0 :         clearDbcErrors(dbc);
     447             : 
     448           0 :         fixWcharIn(InConnectionString, StringLength1, SQLCHAR, in,
     449             :                    addDbcError, dbc, return SQL_ERROR);
     450             : 
     451           0 :         rc = MNDBDriverConnect(dbc, WindowHandle, in, SQL_NTS, NULL, 0, &n,
     452             :                                DriverCompletion, 1);
     453           0 :         if (!SQL_SUCCEEDED(rc))
     454             :                 return rc;
     455           0 :         clearDbcErrors(dbc);
     456           0 :         n++;                    /* account for NUL byte */
     457           0 :         out = malloc(n);
     458           0 :         if (out == NULL) {
     459             :                 /* Memory allocation error */
     460           0 :                 addDbcError(dbc, "HY001", NULL, 0);
     461           0 :                 return SQL_ERROR;
     462             :         }
     463           0 :         rc = MNDBDriverConnect(dbc, WindowHandle, in, SQL_NTS, out, n, &n,
     464             :                                DriverCompletion, 0);
     465           0 :         if (SQL_SUCCEEDED(rc)) {
     466           0 :                 fixWcharOut(rc, out, n, OutConnectionString, BufferLength,
     467             :                             StringLength2Ptr, 1, addDbcError, dbc);
     468             :         }
     469           0 :         free(out);
     470           0 :         if (in)
     471           0 :                 free(in);
     472             :         return rc;
     473             : }

Generated by: LCOV version 1.14