1 /* 2 * Implementation of the ODBC driver installer 3 * 4 * Copyright 2005 Mike McCormack for CodeWeavers 5 * Copyright 2005 Hans Leidekker 6 * Copyright 2007 Bill Medland 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 21 */ 22 23 #include <assert.h> 24 #include <stdarg.h> 25 26 #define COBJMACROS 27 28 #include "windef.h" 29 #include "winbase.h" 30 #include "winreg.h" 31 #include "winnls.h" 32 #include "wine/unicode.h" 33 #include "wine/debug.h" 34 #include "wine/heap.h" 35 36 #include "odbcinst.h" 37 38 WINE_DEFAULT_DEBUG_CHANNEL(odbc); 39 40 /* Registry key names */ 41 static const WCHAR drivers_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','O','D','B','C','I','N','S','T','.','I','N','I','\\','O','D','B','C',' ','D','r','i','v','e','r','s',0}; 42 static const WCHAR odbcW[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C',0}; 43 static const WCHAR odbcini[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','O','D','B','C','I','N','S','T','.','I','N','I','\\',0}; 44 static const WCHAR odbcdrivers[] = {'O','D','B','C',' ','D','r','i','v','e','r','s',0}; 45 static const WCHAR odbctranslators[] = {'O','D','B','C',' ','T','r','a','n','s','l','a','t','o','r','s',0}; 46 47 /* This config mode is known to be process-wide. 48 * MSDN documentation suggests that the value is hidden somewhere in the registry but I haven't found it yet. 49 * Although both the registry and the ODBC.ini files appear to be maintained together they are not maintained automatically through the registry's IniFileMapping. 50 */ 51 static UWORD config_mode = ODBC_BOTH_DSN; 52 53 /* MSDN documentation suggests that the error subsystem handles errors 1 to 8 54 * only and experimentation (Windows 2000) shows that the errors are process- 55 * wide so go for the simple solution; static arrays. 56 */ 57 static int num_errors; 58 static int error_code[8]; 59 static const WCHAR *error_msg[8]; 60 static const WCHAR odbc_error_general_err[] = {'G','e','n','e','r','a','l',' ','e','r','r','o','r',0}; 61 static const WCHAR odbc_error_invalid_buff_len[] = {'I','n','v','a','l','i','d',' ','b','u','f','f','e','r',' ','l','e','n','g','t','h',0}; 62 static const WCHAR odbc_error_component_not_found[] = {'C','o','m','p','o','n','e','n','t',' ','n','o','t',' ','f','o','u','n','d',0}; 63 static const WCHAR odbc_error_out_of_mem[] = {'O','u','t',' ','o','f',' ','m','e','m','o','r','y',0}; 64 static const WCHAR odbc_error_invalid_param_sequence[] = {'I','n','v','a','l','i','d',' ','p','a','r','a','m','e','t','e','r',' ','s','e','q','u','e','n','c','e',0}; 65 static const WCHAR odbc_error_invalid_param_string[] = {'I','n','v','a','l','i','d',' ','p','a','r','a','m','e','t','e','r',' ','s','t','r','i','n','g',0}; 66 static const WCHAR odbc_error_invalid_dsn[] = {'I','n','v','a','l','i','d',' ','D','S','N',0}; 67 static const WCHAR odbc_error_load_lib_failed[] = {'L','o','a','d',' ','L','i','b','r','a','r','y',' ','F','a','i','l','e','d',0}; 68 static const WCHAR odbc_error_request_failed[] = {'R','e','q','u','e','s','t',' ','F','a','i','l','e','d',0}; 69 static const WCHAR odbc_error_invalid_keyword[] = {'I','n','v','a','l','i','d',' ','k','e','y','w','o','r','d',' ','v','a','l','u','e',0}; 70 71 /* Push an error onto the error stack, taking care of ranges etc. */ 72 static void push_error(int code, LPCWSTR msg) 73 { 74 if (num_errors < sizeof error_code/sizeof error_code[0]) 75 { 76 error_code[num_errors] = code; 77 error_msg[num_errors] = msg; 78 num_errors++; 79 } 80 } 81 82 /* Clear the error stack */ 83 static void clear_errors(void) 84 { 85 num_errors = 0; 86 } 87 88 static inline WCHAR *heap_strdupAtoW(const char *str) 89 { 90 LPWSTR ret = NULL; 91 92 if(str) { 93 DWORD len; 94 95 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); 96 ret = heap_alloc(len*sizeof(WCHAR)); 97 if(ret) 98 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len); 99 } 100 101 return ret; 102 } 103 104 105 BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2) 106 { 107 clear_errors(); 108 FIXME( "( %d %d %p %p) : stub!\n", i, j, p1, p2); 109 return FALSE; 110 } 111 112 static LPWSTR SQLInstall_strdup_multi(LPCSTR str) 113 { 114 LPCSTR p; 115 LPWSTR ret = NULL; 116 DWORD len; 117 118 if (!str) 119 return ret; 120 121 for (p = str; *p; p += lstrlenA(p) + 1) 122 ; 123 124 len = MultiByteToWideChar(CP_ACP, 0, str, p - str, NULL, 0 ); 125 ret = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR)); 126 MultiByteToWideChar(CP_ACP, 0, str, p - str, ret, len ); 127 ret[len] = 0; 128 129 return ret; 130 } 131 132 static LPWSTR SQLInstall_strdup(LPCSTR str) 133 { 134 DWORD len; 135 LPWSTR ret = NULL; 136 137 if (!str) 138 return ret; 139 140 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0 ); 141 ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); 142 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len ); 143 144 return ret; 145 } 146 147 /* Convert the wide string or zero-length-terminated list of wide strings to a 148 * narrow string or zero-length-terminated list of narrow strings. 149 * Do not try to emulate windows undocumented excesses (e.g. adding a third \0 150 * to a list) 151 * Arguments 152 * mode Indicates the sort of string. 153 * 1 denotes that the buffers contain strings terminated by a single nul 154 * character 155 * 2 denotes that the buffers contain zero-length-terminated lists 156 * (frequently erroneously referred to as double-null-terminated) 157 * buffer The narrow-character buffer into which to place the result. This 158 * must be a non-null pointer to the first element of a buffer whose 159 * length is passed in buffer_length. 160 * str The wide-character buffer containing the string or list of strings to 161 * be converted. str_length defines how many wide characters in the 162 * buffer are to be converted, including all desired terminating nul 163 * characters. 164 * str_length Effective length of str 165 * buffer_length Length of buffer 166 * returned_length A pointer to a variable that will receive the number of 167 * narrow characters placed into the buffer. This pointer 168 * may be NULL. 169 */ 170 static BOOL SQLInstall_narrow(int mode, LPSTR buffer, LPCWSTR str, WORD str_length, WORD buffer_length, WORD *returned_length) 171 { 172 LPSTR pbuf; /* allows us to allocate a temporary buffer only if needed */ 173 int len; /* Length of the converted list */ 174 BOOL success = FALSE; 175 assert(mode == 1 || mode == 2); 176 assert(buffer_length); 177 len = WideCharToMultiByte(CP_ACP, 0, str, str_length, 0, 0, NULL, NULL); 178 if (len > 0) 179 { 180 if (len > buffer_length) 181 { 182 pbuf = HeapAlloc(GetProcessHeap(), 0, len); 183 } 184 else 185 { 186 pbuf = buffer; 187 } 188 len = WideCharToMultiByte(CP_ACP, 0, str, str_length, pbuf, len, NULL, NULL); 189 if (len > 0) 190 { 191 if (pbuf != buffer) 192 { 193 if (buffer_length > (mode - 1)) 194 { 195 memcpy (buffer, pbuf, buffer_length-mode); 196 *(buffer+buffer_length-mode) = '\0'; 197 } 198 *(buffer+buffer_length-1) = '\0'; 199 } 200 if (returned_length) 201 { 202 *returned_length = pbuf == buffer ? len : buffer_length; 203 } 204 success = TRUE; 205 } 206 else 207 { 208 ERR("transferring wide to narrow\n"); 209 } 210 if (pbuf != buffer) 211 { 212 HeapFree(GetProcessHeap(), 0, pbuf); 213 } 214 } 215 else 216 { 217 ERR("measuring wide to narrow\n"); 218 } 219 return success; 220 } 221 222 BOOL WINAPI SQLConfigDataSourceW(HWND hwndParent, WORD fRequest, 223 LPCWSTR lpszDriver, LPCWSTR lpszAttributes) 224 { 225 LPCWSTR p; 226 227 clear_errors(); 228 FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_w(lpszDriver), 229 debugstr_w(lpszAttributes)); 230 231 for (p = lpszAttributes; *p; p += lstrlenW(p) + 1) 232 FIXME("%s\n", debugstr_w(p)); 233 234 return TRUE; 235 } 236 237 BOOL WINAPI SQLConfigDataSource(HWND hwndParent, WORD fRequest, 238 LPCSTR lpszDriver, LPCSTR lpszAttributes) 239 { 240 FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_a(lpszDriver), 241 debugstr_a(lpszAttributes)); 242 clear_errors(); 243 return TRUE; 244 } 245 246 static HMODULE load_config_driver(const WCHAR *driver) 247 { 248 static WCHAR reg_driver[] = {'d','r','i','v','e','r',0}; 249 long ret; 250 HMODULE hmod; 251 WCHAR *filename = NULL; 252 DWORD size = 0, type; 253 HKEY hkey; 254 255 if ((ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey)) == ERROR_SUCCESS) 256 { 257 HKEY hkeydriver; 258 259 if ((ret = RegOpenKeyW(hkey, driver, &hkeydriver)) == ERROR_SUCCESS) 260 { 261 ret = RegGetValueW(hkeydriver, NULL, reg_driver, RRF_RT_REG_SZ, &type, NULL, &size); 262 if(ret == ERROR_MORE_DATA) 263 { 264 filename = HeapAlloc(GetProcessHeap(), 0, size); 265 if(!filename) 266 { 267 RegCloseKey(hkeydriver); 268 RegCloseKey(hkey); 269 push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem); 270 271 return NULL; 272 } 273 ret = RegGetValueW(hkeydriver, NULL, driver, RRF_RT_REG_SZ, &type, filename, &size); 274 } 275 276 RegCloseKey(hkeydriver); 277 } 278 279 RegCloseKey(hkey); 280 } 281 282 if(ret != ERROR_SUCCESS) 283 { 284 HeapFree(GetProcessHeap(), 0, filename); 285 push_error(ODBC_ERROR_INVALID_DSN, odbc_error_invalid_dsn); 286 return NULL; 287 } 288 289 hmod = LoadLibraryW(filename); 290 HeapFree(GetProcessHeap(), 0, filename); 291 292 if(!hmod) 293 push_error(ODBC_ERROR_LOAD_LIB_FAILED, odbc_error_load_lib_failed); 294 295 return hmod; 296 } 297 298 static BOOL write_config_value(const WCHAR *driver, const WCHAR *args) 299 { 300 long ret; 301 HKEY hkey, hkeydriver; 302 WCHAR *name = NULL; 303 304 if(!args) 305 return FALSE; 306 307 if((ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey)) == ERROR_SUCCESS) 308 { 309 if((ret = RegOpenKeyW(hkey, driver, &hkeydriver)) == ERROR_SUCCESS) 310 { 311 WCHAR *divider, *value; 312 313 name = heap_alloc( (strlenW(args) + 1) * sizeof(WCHAR)); 314 if(!name) 315 { 316 push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem); 317 goto fail; 318 } 319 lstrcpyW(name, args); 320 321 divider = strchrW(name,'='); 322 if(!divider) 323 { 324 push_error(ODBC_ERROR_INVALID_KEYWORD_VALUE, odbc_error_invalid_keyword); 325 goto fail; 326 } 327 328 value = divider + 1; 329 *divider = '\0'; 330 331 TRACE("Write pair: %s = %s\n", debugstr_w(name), debugstr_w(value)); 332 if(RegSetValueExW(hkeydriver, name, 0, REG_SZ, (BYTE*)value, 333 (strlenW(value)+1) * sizeof(WCHAR)) != ERROR_SUCCESS) 334 ERR("Failed to write registry installed key\n"); 335 heap_free(name); 336 337 RegCloseKey(hkeydriver); 338 } 339 340 RegCloseKey(hkey); 341 } 342 343 if(ret != ERROR_SUCCESS) 344 push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found); 345 346 return ret == ERROR_SUCCESS; 347 348 fail: 349 RegCloseKey(hkeydriver); 350 RegCloseKey(hkey); 351 heap_free(name); 352 353 return FALSE; 354 } 355 356 BOOL WINAPI SQLConfigDriverW(HWND hwnd, WORD request, LPCWSTR driver, 357 LPCWSTR args, LPWSTR msg, WORD msgmax, WORD *msgout) 358 { 359 BOOL (WINAPI *pConfigDriverW)(HWND hwnd, WORD request, const WCHAR *driver, const WCHAR *args, const WCHAR *msg, WORD msgmax, WORD *msgout); 360 HMODULE hmod; 361 BOOL funcret = FALSE; 362 363 clear_errors(); 364 TRACE("(%p %d %s %s %p %d %p)\n", hwnd, request, debugstr_w(driver), 365 debugstr_w(args), msg, msgmax, msgout); 366 367 if(request == ODBC_CONFIG_DRIVER) 368 { 369 return write_config_value(driver, args); 370 } 371 372 hmod = load_config_driver(driver); 373 if(!hmod) 374 return FALSE; 375 376 pConfigDriverW = (void*)GetProcAddress(hmod, "ConfigDriverW"); 377 if(pConfigDriverW) 378 funcret = pConfigDriverW(hwnd, request, driver, args, msg, msgmax, msgout); 379 380 if(!funcret) 381 push_error(ODBC_ERROR_REQUEST_FAILED, odbc_error_request_failed); 382 383 FreeLibrary(hmod); 384 385 return funcret; 386 } 387 388 BOOL WINAPI SQLConfigDriver(HWND hwnd, WORD request, LPCSTR driver, 389 LPCSTR args, LPSTR msg, WORD msgmax, WORD *msgout) 390 { 391 BOOL (WINAPI *pConfigDriverA)(HWND hwnd, WORD request, const char *driver, const char *args, const char *msg, WORD msgmax, WORD *msgout); 392 HMODULE hmod; 393 WCHAR *driverW; 394 BOOL funcret = FALSE; 395 396 clear_errors(); 397 TRACE("(%p %d %s %s %p %d %p)\n", hwnd, request, debugstr_a(driver), 398 debugstr_a(args), msg, msgmax, msgout); 399 400 driverW = heap_strdupAtoW(driver); 401 if(!driverW) 402 { 403 push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem); 404 return FALSE; 405 } 406 if(request == ODBC_CONFIG_DRIVER) 407 { 408 BOOL ret = FALSE; 409 WCHAR *argsW = heap_strdupAtoW(args); 410 if(argsW) 411 { 412 ret = write_config_value(driverW, argsW); 413 HeapFree(GetProcessHeap(), 0, argsW); 414 } 415 else 416 { 417 push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem); 418 } 419 420 HeapFree(GetProcessHeap(), 0, driverW); 421 422 return ret; 423 } 424 425 hmod = load_config_driver(driverW); 426 HeapFree(GetProcessHeap(), 0, driverW); 427 if(!hmod) 428 return FALSE; 429 430 pConfigDriverA = (void*)GetProcAddress(hmod, "ConfigDriver"); 431 if(pConfigDriverA) 432 funcret = pConfigDriverA(hwnd, request, driver, args, msg, msgmax, msgout); 433 434 if(!funcret) 435 push_error(ODBC_ERROR_REQUEST_FAILED, odbc_error_request_failed); 436 437 FreeLibrary(hmod); 438 439 return funcret; 440 } 441 442 BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPCWSTR lpszDS) 443 { 444 clear_errors(); 445 FIXME("%p %s\n", hwnd, debugstr_w(lpszDS)); 446 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 447 return FALSE; 448 } 449 450 BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPCSTR lpszDS) 451 { 452 clear_errors(); 453 FIXME("%p %s\n", hwnd, debugstr_a(lpszDS)); 454 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 455 return FALSE; 456 } 457 458 BOOL WINAPI SQLGetAvailableDriversW(LPCWSTR lpszInfFile, LPWSTR lpszBuf, 459 WORD cbBufMax, WORD *pcbBufOut) 460 { 461 clear_errors(); 462 FIXME("%s %p %d %p\n", debugstr_w(lpszInfFile), lpszBuf, cbBufMax, pcbBufOut); 463 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 464 return FALSE; 465 } 466 467 BOOL WINAPI SQLGetAvailableDrivers(LPCSTR lpszInfFile, LPSTR lpszBuf, 468 WORD cbBufMax, WORD *pcbBufOut) 469 { 470 clear_errors(); 471 FIXME("%s %p %d %p\n", debugstr_a(lpszInfFile), lpszBuf, cbBufMax, pcbBufOut); 472 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 473 return FALSE; 474 } 475 476 BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode) 477 { 478 clear_errors(); 479 TRACE("%p\n", pwConfigMode); 480 if (pwConfigMode) 481 *pwConfigMode = config_mode; 482 return TRUE; 483 } 484 485 BOOL WINAPI SQLGetInstalledDriversW(WCHAR *buf, WORD size, WORD *sizeout) 486 { 487 WORD written = 0; 488 DWORD index = 0; 489 BOOL ret = TRUE; 490 DWORD valuelen; 491 WCHAR *value; 492 HKEY drivers; 493 DWORD len; 494 LONG res; 495 496 clear_errors(); 497 498 TRACE("%p %d %p\n", buf, size, sizeout); 499 500 if (!buf || !size) 501 { 502 push_error(ODBC_ERROR_INVALID_BUFF_LEN, odbc_error_invalid_buff_len); 503 return FALSE; 504 } 505 506 res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drivers_key, 0, KEY_QUERY_VALUE, &drivers); 507 if (res) 508 { 509 push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found); 510 return FALSE; 511 } 512 513 valuelen = 256; 514 value = heap_alloc(valuelen * sizeof(WCHAR)); 515 516 size--; 517 518 while (1) 519 { 520 len = valuelen; 521 res = RegEnumValueW(drivers, index, value, &len, NULL, NULL, NULL, NULL); 522 while (res == ERROR_MORE_DATA) 523 { 524 value = heap_realloc(value, ++len * sizeof(WCHAR)); 525 res = RegEnumValueW(drivers, index, value, &len, NULL, NULL, NULL, NULL); 526 } 527 if (res == ERROR_SUCCESS) 528 { 529 lstrcpynW(buf + written, value, size - written); 530 written += min(len + 1, size - written); 531 } 532 else if (res == ERROR_NO_MORE_ITEMS) 533 break; 534 else 535 { 536 push_error(ODBC_ERROR_GENERAL_ERR, odbc_error_general_err); 537 ret = FALSE; 538 break; 539 } 540 index++; 541 } 542 543 buf[written++] = 0; 544 545 heap_free(value); 546 RegCloseKey(drivers); 547 if (sizeout) 548 *sizeout = written; 549 return ret; 550 } 551 552 BOOL WINAPI SQLGetInstalledDrivers(char *buf, WORD size, WORD *sizeout) 553 { 554 WORD written; 555 WCHAR *wbuf; 556 BOOL ret; 557 558 TRACE("%p %d %p\n", buf, size, sizeout); 559 560 if (!buf || !size) 561 { 562 push_error(ODBC_ERROR_INVALID_BUFF_LEN, odbc_error_invalid_buff_len); 563 return FALSE; 564 } 565 566 wbuf = heap_alloc(size * sizeof(WCHAR)); 567 if (!wbuf) 568 { 569 push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem); 570 return FALSE; 571 } 572 573 ret = SQLGetInstalledDriversW(wbuf, size, &written); 574 if (!ret) 575 return FALSE; 576 577 *sizeout = WideCharToMultiByte(CP_ACP, 0, wbuf, written, NULL, 0, NULL, NULL); 578 WideCharToMultiByte(CP_ACP, 0, wbuf, written, buf, size, NULL, NULL); 579 580 heap_free(wbuf); 581 return TRUE; 582 } 583 584 static HKEY get_privateprofile_sectionkey(LPCWSTR section, LPCWSTR filename) 585 { 586 HKEY hkey, hkeyfilename, hkeysection; 587 LONG ret; 588 589 if (RegOpenKeyW(HKEY_CURRENT_USER, odbcW, &hkey)) 590 return NULL; 591 592 ret = RegOpenKeyW(hkey, filename, &hkeyfilename); 593 RegCloseKey(hkey); 594 if (ret) 595 return NULL; 596 597 ret = RegOpenKeyW(hkeyfilename, section, &hkeysection); 598 RegCloseKey(hkeyfilename); 599 600 return ret ? NULL : hkeysection; 601 } 602 603 int WINAPI SQLGetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry, 604 LPCWSTR defvalue, LPWSTR buff, int buff_len, LPCWSTR filename) 605 { 606 BOOL usedefault = TRUE; 607 HKEY sectionkey; 608 LONG ret = 0; 609 610 TRACE("%s %s %s %p %d %s\n", debugstr_w(section), debugstr_w(entry), 611 debugstr_w(defvalue), buff, buff_len, debugstr_w(filename)); 612 613 clear_errors(); 614 615 if (buff_len <= 0 || !section) 616 return 0; 617 618 if(buff) 619 buff[0] = 0; 620 621 if (!defvalue || !buff) 622 return 0; 623 624 sectionkey = get_privateprofile_sectionkey(section, filename); 625 if (sectionkey) 626 { 627 DWORD type, size; 628 629 if (entry) 630 { 631 size = buff_len * sizeof(*buff); 632 if (RegGetValueW(sectionkey, NULL, entry, RRF_RT_REG_SZ, &type, buff, &size) == ERROR_SUCCESS) 633 { 634 usedefault = FALSE; 635 ret = (size / sizeof(*buff)) - 1; 636 } 637 } 638 else 639 { 640 WCHAR name[MAX_PATH]; 641 DWORD index = 0; 642 DWORD namelen; 643 644 usedefault = FALSE; 645 646 memset(buff, 0, buff_len); 647 648 namelen = sizeof(name); 649 while (RegEnumValueW(sectionkey, index, name, &namelen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) 650 { 651 if ((ret + namelen+1) > buff_len) 652 break; 653 654 lstrcpyW(buff+ret, name); 655 ret += namelen+1; 656 namelen = sizeof(name); 657 index++; 658 } 659 } 660 661 RegCloseKey(sectionkey); 662 } 663 else 664 usedefault = entry != NULL; 665 666 if (usedefault) 667 { 668 lstrcpynW(buff, defvalue, buff_len); 669 ret = lstrlenW(buff); 670 } 671 672 return ret; 673 } 674 675 int WINAPI SQLGetPrivateProfileString(LPCSTR section, LPCSTR entry, 676 LPCSTR defvalue, LPSTR buff, int buff_len, LPCSTR filename) 677 { 678 WCHAR *sectionW, *filenameW; 679 BOOL usedefault = TRUE; 680 HKEY sectionkey; 681 LONG ret = 0; 682 683 TRACE("%s %s %s %p %d %s\n", debugstr_a(section), debugstr_a(entry), 684 debugstr_a(defvalue), buff, buff_len, debugstr_a(filename)); 685 686 clear_errors(); 687 688 if (buff_len <= 0) 689 return 0; 690 691 if (buff) 692 buff[0] = 0; 693 694 if (!section || !defvalue || !buff) 695 return 0; 696 697 sectionW = heap_strdupAtoW(section); 698 filenameW = heap_strdupAtoW(filename); 699 700 sectionkey = get_privateprofile_sectionkey(sectionW, filenameW); 701 702 heap_free(sectionW); 703 heap_free(filenameW); 704 705 if (sectionkey) 706 { 707 DWORD type, size; 708 709 if (entry) 710 { 711 size = buff_len * sizeof(*buff); 712 if (RegGetValueA(sectionkey, NULL, entry, RRF_RT_REG_SZ, &type, buff, &size) == ERROR_SUCCESS) 713 { 714 usedefault = FALSE; 715 ret = (size / sizeof(*buff)) - 1; 716 } 717 } 718 else 719 { 720 char name[MAX_PATH] = {0}; 721 DWORD index = 0; 722 DWORD namelen; 723 724 usedefault = FALSE; 725 726 memset(buff, 0, buff_len); 727 728 namelen = sizeof(name); 729 while (RegEnumValueA(sectionkey, index, name, &namelen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) 730 { 731 if ((ret + namelen+1) > buff_len) 732 break; 733 734 lstrcpyA(buff+ret, name); 735 736 ret += namelen+1; 737 namelen = sizeof(name); 738 index++; 739 } 740 } 741 742 RegCloseKey(sectionkey); 743 } 744 else 745 usedefault = entry != NULL; 746 747 if (usedefault) 748 { 749 lstrcpynA(buff, defvalue, buff_len); 750 ret = strlen(buff); 751 } 752 753 return ret; 754 } 755 756 BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax, 757 WORD *pcbNameOut, LPWSTR lpszPath, WORD cbPathMax, 758 WORD *pcbPathOut, DWORD *pvOption) 759 { 760 clear_errors(); 761 FIXME("%p %s %d %p %p %d %p %p\n", hwndParent, debugstr_w(lpszName), cbNameMax, 762 pcbNameOut, lpszPath, cbPathMax, pcbPathOut, pvOption); 763 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 764 return FALSE; 765 } 766 767 BOOL WINAPI SQLGetTranslator(HWND hwndParent, LPSTR lpszName, WORD cbNameMax, 768 WORD *pcbNameOut, LPSTR lpszPath, WORD cbPathMax, 769 WORD *pcbPathOut, DWORD *pvOption) 770 { 771 clear_errors(); 772 FIXME("%p %s %d %p %p %d %p %p\n", hwndParent, debugstr_a(lpszName), cbNameMax, 773 pcbNameOut, lpszPath, cbPathMax, pcbPathOut, pvOption); 774 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 775 return FALSE; 776 } 777 778 BOOL WINAPI SQLInstallDriverW(LPCWSTR lpszInfFile, LPCWSTR lpszDriver, 779 LPWSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut) 780 { 781 DWORD usage; 782 783 clear_errors(); 784 TRACE("%s %s %p %d %p\n", debugstr_w(lpszInfFile), 785 debugstr_w(lpszDriver), lpszPath, cbPathMax, pcbPathOut); 786 787 if (lpszInfFile) 788 return FALSE; 789 790 return SQLInstallDriverExW(lpszDriver, NULL, lpszPath, cbPathMax, 791 pcbPathOut, ODBC_INSTALL_COMPLETE, &usage); 792 } 793 794 BOOL WINAPI SQLInstallDriver(LPCSTR lpszInfFile, LPCSTR lpszDriver, 795 LPSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut) 796 { 797 DWORD usage; 798 799 clear_errors(); 800 TRACE("%s %s %p %d %p\n", debugstr_a(lpszInfFile), 801 debugstr_a(lpszDriver), lpszPath, cbPathMax, pcbPathOut); 802 803 if (lpszInfFile) 804 return FALSE; 805 806 return SQLInstallDriverEx(lpszDriver, NULL, lpszPath, cbPathMax, 807 pcbPathOut, ODBC_INSTALL_COMPLETE, &usage); 808 } 809 810 static void write_registry_values(const WCHAR *regkey, const WCHAR *driver, const WCHAR *path_in, WCHAR *path, 811 DWORD *usage_count) 812 { 813 static const WCHAR installed[] = {'I','n','s','t','a','l','l','e','d',0}; 814 static const WCHAR slash[] = {'\\', 0}; 815 static const WCHAR driverW[] = {'D','r','i','v','e','r',0}; 816 static const WCHAR setupW[] = {'S','e','t','u','p',0}; 817 static const WCHAR translator[] = {'T','r','a','n','s','l','a','t','o','r',0}; 818 HKEY hkey, hkeydriver; 819 820 if (RegCreateKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS) 821 { 822 if (RegCreateKeyW(hkey, regkey, &hkeydriver) == ERROR_SUCCESS) 823 { 824 if(RegSetValueExW(hkeydriver, driver, 0, REG_SZ, (BYTE*)installed, sizeof(installed)) != ERROR_SUCCESS) 825 ERR("Failed to write registry installed key\n"); 826 827 RegCloseKey(hkeydriver); 828 } 829 830 if (RegCreateKeyW(hkey, driver, &hkeydriver) == ERROR_SUCCESS) 831 { 832 WCHAR entry[1024]; 833 const WCHAR *p; 834 DWORD usagecount = 0; 835 DWORD type, size; 836 837 /* Skip name entry */ 838 p = driver; 839 p += lstrlenW(p) + 1; 840 841 if (!path_in) 842 GetSystemDirectoryW(path, MAX_PATH); 843 else 844 lstrcpyW(path, path_in); 845 846 /* Store Usage */ 847 size = sizeof(usagecount); 848 RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size); 849 TRACE("Usage count %d\n", usagecount); 850 851 for (; *p; p += lstrlenW(p) + 1) 852 { 853 WCHAR *divider = strchrW(p,'='); 854 855 if (divider) 856 { 857 WCHAR *value; 858 int len; 859 860 /* Write pair values to the registry. */ 861 lstrcpynW(entry, p, divider - p + 1); 862 863 divider++; 864 TRACE("Writing pair %s,%s\n", debugstr_w(entry), debugstr_w(divider)); 865 866 /* Driver, Setup, Translator entries use the system path unless a path is specified. */ 867 if(lstrcmpiW(driverW, entry) == 0 || lstrcmpiW(setupW, entry) == 0 || 868 lstrcmpiW(translator, entry) == 0) 869 { 870 len = lstrlenW(path) + lstrlenW(slash) + lstrlenW(divider) + 1; 871 value = heap_alloc(len * sizeof(WCHAR)); 872 if(!value) 873 { 874 ERR("Out of memory\n"); 875 return; 876 } 877 878 lstrcpyW(value, path); 879 lstrcatW(value, slash); 880 lstrcatW(value, divider); 881 } 882 else 883 { 884 len = lstrlenW(divider) + 1; 885 value = heap_alloc(len * sizeof(WCHAR)); 886 lstrcpyW(value, divider); 887 } 888 889 if (RegSetValueExW(hkeydriver, entry, 0, REG_SZ, (BYTE*)value, 890 (lstrlenW(value)+1)*sizeof(WCHAR)) != ERROR_SUCCESS) 891 ERR("Failed to write registry data %s %s\n", debugstr_w(entry), debugstr_w(value)); 892 heap_free(value); 893 } 894 else 895 { 896 ERR("No pair found. %s\n", debugstr_w(p)); 897 break; 898 } 899 } 900 901 /* Set Usage Count */ 902 usagecount++; 903 if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&usagecount, sizeof(usagecount)) != ERROR_SUCCESS) 904 ERR("Failed to write registry UsageCount key\n"); 905 906 if (usage_count) 907 *usage_count = usagecount; 908 909 RegCloseKey(hkeydriver); 910 } 911 912 RegCloseKey(hkey); 913 } 914 } 915 916 BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn, 917 LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut, 918 WORD fRequest, LPDWORD lpdwUsageCount) 919 { 920 UINT len; 921 WCHAR path[MAX_PATH]; 922 923 clear_errors(); 924 TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver), 925 debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut, 926 fRequest, lpdwUsageCount); 927 928 write_registry_values(odbcdrivers, lpszDriver, lpszPathIn, path, lpdwUsageCount); 929 930 len = lstrlenW(path); 931 932 if (pcbPathOut) 933 *pcbPathOut = len; 934 935 if (lpszPathOut && cbPathOutMax > len) 936 { 937 lstrcpyW(lpszPathOut, path); 938 return TRUE; 939 } 940 return FALSE; 941 } 942 943 BOOL WINAPI SQLInstallDriverEx(LPCSTR lpszDriver, LPCSTR lpszPathIn, 944 LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut, 945 WORD fRequest, LPDWORD lpdwUsageCount) 946 { 947 LPWSTR driver, pathin; 948 WCHAR pathout[MAX_PATH]; 949 BOOL ret; 950 WORD cbOut = 0; 951 952 clear_errors(); 953 TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszDriver), 954 debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut, 955 fRequest, lpdwUsageCount); 956 957 driver = SQLInstall_strdup_multi(lpszDriver); 958 pathin = SQLInstall_strdup(lpszPathIn); 959 960 ret = SQLInstallDriverExW(driver, pathin, pathout, MAX_PATH, &cbOut, 961 fRequest, lpdwUsageCount); 962 if (ret) 963 { 964 int len = WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut, 965 0, NULL, NULL); 966 if (len) 967 { 968 if (pcbPathOut) 969 *pcbPathOut = len - 1; 970 971 if (!lpszPathOut || cbPathOutMax < len) 972 { 973 ret = FALSE; 974 goto out; 975 } 976 len = WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut, 977 cbPathOutMax, NULL, NULL); 978 } 979 } 980 981 out: 982 HeapFree(GetProcessHeap(), 0, driver); 983 HeapFree(GetProcessHeap(), 0, pathin); 984 return ret; 985 } 986 987 BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax, 988 WORD *pcbPathOut) 989 { 990 UINT len; 991 WCHAR path[MAX_PATH]; 992 993 TRACE("(%p %d %p)\n", lpszPath, cbPathMax, pcbPathOut); 994 995 if (cbPathMax < MAX_PATH) 996 return FALSE; 997 998 clear_errors(); 999 1000 len = GetSystemDirectoryW(path, MAX_PATH); 1001 1002 if (pcbPathOut) 1003 *pcbPathOut = len; 1004 1005 if (lpszPath && cbPathMax > len) 1006 { 1007 lstrcpyW(lpszPath, path); 1008 return TRUE; 1009 } 1010 return FALSE; 1011 } 1012 1013 BOOL WINAPI SQLInstallDriverManager(LPSTR lpszPath, WORD cbPathMax, 1014 WORD *pcbPathOut) 1015 { 1016 BOOL ret; 1017 WORD len, cbOut = 0; 1018 WCHAR path[MAX_PATH]; 1019 1020 TRACE("(%p %d %p)\n", lpszPath, cbPathMax, pcbPathOut); 1021 1022 if (cbPathMax < MAX_PATH) 1023 return FALSE; 1024 1025 clear_errors(); 1026 1027 ret = SQLInstallDriverManagerW(path, MAX_PATH, &cbOut); 1028 if (ret) 1029 { 1030 len = WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath, 0, 1031 NULL, NULL); 1032 if (len) 1033 { 1034 if (pcbPathOut) 1035 *pcbPathOut = len - 1; 1036 1037 if (!lpszPath || cbPathMax < len) 1038 return FALSE; 1039 1040 len = WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath, 1041 cbPathMax, NULL, NULL); 1042 } 1043 } 1044 return ret; 1045 } 1046 1047 BOOL WINAPI SQLInstallODBCW(HWND hwndParent, LPCWSTR lpszInfFile, 1048 LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers) 1049 { 1050 clear_errors(); 1051 FIXME("%p %s %s %s\n", hwndParent, debugstr_w(lpszInfFile), 1052 debugstr_w(lpszSrcPath), debugstr_w(lpszDrivers)); 1053 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1054 return FALSE; 1055 } 1056 1057 BOOL WINAPI SQLInstallODBC(HWND hwndParent, LPCSTR lpszInfFile, 1058 LPCSTR lpszSrcPath, LPCSTR lpszDrivers) 1059 { 1060 clear_errors(); 1061 FIXME("%p %s %s %s\n", hwndParent, debugstr_a(lpszInfFile), 1062 debugstr_a(lpszSrcPath), debugstr_a(lpszDrivers)); 1063 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1064 return FALSE; 1065 } 1066 1067 SQLRETURN WINAPI SQLInstallerErrorW(WORD iError, DWORD *pfErrorCode, 1068 LPWSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg) 1069 { 1070 TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg, 1071 cbErrorMsgMax, pcbErrorMsg); 1072 1073 if (iError == 0) 1074 { 1075 return SQL_ERROR; 1076 } 1077 else if (iError <= num_errors) 1078 { 1079 BOOL truncated = FALSE; 1080 WORD len; 1081 LPCWSTR msg; 1082 iError--; 1083 if (pfErrorCode) 1084 *pfErrorCode = error_code[iError]; 1085 msg = error_msg[iError]; 1086 len = msg ? lstrlenW(msg) : 0; 1087 if (pcbErrorMsg) 1088 *pcbErrorMsg = len; 1089 len++; 1090 if (cbErrorMsgMax < len) 1091 { 1092 len = cbErrorMsgMax; 1093 truncated = TRUE; 1094 } 1095 if (lpszErrorMsg && len) 1096 { 1097 if (msg) 1098 { 1099 memcpy (lpszErrorMsg, msg, len * sizeof(WCHAR)); 1100 } 1101 else 1102 { 1103 assert(len==1); 1104 *lpszErrorMsg = 0; 1105 } 1106 } 1107 else 1108 { 1109 /* Yes. If you pass a null pointer and a large length it is not an error! */ 1110 truncated = TRUE; 1111 } 1112 1113 return truncated ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS; 1114 } 1115 1116 /* At least on Windows 2000 , the buffers are not altered in this case. However that is a little too dangerous a test for just now */ 1117 if (pcbErrorMsg) 1118 *pcbErrorMsg = 0; 1119 1120 if (lpszErrorMsg && cbErrorMsgMax > 0) 1121 *lpszErrorMsg = '\0'; 1122 1123 return SQL_NO_DATA; 1124 } 1125 1126 SQLRETURN WINAPI SQLInstallerError(WORD iError, DWORD *pfErrorCode, 1127 LPSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg) 1128 { 1129 SQLRETURN ret; 1130 LPWSTR wbuf; 1131 WORD cbwbuf; 1132 TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg, 1133 cbErrorMsgMax, pcbErrorMsg); 1134 1135 wbuf = 0; 1136 if (lpszErrorMsg && cbErrorMsgMax) 1137 { 1138 wbuf = HeapAlloc(GetProcessHeap(), 0, cbErrorMsgMax*sizeof(WCHAR)); 1139 if (!wbuf) 1140 return SQL_ERROR; 1141 } 1142 ret = SQLInstallerErrorW(iError, pfErrorCode, wbuf, cbErrorMsgMax, &cbwbuf); 1143 if (wbuf) 1144 { 1145 WORD cbBuf = 0; 1146 SQLInstall_narrow(1, lpszErrorMsg, wbuf, cbwbuf+1, cbErrorMsgMax, &cbBuf); 1147 HeapFree(GetProcessHeap(), 0, wbuf); 1148 if (pcbErrorMsg) 1149 *pcbErrorMsg = cbBuf-1; 1150 } 1151 return ret; 1152 } 1153 1154 BOOL WINAPI SQLInstallTranslatorExW(LPCWSTR lpszTranslator, LPCWSTR lpszPathIn, 1155 LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut, 1156 WORD fRequest, LPDWORD lpdwUsageCount) 1157 { 1158 UINT len; 1159 WCHAR path[MAX_PATH]; 1160 1161 clear_errors(); 1162 TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszTranslator), 1163 debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut, 1164 fRequest, lpdwUsageCount); 1165 1166 write_registry_values(odbctranslators, lpszTranslator, lpszPathIn, path, lpdwUsageCount); 1167 1168 len = lstrlenW(path); 1169 1170 if (pcbPathOut) 1171 *pcbPathOut = len; 1172 1173 if (lpszPathOut && cbPathOutMax > len) 1174 { 1175 lstrcpyW(lpszPathOut, path); 1176 return TRUE; 1177 } 1178 return FALSE; 1179 } 1180 1181 BOOL WINAPI SQLInstallTranslatorEx(LPCSTR lpszTranslator, LPCSTR lpszPathIn, 1182 LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut, 1183 WORD fRequest, LPDWORD lpdwUsageCount) 1184 { 1185 LPCSTR p; 1186 LPWSTR translator, pathin; 1187 WCHAR pathout[MAX_PATH]; 1188 BOOL ret; 1189 WORD cbOut = 0; 1190 1191 clear_errors(); 1192 TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszTranslator), 1193 debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut, 1194 fRequest, lpdwUsageCount); 1195 1196 for (p = lpszTranslator; *p; p += lstrlenA(p) + 1) 1197 TRACE("%s\n", debugstr_a(p)); 1198 1199 translator = SQLInstall_strdup_multi(lpszTranslator); 1200 pathin = SQLInstall_strdup(lpszPathIn); 1201 1202 ret = SQLInstallTranslatorExW(translator, pathin, pathout, MAX_PATH, 1203 &cbOut, fRequest, lpdwUsageCount); 1204 if (ret) 1205 { 1206 int len = WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut, 1207 0, NULL, NULL); 1208 if (len) 1209 { 1210 if (pcbPathOut) 1211 *pcbPathOut = len - 1; 1212 1213 if (!lpszPathOut || cbPathOutMax < len) 1214 { 1215 ret = FALSE; 1216 goto out; 1217 } 1218 len = WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut, 1219 cbPathOutMax, NULL, NULL); 1220 } 1221 } 1222 1223 out: 1224 HeapFree(GetProcessHeap(), 0, translator); 1225 HeapFree(GetProcessHeap(), 0, pathin); 1226 return ret; 1227 } 1228 1229 BOOL WINAPI SQLInstallTranslator(LPCSTR lpszInfFile, LPCSTR lpszTranslator, 1230 LPCSTR lpszPathIn, LPSTR lpszPathOut, WORD cbPathOutMax, 1231 WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount) 1232 { 1233 clear_errors(); 1234 TRACE("%s %s %s %p %d %p %d %p\n", debugstr_a(lpszInfFile), 1235 debugstr_a(lpszTranslator), debugstr_a(lpszPathIn), lpszPathOut, 1236 cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount); 1237 1238 if (lpszInfFile) 1239 return FALSE; 1240 1241 return SQLInstallTranslatorEx(lpszTranslator, lpszPathIn, lpszPathOut, 1242 cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount); 1243 } 1244 1245 BOOL WINAPI SQLInstallTranslatorW(LPCWSTR lpszInfFile, LPCWSTR lpszTranslator, 1246 LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax, 1247 WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount) 1248 { 1249 clear_errors(); 1250 TRACE("%s %s %s %p %d %p %d %p\n", debugstr_w(lpszInfFile), 1251 debugstr_w(lpszTranslator), debugstr_w(lpszPathIn), lpszPathOut, 1252 cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount); 1253 1254 if (lpszInfFile) 1255 return FALSE; 1256 1257 return SQLInstallTranslatorExW(lpszTranslator, lpszPathIn, lpszPathOut, 1258 cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount); 1259 } 1260 1261 BOOL WINAPI SQLManageDataSources(HWND hwnd) 1262 { 1263 clear_errors(); 1264 FIXME("%p\n", hwnd); 1265 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1266 return FALSE; 1267 } 1268 1269 SQLRETURN WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPCWSTR szErrorMsg) 1270 { 1271 FIXME("%u %s\n", fErrorCode, debugstr_w(szErrorMsg)); 1272 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1273 return FALSE; 1274 } 1275 1276 SQLRETURN WINAPI SQLPostInstallerError(DWORD fErrorCode, LPCSTR szErrorMsg) 1277 { 1278 FIXME("%u %s\n", fErrorCode, debugstr_a(szErrorMsg)); 1279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1280 return FALSE; 1281 } 1282 1283 BOOL WINAPI SQLReadFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName, 1284 LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString, 1285 WORD *pcbString) 1286 { 1287 clear_errors(); 1288 FIXME("%s %s %s %s %d %p\n", debugstr_w(lpszFileName), debugstr_w(lpszAppName), 1289 debugstr_w(lpszKeyName), debugstr_w(lpszString), cbString, pcbString); 1290 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1291 return FALSE; 1292 } 1293 1294 BOOL WINAPI SQLReadFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName, 1295 LPCSTR lpszKeyName, LPSTR lpszString, WORD cbString, 1296 WORD *pcbString) 1297 { 1298 clear_errors(); 1299 FIXME("%s %s %s %s %d %p\n", debugstr_a(lpszFileName), debugstr_a(lpszAppName), 1300 debugstr_a(lpszKeyName), debugstr_a(lpszString), cbString, pcbString); 1301 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1302 return FALSE; 1303 } 1304 1305 BOOL WINAPI SQLRemoveDefaultDataSource(void) 1306 { 1307 clear_errors(); 1308 FIXME("\n"); 1309 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1310 return FALSE; 1311 } 1312 1313 BOOL WINAPI SQLRemoveDriverW(LPCWSTR drivername, BOOL remove_dsn, LPDWORD usage_count) 1314 { 1315 HKEY hkey; 1316 DWORD usagecount = 1; 1317 1318 clear_errors(); 1319 TRACE("%s %d %p\n", debugstr_w(drivername), remove_dsn, usage_count); 1320 1321 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS) 1322 { 1323 HKEY hkeydriver; 1324 1325 if (RegOpenKeyW(hkey, drivername, &hkeydriver) == ERROR_SUCCESS) 1326 { 1327 DWORD size, type; 1328 DWORD count; 1329 1330 size = sizeof(usagecount); 1331 RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size); 1332 TRACE("Usage count %d\n", usagecount); 1333 count = usagecount - 1; 1334 if (count) 1335 { 1336 if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&count, sizeof(count)) != ERROR_SUCCESS) 1337 ERR("Failed to write registry UsageCount key\n"); 1338 } 1339 1340 RegCloseKey(hkeydriver); 1341 } 1342 1343 if (usagecount) 1344 usagecount--; 1345 1346 if (!usagecount) 1347 { 1348 if (RegDeleteKeyW(hkey, drivername) != ERROR_SUCCESS) 1349 ERR("Failed to delete registry key: %s\n", debugstr_w(drivername)); 1350 1351 if (RegOpenKeyW(hkey, odbcdrivers, &hkeydriver) == ERROR_SUCCESS) 1352 { 1353 if(RegDeleteValueW(hkeydriver, drivername) != ERROR_SUCCESS) 1354 ERR("Failed to delete registry value: %s\n", debugstr_w(drivername)); 1355 RegCloseKey(hkeydriver); 1356 } 1357 } 1358 1359 RegCloseKey(hkey); 1360 } 1361 1362 if (usage_count) 1363 *usage_count = usagecount; 1364 1365 return TRUE; 1366 } 1367 1368 BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN, 1369 LPDWORD lpdwUsageCount) 1370 { 1371 WCHAR *driver; 1372 BOOL ret; 1373 1374 clear_errors(); 1375 TRACE("%s %d %p\n", debugstr_a(lpszDriver), fRemoveDSN, lpdwUsageCount); 1376 1377 driver = SQLInstall_strdup(lpszDriver); 1378 1379 ret = SQLRemoveDriverW(driver, fRemoveDSN, lpdwUsageCount); 1380 1381 HeapFree(GetProcessHeap(), 0, driver); 1382 return ret; 1383 } 1384 1385 BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount) 1386 { 1387 clear_errors(); 1388 FIXME("%p\n", pdwUsageCount); 1389 if (pdwUsageCount) *pdwUsageCount = 1; 1390 return TRUE; 1391 } 1392 1393 BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN) 1394 { 1395 clear_errors(); 1396 FIXME("%s\n", debugstr_w(lpszDSN)); 1397 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1398 return FALSE; 1399 } 1400 1401 BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN) 1402 { 1403 clear_errors(); 1404 FIXME("%s\n", debugstr_a(lpszDSN)); 1405 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1406 return FALSE; 1407 } 1408 1409 BOOL WINAPI SQLRemoveTranslatorW(const WCHAR *translator, DWORD *usage_count) 1410 { 1411 HKEY hkey; 1412 DWORD usagecount = 1; 1413 BOOL ret = TRUE; 1414 1415 clear_errors(); 1416 TRACE("%s %p\n", debugstr_w(translator), usage_count); 1417 1418 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS) 1419 { 1420 HKEY hkeydriver; 1421 1422 if (RegOpenKeyW(hkey, translator, &hkeydriver) == ERROR_SUCCESS) 1423 { 1424 DWORD size, type; 1425 DWORD count; 1426 1427 size = sizeof(usagecount); 1428 RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size); 1429 TRACE("Usage count %d\n", usagecount); 1430 count = usagecount - 1; 1431 if (count) 1432 { 1433 if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&count, sizeof(count)) != ERROR_SUCCESS) 1434 ERR("Failed to write registry UsageCount key\n"); 1435 } 1436 1437 RegCloseKey(hkeydriver); 1438 } 1439 1440 if (usagecount) 1441 usagecount--; 1442 1443 if (!usagecount) 1444 { 1445 if(RegDeleteKeyW(hkey, translator) != ERROR_SUCCESS) 1446 { 1447 push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found); 1448 WARN("Failed to delete registry key: %s\n", debugstr_w(translator)); 1449 ret = FALSE; 1450 } 1451 1452 if (ret && RegOpenKeyW(hkey, odbctranslators, &hkeydriver) == ERROR_SUCCESS) 1453 { 1454 if(RegDeleteValueW(hkeydriver, translator) != ERROR_SUCCESS) 1455 { 1456 push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found); 1457 WARN("Failed to delete registry key: %s\n", debugstr_w(translator)); 1458 ret = FALSE; 1459 } 1460 1461 RegCloseKey(hkeydriver); 1462 } 1463 } 1464 1465 RegCloseKey(hkey); 1466 } 1467 1468 if (ret && usage_count) 1469 *usage_count = usagecount; 1470 1471 return ret; 1472 } 1473 1474 BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount) 1475 { 1476 WCHAR *translator; 1477 BOOL ret; 1478 1479 clear_errors(); 1480 TRACE("%s %p\n", debugstr_a(lpszTranslator), lpdwUsageCount); 1481 1482 translator = SQLInstall_strdup(lpszTranslator); 1483 ret = SQLRemoveTranslatorW(translator, lpdwUsageCount); 1484 1485 HeapFree(GetProcessHeap(), 0, translator); 1486 return ret; 1487 } 1488 1489 BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode) 1490 { 1491 clear_errors(); 1492 TRACE("%u\n", wConfigMode); 1493 1494 if (wConfigMode > ODBC_SYSTEM_DSN) 1495 { 1496 push_error(ODBC_ERROR_INVALID_PARAM_SEQUENCE, odbc_error_invalid_param_sequence); 1497 return FALSE; 1498 } 1499 else 1500 { 1501 config_mode = wConfigMode; 1502 return TRUE; 1503 } 1504 } 1505 1506 BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN) 1507 { 1508 clear_errors(); 1509 FIXME("%s\n", debugstr_w(lpszDSN)); 1510 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1511 return FALSE; 1512 } 1513 1514 BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN) 1515 { 1516 clear_errors(); 1517 FIXME("%s\n", debugstr_a(lpszDSN)); 1518 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1519 return FALSE; 1520 } 1521 1522 BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver) 1523 { 1524 clear_errors(); 1525 FIXME("%s %s\n", debugstr_w(lpszDSN), debugstr_w(lpszDriver)); 1526 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1527 return FALSE; 1528 } 1529 1530 BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver) 1531 { 1532 clear_errors(); 1533 FIXME("%s %s\n", debugstr_a(lpszDSN), debugstr_a(lpszDriver)); 1534 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1535 return FALSE; 1536 } 1537 1538 BOOL WINAPI SQLWriteFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName, 1539 LPCWSTR lpszKeyName, LPCWSTR lpszString) 1540 { 1541 clear_errors(); 1542 FIXME("%s %s %s %s\n", debugstr_w(lpszFileName), debugstr_w(lpszAppName), 1543 debugstr_w(lpszKeyName), debugstr_w(lpszString)); 1544 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1545 return FALSE; 1546 } 1547 1548 BOOL WINAPI SQLWriteFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName, 1549 LPCSTR lpszKeyName, LPCSTR lpszString) 1550 { 1551 clear_errors(); 1552 FIXME("%s %s %s %s\n", debugstr_a(lpszFileName), debugstr_a(lpszAppName), 1553 debugstr_a(lpszKeyName), debugstr_a(lpszString)); 1554 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 1555 return FALSE; 1556 } 1557 1558 BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry, 1559 LPCWSTR lpszString, LPCWSTR lpszFilename) 1560 { 1561 LONG ret; 1562 HKEY hkey; 1563 1564 clear_errors(); 1565 TRACE("%s %s %s %s\n", debugstr_w(lpszSection), debugstr_w(lpszEntry), 1566 debugstr_w(lpszString), debugstr_w(lpszFilename)); 1567 1568 if(!lpszFilename || !*lpszFilename) 1569 { 1570 push_error(ODBC_ERROR_INVALID_STR, odbc_error_invalid_param_string); 1571 return FALSE; 1572 } 1573 1574 if ((ret = RegCreateKeyW(HKEY_CURRENT_USER, odbcW, &hkey)) == ERROR_SUCCESS) 1575 { 1576 HKEY hkeyfilename; 1577 1578 if ((ret = RegCreateKeyW(hkey, lpszFilename, &hkeyfilename)) == ERROR_SUCCESS) 1579 { 1580 HKEY hkey_section; 1581 1582 if ((ret = RegCreateKeyW(hkeyfilename, lpszSection, &hkey_section)) == ERROR_SUCCESS) 1583 { 1584 ret = RegSetValueExW(hkey_section, lpszEntry, 0, REG_SZ, (BYTE*)lpszString, (lstrlenW(lpszString)+1)*sizeof(WCHAR)); 1585 RegCloseKey(hkey_section); 1586 } 1587 1588 RegCloseKey(hkeyfilename); 1589 } 1590 1591 RegCloseKey(hkey); 1592 } 1593 1594 return ret == ERROR_SUCCESS; 1595 } 1596 1597 BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry, 1598 LPCSTR lpszString, LPCSTR lpszFilename) 1599 { 1600 BOOL ret; 1601 WCHAR *sect, *entry, *string, *file; 1602 clear_errors(); 1603 TRACE("%s %s %s %s\n", lpszSection, lpszEntry, lpszString, lpszFilename); 1604 1605 sect = heap_strdupAtoW(lpszSection); 1606 entry = heap_strdupAtoW(lpszEntry); 1607 string = heap_strdupAtoW(lpszString); 1608 file = heap_strdupAtoW(lpszFilename); 1609 1610 ret = SQLWritePrivateProfileStringW(sect, entry, string, file); 1611 1612 heap_free(sect); 1613 heap_free(entry); 1614 heap_free(string); 1615 heap_free(file); 1616 1617 return ret; 1618 } 1619