winecoreaudio: Initial Audio Driver for Mac OS X.
[wine] / 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( "( %ld %ld %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 }