Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * This code was created by Peter Harvey (mostly during Christmas 98/99).
15 : * This code is LGPL. Please ensure that this message remains in future
16 : * distributions and uses of this code (that's about all I get out of it).
17 : * - Peter Harvey pharvey@codebydesign.com
18 : *
19 : * This file has been modified for the MonetDB project. See the file
20 : * Copyright in this directory for more information.
21 : */
22 :
23 : /**********************************************************************
24 : * SQLDriverConnect()
25 : * CLI Compliance: ODBC (Microsoft)
26 : *
27 : * Author: Martin van Dinther, Sjoerd Mullender
28 : * Date : 30 aug 2002
29 : *
30 : **********************************************************************/
31 :
32 : #include "ODBCGlobal.h"
33 : #include "ODBCDbc.h"
34 : #include "ODBCUtil.h"
35 : #include "ODBCAttrs.h"
36 : #ifdef HAVE_STRINGS_H
37 : #include <strings.h> /* for strcasecmp */
38 : #else
39 : #include <string.h>
40 : #endif
41 :
42 : int
43 576 : ODBCGetKeyAttr(const SQLCHAR **conn, SQLSMALLINT *nconn, char **key, char **attr)
44 : {
45 576 : const SQLCHAR *p;
46 576 : size_t len;
47 :
48 576 : *key = *attr = NULL;
49 :
50 576 : p = *conn;
51 576 : if (!**conn)
52 : return 0;
53 1832 : while (*nconn > 0 && **conn && **conn != '=' && **conn != ';') {
54 1432 : (*conn)++;
55 1432 : (*nconn)--;
56 : }
57 400 : if (*nconn == 0 || !**conn || **conn == ';')
58 : return 0;
59 399 : len = *conn - p;
60 399 : *key = (char *) malloc(len + 1);
61 399 : if (*key == NULL)
62 : return -1;
63 399 : strcpy_len(*key, (char *) p, len + 1);
64 399 : (*conn)++;
65 399 : (*nconn)--;
66 399 : p = *conn;
67 :
68 399 : if (*nconn > 0 && **conn == '{' && strcasecmp(*key, "DRIVER") == 0) {
69 10 : (*conn)++;
70 10 : (*nconn)--;
71 10 : p++;
72 80 : while (*nconn > 0 && **conn && **conn != '}') {
73 70 : (*conn)++;
74 70 : (*nconn)--;
75 : }
76 10 : len = *conn - p;
77 10 : *attr = (char *) malloc(len + 1);
78 10 : if (*attr == NULL) {
79 0 : free(*key);
80 0 : *key = NULL;
81 0 : return -1;
82 : }
83 10 : strcpy_len(*attr, (char *) p, len + 1);
84 10 : (*conn)++;
85 10 : (*nconn)--;
86 : /* should check that *nconn == 0 || **conn == ';' */
87 : } else {
88 4951 : while (*nconn > 0 && **conn && **conn != ';') {
89 4562 : (*conn)++;
90 4562 : (*nconn)--;
91 : }
92 389 : len = *conn - p;
93 389 : *attr = (char *) malloc(len + 1);
94 389 : if (*attr == NULL) {
95 0 : free(*key);
96 0 : *key = NULL;
97 0 : return -1;
98 : }
99 389 : strcpy_len(*attr, (char *) p, len + 1);
100 : }
101 399 : if (*nconn > 0 && **conn) {
102 367 : (*conn)++;
103 367 : (*nconn)--;
104 : }
105 : return 1;
106 : }
107 :
108 : #ifdef ODBCDEBUG
109 : static char *
110 169 : translateDriverCompletion(SQLUSMALLINT DriverCompletion)
111 : {
112 169 : switch (DriverCompletion) {
113 : case SQL_DRIVER_PROMPT:
114 : return "SQL_DRIVER_PROMPT";
115 0 : case SQL_DRIVER_COMPLETE:
116 0 : return "SQL_DRIVER_COMPLETE";
117 0 : case SQL_DRIVER_COMPLETE_REQUIRED:
118 0 : return "SQL_DRIVER_COMPLETE_REQUIRED";
119 169 : case SQL_DRIVER_NOPROMPT:
120 169 : return "SQL_DRIVER_NOPROMPT";
121 0 : default:
122 0 : return "unknown";
123 : }
124 : }
125 : #endif
126 :
127 : SQLRETURN
128 169 : MNDBDriverConnect(ODBCDbc *dbc,
129 : SQLHWND WindowHandle,
130 : const SQLCHAR *InConnectionString,
131 : SQLSMALLINT StringLength1,
132 : SQLCHAR *OutConnectionString,
133 : SQLSMALLINT BufferLength,
134 : SQLSMALLINT *StringLength2Ptr,
135 : SQLUSMALLINT DriverCompletion,
136 : int tryOnly)
137 : {
138 169 : (void) WindowHandle;
139 :
140 169 : SQLRETURN rc = SQL_SUCCESS;
141 169 : const char *sqlstate = NULL;
142 169 : size_t out_len;
143 169 : const char *scratch_no_alloc;
144 :
145 : // These will be free'd at the end label
146 169 : msettings *settings = NULL;
147 169 : char *scratch_alloc = NULL;
148 169 : char *dsn = NULL;
149 :
150 : /* check connection state, should not be connected */
151 169 : if (dbc->Connected) {
152 0 : sqlstate = "08002";
153 0 : goto failure;
154 : }
155 :
156 169 : fixODBCstring(InConnectionString, StringLength1, SQLSMALLINT,
157 : addDbcError, dbc, return SQL_ERROR);
158 :
159 169 : settings = msettings_clone(dbc->settings);
160 169 : if (!settings)
161 0 : goto failure;
162 :
163 : #ifdef ODBCDEBUG
164 169 : ODBCLOG("\"%.*s\" %s\n", StringLength1,
165 : (char *) InConnectionString,
166 : translateDriverCompletion(DriverCompletion));
167 : #endif
168 :
169 : /* check input arguments */
170 169 : switch (DriverCompletion) {
171 : case SQL_DRIVER_PROMPT:
172 : case SQL_DRIVER_COMPLETE:
173 : case SQL_DRIVER_COMPLETE_REQUIRED:
174 : case SQL_DRIVER_NOPROMPT:
175 169 : break;
176 0 : default:
177 : /* Invalid attribute/option identifier */
178 0 : sqlstate = "HY092";
179 0 : goto failure;
180 : }
181 :
182 169 : rc = takeFromConnString(dbc, settings, InConnectionString, StringLength1, &dsn);
183 169 : if (!SQL_SUCCEEDED(rc))
184 0 : goto end;
185 :
186 169 : scratch_no_alloc = msettings_validate(settings);
187 169 : if (scratch_no_alloc != NULL) {
188 0 : addDbcError(dbc, "HY009", scratch_no_alloc, 0);
189 0 : rc = SQL_ERROR;
190 0 : goto end;
191 : }
192 :
193 : // Build a connect string for the current connection and put it in the out buffer.
194 330 : scratch_alloc = buildConnectionString(dsn ? dsn : "DEFAULT", settings);
195 169 : if (!scratch_alloc)
196 0 : goto failure;
197 169 : out_len = strcpy_len((char*)OutConnectionString, scratch_alloc, BufferLength);
198 169 : if (StringLength2Ptr)
199 169 : *StringLength2Ptr = (SQLSMALLINT)out_len;
200 169 : if (out_len + 1 > (size_t)BufferLength) {
201 73 : addDbcError(dbc, "01004", NULL, 0);
202 73 : rc = SQL_SUCCESS_WITH_INFO;
203 : }
204 :
205 169 : if (tryOnly) {
206 73 : assert(sqlstate == NULL);
207 73 : goto end;
208 : }
209 :
210 96 : scratch_no_alloc = msetting_string(settings, MP_LOGFILE);
211 96 : if (*scratch_no_alloc)
212 0 : setODBCdebug(scratch_no_alloc, false);
213 :
214 96 : rc = MNDBConnectSettings(dbc, dsn, settings);
215 96 : settings = NULL; // do not free now
216 :
217 : // always go to end, MNDBConnectSettings has already logged any failures
218 96 : goto end;
219 :
220 0 : failure:
221 0 : if (sqlstate == NULL)
222 0 : sqlstate = "HY001"; // malloc failure
223 : rc = SQL_ERROR;
224 : // fallthrough
225 169 : end:
226 169 : if (sqlstate != NULL)
227 0 : addDbcError(dbc, sqlstate, NULL, 0);
228 169 : msettings_destroy(settings);
229 169 : free(scratch_alloc);
230 169 : free(dsn);
231 169 : return rc;
232 : }
233 :
234 : SQLRETURN SQL_API
235 : SQLDriverConnect(SQLHDBC ConnectionHandle,
236 : SQLHWND WindowHandle,
237 : SQLCHAR *InConnectionString,
238 : SQLSMALLINT StringLength1,
239 : SQLCHAR *OutConnectionString,
240 : SQLSMALLINT BufferLength,
241 : SQLSMALLINT *StringLength2Ptr,
242 : SQLUSMALLINT DriverCompletion)
243 : {
244 13 : ODBCDbc *dbc = (ODBCDbc *) ConnectionHandle;
245 :
246 : #ifdef ODBCDEBUG
247 13 : ODBCLOG("SQLDriverConnect %p ", ConnectionHandle);
248 : #endif
249 :
250 13 : if (!isValidDbc(dbc))
251 : return SQL_INVALID_HANDLE;
252 :
253 13 : clearDbcErrors(dbc);
254 :
255 13 : return MNDBDriverConnect(dbc,
256 : WindowHandle,
257 : InConnectionString,
258 : StringLength1,
259 : OutConnectionString,
260 : BufferLength,
261 : StringLength2Ptr,
262 : DriverCompletion,
263 : 0);
264 : }
265 :
266 : SQLRETURN SQL_API
267 : SQLDriverConnectA(SQLHDBC ConnectionHandle,
268 : SQLHWND WindowHandle,
269 : SQLCHAR *InConnectionString,
270 : SQLSMALLINT StringLength1,
271 : SQLCHAR *OutConnectionString,
272 : SQLSMALLINT BufferLength,
273 : SQLSMALLINT *StringLength2Ptr,
274 : SQLUSMALLINT DriverCompletion)
275 : {
276 0 : return SQLDriverConnect(ConnectionHandle,
277 : WindowHandle,
278 : InConnectionString,
279 : StringLength1,
280 : OutConnectionString,
281 : BufferLength,
282 : StringLength2Ptr,
283 : DriverCompletion);
284 : }
285 :
286 : SQLRETURN SQL_API
287 : SQLDriverConnectW(SQLHDBC ConnectionHandle,
288 : SQLHWND WindowHandle,
289 : SQLWCHAR *InConnectionString,
290 : SQLSMALLINT StringLength1,
291 : SQLWCHAR *OutConnectionString,
292 : SQLSMALLINT BufferLength,
293 : SQLSMALLINT *StringLength2Ptr,
294 : SQLUSMALLINT DriverCompletion)
295 : {
296 73 : ODBCDbc *dbc = (ODBCDbc *) ConnectionHandle;
297 73 : SQLCHAR *in = NULL, *out;
298 73 : SQLSMALLINT n;
299 73 : SQLRETURN rc;
300 :
301 : #ifdef ODBCDEBUG
302 73 : ODBCLOG("SQLDriverConnectW %p ", ConnectionHandle);
303 : #endif
304 :
305 73 : if (!isValidDbc(dbc))
306 : return SQL_INVALID_HANDLE;
307 :
308 73 : clearDbcErrors(dbc);
309 :
310 73 : fixWcharIn(InConnectionString, StringLength1, SQLCHAR, in,
311 : addDbcError, dbc, return SQL_ERROR);
312 :
313 73 : rc = MNDBDriverConnect(dbc, WindowHandle, in, SQL_NTS, NULL, 0, &n,
314 : DriverCompletion, 1); // 1 = Try Only
315 73 : if (!SQL_SUCCEEDED(rc))
316 : return rc;
317 73 : clearDbcErrors(dbc);
318 73 : n++; /* account for NUL byte */
319 73 : out = malloc(n);
320 73 : if (out == NULL) {
321 : /* Memory allocation error */
322 0 : addDbcError(dbc, "HY001", NULL, 0);
323 0 : return SQL_ERROR;
324 : }
325 73 : rc = MNDBDriverConnect(dbc, WindowHandle, in, SQL_NTS, out, n, &n,
326 : DriverCompletion, 0);
327 73 : if (SQL_SUCCEEDED(rc)) {
328 72 : fixWcharOut(rc, out, n, OutConnectionString, BufferLength,
329 : StringLength2Ptr, 1, addDbcError, dbc);
330 : }
331 73 : free(out);
332 73 : if (in)
333 73 : free(in);
334 : return rc;
335 : }
|
