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