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