* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#define WIN32_NO_STATUS
-
#include <assert.h>
#include <stdarg.h>
#define COBJMACROS
-#define NONAMELESSUNION
-#include <windef.h>
-#include <winbase.h>
-#include <winreg.h>
-#include <winnls.h>
-#include <wine/debug.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winreg.h"
+#include "winnls.h"
+#include "wine/unicode.h"
+#include "wine/debug.h"
+#include "wine/heap.h"
-#include <odbcinst.h>
+#include "odbcinst.h"
WINE_DEFAULT_DEBUG_CHANNEL(odbc);
/* Registry key names */
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};
+static const WCHAR odbcW[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C',0};
+static const WCHAR odbcini[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','O','D','B','C','I','N','S','T','.','I','N','I','\\',0};
+static const WCHAR odbcdrivers[] = {'O','D','B','C',' ','D','r','i','v','e','r','s',0};
+static const WCHAR odbctranslators[] = {'O','D','B','C',' ','T','r','a','n','s','l','a','t','o','r','s',0};
/* This config mode is known to be process-wide.
* MSDN documentation suggests that the value is hidden somewhere in the registry but I haven't found it yet.
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};
static const WCHAR odbc_error_out_of_mem[] = {'O','u','t',' ','o','f',' ','m','e','m','o','r','y',0};
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};
+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};
+static const WCHAR odbc_error_invalid_dsn[] = {'I','n','v','a','l','i','d',' ','D','S','N',0};
+static const WCHAR odbc_error_load_lib_failed[] = {'L','o','a','d',' ','L','i','b','r','a','r','y',' ','F','a','i','l','e','d',0};
+static const WCHAR odbc_error_request_failed[] = {'R','e','q','u','e','s','t',' ','F','a','i','l','e','d',0};
+static const WCHAR odbc_error_invalid_keyword[] = {'I','n','v','a','l','i','d',' ','k','e','y','w','o','r','d',' ','v','a','l','u','e',0};
/* Push an error onto the error stack, taking care of ranges etc. */
static void push_error(int code, LPCWSTR msg)
num_errors = 0;
}
+static inline WCHAR *heap_strdupAtoW(const char *str)
+{
+ LPWSTR ret = NULL;
+
+ if(str) {
+ DWORD len;
+
+ len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+ ret = heap_alloc(len*sizeof(WCHAR));
+ if(ret)
+ MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
+ }
+
+ return ret;
+}
+
+
BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2)
{
clear_errors();
return TRUE;
}
-BOOL WINAPI SQLConfigDriverW(HWND hwndParent, WORD fRequest, LPCWSTR lpszDriver,
- LPCWSTR lpszArgs, LPWSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
+static HMODULE load_config_driver(const WCHAR *driver)
+{
+ static WCHAR reg_driver[] = {'d','r','i','v','e','r',0};
+ long ret;
+ HMODULE hmod;
+ WCHAR *filename = NULL;
+ DWORD size = 0, type;
+ HKEY hkey;
+
+ if ((ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey)) == ERROR_SUCCESS)
+ {
+ HKEY hkeydriver;
+
+ if ((ret = RegOpenKeyW(hkey, driver, &hkeydriver)) == ERROR_SUCCESS)
+ {
+ ret = RegGetValueW(hkeydriver, NULL, reg_driver, RRF_RT_REG_SZ, &type, NULL, &size);
+ if(ret == ERROR_MORE_DATA)
+ {
+ filename = HeapAlloc(GetProcessHeap(), 0, size);
+ if(!filename)
+ {
+ RegCloseKey(hkeydriver);
+ RegCloseKey(hkey);
+ push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
+
+ return NULL;
+ }
+ ret = RegGetValueW(hkeydriver, NULL, driver, RRF_RT_REG_SZ, &type, filename, &size);
+ }
+
+ RegCloseKey(hkeydriver);
+ }
+
+ RegCloseKey(hkey);
+ }
+
+ if(ret != ERROR_SUCCESS)
+ {
+ HeapFree(GetProcessHeap(), 0, filename);
+ push_error(ODBC_ERROR_INVALID_DSN, odbc_error_invalid_dsn);
+ return NULL;
+ }
+
+ hmod = LoadLibraryW(filename);
+ HeapFree(GetProcessHeap(), 0, filename);
+
+ if(!hmod)
+ push_error(ODBC_ERROR_LOAD_LIB_FAILED, odbc_error_load_lib_failed);
+
+ return hmod;
+}
+
+static BOOL write_config_value(const WCHAR *driver, const WCHAR *args)
+{
+ long ret;
+ HKEY hkey, hkeydriver;
+ WCHAR *name = NULL;
+
+ if(!args)
+ return FALSE;
+
+ if((ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey)) == ERROR_SUCCESS)
+ {
+ if((ret = RegOpenKeyW(hkey, driver, &hkeydriver)) == ERROR_SUCCESS)
+ {
+ WCHAR *divider, *value;
+
+ name = heap_alloc( (strlenW(args) + 1) * sizeof(WCHAR));
+ if(!name)
+ {
+ push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
+ goto fail;
+ }
+ lstrcpyW(name, args);
+
+ divider = strchrW(name,'=');
+ if(!divider)
+ {
+ push_error(ODBC_ERROR_INVALID_KEYWORD_VALUE, odbc_error_invalid_keyword);
+ goto fail;
+ }
+
+ value = divider + 1;
+ *divider = '\0';
+
+ TRACE("Write pair: %s = %s\n", debugstr_w(name), debugstr_w(value));
+ if(RegSetValueExW(hkeydriver, name, 0, REG_SZ, (BYTE*)value,
+ (strlenW(value)+1) * sizeof(WCHAR)) != ERROR_SUCCESS)
+ ERR("Failed to write registry installed key\n");
+ heap_free(name);
+
+ RegCloseKey(hkeydriver);
+ }
+
+ RegCloseKey(hkey);
+ }
+
+ if(ret != ERROR_SUCCESS)
+ push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found);
+
+ return ret == ERROR_SUCCESS;
+
+fail:
+ RegCloseKey(hkeydriver);
+ RegCloseKey(hkey);
+ heap_free(name);
+
+ return FALSE;
+}
+
+BOOL WINAPI SQLConfigDriverW(HWND hwnd, WORD request, LPCWSTR driver,
+ LPCWSTR args, LPWSTR msg, WORD msgmax, WORD *msgout)
{
+ BOOL (WINAPI *pConfigDriverW)(HWND hwnd, WORD request, const WCHAR *driver, const WCHAR *args, const WCHAR *msg, WORD msgmax, WORD *msgout);
+ HMODULE hmod;
+ BOOL funcret = FALSE;
+
clear_errors();
- FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_w(lpszDriver),
- debugstr_w(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
- return TRUE;
+ TRACE("(%p %d %s %s %p %d %p)\n", hwnd, request, debugstr_w(driver),
+ debugstr_w(args), msg, msgmax, msgout);
+
+ if(request == ODBC_CONFIG_DRIVER)
+ {
+ return write_config_value(driver, args);
+ }
+
+ hmod = load_config_driver(driver);
+ if(!hmod)
+ return FALSE;
+
+ pConfigDriverW = (void*)GetProcAddress(hmod, "ConfigDriverW");
+ if(pConfigDriverW)
+ funcret = pConfigDriverW(hwnd, request, driver, args, msg, msgmax, msgout);
+
+ if(!funcret)
+ push_error(ODBC_ERROR_REQUEST_FAILED, odbc_error_request_failed);
+
+ FreeLibrary(hmod);
+
+ return funcret;
}
-BOOL WINAPI SQLConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver,
- LPCSTR lpszArgs, LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
+BOOL WINAPI SQLConfigDriver(HWND hwnd, WORD request, LPCSTR driver,
+ LPCSTR args, LPSTR msg, WORD msgmax, WORD *msgout)
{
+ BOOL (WINAPI *pConfigDriverA)(HWND hwnd, WORD request, const char *driver, const char *args, const char *msg, WORD msgmax, WORD *msgout);
+ HMODULE hmod;
+ WCHAR *driverW;
+ BOOL funcret = FALSE;
+
clear_errors();
- FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest, debugstr_a(lpszDriver),
- debugstr_a(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
- return TRUE;
+ TRACE("(%p %d %s %s %p %d %p)\n", hwnd, request, debugstr_a(driver),
+ debugstr_a(args), msg, msgmax, msgout);
+
+ driverW = heap_strdupAtoW(driver);
+ if(!driverW)
+ {
+ push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
+ return FALSE;
+ }
+ if(request == ODBC_CONFIG_DRIVER)
+ {
+ BOOL ret = FALSE;
+ WCHAR *argsW = heap_strdupAtoW(args);
+ if(argsW)
+ {
+ ret = write_config_value(driverW, argsW);
+ HeapFree(GetProcessHeap(), 0, argsW);
+ }
+ else
+ {
+ push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
+ }
+
+ HeapFree(GetProcessHeap(), 0, driverW);
+
+ return ret;
+ }
+
+ hmod = load_config_driver(driverW);
+ HeapFree(GetProcessHeap(), 0, driverW);
+ if(!hmod)
+ return FALSE;
+
+ pConfigDriverA = (void*)GetProcAddress(hmod, "ConfigDriver");
+ if(pConfigDriverA)
+ funcret = pConfigDriverA(hwnd, request, driver, args, msg, msgmax, msgout);
+
+ if(!funcret)
+ push_error(ODBC_ERROR_REQUEST_FAILED, odbc_error_request_failed);
+
+ FreeLibrary(hmod);
+
+ return funcret;
}
BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPCWSTR lpszDS)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s\n", hwnd, debugstr_w(lpszDS));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPCSTR lpszDS)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s\n", hwnd, debugstr_a(lpszDS));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD cbBufMax, WORD *pcbBufOut)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %p %d %p\n", debugstr_w(lpszInfFile), lpszBuf, cbBufMax, pcbBufOut);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD cbBufMax, WORD *pcbBufOut)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %p %d %p\n", debugstr_a(lpszInfFile), lpszBuf, cbBufMax, pcbBufOut);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode)
{
clear_errors();
+ TRACE("%p\n", pwConfigMode);
if (pwConfigMode)
*pwConfigMode = config_mode;
return TRUE;
BOOL success = FALSE; /* The value we will return */
clear_errors();
+
+ TRACE("%p %d %p\n", lpszBuf, cbBufMax, pcbBufOut);
+
if (!lpszBuf || cbBufMax == 0)
{
push_error(ODBC_ERROR_INVALID_BUFF_LEN, odbc_error_invalid_buff_len);
int size_wbuf = cbBufMax;
LPWSTR wbuf;
WORD size_used;
+
+ TRACE("%p %d %p\n", lpszBuf, cbBufMax, pcbBufOut);
+
wbuf = HeapAlloc(GetProcessHeap(), 0, size_wbuf*sizeof(WCHAR));
if (wbuf)
{
return ret;
}
-int WINAPI SQLGetPrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
- LPCWSTR lpszDefault, LPCWSTR RetBuffer, int cbRetBuffer,
- LPCWSTR lpszFilename)
+static HKEY get_privateprofile_sectionkey(LPCWSTR section, LPCWSTR filename)
{
+ HKEY hkey, hkeyfilename, hkeysection;
+ LONG ret;
+
+ if (RegOpenKeyW(HKEY_CURRENT_USER, odbcW, &hkey))
+ return NULL;
+
+ ret = RegOpenKeyW(hkey, filename, &hkeyfilename);
+ RegCloseKey(hkey);
+ if (ret)
+ return NULL;
+
+ ret = RegOpenKeyW(hkeyfilename, section, &hkeysection);
+ RegCloseKey(hkeyfilename);
+
+ return ret ? NULL : hkeysection;
+}
+
+int WINAPI SQLGetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry,
+ LPCWSTR defvalue, LPWSTR buff, int buff_len, LPCWSTR filename)
+{
+ BOOL usedefault = TRUE;
+ HKEY sectionkey;
+ LONG ret = 0;
+
+ TRACE("%s %s %s %p %d %s\n", debugstr_w(section), debugstr_w(entry),
+ debugstr_w(defvalue), buff, buff_len, debugstr_w(filename));
+
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+
+ if (buff_len <= 0 || !section)
+ return 0;
+
+ if(buff)
+ buff[0] = 0;
+
+ if (!defvalue || !buff)
+ return 0;
+
+ sectionkey = get_privateprofile_sectionkey(section, filename);
+ if (sectionkey)
+ {
+ DWORD type, size;
+
+ if (entry)
+ {
+ size = buff_len * sizeof(*buff);
+ if (RegGetValueW(sectionkey, NULL, entry, RRF_RT_REG_SZ, &type, buff, &size) == ERROR_SUCCESS)
+ {
+ usedefault = FALSE;
+ ret = (size / sizeof(*buff)) - 1;
+ }
+ }
+ else
+ {
+ WCHAR name[MAX_PATH];
+ DWORD index = 0;
+ DWORD namelen;
+
+ usedefault = FALSE;
+
+ memset(buff, 0, buff_len);
+
+ namelen = sizeof(name);
+ while (RegEnumValueW(sectionkey, index, name, &namelen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
+ {
+ if ((ret + namelen+1) > buff_len)
+ break;
+
+ lstrcpyW(buff+ret, name);
+ ret += namelen+1;
+ namelen = sizeof(name);
+ index++;
+ }
+ }
+
+ RegCloseKey(sectionkey);
+ }
+ else
+ usedefault = entry != NULL;
+
+ if (usedefault)
+ {
+ lstrcpynW(buff, defvalue, buff_len);
+ ret = lstrlenW(buff);
+ }
+
+ return ret;
}
-int WINAPI SQLGetPrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
- LPCSTR lpszDefault, LPCSTR RetBuffer, int cbRetBuffer,
- LPCSTR lpszFilename)
+int WINAPI SQLGetPrivateProfileString(LPCSTR section, LPCSTR entry,
+ LPCSTR defvalue, LPSTR buff, int buff_len, LPCSTR filename)
{
+ WCHAR *sectionW, *filenameW;
+ BOOL usedefault = TRUE;
+ HKEY sectionkey;
+ LONG ret = 0;
+
+ TRACE("%s %s %s %p %d %s\n", debugstr_a(section), debugstr_a(entry),
+ debugstr_a(defvalue), buff, buff_len, debugstr_a(filename));
+
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+
+ if (buff_len <= 0)
+ return 0;
+
+ if (buff)
+ buff[0] = 0;
+
+ if (!section || !defvalue || !buff)
+ return 0;
+
+ sectionW = heap_strdupAtoW(section);
+ filenameW = heap_strdupAtoW(filename);
+
+ sectionkey = get_privateprofile_sectionkey(sectionW, filenameW);
+
+ heap_free(sectionW);
+ heap_free(filenameW);
+
+ if (sectionkey)
+ {
+ DWORD type, size;
+
+ if (entry)
+ {
+ size = buff_len * sizeof(*buff);
+ if (RegGetValueA(sectionkey, NULL, entry, RRF_RT_REG_SZ, &type, buff, &size) == ERROR_SUCCESS)
+ {
+ usedefault = FALSE;
+ ret = (size / sizeof(*buff)) - 1;
+ }
+ }
+ else
+ {
+ char name[MAX_PATH] = {0};
+ DWORD index = 0;
+ DWORD namelen;
+
+ usedefault = FALSE;
+
+ memset(buff, 0, buff_len);
+
+ namelen = sizeof(name);
+ while (RegEnumValueA(sectionkey, index, name, &namelen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
+ {
+ if ((ret + namelen+1) > buff_len)
+ break;
+
+ lstrcpyA(buff+ret, name);
+
+ ret += namelen+1;
+ namelen = sizeof(name);
+ index++;
+ }
+ }
+
+ RegCloseKey(sectionkey);
+ }
+ else
+ usedefault = entry != NULL;
+
+ if (usedefault)
+ {
+ lstrcpynA(buff, defvalue, buff_len);
+ ret = strlen(buff);
+ }
+
+ return ret;
}
BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax,
WORD *pcbPathOut, DWORD *pvOption)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s %d %p %p %d %p %p\n", hwndParent, debugstr_w(lpszName), cbNameMax,
+ pcbNameOut, lpszPath, cbPathMax, pcbPathOut, pvOption);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD *pcbPathOut, DWORD *pvOption)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s %d %p %p %d %p %p\n", hwndParent, debugstr_a(lpszName), cbNameMax,
+ pcbNameOut, lpszPath, cbPathMax, pcbPathOut, pvOption);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
}
+static void write_registry_values(const WCHAR *regkey, const WCHAR *driver, const WCHAR *path_in, WCHAR *path,
+ DWORD *usage_count)
+{
+ static const WCHAR installed[] = {'I','n','s','t','a','l','l','e','d',0};
+ static const WCHAR slash[] = {'\\', 0};
+ static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
+ static const WCHAR setupW[] = {'S','e','t','u','p',0};
+ static const WCHAR translator[] = {'T','r','a','n','s','l','a','t','o','r',0};
+ HKEY hkey, hkeydriver;
+
+ if (RegCreateKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS)
+ {
+ if (RegCreateKeyW(hkey, regkey, &hkeydriver) == ERROR_SUCCESS)
+ {
+ if(RegSetValueExW(hkeydriver, driver, 0, REG_SZ, (BYTE*)installed, sizeof(installed)) != ERROR_SUCCESS)
+ ERR("Failed to write registry installed key\n");
+
+ RegCloseKey(hkeydriver);
+ }
+
+ if (RegCreateKeyW(hkey, driver, &hkeydriver) == ERROR_SUCCESS)
+ {
+ WCHAR entry[1024];
+ const WCHAR *p;
+ DWORD usagecount = 0;
+ DWORD type, size;
+
+ /* Skip name entry */
+ p = driver;
+ p += lstrlenW(p) + 1;
+
+ if (!path_in)
+ GetSystemDirectoryW(path, MAX_PATH);
+ else
+ lstrcpyW(path, path_in);
+
+ /* Store Usage */
+ size = sizeof(usagecount);
+ RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size);
+ TRACE("Usage count %d\n", usagecount);
+
+ for (; *p; p += lstrlenW(p) + 1)
+ {
+ WCHAR *divider = strchrW(p,'=');
+
+ if (divider)
+ {
+ WCHAR *value;
+ int len;
+
+ /* Write pair values to the registry. */
+ lstrcpynW(entry, p, divider - p + 1);
+
+ divider++;
+ TRACE("Writing pair %s,%s\n", debugstr_w(entry), debugstr_w(divider));
+
+ /* Driver, Setup, Translator entries use the system path unless a path is specified. */
+ if(lstrcmpiW(driverW, entry) == 0 || lstrcmpiW(setupW, entry) == 0 ||
+ lstrcmpiW(translator, entry) == 0)
+ {
+ len = lstrlenW(path) + lstrlenW(slash) + lstrlenW(divider) + 1;
+ value = heap_alloc(len * sizeof(WCHAR));
+ if(!value)
+ {
+ ERR("Out of memory\n");
+ return;
+ }
+
+ lstrcpyW(value, path);
+ lstrcatW(value, slash);
+ lstrcatW(value, divider);
+ }
+ else
+ {
+ len = lstrlenW(divider) + 1;
+ value = heap_alloc(len * sizeof(WCHAR));
+ lstrcpyW(value, divider);
+ }
+
+ if (RegSetValueExW(hkeydriver, entry, 0, REG_SZ, (BYTE*)value,
+ (lstrlenW(value)+1)*sizeof(WCHAR)) != ERROR_SUCCESS)
+ ERR("Failed to write registry data %s %s\n", debugstr_w(entry), debugstr_w(value));
+ heap_free(value);
+ }
+ else
+ {
+ ERR("No pair found. %s\n", debugstr_w(p));
+ break;
+ }
+ }
+
+ /* Set Usage Count */
+ usagecount++;
+ if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&usagecount, sizeof(usagecount)) != ERROR_SUCCESS)
+ ERR("Failed to write registry UsageCount key\n");
+
+ if (usage_count)
+ *usage_count = usagecount;
+
+ RegCloseKey(hkeydriver);
+ }
+
+ RegCloseKey(hkey);
+ }
+}
+
BOOL WINAPI SQLInstallDriverExW(LPCWSTR lpszDriver, LPCWSTR lpszPathIn,
LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
WORD fRequest, LPDWORD lpdwUsageCount)
{
UINT len;
- LPCWSTR p;
WCHAR path[MAX_PATH];
clear_errors();
debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
fRequest, lpdwUsageCount);
- for (p = lpszDriver; *p; p += lstrlenW(p) + 1)
- TRACE("%s\n", debugstr_w(p));
+ write_registry_values(odbcdrivers, lpszDriver, lpszPathIn, path, lpdwUsageCount);
- len = GetSystemDirectoryW(path, MAX_PATH);
+ len = lstrlenW(path);
if (pcbPathOut)
*pcbPathOut = len;
- len = GetSystemDirectoryW(path, MAX_PATH);
-
if (lpszPathOut && cbPathOutMax > len)
{
lstrcpyW(lpszPathOut, path);
LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
WORD fRequest, LPDWORD lpdwUsageCount)
{
- LPCSTR p;
LPWSTR driver, pathin;
WCHAR pathout[MAX_PATH];
BOOL ret;
debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
fRequest, lpdwUsageCount);
- for (p = lpszDriver; *p; p += lstrlenA(p) + 1)
- TRACE("%s\n", debugstr_a(p));
-
driver = SQLInstall_strdup_multi(lpszDriver);
pathin = SQLInstall_strdup(lpszPathIn);
LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s %s %s\n", hwndParent, debugstr_w(lpszInfFile),
+ debugstr_w(lpszSrcPath), debugstr_w(lpszDrivers));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
LPCSTR lpszSrcPath, LPCSTR lpszDrivers)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p %s %s %s\n", hwndParent, debugstr_a(lpszInfFile),
+ debugstr_a(lpszSrcPath), debugstr_a(lpszDrivers));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD fRequest, LPDWORD lpdwUsageCount)
{
UINT len;
- LPCWSTR p;
WCHAR path[MAX_PATH];
clear_errors();
debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
fRequest, lpdwUsageCount);
- for (p = lpszTranslator; *p; p += lstrlenW(p) + 1)
- TRACE("%s\n", debugstr_w(p));
+ write_registry_values(odbctranslators, lpszTranslator, lpszPathIn, path, lpdwUsageCount);
- len = GetSystemDirectoryW(path, MAX_PATH);
+ len = lstrlenW(path);
if (pcbPathOut)
*pcbPathOut = len;
BOOL WINAPI SQLManageDataSources(HWND hwnd)
{
clear_errors();
- FIXME("\n");
+ FIXME("%p\n", hwnd);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
SQLRETURN WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPCWSTR szErrorMsg)
{
- FIXME("\n");
+ FIXME("%u %s\n", fErrorCode, debugstr_w(szErrorMsg));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
SQLRETURN WINAPI SQLPostInstallerError(DWORD fErrorCode, LPCSTR szErrorMsg)
{
- FIXME("\n");
+ FIXME("%u %s\n", fErrorCode, debugstr_a(szErrorMsg));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD *pcbString)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s %s %s %d %p\n", debugstr_w(lpszFileName), debugstr_w(lpszAppName),
+ debugstr_w(lpszKeyName), debugstr_w(lpszString), cbString, pcbString);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WORD *pcbString)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s %s %s %d %p\n", debugstr_a(lpszFileName), debugstr_a(lpszAppName),
+ debugstr_a(lpszKeyName), debugstr_a(lpszString), cbString, pcbString);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
return FALSE;
}
-BOOL WINAPI SQLRemoveDriverW(LPCWSTR lpszDriver, BOOL fRemoveDSN,
- LPDWORD lpdwUsageCount)
+BOOL WINAPI SQLRemoveDriverW(LPCWSTR drivername, BOOL remove_dsn, LPDWORD usage_count)
{
+ HKEY hkey;
+ DWORD usagecount = 1;
+
clear_errors();
- FIXME("stub\n");
- if (lpdwUsageCount) *lpdwUsageCount = 1;
+ TRACE("%s %d %p\n", debugstr_w(drivername), remove_dsn, usage_count);
+
+ if (RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS)
+ {
+ HKEY hkeydriver;
+
+ if (RegOpenKeyW(hkey, drivername, &hkeydriver) == ERROR_SUCCESS)
+ {
+ DWORD size, type;
+ DWORD count;
+
+ size = sizeof(usagecount);
+ RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size);
+ TRACE("Usage count %d\n", usagecount);
+ count = usagecount - 1;
+ if (count)
+ {
+ if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&count, sizeof(count)) != ERROR_SUCCESS)
+ ERR("Failed to write registry UsageCount key\n");
+ }
+
+ RegCloseKey(hkeydriver);
+ }
+
+ if (usagecount)
+ usagecount--;
+
+ if (!usagecount)
+ {
+ if (RegDeleteKeyW(hkey, drivername) != ERROR_SUCCESS)
+ ERR("Failed to delete registry key: %s\n", debugstr_w(drivername));
+
+ if (RegOpenKeyW(hkey, odbcdrivers, &hkeydriver) == ERROR_SUCCESS)
+ {
+ if(RegDeleteValueW(hkeydriver, drivername) != ERROR_SUCCESS)
+ ERR("Failed to delete registry value: %s\n", debugstr_w(drivername));
+ RegCloseKey(hkeydriver);
+ }
+ }
+
+ RegCloseKey(hkey);
+ }
+
+ if (usage_count)
+ *usage_count = usagecount;
+
return TRUE;
}
BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
LPDWORD lpdwUsageCount)
{
+ WCHAR *driver;
+ BOOL ret;
+
clear_errors();
- FIXME("stub\n");
- if (lpdwUsageCount) *lpdwUsageCount = 1;
- return TRUE;
+ TRACE("%s %d %p\n", debugstr_a(lpszDriver), fRemoveDSN, lpdwUsageCount);
+
+ driver = SQLInstall_strdup(lpszDriver);
+
+ ret = SQLRemoveDriverW(driver, fRemoveDSN, lpdwUsageCount);
+
+ HeapFree(GetProcessHeap(), 0, driver);
+ return ret;
}
BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
{
clear_errors();
- FIXME("stub\n");
+ FIXME("%p\n", pdwUsageCount);
if (pdwUsageCount) *pdwUsageCount = 1;
return TRUE;
}
BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s\n", debugstr_w(lpszDSN));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s\n", debugstr_a(lpszDSN));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
-BOOL WINAPI SQLRemoveTranslatorW(LPCWSTR lpszTranslator, LPDWORD lpdwUsageCount)
+BOOL WINAPI SQLRemoveTranslatorW(const WCHAR *translator, DWORD *usage_count)
{
+ HKEY hkey;
+ DWORD usagecount = 1;
+ BOOL ret = TRUE;
+
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ TRACE("%s %p\n", debugstr_w(translator), usage_count);
+
+ if (RegOpenKeyW(HKEY_LOCAL_MACHINE, odbcini, &hkey) == ERROR_SUCCESS)
+ {
+ HKEY hkeydriver;
+
+ if (RegOpenKeyW(hkey, translator, &hkeydriver) == ERROR_SUCCESS)
+ {
+ DWORD size, type;
+ DWORD count;
+
+ size = sizeof(usagecount);
+ RegGetValueA(hkeydriver, NULL, "UsageCount", RRF_RT_DWORD, &type, &usagecount, &size);
+ TRACE("Usage count %d\n", usagecount);
+ count = usagecount - 1;
+ if (count)
+ {
+ if (RegSetValueExA(hkeydriver, "UsageCount", 0, REG_DWORD, (BYTE*)&count, sizeof(count)) != ERROR_SUCCESS)
+ ERR("Failed to write registry UsageCount key\n");
+ }
+
+ RegCloseKey(hkeydriver);
+ }
+
+ if (usagecount)
+ usagecount--;
+
+ if (!usagecount)
+ {
+ if(RegDeleteKeyW(hkey, translator) != ERROR_SUCCESS)
+ {
+ push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found);
+ WARN("Failed to delete registry key: %s\n", debugstr_w(translator));
+ ret = FALSE;
+ }
+
+ if (ret && RegOpenKeyW(hkey, odbctranslators, &hkeydriver) == ERROR_SUCCESS)
+ {
+ if(RegDeleteValueW(hkeydriver, translator) != ERROR_SUCCESS)
+ {
+ push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found);
+ WARN("Failed to delete registry key: %s\n", debugstr_w(translator));
+ ret = FALSE;
+ }
+
+ RegCloseKey(hkeydriver);
+ }
+ }
+
+ RegCloseKey(hkey);
+ }
+
+ if (ret && usage_count)
+ *usage_count = usagecount;
+
+ return ret;
}
BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount)
{
+ WCHAR *translator;
+ BOOL ret;
+
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ TRACE("%s %p\n", debugstr_a(lpszTranslator), lpdwUsageCount);
+
+ translator = SQLInstall_strdup(lpszTranslator);
+ ret = SQLRemoveTranslatorW(translator, lpdwUsageCount);
+
+ HeapFree(GetProcessHeap(), 0, translator);
+ return ret;
}
BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode)
{
clear_errors();
+ TRACE("%u\n", wConfigMode);
+
if (wConfigMode > ODBC_SYSTEM_DSN)
{
push_error(ODBC_ERROR_INVALID_PARAM_SEQUENCE, odbc_error_invalid_param_sequence);
BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s\n", debugstr_w(lpszDSN));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s\n", debugstr_a(lpszDSN));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s\n", debugstr_w(lpszDSN), debugstr_w(lpszDriver));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s\n", debugstr_a(lpszDSN), debugstr_a(lpszDriver));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
LPCWSTR lpszKeyName, LPCWSTR lpszString)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s %s %s\n", debugstr_w(lpszFileName), debugstr_w(lpszAppName),
+ debugstr_w(lpszKeyName), debugstr_w(lpszString));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
LPCSTR lpszKeyName, LPCSTR lpszString)
{
clear_errors();
- FIXME("\n");
+ FIXME("%s %s %s %s\n", debugstr_a(lpszFileName), debugstr_a(lpszAppName),
+ debugstr_a(lpszKeyName), debugstr_a(lpszString));
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
LPCWSTR lpszString, LPCWSTR lpszFilename)
{
+ LONG ret;
+ HKEY hkey;
+
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ TRACE("%s %s %s %s\n", debugstr_w(lpszSection), debugstr_w(lpszEntry),
+ debugstr_w(lpszString), debugstr_w(lpszFilename));
+
+ if(!lpszFilename || !*lpszFilename)
+ {
+ push_error(ODBC_ERROR_INVALID_STR, odbc_error_invalid_param_string);
+ return FALSE;
+ }
+
+ if ((ret = RegCreateKeyW(HKEY_CURRENT_USER, odbcW, &hkey)) == ERROR_SUCCESS)
+ {
+ HKEY hkeyfilename;
+
+ if ((ret = RegCreateKeyW(hkey, lpszFilename, &hkeyfilename)) == ERROR_SUCCESS)
+ {
+ HKEY hkey_section;
+
+ if ((ret = RegCreateKeyW(hkeyfilename, lpszSection, &hkey_section)) == ERROR_SUCCESS)
+ {
+ ret = RegSetValueExW(hkey_section, lpszEntry, 0, REG_SZ, (BYTE*)lpszString, (lstrlenW(lpszString)+1)*sizeof(WCHAR));
+ RegCloseKey(hkey_section);
+ }
+
+ RegCloseKey(hkeyfilename);
+ }
+
+ RegCloseKey(hkey);
+ }
+
+ return ret == ERROR_SUCCESS;
}
BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
LPCSTR lpszString, LPCSTR lpszFilename)
{
+ BOOL ret;
+ WCHAR *sect, *entry, *string, *file;
clear_errors();
- FIXME("\n");
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
+ TRACE("%s %s %s %s\n", lpszSection, lpszEntry, lpszString, lpszFilename);
+
+ sect = heap_strdupAtoW(lpszSection);
+ entry = heap_strdupAtoW(lpszEntry);
+ string = heap_strdupAtoW(lpszString);
+ file = heap_strdupAtoW(lpszFilename);
+
+ ret = SQLWritePrivateProfileStringW(sect, entry, string, file);
+
+ heap_free(sect);
+ heap_free(entry);
+ heap_free(string);
+ heap_free(file);
+
+ return ret;
}
projects / reactos.git / blobdiff