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 : * SQLConnect()
25 : * CLI Compliance: ISO 92
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 : #include <time.h>
37 : #include "msettings.h"
38 : #include "mstring.h"
39 :
40 : #ifdef HAVE_ODBCINST_H
41 : #include <odbcinst.h>
42 : #endif
43 :
44 : #ifndef HAVE_SQLGETPRIVATEPROFILESTRING
45 : #define SQLGetPrivateProfileString(section,entry,default,buffer,bufferlen,filename) ((int) strcpy_len(buffer,default,bufferlen))
46 : #endif
47 :
48 : static SQLRETURN
49 102 : get_serverinfo(ODBCDbc *dbc)
50 : {
51 102 : MapiHdl hdl = NULL;
52 102 : SQLRETURN rc; // intentionally uninitialized
53 102 : char *n, *v;
54 :
55 102 : if ((hdl = mapi_query(dbc->mid, "select name, value from sys.env() where name in ('monet_version', 'gdk_dbname', 'max_clients', 'raw_strings')")) == NULL)
56 0 : goto end;
57 102 : dbc->raw_strings = false;
58 510 : while (mapi_fetch_row(hdl)) {
59 408 : n = mapi_fetch_field(hdl, 0);
60 408 : v = mapi_fetch_field(hdl, 1);
61 408 : if (strcmp(n, "monet_version") == 0) {
62 102 : sscanf(v, "%hd.%hd.%hd",
63 : &dbc->major, &dbc->minor, &dbc->patch);
64 : } else
65 306 : if (strcmp(n, "max_clients") == 0) {
66 102 : sscanf(v, "%hu", &dbc->maxclients);
67 204 : } else if (strcmp(n, "raw_strings") == 0) {
68 102 : dbc->raw_strings = strcmp(v, "true") == 0;
69 : } else {
70 102 : assert(strcmp(n, "gdk_dbname") == 0);
71 102 : msetting_set_string(dbc->settings, MP_DATABASE, v);
72 : }
73 : }
74 102 : if (mapi_error(dbc->mid))
75 0 : goto end;
76 :
77 : /* table sys.comments should exist since Mar2018 (11.29) */
78 102 : if (dbc->major == 11 && dbc->minor > 29) {
79 102 : dbc->has_comment = true;
80 : } else {
81 0 : mapi_close_handle(hdl);
82 0 : if ((hdl = mapi_query(dbc->mid, "select id from sys._tables where name = 'comments' and schema_id = (select id from sys.schemas where name = 'sys')")) == NULL)
83 0 : goto end;
84 0 : if (mapi_error(dbc->mid))
85 0 : goto end;
86 0 : n = NULL;
87 0 : if (mapi_fetch_row(hdl)) {
88 0 : n = mapi_fetch_field(hdl, 0);
89 : }
90 0 : dbc->has_comment = n != NULL;
91 : }
92 :
93 : rc = SQL_SUCCESS;
94 102 : end:
95 102 : if (mapi_error(dbc->mid)) {
96 0 : addDbcError(dbc, "08001", mapi_error_str(dbc->mid), 0);
97 0 : rc = SQL_ERROR;
98 : }
99 102 : mapi_close_handle(hdl);
100 102 : return rc;
101 : }
102 :
103 :
104 : // Ensure '*argument' is either NULL or a NUL-terminated string,
105 : // taking into account 'argument_len' being either a proper string length
106 : // or one of the special values SQL_NULL_DATA or SQL_NTS.
107 : //
108 : // Return 'true' on success and 'false' on allocation failure.
109 : //
110 : // If memory needs to be allocated and 'scratch' is not NULL,
111 : // a pointer to the allocated memory will be stored in '*scratch'
112 : // and the previous value of '*scratch' will be free'd.
113 : //
114 : // '*argument' is never free'd.
115 : bool
116 47 : makeNulTerminated(const SQLCHAR **argument, ssize_t argument_len, void **scratch)
117 : {
118 47 : assert(argument != NULL);
119 :
120 47 : if (*argument == NULL || argument_len == SQL_NTS)
121 : return true;
122 2 : if (argument_len == SQL_NULL_DATA) {
123 0 : *argument = NULL;
124 0 : return true;
125 : }
126 :
127 2 : SQLCHAR *value = malloc(argument_len + 1);
128 2 : if (value == NULL)
129 : return false;
130 2 : memmove(value, *argument, argument_len);
131 2 : value[argument_len] = '\0';
132 :
133 2 : *argument = value;
134 2 : if (scratch) {
135 2 : free(*scratch);
136 2 : *scratch = value;
137 : }
138 :
139 : return value;
140 : }
141 :
142 : char*
143 183 : buildConnectionString(const char *dsn, const msettings *settings)
144 : {
145 183 : size_t pos = 0;
146 183 : size_t cap = 1024;
147 183 : char *buf = malloc(cap); // reallocprintf will deal with allocation failures
148 183 : char *sep = "";
149 183 : const char *value = NULL;
150 183 : const char *default_value = NULL;
151 183 : char scratch1[40], scratch2[40];
152 183 : bool ok = false;
153 :
154 183 : if (dsn) {
155 183 : if (reallocprintf(&buf, &pos, &cap, "DSN=%s", dsn) < 0)
156 0 : goto end;
157 : sep = ";";
158 : }
159 :
160 4209 : for (int i = 0; i < attr_setting_count; i++) {
161 4026 : const struct attr_setting *entry = &attr_settings[i];
162 4026 : mparm parm = entry->parm;
163 :
164 4026 : if (parm == MP_IGNORE || parm == MP_TABLE || parm == MP_TABLESCHEMA)
165 0 : continue;
166 :
167 4026 : value = msetting_as_string(settings, parm, scratch1, sizeof(scratch1));
168 4026 : if (!value)
169 0 : goto end;
170 :
171 4026 : bool show_this; // intentionally uninitialized
172 4026 : if (parm == MP_USER || parm == MP_PASSWORD) {
173 : show_this = true;
174 3660 : } else if (parm == MP_PORT && msetting_long(settings, MP_PORT) <= 0) {
175 : show_this = false;
176 3654 : } else if (parm == MP_TLS) {
177 183 : show_this = msetting_bool(settings, MP_TLS);
178 3471 : } else if (mparm_is_core(parm)) {
179 : show_this = true;
180 : } else {
181 : // skip if still default
182 2928 : default_value = msetting_as_string(msettings_default, parm, scratch2, sizeof(scratch2));
183 2928 : if (!default_value)
184 0 : goto end;
185 2928 : show_this = (strcmp(value, default_value) != 0);
186 : }
187 3111 : if (show_this) {
188 917 : if (reallocprintf(&buf, &pos, &cap, "%s%s=%s", sep, entry->name, value) < 0)
189 0 : goto end;
190 : sep = ";";
191 : }
192 : }
193 :
194 : ok = true;
195 :
196 183 : end:
197 0 : if (ok) {
198 183 : return buf;
199 : } else {
200 0 : free(buf);
201 0 : return NULL;
202 : }
203 : }
204 :
205 : static int
206 3894 : lookup(const char *dsn, const struct attr_setting *entry, char *buf, int bufsize)
207 : {
208 3894 : int n;
209 3894 : assert(entry->name);
210 3894 : n = SQLGetPrivateProfileString(dsn, entry->name, "", buf, bufsize, "odbc.ini");
211 3894 : if (n > 0)
212 : return n;
213 3363 : if (entry->alt_name)
214 3186 : n = SQLGetPrivateProfileString(dsn, entry->alt_name, "", buf, bufsize, "odbc.ini");
215 : return n;
216 : }
217 :
218 : const char*
219 177 : takeFromDataSource(ODBCDbc *dbc, msettings *settings, const char *dsn)
220 : {
221 177 : char buf[1024] = { 0 };
222 :
223 4071 : for (int i = 0; i < attr_setting_count; i++) {
224 3894 : const struct attr_setting *entry = &attr_settings[i];
225 3894 : mparm parm = entry->parm;
226 3894 : int n = lookup(dsn, entry, buf, sizeof(buf));
227 3894 : if (n > 0) {
228 885 : if (sizeof(buf) - n <= 1)
229 : return "01004"; // truncated
230 885 : const char *msg = msetting_parse(settings, parm, buf);
231 885 : if (msg != NULL)
232 0 : return msg;
233 885 : dbc->setting_touched[(int)parm] = 1;
234 : }
235 : }
236 :
237 : return NULL;
238 : }
239 :
240 : SQLRETURN
241 169 : takeFromConnString(
242 : ODBCDbc *dbc,
243 : msettings *settings,
244 : const SQLCHAR *InConnectionString,
245 : SQLSMALLINT StringLength1,
246 : char **dsn_out)
247 : {
248 169 : SQLRETURN rc = SQL_SUCCESS;
249 169 : const char *sqlstate = NULL;
250 169 : const char *sql_explanation = NULL;
251 169 : const SQLCHAR *cursor;
252 169 : SQLSMALLINT n;
253 169 : char *dsn = NULL, *key = NULL, *attr = NULL;
254 :
255 : // figure out the DSN and load its settings
256 169 : cursor = InConnectionString;
257 169 : n = StringLength1;
258 196 : while (ODBCGetKeyAttr(&cursor, &n, &key, &attr) > 0) {
259 188 : if (strcasecmp(key, "dsn") == 0) {
260 161 : dsn = attr;
261 161 : free(key);
262 161 : break;
263 : }
264 27 : free(key);
265 27 : free(attr);
266 : }
267 169 : key = NULL;
268 169 : attr = NULL;
269 169 : if (dsn) {
270 161 : if (strlen(dsn) > SQL_MAX_DSN_LENGTH)
271 : sqlstate = "IM010"; // Data source name too long
272 : else
273 161 : sqlstate = takeFromDataSource(dbc, settings, dsn);
274 : }
275 161 : if (sqlstate)
276 0 : goto end;
277 :
278 : // Override with settings from the connect string itself
279 169 : cursor = InConnectionString;
280 169 : n = StringLength1;
281 380 : while (ODBCGetKeyAttr(&cursor, &n, &key, &attr) > 0) {
282 211 : int i = attr_setting_lookup(key, true);
283 211 : if (i >= 0) {
284 42 : mparm parm = attr_settings[i].parm;
285 42 : sql_explanation = msetting_parse(settings, parm, attr);
286 42 : if (sql_explanation)
287 0 : goto end;
288 42 : dbc->setting_touched[(int)parm] = 1;
289 : }
290 211 : free(key);
291 211 : free(attr);
292 : }
293 169 : key = NULL;
294 169 : attr = NULL;
295 :
296 169 : if (dsn && dsn_out) {
297 161 : *dsn_out = dsn;
298 161 : dsn = NULL;
299 : }
300 :
301 8 : end:
302 169 : if (sql_explanation && !sqlstate)
303 : sqlstate = "HY009";
304 169 : if (sqlstate) {
305 0 : addDbcError(dbc, sqlstate, sql_explanation, 0);
306 0 : rc = SQL_ERROR;
307 : }
308 169 : free(key);
309 169 : free(attr);
310 169 : free(dsn);
311 169 : return rc;
312 : }
313 :
314 :
315 : SQLRETURN
316 16 : MNDBConnect(ODBCDbc *dbc,
317 : const SQLCHAR *ServerName,
318 : SQLSMALLINT NameLength1,
319 : const SQLCHAR *UserName,
320 : SQLSMALLINT NameLength2,
321 : const SQLCHAR *Authentication,
322 : SQLSMALLINT NameLength3)
323 : {
324 : // These will be passed to addDbcError if you 'goto failure'.
325 : // If unset, 'goto failure' will assume an allocation error.
326 16 : const char *error_state = NULL;
327 16 : const char *error_explanation = NULL;
328 16 : SQLRETURN ret = SQL_ERROR;
329 :
330 : // These will be free'd / destroyed at the 'end' label at the bottom of this function
331 16 : char *dsn = NULL;
332 16 : msettings *settings = NULL;
333 16 : void *scratch = NULL;
334 :
335 : // These do not need to be free'd
336 16 : const char *mapiport_env;
337 :
338 : // Check connection state, should not be connected
339 16 : if (dbc->Connected) {
340 0 : error_state = "08002";
341 0 : goto failure;
342 : }
343 :
344 : // Modify a copy so the original remains unchanged when we return an error
345 16 : settings = msettings_clone(dbc->settings);
346 16 : if (settings == NULL)
347 0 : goto failure;
348 :
349 : // ServerName is really the Data Source name
350 16 : if (!makeNulTerminated(&ServerName, NameLength1, &scratch))
351 0 : goto failure;
352 16 : if (ServerName != NULL) {
353 16 : dsn = strdup((char*)ServerName);
354 16 : if (dsn == NULL)
355 0 : goto failure;
356 : }
357 :
358 : // data source settings take precedence over existing ones
359 16 : if (dsn && *dsn) {
360 16 : error_state = takeFromDataSource(dbc, settings, dsn);
361 16 : if (error_state != NULL)
362 0 : goto failure;
363 : }
364 :
365 : #ifdef ODBCDEBUG
366 16 : if (ODBCdebug == NULL || *ODBCdebug == 0) {
367 16 : const char *logfile = msetting_string(settings, MP_LOGFILE);
368 16 : if (*logfile)
369 0 : setODBCdebug(logfile, true);
370 : }
371 : #endif
372 :
373 : // The dedicated parameters for user name, password, host, port and database name
374 : // override the pre-existing values and whatever came from the data source.
375 : // We also take the MAPIPORT environment variable into account.
376 :
377 16 : if (!makeNulTerminated(&UserName, NameLength2, &scratch))
378 0 : goto failure;
379 16 : if (UserName) {
380 11 : if (!*UserName) {
381 1 : error_state = "28000";
382 1 : error_explanation = "user name not set";
383 1 : goto failure;
384 : }
385 10 : error_explanation = msetting_set_string(settings, MP_USER, (char*)UserName);
386 10 : if (error_explanation != NULL)
387 0 : goto failure;
388 : }
389 :
390 15 : if (!makeNulTerminated(&Authentication, NameLength3, &scratch))
391 0 : goto failure;
392 15 : if (Authentication) {
393 11 : if (!*Authentication) {
394 1 : error_state = "28000";
395 1 : error_explanation = "password not set";
396 1 : goto failure;
397 : }
398 10 : error_explanation = msetting_set_string(settings, MP_PASSWORD, (char*)Authentication);
399 10 : if (error_explanation != NULL)
400 0 : goto failure;
401 : }
402 :
403 14 : mapiport_env = getenv("MAPIPORT");
404 14 : if (mapiport_env != NULL)
405 14 : error_explanation = msetting_parse(settings, MP_PORT, mapiport_env);
406 14 : if (error_explanation != NULL)
407 0 : goto failure;
408 :
409 : #ifdef ODBCDEBUG
410 : {
411 14 : free(scratch);
412 14 : char *connstring = scratch = buildConnectionString(dsn, settings);
413 14 : if (!connstring)
414 0 : goto failure;
415 14 : ODBCLOG("SQLConnect: %s\n", connstring);
416 : }
417 : #endif
418 :
419 14 : assert(error_state == NULL);
420 14 : assert(error_explanation == NULL);
421 :
422 14 : ret = MNDBConnectSettings(dbc, dsn, settings);
423 14 : settings = NULL; // must not be free'd now
424 :
425 14 : goto end;
426 :
427 2 : failure:
428 2 : if (error_state == NULL) {
429 0 : if (error_explanation == NULL || msettings_malloc_failed(error_explanation))
430 : error_state = "HY001"; // allocation failure
431 : else
432 : error_state = "HY009"; // invalid argument
433 : }
434 2 : addDbcError(dbc, error_state, error_explanation, 0);
435 :
436 : // fallthrough
437 16 : end:
438 16 : free(dsn);
439 16 : free(scratch);
440 16 : msettings_destroy(settings);
441 :
442 16 : return ret;
443 : }
444 :
445 : SQLRETURN
446 110 : MNDBConnectSettings(ODBCDbc *dbc, const char *dsn, msettings *settings)
447 : {
448 110 : SQLRETURN rc;
449 110 : msettings *clone = msettings_clone(settings);
450 :
451 110 : if (clone == NULL) {
452 0 : addDbcError(dbc, "HY001", NULL, 0);
453 0 : return SQL_ERROR;
454 : }
455 :
456 110 : Mapi mid = mapi_settings(settings);
457 110 : if (mid) {
458 110 : settings = NULL; // will be free'd as part of 'mid' now
459 110 : mapi_setclientprefix(mid, "ODBC " MONETDB_VERSION);
460 110 : mapi_set_size_header(mid, true);
461 110 : mapi_reconnect(mid);
462 : }
463 110 : if (mid == NULL || mapi_error(mid)) {
464 8 : const char *error_state = "08001";
465 8 : const char *error_explanation = mid ? mapi_error_str(mid) : NULL;
466 8 : if (error_explanation) {
467 8 : if (strncmp(error_explanation, "InvalidCredentialsException:", 28) == 0)
468 : error_state = "28000";
469 : else
470 5 : if (strncmp(error_explanation, "could not connect: Connection timed out", 39) == 0)
471 0 : error_state = "HYT00";
472 : }
473 8 : addDbcError(dbc, error_state, error_explanation, 0);
474 8 : if (mid)
475 8 : mapi_destroy(mid);
476 8 : msettings_destroy(settings);
477 8 : msettings_destroy(clone);
478 8 : return SQL_ERROR;
479 : }
480 :
481 102 : free(dbc->dsn);
482 102 : dbc->dsn = dsn ? strdup(dsn) : NULL;
483 :
484 102 : if (dbc->mid)
485 0 : mapi_destroy(dbc->mid);
486 102 : dbc->mid = mid;
487 :
488 102 : msettings_destroy(dbc->settings);
489 102 : dbc->settings = clone;
490 :
491 102 : dbc->mapToLongVarchar = msetting_long(dbc->settings, MP_MAPTOLONGVARCHAR);
492 :
493 102 : dbc->Connected = true;
494 :
495 102 : rc = get_serverinfo(dbc);
496 102 : if (!SQL_SUCCEEDED(rc))
497 0 : return rc;
498 :
499 : return SQL_SUCCESS;
500 : }
501 :
502 : SQLRETURN SQL_API
503 : SQLConnect(SQLHDBC ConnectionHandle,
504 : SQLCHAR *ServerName,
505 : SQLSMALLINT NameLength1,
506 : SQLCHAR *UserName,
507 : SQLSMALLINT NameLength2,
508 : SQLCHAR *Authentication,
509 : SQLSMALLINT NameLength3)
510 : {
511 : #ifdef ODBCDEBUG
512 14 : ODBCLOG("SQLConnect %p\n", ConnectionHandle);
513 : #endif
514 :
515 14 : if (!isValidDbc((ODBCDbc *) ConnectionHandle))
516 : return SQL_INVALID_HANDLE;
517 :
518 14 : clearDbcErrors((ODBCDbc *) ConnectionHandle);
519 :
520 14 : return MNDBConnect((ODBCDbc *) ConnectionHandle,
521 : ServerName, NameLength1,
522 : UserName, NameLength2,
523 : Authentication, NameLength3);
524 : }
525 :
526 : SQLRETURN SQL_API
527 : SQLConnectA(SQLHDBC ConnectionHandle,
528 : SQLCHAR *ServerName,
529 : SQLSMALLINT NameLength1,
530 : SQLCHAR *UserName,
531 : SQLSMALLINT NameLength2,
532 : SQLCHAR *Authentication,
533 : SQLSMALLINT NameLength3)
534 : {
535 0 : return SQLConnect(ConnectionHandle,
536 : ServerName, NameLength1,
537 : UserName, NameLength2,
538 : Authentication, NameLength3);
539 : }
540 :
541 : SQLRETURN SQL_API
542 : SQLConnectW(SQLHDBC ConnectionHandle,
543 : SQLWCHAR *ServerName,
544 : SQLSMALLINT NameLength1,
545 : SQLWCHAR *UserName,
546 : SQLSMALLINT NameLength2,
547 : SQLWCHAR *Authentication,
548 : SQLSMALLINT NameLength3)
549 : {
550 2 : SQLCHAR *ds = NULL, *uid = NULL, *pwd = NULL;
551 2 : SQLRETURN rc = SQL_ERROR;
552 2 : ODBCDbc *dbc = (ODBCDbc *) ConnectionHandle;
553 :
554 : #ifdef ODBCDEBUG
555 2 : ODBCLOG("SQLConnectW %p\n", ConnectionHandle);
556 : #endif
557 :
558 2 : if (!isValidDbc(dbc))
559 : return SQL_INVALID_HANDLE;
560 :
561 2 : clearDbcErrors(dbc);
562 :
563 2 : fixWcharIn(ServerName, NameLength1, SQLCHAR, ds,
564 : addDbcError, dbc, goto bailout);
565 2 : fixWcharIn(UserName, NameLength2, SQLCHAR, uid,
566 : addDbcError, dbc, goto bailout);
567 2 : fixWcharIn(Authentication, NameLength3, SQLCHAR, pwd,
568 : addDbcError, dbc, goto bailout);
569 :
570 2 : rc = MNDBConnect(dbc,
571 : ds, SQL_NTS,
572 : uid, SQL_NTS,
573 : pwd, SQL_NTS);
574 :
575 2 : bailout:
576 2 : if (ds)
577 2 : free(ds);
578 2 : if (uid)
579 2 : free(uid);
580 2 : if (pwd)
581 2 : free(pwd);
582 : return rc;
583 : }
|
