[ros-diffs] [winesync] 26076: Autosyncing with Wine HEAD

Author: winesync
Date: Wed Mar 14 15:48:32 2007
New Revision: 26076
URL: http://svn.reactos.org/svn/reactos?rev=26076&view=rev
Log:
Autosyncing with Wine HEAD
Added:
    trunk/reactos/dll/win32/odbccp32/odbccp32.c   (with props)
    trunk/reactos/dll/win32/odbccp32/odbccp32.rbuild   (with props)
    trunk/reactos/dll/win32/odbccp32/odbccp32.spec   (with props)
Modified:
    trunk/reactos/baseaddress.rbuild
Modified: trunk/reactos/baseaddress.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/baseaddress.rbuild?rev=260…
==============================================================================
--- trunk/reactos/baseaddress.rbuild (original)
+++ trunk/reactos/baseaddress.rbuild Wed Mar 14 15:48:32 2007
@@ -94,6 +94,7 @@
   <property name="BASEADDRESS_LSASRV" value="0x76540000" />
   <property name="BASEADDRESS_MIDIMAP" value="0x76600000" />
   <property name="BASEADDRESS_ODBC32" value="0x76660000" />
+  <property name="BASEADDRESS_ODBCCP32" value="0x76380000" />
   <property name="BASEADDRESS_WAVEMAP" value="0x76610000" />
   <property name="BASEADDRESS_MPR" value="0x76620000" />
   <property name="BASEADDRESS_SETUPAPI" value="0x76660000" />
Added: trunk/reactos/dll/win32/odbccp32/odbccp32.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/odbccp32/odbccp3…
==============================================================================
--- trunk/reactos/dll/win32/odbccp32/odbccp32.c (added)
+++ trunk/reactos/dll/win32/odbccp32/odbccp32.c Wed Mar 14 15:48:32 2007
@@ -1,0 +1,974 @@
+/*
+ * Implementation of the ODBC driver installer
+ *
+ * Copyright 2005 Mike McCormack for CodeWeavers
+ * Copyright 2005 Hans Leidekker
+ * Copyright 2007 Bill Medland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#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 "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};
+
+/* 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.
+ * Although both the registry and the ODBC.ini files appear to be maintained together
they are not maintained automatically through the registry's IniFileMapping.
+ */
+static UWORD config_mode = ODBC_BOTH_DSN;
+
+/* MSDN documentation suggests that the error subsystem handles errors 1 to 8
+ * only and experimentation (Windows 2000) shows that the errors are process-
+ * wide so go for the simple solution; static arrays.
+ */
+static int num_errors;
+static int error_code[8];
+static const WCHAR *error_msg[8];
+static const WCHAR odbc_error_general_err[] =
{'G','e','n','e','r','a','l','
','e','r','r','o','r',0};
+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};
+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};
+
+/* Push an error onto the error stack, taking care of ranges etc. */
+static void push_error(int code, LPCWSTR msg)
+{
+    if (num_errors < sizeof error_code/sizeof error_code[0])
+    {
+        error_code[num_errors] = code;
+        error_msg[num_errors] = msg;
+        num_errors++;
+    }
+}
+
+/* Clear the error stack */
+static void clear_errors(void)
+{
+    num_errors = 0;
+}
+
+BOOL WINAPI ODBCCPlApplet( LONG i, LONG j, LONG * p1, LONG * p2)
+{
+    clear_errors();
+    FIXME( "( %d %d %p %p) : stub!\n", i, j, p1, p2);
+    return FALSE;
+}
+
+static LPWSTR SQLInstall_strdup_multi(LPCSTR str)
+{
+    LPCSTR p;
+    LPWSTR ret = NULL;
+    DWORD len;
+
+    if (!str)
+        return ret;
+
+    for (p = str; *p; p += lstrlenA(p) + 1)
+        ;
+
+    len = MultiByteToWideChar(CP_ACP, 0, str, p - str, NULL, 0 );
+    ret = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
+    MultiByteToWideChar(CP_ACP, 0, str, p - str, ret, len );
+    ret[len] = 0;
+
+    return ret;
+}
+
+static LPWSTR SQLInstall_strdup(LPCSTR str)
+{
+    DWORD len;
+    LPWSTR ret = NULL;
+
+    if (!str)
+        return ret;
+
+    len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0 );
+    ret = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
+    MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len );
+
+    return ret;
+}
+
+/* Convert the wide string or zero-length-terminated list of wide strings to a
+ * narrow string or zero-length-terminated list of narrow strings.
+ * Do not try to emulate windows undocumented excesses (e.g. adding a third \0
+ * to a list)
+ * Arguments
+ *   mode Indicates the sort of string.
+ *     1 denotes that the buffers contain strings terminated by a single nul
+ *       character
+ *     2 denotes that the buffers contain zero-length-terminated lists
+ *       (frequently erroneously referred to as double-null-terminated)
+ *   buffer The narrow-character buffer into which to place the result.  This
+ *          must be a non-null pointer to the first element of a buffer whose
+ *          length is passed in buffer_length.
+ *   str The wide-character buffer containing the string or list of strings to
+ *       be converted.  str_length defines how many wide characters in the
+ *       buffer are to be converted, including all desired terminating nul
+ *       characters.
+ *   str_length Effective length of str
+ *   buffer_length Length of buffer
+ *   returned_length A pointer to a variable that will receive the number of
+ *                   narrow characters placed into the buffer.  This pointer
+ *                   may be NULL.
+ */
+static BOOL SQLInstall_narrow(int mode, LPSTR buffer, LPCWSTR str, WORD str_length, WORD
buffer_length, WORD *returned_length)
+{
+    LPSTR pbuf; /* allows us to allocate a temporary buffer only if needed */
+    int len; /* Length of the converted list */
+    BOOL success = FALSE;
+    assert(mode == 1 || mode == 2);
+    assert(buffer_length);
+    len = WideCharToMultiByte(CP_ACP, 0, str, str_length, 0, 0, NULL, NULL);
+    if (len > 0)
+    {
+        if (len > buffer_length)
+        {
+            pbuf = HeapAlloc(GetProcessHeap(), 0, len);
+        }
+        else
+        {
+            pbuf = buffer;
+        }
+        len = WideCharToMultiByte(CP_ACP, 0, str, str_length, pbuf, len, NULL, NULL);
+        if (len > 0)
+        {
+            if (pbuf != buffer)
+            {
+                if (buffer_length > (mode - 1))
+                {
+                    memcpy (buffer, pbuf, buffer_length-mode);
+                    *(buffer+buffer_length-mode) = '\0';
+                }
+                *(buffer+buffer_length-1) = '\0';
+            }
+            if (returned_length)
+            {
+                *returned_length = pbuf == buffer ? len : buffer_length;
+            }
+            success = TRUE;
+        }
+        else
+        {
+            ERR("transferring wide to narrow\n");
+        }
+        if (pbuf != buffer)
+        {
+            HeapFree(GetProcessHeap(), 0, pbuf);
+        }
+    }
+    else
+    {
+        ERR("measuring wide to narrow\n");
+    }
+    return success;
+}
+
+BOOL WINAPI SQLConfigDataSourceW(HWND hwndParent, WORD fRequest,
+               LPCWSTR lpszDriver, LPCWSTR lpszAttributes)
+{
+    LPCWSTR p;
+
+    clear_errors();
+    FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_w(lpszDriver),
+          debugstr_w(lpszAttributes));
+
+    for (p = lpszAttributes; *p; p += lstrlenW(p) + 1)
+        FIXME("%s\n", debugstr_w(p));
+
+    return TRUE;
+}
+
+BOOL WINAPI SQLConfigDataSource(HWND hwndParent, WORD fRequest,
+               LPCSTR lpszDriver, LPCSTR lpszAttributes)
+{
+    FIXME("%p %d %s %s\n", hwndParent, fRequest, debugstr_a(lpszDriver),
+          debugstr_a(lpszAttributes));
+    clear_errors();
+    return TRUE;
+}
+
+BOOL WINAPI SQLConfigDriverW(HWND hwndParent, WORD fRequest, LPCWSTR lpszDriver,
+               LPCWSTR lpszArgs, LPWSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
+{
+    clear_errors();
+    FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest,
debugstr_w(lpszDriver),
+          debugstr_w(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
+    return TRUE;
+}
+
+BOOL WINAPI SQLConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver,
+               LPCSTR lpszArgs, LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
+{
+    clear_errors();
+    FIXME("(%p %d %s %s %p %d %p)\n", hwndParent, fRequest,
debugstr_a(lpszDriver),
+          debugstr_a(lpszArgs), lpszMsg, cbMsgMax, pcbMsgOut);
+    return TRUE;
+}
+
+BOOL WINAPI SQLCreateDataSourceW(HWND hwnd, LPCWSTR lpszDS)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLCreateDataSource(HWND hwnd, LPCSTR lpszDS)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLGetAvailableDriversW(LPCWSTR lpszInfFile, LPWSTR lpszBuf,
+               WORD cbBufMax, WORD *pcbBufOut)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLGetAvailableDrivers(LPCSTR lpszInfFile, LPSTR lpszBuf,
+               WORD cbBufMax, WORD *pcbBufOut)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLGetConfigMode(UWORD *pwConfigMode)
+{
+    clear_errors();
+    if (pwConfigMode)
+        *pwConfigMode = config_mode;
+    return TRUE;
+}
+
+/* This is implemented sensibly rather than according to exact conformance to
Microsoft's buggy implementations
+ * e.g. The Microsoft one occasionally actually adds a third nul character (possibly
beyond the buffer).
+ * 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.
+ */
+BOOL WINAPI SQLGetInstalledDriversW(LPWSTR lpszBuf, WORD cbBufMax,
+               WORD *pcbBufOut)
+{
+    HKEY hDrivers; /* Registry handle to the Drivers key */
+    LONG reg_ret; /* Return code from registry functions */
+    BOOL success = FALSE; /* The value we will return */
+
+    clear_errors();
+    if (!lpszBuf || cbBufMax == 0)
+    {
+        push_error(ODBC_ERROR_INVALID_BUFF_LEN, odbc_error_invalid_buff_len);
+    }
+    else if ((reg_ret = RegOpenKeyExW (HKEY_LOCAL_MACHINE /* The drivers does not depend
on the config mode */,
+            drivers_key, 0, KEY_READ /* Maybe overkill */,
+            &hDrivers)) == ERROR_SUCCESS)
+    {
+        DWORD index = 0;
+        cbBufMax--;
+        success = TRUE;
+        while (cbBufMax > 0)
+        {
+            DWORD size_name;
+            size_name = cbBufMax;
+            if ((reg_ret = RegEnumValueW(hDrivers, index, lpszBuf, &size_name, NULL,
NULL, NULL, NULL)) == ERROR_SUCCESS)
+            {
+                index++;
+                assert (size_name < cbBufMax && *(lpszBuf + size_name) == 0);
+                size_name++;
+                cbBufMax-= size_name;
+                lpszBuf+=size_name;
+            }
+            else
+            {
+                if (reg_ret != ERROR_NO_MORE_ITEMS)
+                {
+                    success = FALSE;
+                    push_error(ODBC_ERROR_GENERAL_ERR, odbc_error_general_err);
+                }
+                break;
+            }
+        }
+        *lpszBuf = 0;
+        if ((reg_ret = RegCloseKey (hDrivers)) != ERROR_SUCCESS)
+            TRACE ("Error %d closing ODBC Drivers key\n", reg_ret);
+    }
+    else
+    {
+        /* MSDN states that it returns failure with COMPONENT_NOT_FOUND in this case.
+         * Version 3.525.1117.0 (Windows 2000) does not; it actually returns success.
+         * I doubt if it will actually be an issue.
+         */
+        push_error(ODBC_ERROR_COMPONENT_NOT_FOUND, odbc_error_component_not_found);
+    }
+    return success;
+}
+
+BOOL WINAPI SQLGetInstalledDrivers(LPSTR lpszBuf, WORD cbBufMax,
+               WORD *pcbBufOut)
+{
+    BOOL ret;
+    int size_wbuf = cbBufMax;
+    LPWSTR wbuf;
+    WORD size_used;
+    wbuf = HeapAlloc(GetProcessHeap(), 0, size_wbuf*sizeof(WCHAR));
+    if (wbuf)
+    {
+        ret = SQLGetInstalledDriversW(wbuf, size_wbuf, &size_used);
+        if (ret)
+        {
+            if (!(ret = SQLInstall_narrow(2, lpszBuf, wbuf, size_used, cbBufMax,
pcbBufOut)))
+            {
+                push_error(ODBC_ERROR_GENERAL_ERR, odbc_error_general_err);
+            }
+        }
+        HeapFree(GetProcessHeap(), 0, wbuf);
+        /* ignore failure; we have achieved the aim */
+    }
+    else
+    {
+        push_error(ODBC_ERROR_OUT_OF_MEM, odbc_error_out_of_mem);
+        ret = FALSE;
+    }
+    return ret;
+}
+
+int WINAPI SQLGetPrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
+               LPCWSTR lpszDefault, LPCWSTR RetBuffer, int cbRetBuffer,
+               LPCWSTR lpszFilename)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+int WINAPI SQLGetPrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
+               LPCSTR lpszDefault, LPCSTR RetBuffer, int cbRetBuffer,
+               LPCSTR lpszFilename)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLGetTranslatorW(HWND hwndParent, LPWSTR lpszName, WORD cbNameMax,
+               WORD *pcbNameOut, LPWSTR lpszPath, WORD cbPathMax,
+               WORD *pcbPathOut, DWORD *pvOption)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLGetTranslator(HWND hwndParent, LPSTR lpszName, WORD cbNameMax,
+               WORD *pcbNameOut, LPSTR lpszPath, WORD cbPathMax,
+               WORD *pcbPathOut, DWORD *pvOption)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLInstallDriverW(LPCWSTR lpszInfFile, LPCWSTR lpszDriver,
+               LPWSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
+{
+    DWORD usage;
+
+    clear_errors();
+    TRACE("%s %s %p %d %p\n", debugstr_w(lpszInfFile),
+          debugstr_w(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
+
+    if (lpszInfFile)
+        return FALSE;
+
+    return SQLInstallDriverExW(lpszDriver, NULL, lpszPath, cbPathMax,
+                               pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
+}
+
+BOOL WINAPI SQLInstallDriver(LPCSTR lpszInfFile, LPCSTR lpszDriver,
+               LPSTR lpszPath, WORD cbPathMax, WORD * pcbPathOut)
+{
+    DWORD usage;
+
+    clear_errors();
+    TRACE("%s %s %p %d %p\n", debugstr_a(lpszInfFile),
+          debugstr_a(lpszDriver), lpszPath, cbPathMax, pcbPathOut);
+
+    if (lpszInfFile)
+        return FALSE;
+
+    return SQLInstallDriverEx(lpszDriver, NULL, lpszPath, cbPathMax,
+                              pcbPathOut, ODBC_INSTALL_COMPLETE, &usage);
+}
+
+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();
+    TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszDriver),
+          debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
+          fRequest, lpdwUsageCount);
+
+    for (p = lpszDriver; *p; p += lstrlenW(p) + 1)
+        TRACE("%s\n", debugstr_w(p));
+
+    len = GetSystemDirectoryW(path, MAX_PATH);
+
+    if (pcbPathOut)
+        *pcbPathOut = len;
+
+    len = GetSystemDirectoryW(path, MAX_PATH);
+
+    if (lpszPathOut && cbPathOutMax > len)
+    {
+        lstrcpyW(lpszPathOut, path);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+BOOL WINAPI SQLInstallDriverEx(LPCSTR lpszDriver, LPCSTR lpszPathIn,
+               LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
+               WORD fRequest, LPDWORD lpdwUsageCount)
+{
+    LPCSTR p;
+    LPWSTR driver, pathin;
+    WCHAR pathout[MAX_PATH];
+    BOOL ret;
+    WORD cbOut = 0;
+
+    clear_errors();
+    TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszDriver),
+          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);
+
+    ret = SQLInstallDriverExW(driver, pathin, pathout, MAX_PATH, &cbOut,
+                              fRequest, lpdwUsageCount);
+    if (ret)
+    {
+        int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
+                                       0, NULL, NULL);
+        if (len)
+        {
+            if (pcbPathOut)
+                *pcbPathOut = len - 1;
+
+            if (!lpszPathOut || cbPathOutMax < len)
+            {
+                ret = FALSE;
+                goto out;
+            }
+            len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
+                                       cbPathOutMax, NULL, NULL);
+        }
+    }
+
+out:
+    HeapFree(GetProcessHeap(), 0, driver);
+    HeapFree(GetProcessHeap(), 0, pathin);
+    return ret;
+}
+
+BOOL WINAPI SQLInstallDriverManagerW(LPWSTR lpszPath, WORD cbPathMax,
+               WORD *pcbPathOut)
+{
+    UINT len;
+    WCHAR path[MAX_PATH];
+
+    clear_errors();
+    TRACE("(%p %d %d)\n", lpszPath, cbPathMax, *pcbPathOut);
+
+    len = GetSystemDirectoryW(path, MAX_PATH);
+
+    if (pcbPathOut)
+        *pcbPathOut = len;
+
+    if (lpszPath && cbPathMax > len)
+    {
+       lstrcpyW(lpszPath, path);
+       return TRUE;
+    }
+    return FALSE;
+}
+
+BOOL WINAPI SQLInstallDriverManager(LPSTR lpszPath, WORD cbPathMax,
+               WORD *pcbPathOut)
+{
+    BOOL ret;
+    WORD len, cbOut = 0;
+    WCHAR path[MAX_PATH];
+
+    clear_errors();
+    TRACE("(%p %d %d)\n", lpszPath, cbPathMax, *pcbPathOut);
+
+    ret = SQLInstallDriverManagerW(path, MAX_PATH, &cbOut);
+    if (ret)
+    {
+        len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath, 0,
+                                   NULL, NULL);
+        if (len)
+        {
+            if (pcbPathOut)
+                *pcbPathOut = len - 1;
+
+            if (!lpszPath || cbPathMax < len)
+                return FALSE;
+
+            len =  WideCharToMultiByte(CP_ACP, 0, path, -1, lpszPath,
+                                       cbPathMax, NULL, NULL);
+        }
+    }
+    return ret;
+}
+
+BOOL WINAPI SQLInstallODBCW(HWND hwndParent, LPCWSTR lpszInfFile,
+               LPCWSTR lpszSrcPath, LPCWSTR lpszDrivers)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLInstallODBC(HWND hwndParent, LPCSTR lpszInfFile,
+               LPCSTR lpszSrcPath, LPCSTR lpszDrivers)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+SQLRETURN WINAPI SQLInstallerErrorW(WORD iError, DWORD *pfErrorCode,
+               LPWSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
+{
+    TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
+          cbErrorMsgMax, pcbErrorMsg);
+
+    if (iError == 0)
+    {
+        return SQL_ERROR;
+    }
+    else if (iError <= num_errors)
+    {
+        BOOL truncated = FALSE;
+        WORD len;
+        LPCWSTR msg;
+        iError--;
+        if (pfErrorCode)
+            *pfErrorCode = error_code[iError];
+        msg = error_msg[iError];
+        len = msg ? lstrlenW(msg) : 0;
+        if (pcbErrorMsg)
+            *pcbErrorMsg = len;
+        len++;
+        if (cbErrorMsgMax < len)
+        {
+            len = cbErrorMsgMax;
+            truncated = TRUE;
+        }
+        if (lpszErrorMsg && len)
+        {
+            if (msg)
+            {
+                memcpy (lpszErrorMsg, msg, len * sizeof(WCHAR));
+            }
+            else
+            {
+                assert(len==1);
+                *lpszErrorMsg = 0;
+            }
+        }
+        else
+        {
+            /* Yes.  If you pass a null pointer and a large length it is not an error! */
+            truncated = TRUE;
+        }
+
+        return truncated ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS;
+    }
+
+    /* 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 */
+    if (pcbErrorMsg)
+        *pcbErrorMsg = 0;
+
+    if (lpszErrorMsg && cbErrorMsgMax > 0)
+        *lpszErrorMsg = '\0';
+
+    return SQL_NO_DATA;
+}
+
+SQLRETURN WINAPI SQLInstallerError(WORD iError, DWORD *pfErrorCode,
+               LPSTR lpszErrorMsg, WORD cbErrorMsgMax, WORD *pcbErrorMsg)
+{
+    SQLRETURN ret;
+    LPWSTR wbuf;
+    WORD cbwbuf;
+    TRACE("%d %p %p %d %p\n", iError, pfErrorCode, lpszErrorMsg,
+          cbErrorMsgMax, pcbErrorMsg);
+
+    wbuf = 0;
+    if (lpszErrorMsg && cbErrorMsgMax)
+    {
+        wbuf = HeapAlloc(GetProcessHeap(), 0, cbErrorMsgMax*sizeof(WCHAR));
+        if (!wbuf)
+            return SQL_ERROR;
+    }
+    ret = SQLInstallerErrorW(iError, pfErrorCode, wbuf, cbErrorMsgMax, &cbwbuf);
+    if (wbuf)
+    {
+        WORD cbBuf = 0;
+        SQLInstall_narrow(1, lpszErrorMsg, wbuf, cbwbuf+1, cbErrorMsgMax, &cbBuf);
+        HeapFree(GetProcessHeap(), 0, wbuf);
+        if (pcbErrorMsg)
+            *pcbErrorMsg = cbBuf-1;
+    }
+    return ret;
+}
+
+BOOL WINAPI SQLInstallTranslatorExW(LPCWSTR lpszTranslator, LPCWSTR lpszPathIn,
+               LPWSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
+               WORD fRequest, LPDWORD lpdwUsageCount)
+{
+    UINT len;
+    LPCWSTR p;
+    WCHAR path[MAX_PATH];
+
+    clear_errors();
+    TRACE("%s %s %p %d %p %d %p\n", debugstr_w(lpszTranslator),
+          debugstr_w(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
+          fRequest, lpdwUsageCount);
+
+    for (p = lpszTranslator; *p; p += lstrlenW(p) + 1)
+        TRACE("%s\n", debugstr_w(p));
+
+    len = GetSystemDirectoryW(path, MAX_PATH);
+
+    if (pcbPathOut)
+        *pcbPathOut = len;
+
+    if (lpszPathOut && cbPathOutMax > len)
+    {
+        lstrcpyW(lpszPathOut, path);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+BOOL WINAPI SQLInstallTranslatorEx(LPCSTR lpszTranslator, LPCSTR lpszPathIn,
+               LPSTR lpszPathOut, WORD cbPathOutMax, WORD *pcbPathOut,
+               WORD fRequest, LPDWORD lpdwUsageCount)
+{
+    LPCSTR p;
+    LPWSTR translator, pathin;
+    WCHAR pathout[MAX_PATH];
+    BOOL ret;
+    WORD cbOut = 0;
+
+    clear_errors();
+    TRACE("%s %s %p %d %p %d %p\n", debugstr_a(lpszTranslator),
+          debugstr_a(lpszPathIn), lpszPathOut, cbPathOutMax, pcbPathOut,
+          fRequest, lpdwUsageCount);
+
+    for (p = lpszTranslator; *p; p += lstrlenA(p) + 1)
+        TRACE("%s\n", debugstr_a(p));
+
+    translator = SQLInstall_strdup_multi(lpszTranslator);
+    pathin = SQLInstall_strdup(lpszPathIn);
+
+    ret = SQLInstallTranslatorExW(translator, pathin, pathout, MAX_PATH,
+                                  &cbOut, fRequest, lpdwUsageCount);
+    if (ret)
+    {
+        int len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
+                                       0, NULL, NULL);
+        if (len)
+        {
+            if (pcbPathOut)
+                *pcbPathOut = len - 1;
+
+            if (!lpszPathOut || cbPathOutMax < len)
+            {
+                ret = FALSE;
+                goto out;
+            }
+            len =  WideCharToMultiByte(CP_ACP, 0, pathout, -1, lpszPathOut,
+                                       cbPathOutMax, NULL, NULL);
+        }
+    }
+
+out:
+    HeapFree(GetProcessHeap(), 0, translator);
+    HeapFree(GetProcessHeap(), 0, pathin);
+    return ret;
+}
+
+BOOL WINAPI SQLInstallTranslator(LPCSTR lpszInfFile, LPCSTR lpszTranslator,
+               LPCSTR lpszPathIn, LPSTR lpszPathOut, WORD cbPathOutMax,
+               WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    TRACE("%s %s %s %p %d %p %d %p\n", debugstr_a(lpszInfFile),
+          debugstr_a(lpszTranslator), debugstr_a(lpszPathIn), lpszPathOut,
+          cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
+
+    if (lpszInfFile)
+        return FALSE;
+
+    return SQLInstallTranslatorEx(lpszTranslator, lpszPathIn, lpszPathOut,
+                       cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
+}
+
+BOOL WINAPI SQLInstallTranslatorW(LPCWSTR lpszInfFile, LPCWSTR lpszTranslator,
+              LPCWSTR lpszPathIn, LPWSTR lpszPathOut, WORD cbPathOutMax,
+              WORD *pcbPathOut, WORD fRequest, LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    TRACE("%s %s %s %p %d %p %d %p\n", debugstr_w(lpszInfFile),
+          debugstr_w(lpszTranslator), debugstr_w(lpszPathIn), lpszPathOut,
+          cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
+
+    if (lpszInfFile)
+        return FALSE;
+
+    return SQLInstallTranslatorExW(lpszTranslator, lpszPathIn, lpszPathOut,
+                        cbPathOutMax, pcbPathOut, fRequest, lpdwUsageCount);
+}
+
+BOOL WINAPI SQLManageDataSources(HWND hwnd)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+SQLRETURN WINAPI SQLPostInstallerErrorW(DWORD fErrorCode, LPCWSTR szErrorMsg)
+{
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+SQLRETURN WINAPI SQLPostInstallerError(DWORD fErrorCode, LPCSTR szErrorMsg)
+{
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLReadFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
+               LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString,
+               WORD *pcbString)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLReadFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
+               LPCSTR lpszKeyName, LPSTR lpszString, WORD cbString,
+               WORD *pcbString)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDefaultDataSource(void)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDriverW(LPCWSTR lpszDriver, BOOL fRemoveDSN,
+               LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDriver(LPCSTR lpszDriver, BOOL fRemoveDSN,
+               LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDriverManager(LPDWORD pdwUsageCount)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDSNFromIniW(LPCWSTR lpszDSN)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveDSNFromIni(LPCSTR lpszDSN)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveTranslatorW(LPCWSTR lpszTranslator, LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLRemoveTranslator(LPCSTR lpszTranslator, LPDWORD lpdwUsageCount)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLSetConfigMode(UWORD wConfigMode)
+{
+    clear_errors();
+    if (wConfigMode > ODBC_SYSTEM_DSN)
+    {
+        push_error(ODBC_ERROR_INVALID_PARAM_SEQUENCE, odbc_error_invalid_param_sequence);
+        return FALSE;
+    }
+    else
+    {
+        config_mode = wConfigMode;
+        return TRUE;
+    }
+}
+
+BOOL WINAPI SQLValidDSNW(LPCWSTR lpszDSN)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLValidDSN(LPCSTR lpszDSN)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWriteDSNToIniW(LPCWSTR lpszDSN, LPCWSTR lpszDriver)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWriteDSNToIni(LPCSTR lpszDSN, LPCSTR lpszDriver)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWriteFileDSNW(LPCWSTR lpszFileName, LPCWSTR lpszAppName,
+               LPCWSTR lpszKeyName, LPCWSTR lpszString)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWriteFileDSN(LPCSTR lpszFileName, LPCSTR lpszAppName,
+               LPCSTR lpszKeyName, LPCSTR lpszString)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection, LPCWSTR lpszEntry,
+               LPCWSTR lpszString, LPCWSTR lpszFilename)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
+
+BOOL WINAPI SQLWritePrivateProfileString(LPCSTR lpszSection, LPCSTR lpszEntry,
+               LPCSTR lpszString, LPCSTR lpszFilename)
+{
+    clear_errors();
+    FIXME("\n");
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return FALSE;
+}
Propchange: trunk/reactos/dll/win32/odbccp32/odbccp32.c
------------------------------------------------------------------------------
    svn:eol-style = native
Added: trunk/reactos/dll/win32/odbccp32/odbccp32.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/odbccp32/odbccp3…
==============================================================================
--- trunk/reactos/dll/win32/odbccp32/odbccp32.rbuild (added)
+++ trunk/reactos/dll/win32/odbccp32/odbccp32.rbuild Wed Mar 14 15:48:32 2007
@@ -1,0 +1,19 @@
+<module name="odbccp32" type="win32dll"
baseaddress="${BASEADDRESS_ODBCCP32}" installbase="system32"
installname="odbccp32.dll" allowwarnings="true">
+       <importlibrary definition="odbccp32.spec.def" />
+       <include base="odbccp32">.</include>
+       <include base="ReactOS">include/reactos/wine</include>
+       <define name="__REACTOS__" />
+       <define name="__WINESRC__" />
+       <define name="__USE_W32API" />
+       <define name="_WIN32_IE">0x600</define>
+       <define name="_WIN32_WINNT">0x501</define>
+       <define name="WINVER">0x501</define>
+       <library>wine</library>
+       <library>ole32</library>
+       <library>advapi32</library>
+       <library>kernel32</library>
+       <library>uuid</library>
+       <library>ntdll</library>
+       <file>odbccp32.c</file>
+       <file>odbccp32.spec</file>
+</module>
Propchange: trunk/reactos/dll/win32/odbccp32/odbccp32.rbuild
------------------------------------------------------------------------------
    svn:eol-style = native
Added: trunk/reactos/dll/win32/odbccp32/odbccp32.spec
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/odbccp32/odbccp3…
==============================================================================
--- trunk/reactos/dll/win32/odbccp32/odbccp32.spec (added)
+++ trunk/reactos/dll/win32/odbccp32/odbccp32.spec Wed Mar 14 15:48:32 2007
@@ -1,0 +1,57 @@
+@ stdcall ODBCCPlApplet( long long ptr ptr)
+@ stdcall SQLConfigDataSource(ptr long wstr wstr)
+@ stdcall SQLConfigDataSourceW(ptr long str str)
+@ stdcall SQLConfigDriver(ptr long str str ptr long ptr)
+@ stdcall SQLConfigDriverW(ptr long wstr wstr ptr long ptr)
+@ stdcall SQLCreateDataSource(ptr str)
+@ stub SQLCreateDataSourceEx
+@ stub SQLCreateDataSourceExW
+@ stdcall SQLCreateDataSourceW(ptr wstr)
+@ stdcall SQLGetAvailableDrivers(str ptr long ptr)
+@ stdcall SQLGetAvailableDriversW(wstr ptr long ptr)
+@ stdcall SQLGetConfigMode(ptr)
+@ stdcall SQLGetInstalledDrivers(str long ptr)
+@ stdcall SQLGetInstalledDriversW(wstr long ptr)
+@ stdcall SQLGetPrivateProfileString(str str str str long str)
+@ stdcall SQLGetPrivateProfileStringW(wstr wstr wstr wstr long wstr)
+@ stdcall SQLGetTranslator(ptr str long ptr ptr long ptr ptr)
+@ stdcall SQLGetTranslatorW(ptr wstr long ptr ptr long ptr ptr)
+@ stdcall SQLInstallDriver(str str str long ptr)
+@ stdcall SQLInstallDriverEx(str str str long ptr long ptr)
+@ stdcall SQLInstallDriverExW(wstr wstr wstr long ptr long ptr)
+@ stdcall SQLInstallDriverManager(ptr long ptr)
+@ stdcall SQLInstallDriverManagerW(ptr long ptr)
+@ stdcall SQLInstallDriverW(wstr wstr wstr long ptr)
+@ stdcall SQLInstallODBC(ptr str str str)
+@ stdcall SQLInstallODBCW(ptr wstr wstr wstr)
+@ stdcall SQLInstallTranslator(str str str ptr long ptr long ptr)
+@ stdcall SQLInstallTranslatorEx(str str ptr long ptr long ptr)
+@ stdcall SQLInstallTranslatorExW(wstr wstr ptr long ptr long ptr)
+@ stdcall SQLInstallTranslatorW(wstr wstr wstr ptr long ptr long ptr)
+@ stdcall SQLInstallerError(long ptr ptr long ptr)
+@ stdcall SQLInstallerErrorW(long ptr ptr long ptr)
+@ stub SQLLoadDataSourcesListBox
+@ stub SQLLoadDriverListBox
+@ stdcall SQLManageDataSources(ptr)
+@ stdcall SQLPostInstallerError(long ptr)
+@ stdcall SQLPostInstallerErrorW(long ptr)
+@ stdcall SQLReadFileDSN(str str str ptr long ptr)
+@ stdcall SQLReadFileDSNW(wstr wstr wstr ptr long ptr)
+@ stdcall SQLRemoveDSNFromIni(str)
+@ stdcall SQLRemoveDSNFromIniW(wstr)
+@ stdcall SQLRemoveDefaultDataSource()
+@ stdcall SQLRemoveDriver(str long ptr)
+@ stdcall SQLRemoveDriverManager(ptr)
+@ stdcall SQLRemoveDriverW(wstr long ptr)
+@ stdcall SQLRemoveTranslator(str ptr)
+@ stdcall SQLRemoveTranslatorW(wstr ptr)
+@ stdcall SQLSetConfigMode(long)
+@ stdcall SQLValidDSN(str)
+@ stdcall SQLValidDSNW(wstr)
+@ stdcall SQLWriteDSNToIni(str str)
+@ stdcall SQLWriteDSNToIniW(wstr wstr)
+@ stdcall SQLWriteFileDSN(str str str str)
+@ stdcall SQLWriteFileDSNW(wstr wstr wstr wstr)
+@ stdcall SQLWritePrivateProfileString(str str str str)
+@ stdcall SQLWritePrivateProfileStringW(wstr wstr wstr wstr)
+@ stub SelectTransDlg
Propchange: trunk/reactos/dll/win32/odbccp32/odbccp32.spec
------------------------------------------------------------------------------
    svn:eol-style = native