dlls/odbccp32/odbccp32.c

   1 /*
   2  * Implementation of the ODBC driver installer
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winreg.h"
  29 #include "winnls.h"
  30 #include "wine/debug.h"
  31
  32 #include "odbcinst.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(odbc);
  35
  36 BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2)
  37 {
  38     FIXME( "( %ld %ld %p %p) : stub!\n", i, j, p1, p2);
  39     return FALSE;
  40 }
  41
  42 static LPWSTR SQLInstall_strdup_multi(LPCSTR str)
  43 {
  44     LPCSTR p;
  45     LPWSTR ret = NULL;
  46     DWORD len;
  47
  48     if (!str)
  49         return ret;
  50
  51     for (p = str; *p; p += lstrlenA(p) + 1)
  52         ;
  53
  54     len = MultiByteToWideChar(CP_ACP, 0, str, p - str, NULL, 0 );
  55     ret = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
  56     MultiByteToWideChar(CP_ACP, 0, str, p - str, ret, len );
  57     ret[len] = 0;
  58
  59     return ret;
  60 }
  61
  62 static LPWSTR SQLInstall_strdup(LPCSTR str)
  63 {
  64     DWORD len;
  65     LPWSTR ret = NULL;
  66
  67     if (!str)
  68         return ret;
  69
  70     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0 );
  71     ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
  72     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len );
  73
  74     return ret;
  75 }
  76
  77 BOOL WINAPI SQLConfigDataSourceW(HWND hwndParent, WORD fRequest,
  78                LPCWSTR lpszDriver, LPCWSTR lpszAttributes)
  79 {
  80     FIXME("\n");
  81     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  82     return FALSE;
  83 }
  84
  85 BOOL WINAPI SQLConfigDataSource(HWND hwndParent, WORD fRequest,
  86                LPCSTR lpszDriver, LPCSTR lpszAttributes)
  87 {
  88     FIXME("\n");
  89     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  90     return FALSE;
  91 }
  92
  93 BOOL WINAPI SQLConfigDriverW(HWND hwndParent, WORD fRequest, LPCWSTR lpszDriver,
  94                LPCWSTR lpszArgs, LPWSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
  95 {
  96     FIXME("\n");
  97     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  98     return FALSE;
  99 }
 100
 101 BOOL WINAPI SQLConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver,
 102                LPCSTR lpszArgs, LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 103 {
 104     FIXME("\n");
 105     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 106     return FALSE;
 107 }
 108
 109 BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPWSTR lpszDS)
 110 {
 111     FIXME("\n");
 112     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 113     return FALSE;
 114 }
 115
 116 BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPSTR lpszDS)
 117 {
 118     FIXME("\n");
 119     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 120     return FALSE;
 121 }
 122
 123 BOOL WINAPI SQLGetAvailableDriversW(LPCWSTR lpszInfFile, LPWSTR lpszBuf,
 124                WORD cbBufMax, WORD *pcbBufOut)
 125 {
 126     FIXME("\n");
 127     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 128     return FALSE;
 129 }
 130
 131 BOOL WINAPI SQLGetAvailableDrivers(LPCSTR lpszInfFile, LPSTR lpszBuf,
 132                WORD cbBufMax, WORD *pcbBufOut)
 133 {
 134     FIXME("\n");
 135     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 136     return FALSE;
 137 }
 138
 139 BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode)
 140 {
 141     FIXME("\n");
 142     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 143     return FALSE;
 144 }
 145
 146 BOOL WINAPI SQLGetInstalledDriversW(LPWSTR lpszBuf, WORD cbBufMax,
 147                WORD *pcbBufOut)
 148 {
 149     FIXME("\n");
 150     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 151     return FALSE;
 152 }
 153
 154 BOOL WINAPI SQLGetInstalledDrivers(LPSTR lpszBuf, WORD cbBufMax,
 155                WORD *pcbBufOut)
 156 {
 157     FIXME("\n");
 158     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 159     return FALSE;
 160 }
 161
 162 int WINAPI SQLGetPrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 163                LPCWSTR lpszDefault, LPCWSTR RetBuffer, INT cbRetBuffer,
 164                LPCWSTR lpszFilename)
 165 {
 166     FIXME("\n");
 167     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 168     return FALSE;
 169 }
 170
 171 int WINAPI SQLGetPrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 172                LPCSTR lpszDefault, LPCSTR RetBuffer, INT cbRetBuffer,
 173                LPCSTR lpszFilename)
 174 {
 175     FIXME("\n");
 176     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 177     return FALSE;
 178 }
 179
 180 BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax,
 181                WORD *pcbNameOut, LPWSTR lpszPath, WORD cbPathMax,
 182                WORD *pcbPathOut, DWORD *pvOption)
 183 {
 184     FIXME("\n");
 185     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 186     return FALSE;
 187 }
 188
 189 BOOL WINAPI SQLGetTranslator(HWND hwndParent, LPSTR lpszName, WORD cbNameMax,
 190                WORD *pcbNameOut, LPSTR lpszPath, WORD cbPathMax,
 191                WORD *pcbPathOut, DWORD *pvOption)
 192 {
 193     FIXME("\n");
 194     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 195     return FALSE;
 196 }
 197
 198 BOOL WINAPI SQLInstallDriverW(LPCWSTR lpszInfFile, LPCWSTR lpszDriver,
 199                LPWSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 200 {
 201     FIXME("%s %s %p %d %p\n", debugstr_w(lpszInfFile),
 202           debugstr_w(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 203     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 204     return FALSE;
 205 }
 206
 207 BOOL WINAPI SQLInstallDriver(LPCSTR lpszInfFile, LPCSTR lpszDriver,
 208                LPSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
 209 {
 210     FIXME("%s %s %p %d %p\n", debugstr_a(lpszInfFile),
 211           debugstr_a(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
 212     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 213     return FALSE;
 214 }
 215
 216 BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn,
 217                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 218                WORD fRequest, LPDWORD lpdwUsageCount)
 219 {
 220     LPCWSTR p;
 221
 222     FIXME("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver), debugstr_w(lpszPathIn),
 223           lpszPathOut, cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 224
 225     for (p = lpszDriver; *p; p += lstrlenW(p) + 1)
 226         FIXME("%s\n", debugstr_w(p));
 227
 228     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 229     return FALSE;
 230 }
 231
 232 BOOL WINAPI SQLInstallDriverEx(LPCSTR lpszDriver, LPCSTR lpszPathIn,
 233                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 234                WORD fRequest, LPDWORD lpdwUsageCount)
 235 {
 236     LPWSTR driver, pathin;
 237     WCHAR pathout[MAX_PATH];
 238     BOOL r;
 239     WORD cbOut = 0;
 240
 241     TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszDriver), debugstr_a(lpszPathIn),
 242           lpszPathOut, cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
 243
 244     driver = SQLInstall_strdup_multi(lpszDriver);
 245     pathin = SQLInstall_strdup(lpszPathIn);
 246
 247     r = SQLInstallDriverExW( driver, pathin, pathout, MAX_PATH,
 248                              &cbOut, fRequest, lpdwUsageCount );
 249     if (r)
 250     {
 251         *pcbPathOut = WideCharToMultiByte(CP_ACP, 0, pathout, -1,
 252                          lpszPathOut, cbPathOutMax, NULL, NULL );
 253     }
 254
 255     return r;
 256 }
 257
 258 BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax,
 259                WORD *pcbPathOut)
 260 {
 261     FIXME("\n");
 262     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 263     return FALSE;
 264 }
 265
 266 BOOL WINAPI SQLInstallDriverManager(LPSTR lpszPath, WORD cbPathMax,
 267                WORD *pcbPathOut)
 268 {
 269     FIXME("\n");
 270     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 271     return FALSE;
 272 }
 273
 274 BOOL WINAPI SQLInstallODBCW(HWND hwndParent, LPCWSTR lpszInfFile,
 275                LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers)
 276 {
 277     FIXME("\n");
 278     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 279     return FALSE;
 280 }
 281
 282 BOOL WINAPI SQLInstallODBC(HWND hwndParent, LPCSTR lpszInfFile,
 283                LPCSTR lpszSrcPath, LPCSTR lpszDrivers)
 284 {
 285     FIXME("\n");
 286     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 287     return FALSE;
 288 }
 289
 290 RETCODE WINAPI SQLInstallerErrorW(WORD iError, DWORD *pfErrorCode,
 291                LPWSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 292 {
 293     FIXME("\n");
 294     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 295     return FALSE;
 296 }
 297
 298 RETCODE WINAPI SQLInstallerError(WORD iError, DWORD *pfErrorCode,
 299                LPSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
 300 {
 301     FIXME("\n");
 302     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 303     return FALSE;
 304 }
 305
 306 BOOL WINAPI SQLInstallTranslatorExW(LPCWSTR lpszTranslator, LPCWSTR lpszPathIn,
 307                LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 308                WORD fRequest, LPDWORD lpdwUsageCount)
 309 {
 310     FIXME("\n");
 311     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 312     return FALSE;
 313 }
 314
 315 BOOL WINAPI SQLInstallTranslatorEx(LPCSTR lpszTranslator, LPCSTR lpszPathIn,
 316                LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
 317                WORD fRequest, LPDWORD lpdwUsageCount)
 318 {
 319     FIXME("\n");
 320     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 321     return FALSE;
 322 }
 323
 324 BOOL WINAPI SQLInstallTranslator(LPCSTR lpszInfFile, LPCSTR lpszTranslator,
 325                LPCSTR lpszPathIn, LPSTR lpszPathOut, WORD cbPathOutMax,
 326                WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 327 {
 328     FIXME("\n");
 329     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 330     return FALSE;
 331 }
 332
 333 BOOL WINAPI SQLInstallTranslatorW(LPCWSTR lpszInfFile, LPCWSTR lpszTranslator,
 334               LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax,
 335               WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
 336 {
 337     FIXME("\n");
 338     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 339     return FALSE;
 340 }
 341
 342 BOOL WINAPI SQLManageDataSources(HWND hwnd)
 343 {
 344     FIXME("\n");
 345     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 346     return FALSE;
 347 }
 348
 349 RETCODE WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPWSTR szErrorMsg)
 350 {
 351     FIXME("\n");
 352     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 353     return FALSE;
 354 }
 355
 356 RETCODE WINAPI SQLPostInstallerError(DWORD fErrorCode, LPSTR szErrorMsg)
 357 {
 358     FIXME("\n");
 359     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 360     return FALSE;
 361 }
 362
 363 BOOL WINAPI SQLReadFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 364                LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString,
 365                WORD *pcbString)
 366 {
 367     FIXME("\n");
 368     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 369     return FALSE;
 370 }
 371
 372 BOOL WINAPI SQLReadFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 373                LPCSTR lpszKeyName, LPSTR lpszString, WORD cbString,
 374                WORD *pcbString)
 375 {
 376     FIXME("\n");
 377     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 378     return FALSE;
 379 }
 380
 381 BOOL WINAPI SQLRemoveDefaultDataSource(void)
 382 {
 383     FIXME("\n");
 384     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 385     return FALSE;
 386 }
 387
 388 BOOL WINAPI SQLRemoveDriverW(LPCWSTR lpszDriver, BOOL fRemoveDSN,
 389                LPDWORD lpdwUsageCount)
 390 {
 391     FIXME("\n");
 392     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 393     return FALSE;
 394 }
 395
 396 BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
 397                LPDWORD lpdwUsageCount)
 398 {
 399     FIXME("\n");
 400     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 401     return FALSE;
 402 }
 403
 404 BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
 405 {
 406     FIXME("\n");
 407     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 408     return FALSE;
 409 }
 410
 411 BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN)
 412 {
 413     FIXME("\n");
 414     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 415     return FALSE;
 416 }
 417
 418 BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN)
 419 {
 420     FIXME("\n");
 421     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 422     return FALSE;
 423 }
 424
 425 BOOL WINAPI SQLRemoveTranslatorW(LPCWSTR lpszTranslator, LPDWORD lpdwUsageCount)
 426 {
 427     FIXME("\n");
 428     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 429     return FALSE;
 430 }
 431
 432 BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount)
 433 {
 434     FIXME("\n");
 435     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 436     return FALSE;
 437 }
 438
 439 BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode)
 440 {
 441     FIXME("\n");
 442     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 443     return FALSE;
 444 }
 445
 446 BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN)
 447 {
 448     FIXME("\n");
 449     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 450     return FALSE;
 451 }
 452
 453 BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN)
 454 {
 455     FIXME("\n");
 456     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457     return FALSE;
 458 }
 459
 460 BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver)
 461 {
 462     FIXME("\n");
 463     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 464     return FALSE;
 465 }
 466
 467 BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver)
 468 {
 469     FIXME("\n");
 470     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 471     return FALSE;
 472 }
 473
 474 BOOL WINAPI SQLWriteFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
 475                LPCWSTR lpszKeyName, LPCWSTR lpszString)
 476 {
 477     FIXME("\n");
 478     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 479     return FALSE;
 480 }
 481
 482 BOOL WINAPI SQLWriteFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
 483                LPCSTR lpszKeyName, LPCSTR lpszString)
 484 {
 485     FIXME("\n");
 486     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 487     return FALSE;
 488 }
 489
 490 BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
 491                LPCWSTR lpszString, LPCWSTR lpszFilename)
 492 {
 493     FIXME("\n");
 494     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 495     return FALSE;
 496 }
 497
 498 BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
 499                LPCSTR lpszString, LPCSTR lpszFilename)
 500 {
 501     FIXME("\n");
 502     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 503     return FALSE;
 504 }