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  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winreg.h"
  30 #include "winnls.h"
  31 #include "wine/debug.h"
  32
  33 #include "odbcinst.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(odbc);
  36
  37 BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2)
  38 {
  39     FIXME( "( %d %d %p %p) : stub!\n", i, j, p1, p2);
  40     return FALSE;
  41 }
  42
  43 static LPWSTR SQLInstall_strdup_multi(LPCSTR str)
  44 {
  45     LPCSTR p;
  46     LPWSTR ret = NULL;
  47     DWORD len;
  48
  49     if (!str)
  50         return ret;
  51
  52     for (p = str; *p; p += lstrlenA(p) + 1)
  53         ;
  54
  55     len = MultiByteToWideChar(CP_ACP, 0, str, p - str, NULL, 0 );
  56     ret = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
  57     MultiByteToWideChar(CP_ACP, 0, str, p - str, ret, len );
  58     ret[len] = 0;
  59
  60     return ret;
  61 }
  62
  63 static LPWSTR SQLInstall_strdup(LPCSTR str)
  64 {
  65     DWORD len;
  66     LPWSTR ret = NULL;
  67
  68     if (!str)
  69         return ret;
  70
  71     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0 );
  72     ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
  73     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len );
  74
  75     return ret;
  76 }
  77
  78 BOOL WINAPI SQLConfigDataSourceW(HWND hwndParent, WORD fRequest,
  79                LPCWSTR lpszDriver, LPCWSTR lpszAttributes)
  80 {
  81     LPCWSTR p;
  82
  83     FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_w(lpszDriver),
  84           debugstr_w(lpszAttributes));
  85
  86     for (p = lpszAttributes; *p; p += lstrlenW(p) + 1)
  87         FIXME("%s\n", debugstr_w(p));
  88
  89     return TRUE;
  90 }
  91
  92 BOOL WINAPI SQLConfigDataSource(HWND hwndParent, WORD fRequest,
  93                LPCSTR lpszDriver, LPCSTR lpszAttributes)
  94 {
  95     FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_a(lpszDriver),
  96           debugstr_a(lpszAttributes));
  97     return TRUE;
  98 }
  99
 100 BOOL WINAPI SQLConfigDriverW(HWND hwndParent, WORD fRequest, LPCWSTR lpszDriver,
 101                LPCWSTR lpszArgs, LPWSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 102 {
 103     FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_w(lpszDriver),
 104           debugstr_w(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
 105     return TRUE;
 106 }
 107
 108 BOOL WINAPI SQLConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver,
 109                LPCSTR lpszArgs, LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 110 {
 111     FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_a(lpszDriver),
 112           debugstr_a(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
 113     return TRUE;
 114 }
 115
 116 BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPCWSTR lpszDS)
 117 {
 118     FIXME("\n");
 119     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 120     return FALSE;
 121 }
 122
 123 BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPCSTR lpszDS)
 124 {
 125     FIXME("\n");
 126     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 127     return FALSE;
 128 }
 129
 130 BOOL WINAPI SQLGetAvailableDriversW(LPCWSTR lpszInfFile, LPWSTR lpszBuf,
 131                WORD cbBufMax, WORD *pcbBufOut)
 132 {
 133     FIXME("\n");
 134     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 135     return FALSE;
 136 }
 137
 138 BOOL WINAPI SQLGetAvailableDrivers(LPCSTR lpszInfFile, LPSTR lpszBuf,
 139                WORD cbBufMax, WORD *pcbBufOut)
 140 {
 141     FIXME("\n");
 142     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 143     return FALSE;
 144 }
 145
 146 BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode)
 147 {
 148     FIXME("\n");
 149     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 150     return FALSE;
 151 }
 152
 153 BOOL WINAPI SQLGetInstalledDriversW(LPWSTR lpszBuf, WORD cbBufMax,
 154                WORD *pcbBufOut)
 155 {
 156     FIXME("\n");
 157     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 158     return FALSE;
 159 }
 160
 161 BOOL WINAPI SQLGetInstalledDrivers(LPSTR lpszBuf, WORD cbBufMax,
 162                WORD *pcbBufOut)
 163 {
 164     FIXME("\n");
 165     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 166     return FALSE;
 167 }
 168
 169 int WINAPI SQLGetPrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 170                LPCWSTR lpszDefault, LPCWSTR RetBuffer, int cbRetBuffer,
 171                LPCWSTR lpszFilename)
 172 {
 173     FIXME("\n");
 174     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 175     return FALSE;
 176 }
 177
 178 int WINAPI SQLGetPrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 179                LPCSTR lpszDefault, LPCSTR RetBuffer, int cbRetBuffer,
 180                LPCSTR lpszFilename)
 181 {
 182     FIXME("\n");
 183     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 184     return FALSE;
 185 }
 186
 187 BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax,
 188                WORD *pcbNameOut, LPWSTR lpszPath, WORD cbPathMax,
 189                WORD *pcbPathOut, DWORD *pvOption)
 190 {
 191     FIXME("\n");
 192     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 193     return FALSE;
 194 }
 195
 196 BOOL WINAPI SQLGetTranslator(HWND hwndParent, LPSTR lpszName, WORD cbNameMax,
 197                WORD *pcbNameOut, LPSTR lpszPath, WORD cbPathMax,
 198                WORD *pcbPathOut, DWORD *pvOption)
 199 {
 200     FIXME("\n");
 201     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 202     return FALSE;
 203 }
 204
 205 BOOL WINAPI SQLInstallDriverW(LPCWSTR lpszInfFile, LPCWSTR lpszDriver,
 206                LPWSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 207 {
 208     DWORD usage;
 209
 210     TRACE("%s %s %p %d %p\n", debugstr_w(lpszInfFile),
 211           debugstr_w(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 212
 213     if (lpszInfFile)
 214         return FALSE;
 215
 216     return SQLInstallDriverExW(lpszDriver, NULL, lpszPath, cbPathMax,
 217                                pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
 218 }
 219
 220 BOOL WINAPI SQLInstallDriver(LPCSTR lpszInfFile, LPCSTR lpszDriver,
 221                LPSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 222 {
 223     DWORD usage;
 224
 225     TRACE("%s %s %p %d %p\n", debugstr_a(lpszInfFile),
 226           debugstr_a(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 227
 228     if (lpszInfFile)
 229         return FALSE;
 230
 231     return SQLInstallDriverEx(lpszDriver, NULL, lpszPath, cbPathMax,
 232                               pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
 233 }
 234
 235 BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn,
 236                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 237                WORD fRequest, LPDWORD lpdwUsageCount)
 238 {
 239     UINT len;
 240     LPCWSTR p;
 241     WCHAR path[MAX_PATH];
 242
 243     TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver),
 244           debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 245           fRequest, lpdwUsageCount);
 246
 247     for (p = lpszDriver; *p; p += lstrlenW(p) + 1)
 248         TRACE("%s\n", debugstr_w(p));
 249
 250     len = GetSystemDirectoryW(path, MAX_PATH);
 251
 252     if (pcbPathOut)
 253         *pcbPathOut = len;
 254
 255     len = GetSystemDirectoryW(path, MAX_PATH);
 256
 257     if (lpszPathOut && cbPathOutMax > len)
 258     {
 259         lstrcpyW(lpszPathOut, path);
 260         return TRUE;
 261     }
 262     return FALSE;
 263 }
 264
 265 BOOL WINAPI SQLInstallDriverEx(LPCSTR lpszDriver, LPCSTR lpszPathIn,
 266                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 267                WORD fRequest, LPDWORD lpdwUsageCount)
 268 {
 269     LPCSTR p;
 270     LPWSTR driver, pathin;
 271     WCHAR pathout[MAX_PATH];
 272     BOOL ret;
 273     WORD cbOut = 0;
 274
 275     TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszDriver),
 276           debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 277           fRequest, lpdwUsageCount);
 278
 279     for (p = lpszDriver; *p; p += lstrlenA(p) + 1)
 280         TRACE("%s\n", debugstr_a(p));
 281
 282     driver = SQLInstall_strdup_multi(lpszDriver);
 283     pathin = SQLInstall_strdup(lpszPathIn);
 284
 285     ret = SQLInstallDriverExW(driver, pathin, pathout, MAX_PATH, &cbOut,
 286                               fRequest, lpdwUsageCount);
 287     if (ret)
 288     {
 289         int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 290                                        0, NULL, NULL);
 291         if (len)
 292         {
 293             if (pcbPathOut)
 294                 *pcbPathOut = len - 1;
 295
 296             if (!lpszPathOut || cbPathOutMax < len)
 297             {
 298                 ret = FALSE;
 299                 goto out;
 300             }
 301             len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 302                                        cbPathOutMax, NULL, NULL);
 303         }
 304     }
 305
 306 out:
 307     HeapFree(GetProcessHeap(), 0, driver);
 308     HeapFree(GetProcessHeap(), 0, pathin);
 309     return ret;
 310 }
 311
 312 BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax,
 313                WORD *pcbPathOut)
 314 {
 315     UINT len;
 316     WCHAR path[MAX_PATH];
 317
 318     TRACE("(%p %d %d)\n", lpszPath, cbPathMax, *pcbPathOut);
 319
 320     len = GetSystemDirectoryW(path, MAX_PATH);
 321
 322     if (pcbPathOut)
 323         *pcbPathOut = len;
 324
 325     if (lpszPath && cbPathMax > len)
 326     {
 327         lstrcpyW(lpszPath, path);
 328         return TRUE;
 329     }
 330     return FALSE;
 331 }
 332
 333 BOOL WINAPI SQLInstallDriverManager(LPSTR lpszPath, WORD cbPathMax,
 334                WORD *pcbPathOut)
 335 {
 336     BOOL ret;
 337     WORD len, cbOut = 0;
 338     WCHAR path[MAX_PATH];
 339
 340     TRACE("(%p %d %d)\n", lpszPath, cbPathMax, *pcbPathOut);
 341
 342     ret = SQLInstallDriverManagerW(path, MAX_PATH, &cbOut);
 343     if (ret)
 344     {
 345         len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath, 0,
 346                                    NULL, NULL);
 347         if (len)
 348         {
 349             if (pcbPathOut)
 350                 *pcbPathOut = len - 1;
 351
 352             if (!lpszPath || cbPathMax < len)
 353                 return FALSE;
 354
 355             len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath,
 356                                        cbPathMax, NULL, NULL);
 357         }
 358     }
 359     return ret;
 360 }
 361
 362 BOOL WINAPI SQLInstallODBCW(HWND hwndParent, LPCWSTR lpszInfFile,
 363                LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers)
 364 {
 365     FIXME("\n");
 366     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 367     return FALSE;
 368 }
 369
 370 BOOL WINAPI SQLInstallODBC(HWND hwndParent, LPCSTR lpszInfFile,
 371                LPCSTR lpszSrcPath, LPCSTR lpszDrivers)
 372 {
 373     FIXME("\n");
 374     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 375     return FALSE;
 376 }
 377
 378 SQLRETURN WINAPI SQLInstallerErrorW(WORD iError, DWORD *pfErrorCode,
 379                LPWSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 380 {
 381     TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
 382           cbErrorMsgMax, pcbErrorMsg);
 383
 384     if (pcbErrorMsg)
 385         *pcbErrorMsg = 0;
 386
 387     if (lpszErrorMsg && cbErrorMsgMax > 0)
 388         *lpszErrorMsg = '\0';
 389
 390     return SQL_NO_DATA;
 391 }
 392
 393 SQLRETURN WINAPI SQLInstallerError(WORD iError, DWORD *pfErrorCode,
 394                LPSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 395 {
 396     TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
 397           cbErrorMsgMax, pcbErrorMsg);
 398
 399     if (pcbErrorMsg)
 400         *pcbErrorMsg = 0;
 401
 402     if (lpszErrorMsg && cbErrorMsgMax > 0)
 403         *lpszErrorMsg = '\0';
 404
 405     return SQL_NO_DATA;
 406 }
 407
 408 BOOL WINAPI SQLInstallTranslatorExW(LPCWSTR lpszTranslator, LPCWSTR lpszPathIn,
 409                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 410                WORD fRequest, LPDWORD lpdwUsageCount)
 411 {
 412     UINT len;
 413     LPCWSTR p;
 414     WCHAR path[MAX_PATH];
 415
 416     TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszTranslator),
 417           debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 418           fRequest, lpdwUsageCount);
 419
 420     for (p = lpszTranslator; *p; p += lstrlenW(p) + 1)
 421         TRACE("%s\n", debugstr_w(p));
 422
 423     len = GetSystemDirectoryW(path, MAX_PATH);
 424
 425     if (pcbPathOut)
 426         *pcbPathOut = len;
 427
 428     if (lpszPathOut && cbPathOutMax > len)
 429     {
 430         lstrcpyW(lpszPathOut, path);
 431         return TRUE;
 432     }
 433     return FALSE;
 434 }
 435
 436 BOOL WINAPI SQLInstallTranslatorEx(LPCSTR lpszTranslator, LPCSTR lpszPathIn,
 437                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 438                WORD fRequest, LPDWORD lpdwUsageCount)
 439 {
 440     LPCSTR p;
 441     LPWSTR translator, pathin;
 442     WCHAR pathout[MAX_PATH];
 443     BOOL ret;
 444     WORD cbOut = 0;
 445
 446     TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszTranslator),
 447           debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
 448           fRequest, lpdwUsageCount);
 449
 450     for (p = lpszTranslator; *p; p += lstrlenA(p) + 1)
 451         TRACE("%s\n", debugstr_a(p));
 452
 453     translator = SQLInstall_strdup_multi(lpszTranslator);
 454     pathin = SQLInstall_strdup(lpszPathIn);
 455
 456     ret = SQLInstallTranslatorExW(translator, pathin, pathout, MAX_PATH,
 457                                   &cbOut, fRequest, lpdwUsageCount);
 458     if (ret)
 459     {
 460         int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 461                                        0, NULL, NULL);
 462         if (len)
 463         {
 464             if (pcbPathOut)
 465                 *pcbPathOut = len - 1;
 466
 467             if (!lpszPathOut || cbPathOutMax < len)
 468             {
 469                 ret = FALSE;
 470                 goto out;
 471             }
 472             len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
 473                                        cbPathOutMax, NULL, NULL);
 474         }
 475     }
 476
 477 out:
 478     HeapFree(GetProcessHeap(), 0, translator);
 479     HeapFree(GetProcessHeap(), 0, pathin);
 480     return ret;
 481 }
 482
 483 BOOL WINAPI SQLInstallTranslator(LPCSTR lpszInfFile, LPCSTR lpszTranslator,
 484                LPCSTR lpszPathIn, LPSTR lpszPathOut, WORD cbPathOutMax,
 485                WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 486 {
 487     TRACE("%s %s %s %p %d %p %d %p\n", debugstr_a(lpszInfFile),
 488           debugstr_a(lpszTranslator), debugstr_a(lpszPathIn), lpszPathOut,
 489           cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 490
 491     if (lpszInfFile)
 492         return FALSE;
 493
 494     return SQLInstallTranslatorEx(lpszTranslator, lpszPathIn, lpszPathOut,
 495                        cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 496 }
 497
 498 BOOL WINAPI SQLInstallTranslatorW(LPCWSTR lpszInfFile, LPCWSTR lpszTranslator,
 499               LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax,
 500               WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 501 {
 502     TRACE("%s %s %s %p %d %p %d %p\n", debugstr_w(lpszInfFile),
 503           debugstr_w(lpszTranslator), debugstr_w(lpszPathIn), lpszPathOut,
 504           cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 505
 506     if (lpszInfFile)
 507         return FALSE;
 508
 509     return SQLInstallTranslatorExW(lpszTranslator, lpszPathIn, lpszPathOut,
 510                         cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 511 }
 512
 513 BOOL WINAPI SQLManageDataSources(HWND hwnd)
 514 {
 515     FIXME("\n");
 516     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 517     return FALSE;
 518 }
 519
 520 SQLRETURN WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPCWSTR szErrorMsg)
 521 {
 522     FIXME("\n");
 523     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 524     return FALSE;
 525 }
 526
 527 SQLRETURN WINAPI SQLPostInstallerError(DWORD fErrorCode, LPCSTR szErrorMsg)
 528 {
 529     FIXME("\n");
 530     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 531     return FALSE;
 532 }
 533
 534 BOOL WINAPI SQLReadFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 535                LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString,
 536                WORD *pcbString)
 537 {
 538     FIXME("\n");
 539     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 540     return FALSE;
 541 }
 542
 543 BOOL WINAPI SQLReadFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 544                LPCSTR lpszKeyName, LPSTR lpszString, WORD cbString,
 545                WORD *pcbString)
 546 {
 547     FIXME("\n");
 548     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 549     return FALSE;
 550 }
 551
 552 BOOL WINAPI SQLRemoveDefaultDataSource(void)
 553 {
 554     FIXME("\n");
 555     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 556     return FALSE;
 557 }
 558
 559 BOOL WINAPI SQLRemoveDriverW(LPCWSTR lpszDriver, BOOL fRemoveDSN,
 560                LPDWORD lpdwUsageCount)
 561 {
 562     FIXME("\n");
 563     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 564     return FALSE;
 565 }
 566
 567 BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
 568                LPDWORD lpdwUsageCount)
 569 {
 570     FIXME("\n");
 571     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 572     return FALSE;
 573 }
 574
 575 BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
 576 {
 577     FIXME("\n");
 578     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 579     return FALSE;
 580 }
 581
 582 BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN)
 583 {
 584     FIXME("\n");
 585     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 586     return FALSE;
 587 }
 588
 589 BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN)
 590 {
 591     FIXME("\n");
 592     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 593     return FALSE;
 594 }
 595
 596 BOOL WINAPI SQLRemoveTranslatorW(LPCWSTR lpszTranslator, LPDWORD lpdwUsageCount)
 597 {
 598     FIXME("\n");
 599     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 600     return FALSE;
 601 }
 602
 603 BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount)
 604 {
 605     FIXME("\n");
 606     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 607     return FALSE;
 608 }
 609
 610 BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode)
 611 {
 612     FIXME("\n");
 613     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 614     return FALSE;
 615 }
 616
 617 BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN)
 618 {
 619     FIXME("\n");
 620     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 621     return FALSE;
 622 }
 623
 624 BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN)
 625 {
 626     FIXME("\n");
 627     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 628     return FALSE;
 629 }
 630
 631 BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver)
 632 {
 633     FIXME("\n");
 634     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 635     return FALSE;
 636 }
 637
 638 BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver)
 639 {
 640     FIXME("\n");
 641     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 642     return FALSE;
 643 }
 644
 645 BOOL WINAPI SQLWriteFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 646                LPCWSTR lpszKeyName, LPCWSTR lpszString)
 647 {
 648     FIXME("\n");
 649     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 650     return FALSE;
 651 }
 652
 653 BOOL WINAPI SQLWriteFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 654                LPCSTR lpszKeyName, LPCSTR lpszString)
 655 {
 656     FIXME("\n");
 657     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 658     return FALSE;
 659 }
 660
 661 BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 662                LPCWSTR lpszString, LPCWSTR lpszFilename)
 663 {
 664     FIXME("\n");
 665     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 666     return FALSE;
 667 }
 668
 669 BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 670                LPCSTR lpszString, LPCSTR lpszFilename)
 671 {
 672     FIXME("\n");
 673     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 674     return FALSE;
 675 }