dlls/odbccp32/odbccp32.c

   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/debug.h"
  33
  34 #include "odbcinst.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(odbc);
  37
  38 /* Registry key names */
  39 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};
  40
  41 /* This config mode is known to be process-wide.
  42  * MSDN documentation suggests that the value is hidden somewhere in the registry but I haven't found it yet.
  43  * Although both the registry and the ODBC.ini files appear to be maintained together they are not maintained automatically through the registry's IniFileMapping.
  44  */
  45 static UWORD config_mode = ODBC_BOTH_DSN;
  46
  47 /* MSDN documentation suggests that the error subsystem handles errors 1 to 8
  48  * only and experimentation (Windows 2000) shows that the errors are process-
  49  * wide so go for the simple solution; static arrays.
  50  */
  51 static int num_errors;
  52 static int error_code[8];
  53 static const WCHAR *error_msg[8];
  54 static const WCHAR odbc_error_general_err[] = {'G','e','n','e','r','a','l',' ','e','r','r','o','r',0};
  55 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};
  56 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};
  57 static const WCHAR odbc_error_out_of_mem[] = {'O','u','t',' ','o','f',' ','m','e','m','o','r','y',0};
  58 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};
  59
  60 /* Push an error onto the error stack, taking care of ranges etc. */
  61 static void push_error(int code, LPCWSTR msg)
  62 {
  63     if (num_errors < sizeof error_code/sizeof error_code[0])
  64     {
  65         error_code[num_errors] = code;
  66         error_msg[num_errors] = msg;
  67         num_errors++;
  68     }
  69 }
  70
  71 /* Clear the error stack */
  72 static void clear_errors(void)
  73 {
  74     num_errors = 0;
  75 }
  76
  77 BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2)
  78 {
  79     clear_errors();
  80     FIXME( "( %d %d %p %p) : stub!\n", i, j, p1, p2);
  81     return FALSE;
  82 }
  83
  84 static LPWSTR SQLInstall_strdup_multi(LPCSTR str)
  85 {
  86     LPCSTR p;
  87     LPWSTR ret = NULL;
  88     DWORD len;
  89
  90     if (!str)
  91         return ret;
  92
  93     for (p = str; *p; p += lstrlenA(p) + 1)
  94         ;
  95
  96     len = MultiByteToWideChar(CP_ACP, 0, str, p - str, NULL, 0 );
  97     ret = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
  98     MultiByteToWideChar(CP_ACP, 0, str, p - str, ret, len );
  99     ret[len] = 0;
 100
 101     return ret;
 102 }
 103
 104 static LPWSTR SQLInstall_strdup(LPCSTR str)
 105 {
 106     DWORD len;
 107     LPWSTR ret = NULL;
 108
 109     if (!str)
 110         return ret;
 111
 112     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0 );
 113     ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 114     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len );
 115
 116     return ret;
 117 }
 118
 119 /* Convert the wide string or zero-length-terminated list of wide strings to a
 120  * narrow string or zero-length-terminated list of narrow strings.
 121  * Do not try to emulate windows undocumented excesses (e.g. adding a third \0
 122  * to a list)
 123  * Arguments
 124  *   mode Indicates the sort of string.
 125  *     1 denotes that the buffers contain strings terminated by a single nul
 126  *       character
 127  *     2 denotes that the buffers contain zero-length-terminated lists
 128  *       (frequently erroneously referred to as double-null-terminated)
 129  *   buffer The narrow-character buffer into which to place the result.  This
 130  *          must be a non-null pointer to the first element of a buffer whose
 131  *          length is passed in buffer_length.
 132  *   str The wide-character buffer containing the string or list of strings to
 133  *       be converted.  str_length defines how many wide characters in the
 134  *       buffer are to be converted, including all desired terminating nul
 135  *       characters.
 136  *   str_length Effective length of str
 137  *   buffer_length Length of buffer
 138  *   returned_length A pointer to a variable that will receive the number of
 139  *                   narrow characters placed into the buffer.  This pointer
 140  *                   may be NULL.
 141  */
 142 static BOOL SQLInstall_narrow(int mode, LPSTR buffer, LPCWSTR str, WORD str_length, WORD buffer_length, WORD *returned_length)
 143 {
 144     LPSTR pbuf; /* allows us to allocate a temporary buffer only if needed */
 145     int len; /* Length of the converted list */
 146     BOOL success = FALSE;
 147     assert(mode == 1 || mode == 2);
 148     assert(buffer_length);
 149     len = WideCharToMultiByte(CP_ACP, 0, str, str_length, 0, 0, NULL, NULL);
 150     if (len > 0)
 151     {
 152         if (len > buffer_length)
 153         {
 154             pbuf = HeapAlloc(GetProcessHeap(), 0, len);
 155         }
 156         else
 157         {
 158             pbuf = buffer;
 159         }
 160         len = WideCharToMultiByte(CP_ACP, 0, str, str_length, pbuf, len, NULL, NULL);
 161         if (len > 0)
 162         {
 163             if (pbuf != buffer)
 164             {
 165                 if (buffer_length > (mode - 1))
 166                 {
 167                     memcpy (buffer, pbuf, buffer_length-mode);
 168                     *(buffer+buffer_length-mode) = '\0';
 169                 }
 170                 *(buffer+buffer_length-1) = '\0';
 171             }
 172             if (returned_length)
 173             {
 174                 *returned_length = pbuf == buffer ? len : buffer_length;
 175             }
 176             success = TRUE;
 177         }
 178         else
 179         {
 180             ERR("transferring wide to narrow\n");
 181         }
 182         if (pbuf != buffer)
 183         {
 184             HeapFree(GetProcessHeap(), 0, pbuf);
 185         }
 186     }
 187     else
 188     {
 189         ERR("measuring wide to narrow\n");
 190     }
 191     return success;
 192 }
 193
 194 BOOL WINAPI SQLConfigDataSourceW(HWND hwndParent, WORD fRequest,
 195                LPCWSTR lpszDriver, LPCWSTR lpszAttributes)
 196 {
 197     LPCWSTR p;
 198
 199     clear_errors();
 200     FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_w(lpszDriver),
 201           debugstr_w(lpszAttributes));
 202
 203     for (p = lpszAttributes; *p; p += lstrlenW(p) + 1)
 204         FIXME("%s\n", debugstr_w(p));
 205
 206     return TRUE;
 207 }
 208
 209 BOOL WINAPI SQLConfigDataSource(HWND hwndParent, WORD fRequest,
 210                LPCSTR lpszDriver, LPCSTR lpszAttributes)
 211 {
 212     FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_a(lpszDriver),
 213           debugstr_a(lpszAttributes));
 214     clear_errors();
 215     return TRUE;
 216 }
 217
 218 BOOL WINAPI SQLConfigDriverW(HWND hwndParent, WORD fRequest, LPCWSTR lpszDriver,
 219                LPCWSTR lpszArgs, LPWSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 220 {
 221     clear_errors();
 222     FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_w(lpszDriver),
 223           debugstr_w(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
 224     return TRUE;
 225 }
 226
 227 BOOL WINAPI SQLConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver,
 228                LPCSTR lpszArgs, LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 229 {
 230     clear_errors();
 231     FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_a(lpszDriver),
 232           debugstr_a(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
 233     return TRUE;
 234 }
 235
 236 BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPCWSTR lpszDS)
 237 {
 238     clear_errors();
 239     FIXME("\n");
 240     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 241     return FALSE;
 242 }
 243
 244 BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPCSTR lpszDS)
 245 {
 246     clear_errors();
 247     FIXME("\n");
 248     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 249     return FALSE;
 250 }
 251
 252 BOOL WINAPI SQLGetAvailableDriversW(LPCWSTR lpszInfFile, LPWSTR lpszBuf,
 253                WORD cbBufMax, WORD *pcbBufOut)
 254 {
 255     clear_errors();
 256     FIXME("\n");
 257     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 258     return FALSE;
 259 }
 260
 261 BOOL WINAPI SQLGetAvailableDrivers(LPCSTR lpszInfFile, LPSTR lpszBuf,
 262                WORD cbBufMax, WORD *pcbBufOut)
 263 {
 264     clear_errors();
 265     FIXME("\n");
 266     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 267     return FALSE;
 268 }
 269
 270 BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode)
 271 {
 272     clear_errors();
 273     if (pwConfigMode)
 274         *pwConfigMode = config_mode;
 275     return TRUE;
 276 }
 277
 278 /* This is implemented sensibly rather than according to exact conformance to Microsoft's buggy implementations
 279  * e.g. The Microsoft one occasionally actually adds a third nul character (possibly beyond the buffer).
 280  * e.g. If the key has no drivers then version 3.525.1117.0 does not modify the buffer at all, not even a nul character.
 281  */
 282 BOOL WINAPI SQLGetInstalledDriversW(LPWSTR lpszBuf, WORD cbBufMax,
 283                WORD *pcbBufOut)
 284 {
 285     HKEY hDrivers; /* Registry handle to the Drivers key */
 286     LONG reg_ret; /* Return code from registry functions */
 287     BOOL success = FALSE; /* The value we will return */
 288
 289     clear_errors();
 290     if (!lpszBuf || cbBufMax == 0)
 291     {
 292         push_error(ODBC_ERROR_INVALID_BUFF_LEN, odbc_error_invalid_buff_len);
 293     }
 294     else if ((reg_ret = RegOpenKeyExW (HKEY_LOCAL_MACHINE /* The drivers does not depend on the config mode */,
 295             drivers_key, 0, KEY_READ /* Maybe overkill */,
 296             &hDrivers)) == ERROR_SUCCESS)
 297     {
 298         DWORD index = 0;
 299         cbBufMax--;
 300         success = TRUE;
 301         while (cbBufMax > 0)
 302         {
 303             DWORD size_name;
 304             size_name = cbBufMax;
 305             if ((reg_ret = RegEnumValueW(hDrivers, index, lpszBuf, &size_name, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS)
 306             {
 307                 index++;
 308                 assert (size_name < cbBufMax && *(lpszBuf + size_name) == 0);
 309                 size_name++;
 310                 cbBufMax-= size_name;
 311                 lpszBuf+=size_name;
 312             }
 313             else
 314             {
 315                 if (reg_ret != ERROR_NO_MORE_ITEMS)
 316                 {
 317                     success = FALSE;
 318                     push_error(ODBC_ERROR_GENERAL_ERR, odbc_error_general_err);
 319                 }
 320                 break;
 321             }
 322         }
 323         *lpszBuf = 0;
 324         if ((reg_ret = RegCloseKey (hDrivers)) != ERROR_SUCCESS)
 325             TRACE ("Error %d closing ODBC Drivers key\n", reg_ret);
 326     }
 327     else
 328     {
 329         /* MSDN states that it returns failure with COMPONENT_NOT_FOUND in this case.
 330          * Version 3.525.1117.0 (Windows 2000) does not; it actually returns success.
 331          * I doubt if it will actually be an issue.
 332          */
 333         push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found);
 334     }
 335     return success;
 336 }
 337
 338 BOOL WINAPI SQLGetInstalledDrivers(LPSTR lpszBuf, WORD cbBufMax,
 339                WORD *pcbBufOut)
 340 {
 341     BOOL ret;
 342     int size_wbuf = cbBufMax;
 343     LPWSTR wbuf;
 344     WORD size_used;
 345     wbuf = HeapAlloc(GetProcessHeap(), 0, size_wbuf*sizeof(WCHAR));
 346     if (wbuf)
 347     {
 348         ret = SQLGetInstalledDriversW(wbuf, size_wbuf, &size_used);
 349         if (ret)
 350         {
 351             if (!(ret = SQLInstall_narrow(2, lpszBuf, wbuf, size_used, cbBufMax, pcbBufOut)))
 352             {
 353                 push_error(ODBC_ERROR_GENERAL_ERR, odbc_error_general_err);
 354             }
 355         }
 356         HeapFree(GetProcessHeap(), 0, wbuf);
 357         /* ignore failure; we have achieved the aim */
 358     }
 359     else
 360     {
 361         push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
 362         ret = FALSE;
 363     }
 364     return ret;
 365 }
 366
 367 int WINAPI SQLGetPrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 368                LPCWSTR lpszDefault, LPCWSTR RetBuffer, int cbRetBuffer,
 369                LPCWSTR lpszFilename)
 370 {
 371     clear_errors();
 372     FIXME("\n");
 373     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 374     return FALSE;
 375 }
 376
 377 int WINAPI SQLGetPrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 378                LPCSTR lpszDefault, LPCSTR RetBuffer, int cbRetBuffer,
 379                LPCSTR lpszFilename)
 380 {
 381     clear_errors();
 382     FIXME("\n");
 383     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 384     return FALSE;
 385 }
 386
 387 BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax,
 388                WORD *pcbNameOut, LPWSTR lpszPath, WORD cbPathMax,
 389                WORD *pcbPathOut, DWORD *pvOption)
 390 {
 391     clear_errors();
 392     FIXME("\n");
 393     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 394     return FALSE;
 395 }
 396
 397 BOOL WINAPI SQLGetTranslator(HWND hwndParent, LPSTR lpszName, WORD cbNameMax,
 398                WORD *pcbNameOut, LPSTR lpszPath, WORD cbPathMax,
 399                WORD *pcbPathOut, DWORD *pvOption)
 400 {
 401     clear_errors();
 402     FIXME("\n");
 403     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 404     return FALSE;
 405 }
 406
 407 BOOL WINAPI SQLInstallDriverW(LPCWSTR lpszInfFile, LPCWSTR lpszDriver,
 408                LPWSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 409 {
 410     DWORD usage;
 411
 412     clear_errors();
 413     TRACE("%s %s %p %d %p\n", debugstr_w(lpszInfFile),
 414           debugstr_w(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 415
 416     if (lpszInfFile)
 417         return FALSE;
 418
 419     return SQLInstallDriverExW(lpszDriver, NULL, lpszPath, cbPathMax,
 420                                pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
 421 }
 422
 423 BOOL WINAPI SQLInstallDriver(LPCSTR lpszInfFile, LPCSTR lpszDriver,
 424                LPSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 425 {
 426     DWORD usage;
 427
 428     clear_errors();
 429     TRACE("%s %s %p %d %p\n", debugstr_a(lpszInfFile),
 430           debugstr_a(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 431
 432     if (lpszInfFile)
 433         return FALSE;
 434
 435     return SQLInstallDriverEx(lpszDriver, NULL, lpszPath, cbPathMax,
 436                               pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
 437 }
 438
 439 BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn,
 440                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 441                WORD fRequest, LPDWORD lpdwUsageCount)
 442 {
 443     UINT len;
 444     LPCWSTR p;
 445     WCHAR path[MAX_PATH];
 446
 447     clear_errors();
 448     TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver),
 449           debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 450           fRequest, lpdwUsageCount);
 451
 452     for (p = lpszDriver; *p; p += lstrlenW(p) + 1)
 453         TRACE("%s\n", debugstr_w(p));
 454
 455     len = GetSystemDirectoryW(path, MAX_PATH);
 456
 457     if (pcbPathOut)
 458         *pcbPathOut = len;
 459
 460     len = GetSystemDirectoryW(path, MAX_PATH);
 461
 462     if (lpszPathOut && cbPathOutMax > len)
 463     {
 464         lstrcpyW(lpszPathOut, path);
 465         return TRUE;
 466     }
 467     return FALSE;
 468 }
 469
 470 BOOL WINAPI SQLInstallDriverEx(LPCSTR lpszDriver, LPCSTR lpszPathIn,
 471                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 472                WORD fRequest, LPDWORD lpdwUsageCount)
 473 {
 474     LPCSTR p;
 475     LPWSTR driver, pathin;
 476     WCHAR pathout[MAX_PATH];
 477     BOOL ret;
 478     WORD cbOut = 0;
 479
 480     clear_errors();
 481     TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszDriver),
 482           debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 483           fRequest, lpdwUsageCount);
 484
 485     for (p = lpszDriver; *p; p += lstrlenA(p) + 1)
 486         TRACE("%s\n", debugstr_a(p));
 487
 488     driver = SQLInstall_strdup_multi(lpszDriver);
 489     pathin = SQLInstall_strdup(lpszPathIn);
 490
 491     ret = SQLInstallDriverExW(driver, pathin, pathout, MAX_PATH, &cbOut,
 492                               fRequest, lpdwUsageCount);
 493     if (ret)
 494     {
 495         int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 496                                        0, NULL, NULL);
 497         if (len)
 498         {
 499             if (pcbPathOut)
 500                 *pcbPathOut = len - 1;
 501
 502             if (!lpszPathOut || cbPathOutMax < len)
 503             {
 504                 ret = FALSE;
 505                 goto out;
 506             }
 507             len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 508                                        cbPathOutMax, NULL, NULL);
 509         }
 510     }
 511
 512 out:
 513     HeapFree(GetProcessHeap(), 0, driver);
 514     HeapFree(GetProcessHeap(), 0, pathin);
 515     return ret;
 516 }
 517
 518 BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax,
 519                WORD *pcbPathOut)
 520 {
 521     UINT len;
 522     WCHAR path[MAX_PATH];
 523
 524     TRACE("(%p %d %p)\n", lpszPath, cbPathMax, pcbPathOut);
 525
 526     if (cbPathMax < MAX_PATH)
 527         return FALSE;
 528
 529     clear_errors();
 530
 531     len = GetSystemDirectoryW(path, MAX_PATH);
 532
 533     if (pcbPathOut)
 534         *pcbPathOut = len;
 535
 536     if (lpszPath && cbPathMax > len)
 537     {
 538         lstrcpyW(lpszPath, path);
 539         return TRUE;
 540     }
 541     return FALSE;
 542 }
 543
 544 BOOL WINAPI SQLInstallDriverManager(LPSTR lpszPath, WORD cbPathMax,
 545                WORD *pcbPathOut)
 546 {
 547     BOOL ret;
 548     WORD len, cbOut = 0;
 549     WCHAR path[MAX_PATH];
 550
 551     TRACE("(%p %d %p)\n", lpszPath, cbPathMax, pcbPathOut);
 552
 553     if (cbPathMax < MAX_PATH)
 554         return FALSE;
 555
 556     clear_errors();
 557
 558     ret = SQLInstallDriverManagerW(path, MAX_PATH, &cbOut);
 559     if (ret)
 560     {
 561         len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath, 0,
 562                                    NULL, NULL);
 563         if (len)
 564         {
 565             if (pcbPathOut)
 566                 *pcbPathOut = len - 1;
 567
 568             if (!lpszPath || cbPathMax < len)
 569                 return FALSE;
 570
 571             len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath,
 572                                        cbPathMax, NULL, NULL);
 573         }
 574     }
 575     return ret;
 576 }
 577
 578 BOOL WINAPI SQLInstallODBCW(HWND hwndParent, LPCWSTR lpszInfFile,
 579                LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers)
 580 {
 581     clear_errors();
 582     FIXME("\n");
 583     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 584     return FALSE;
 585 }
 586
 587 BOOL WINAPI SQLInstallODBC(HWND hwndParent, LPCSTR lpszInfFile,
 588                LPCSTR lpszSrcPath, LPCSTR lpszDrivers)
 589 {
 590     clear_errors();
 591     FIXME("\n");
 592     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 593     return FALSE;
 594 }
 595
 596 SQLRETURN WINAPI SQLInstallerErrorW(WORD iError, DWORD *pfErrorCode,
 597                LPWSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 598 {
 599     TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
 600           cbErrorMsgMax, pcbErrorMsg);
 601
 602     if (iError == 0)
 603     {
 604         return SQL_ERROR;
 605     }
 606     else if (iError <= num_errors)
 607     {
 608         BOOL truncated = FALSE;
 609         WORD len;
 610         LPCWSTR msg;
 611         iError--;
 612         if (pfErrorCode)
 613             *pfErrorCode = error_code[iError];
 614         msg = error_msg[iError];
 615         len = msg ? lstrlenW(msg) : 0;
 616         if (pcbErrorMsg)
 617             *pcbErrorMsg = len;
 618         len++;
 619         if (cbErrorMsgMax < len)
 620         {
 621             len = cbErrorMsgMax;
 622             truncated = TRUE;
 623         }
 624         if (lpszErrorMsg && len)
 625         {
 626             if (msg)
 627             {
 628                 memcpy (lpszErrorMsg, msg, len * sizeof(WCHAR));
 629             }
 630             else
 631             {
 632                 assert(len==1);
 633                 *lpszErrorMsg = 0;
 634             }
 635         }
 636         else
 637         {
 638             /* Yes.  If you pass a null pointer and a large length it is not an error! */
 639             truncated = TRUE;
 640         }
 641
 642         return truncated ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
 643     }
 644
 645     /* 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 */
 646     if (pcbErrorMsg)
 647         *pcbErrorMsg = 0;
 648
 649     if (lpszErrorMsg && cbErrorMsgMax > 0)
 650         *lpszErrorMsg = '\0';
 651
 652     return SQL_NO_DATA;
 653 }
 654
 655 SQLRETURN WINAPI SQLInstallerError(WORD iError, DWORD *pfErrorCode,
 656                LPSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 657 {
 658     SQLRETURN ret;
 659     LPWSTR wbuf;
 660     WORD cbwbuf;
 661     TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
 662           cbErrorMsgMax, pcbErrorMsg);
 663
 664     wbuf = 0;
 665     if (lpszErrorMsg && cbErrorMsgMax)
 666     {
 667         wbuf = HeapAlloc(GetProcessHeap(), 0, cbErrorMsgMax*sizeof(WCHAR));
 668         if (!wbuf)
 669             return SQL_ERROR;
 670     }
 671     ret = SQLInstallerErrorW(iError, pfErrorCode, wbuf, cbErrorMsgMax, &cbwbuf);
 672     if (wbuf)
 673     {
 674         WORD cbBuf = 0;
 675         SQLInstall_narrow(1, lpszErrorMsg, wbuf, cbwbuf+1, cbErrorMsgMax, &cbBuf);
 676         HeapFree(GetProcessHeap(), 0, wbuf);
 677         if (pcbErrorMsg)
 678             *pcbErrorMsg = cbBuf-1;
 679     }
 680     return ret;
 681 }
 682
 683 BOOL WINAPI SQLInstallTranslatorExW(LPCWSTR lpszTranslator, LPCWSTR lpszPathIn,
 684                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 685                WORD fRequest, LPDWORD lpdwUsageCount)
 686 {
 687     UINT len;
 688     LPCWSTR p;
 689     WCHAR path[MAX_PATH];
 690
 691     clear_errors();
 692     TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszTranslator),
 693           debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 694           fRequest, lpdwUsageCount);
 695
 696     for (p = lpszTranslator; *p; p += lstrlenW(p) + 1)
 697         TRACE("%s\n", debugstr_w(p));
 698
 699     len = GetSystemDirectoryW(path, MAX_PATH);
 700
 701     if (pcbPathOut)
 702         *pcbPathOut = len;
 703
 704     if (lpszPathOut && cbPathOutMax > len)
 705     {
 706         lstrcpyW(lpszPathOut, path);
 707         return TRUE;
 708     }
 709     return FALSE;
 710 }
 711
 712 BOOL WINAPI SQLInstallTranslatorEx(LPCSTR lpszTranslator, LPCSTR lpszPathIn,
 713                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 714                WORD fRequest, LPDWORD lpdwUsageCount)
 715 {
 716     LPCSTR p;
 717     LPWSTR translator, pathin;
 718     WCHAR pathout[MAX_PATH];
 719     BOOL ret;
 720     WORD cbOut = 0;
 721
 722     clear_errors();
 723     TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszTranslator),
 724           debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 725           fRequest, lpdwUsageCount);
 726
 727     for (p = lpszTranslator; *p; p += lstrlenA(p) + 1)
 728         TRACE("%s\n", debugstr_a(p));
 729
 730     translator = SQLInstall_strdup_multi(lpszTranslator);
 731     pathin = SQLInstall_strdup(lpszPathIn);
 732
 733     ret = SQLInstallTranslatorExW(translator, pathin, pathout, MAX_PATH,
 734                                   &cbOut, fRequest, lpdwUsageCount);
 735     if (ret)
 736     {
 737         int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 738                                        0, NULL, NULL);
 739         if (len)
 740         {
 741             if (pcbPathOut)
 742                 *pcbPathOut = len - 1;
 743
 744             if (!lpszPathOut || cbPathOutMax < len)
 745             {
 746                 ret = FALSE;
 747                 goto out;
 748             }
 749             len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 750                                        cbPathOutMax, NULL, NULL);
 751         }
 752     }
 753
 754 out:
 755     HeapFree(GetProcessHeap(), 0, translator);
 756     HeapFree(GetProcessHeap(), 0, pathin);
 757     return ret;
 758 }
 759
 760 BOOL WINAPI SQLInstallTranslator(LPCSTR lpszInfFile, LPCSTR lpszTranslator,
 761                LPCSTR lpszPathIn, LPSTR lpszPathOut, WORD cbPathOutMax,
 762                WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 763 {
 764     clear_errors();
 765     TRACE("%s %s %s %p %d %p %d %p\n", debugstr_a(lpszInfFile),
 766           debugstr_a(lpszTranslator), debugstr_a(lpszPathIn), lpszPathOut,
 767           cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 768
 769     if (lpszInfFile)
 770         return FALSE;
 771
 772     return SQLInstallTranslatorEx(lpszTranslator, lpszPathIn, lpszPathOut,
 773                        cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 774 }
 775
 776 BOOL WINAPI SQLInstallTranslatorW(LPCWSTR lpszInfFile, LPCWSTR lpszTranslator,
 777               LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax,
 778               WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 779 {
 780     clear_errors();
 781     TRACE("%s %s %s %p %d %p %d %p\n", debugstr_w(lpszInfFile),
 782           debugstr_w(lpszTranslator), debugstr_w(lpszPathIn), lpszPathOut,
 783           cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 784
 785     if (lpszInfFile)
 786         return FALSE;
 787
 788     return SQLInstallTranslatorExW(lpszTranslator, lpszPathIn, lpszPathOut,
 789                         cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 790 }
 791
 792 BOOL WINAPI SQLManageDataSources(HWND hwnd)
 793 {
 794     clear_errors();
 795     FIXME("\n");
 796     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 797     return FALSE;
 798 }
 799
 800 SQLRETURN WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPCWSTR szErrorMsg)
 801 {
 802     FIXME("\n");
 803     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 804     return FALSE;
 805 }
 806
 807 SQLRETURN WINAPI SQLPostInstallerError(DWORD fErrorCode, LPCSTR szErrorMsg)
 808 {
 809     FIXME("\n");
 810     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 811     return FALSE;
 812 }
 813
 814 BOOL WINAPI SQLReadFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 815                LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString,
 816                WORD *pcbString)
 817 {
 818     clear_errors();
 819     FIXME("\n");
 820     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 821     return FALSE;
 822 }
 823
 824 BOOL WINAPI SQLReadFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 825                LPCSTR lpszKeyName, LPSTR lpszString, WORD cbString,
 826                WORD *pcbString)
 827 {
 828     clear_errors();
 829     FIXME("\n");
 830     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 831     return FALSE;
 832 }
 833
 834 BOOL WINAPI SQLRemoveDefaultDataSource(void)
 835 {
 836     clear_errors();
 837     FIXME("\n");
 838     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 839     return FALSE;
 840 }
 841
 842 BOOL WINAPI SQLRemoveDriverW(LPCWSTR lpszDriver, BOOL fRemoveDSN,
 843                LPDWORD lpdwUsageCount)
 844 {
 845     clear_errors();
 846     FIXME("stub\n");
 847     if (lpdwUsageCount) *lpdwUsageCount = 1;
 848     return TRUE;
 849 }
 850
 851 BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
 852                LPDWORD lpdwUsageCount)
 853 {
 854     clear_errors();
 855     FIXME("stub\n");
 856     if (lpdwUsageCount) *lpdwUsageCount = 1;
 857     return TRUE;
 858 }
 859
 860 BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
 861 {
 862     clear_errors();
 863     FIXME("stub\n");
 864     if (pdwUsageCount) *pdwUsageCount = 1;
 865     return TRUE;
 866 }
 867
 868 BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN)
 869 {
 870     clear_errors();
 871     FIXME("\n");
 872     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 873     return FALSE;
 874 }
 875
 876 BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN)
 877 {
 878     clear_errors();
 879     FIXME("\n");
 880     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 881     return FALSE;
 882 }
 883
 884 BOOL WINAPI SQLRemoveTranslatorW(LPCWSTR lpszTranslator, LPDWORD lpdwUsageCount)
 885 {
 886     clear_errors();
 887     FIXME("\n");
 888     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 889     return FALSE;
 890 }
 891
 892 BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount)
 893 {
 894     clear_errors();
 895     FIXME("\n");
 896     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 897     return FALSE;
 898 }
 899
 900 BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode)
 901 {
 902     clear_errors();
 903     if (wConfigMode > ODBC_SYSTEM_DSN)
 904     {
 905         push_error(ODBC_ERROR_INVALID_PARAM_SEQUENCE, odbc_error_invalid_param_sequence);
 906         return FALSE;
 907     }
 908     else
 909     {
 910         config_mode = wConfigMode;
 911         return TRUE;
 912     }
 913 }
 914
 915 BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN)
 916 {
 917     clear_errors();
 918     FIXME("\n");
 919     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 920     return FALSE;
 921 }
 922
 923 BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN)
 924 {
 925     clear_errors();
 926     FIXME("\n");
 927     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928     return FALSE;
 929 }
 930
 931 BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver)
 932 {
 933     clear_errors();
 934     FIXME("\n");
 935     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 936     return FALSE;
 937 }
 938
 939 BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver)
 940 {
 941     clear_errors();
 942     FIXME("\n");
 943     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 944     return FALSE;
 945 }
 946
 947 BOOL WINAPI SQLWriteFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 948                LPCWSTR lpszKeyName, LPCWSTR lpszString)
 949 {
 950     clear_errors();
 951     FIXME("\n");
 952     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 953     return FALSE;
 954 }
 955
 956 BOOL WINAPI SQLWriteFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 957                LPCSTR lpszKeyName, LPCSTR lpszString)
 958 {
 959     clear_errors();
 960     FIXME("\n");
 961     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 962     return FALSE;
 963 }
 964
 965 BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 966                LPCWSTR lpszString, LPCWSTR lpszFilename)
 967 {
 968     clear_errors();
 969     FIXME("\n");
 970     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 971     return FALSE;
 972 }
 973
 974 BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 975                LPCSTR lpszString, LPCSTR lpszFilename)
 976 {
 977     clear_errors();
 978     FIXME("\n");
 979     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 980     return FALSE;
 981 }