?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32: Simplify CommandLineToArgvW() a bit.
[wine.git] / dlls / odbccp32 / odbccp32.c
blobfb4ea2c7ea19c818673ff6ea319941b403d2acd4
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("stub\n");
848 if (lpdwUsageCount) *lpdwUsageCount = 1;
849 return TRUE;
850 }
851
852 BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
853 LPDWORD lpdwUsageCount)
854 {
855 clear_errors();
856 FIXME("stub\n");
857 if (lpdwUsageCount) *lpdwUsageCount = 1;
858 return TRUE;
859 }
860
861 BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
862 {
863 clear_errors();
864 FIXME("stub\n");
865 if (pdwUsageCount) *pdwUsageCount = 1;
866 return TRUE;
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 }
Windows API implementation