From 07405fb46496445ff2173d4b4834e037de6db6ae Mon Sep 17 00:00:00 2001 From: Steven Edwards Date: Wed, 25 Feb 2004 20:09:39 +0000 Subject: [PATCH] Added a stub odbc32.dll as MFC depends on it. svn path=/trunk/; revision=8378 --- reactos/lib/odbc32/.cvsignore | 9 + reactos/lib/odbc32/Makefile.in | 13 + reactos/lib/odbc32/Makefile.ros | 21 + reactos/lib/odbc32/Makefile.ros-template | 21 + reactos/lib/odbc32/README.txt | 3 + reactos/lib/odbc32/makefile | 9 + reactos/lib/odbc32/odbc32.rc | 38 + reactos/lib/odbc32/odbc32.spec | 176 +++ reactos/lib/odbc32/proxyodbc.c | 1803 ++++++++++++++++++++++ reactos/lib/odbc32/proxyodbc.h | 131 ++ 10 files changed, 2224 insertions(+) create mode 100644 reactos/lib/odbc32/.cvsignore create mode 100644 reactos/lib/odbc32/Makefile.in create mode 100644 reactos/lib/odbc32/Makefile.ros create mode 100644 reactos/lib/odbc32/Makefile.ros-template create mode 100644 reactos/lib/odbc32/README.txt create mode 100644 reactos/lib/odbc32/makefile create mode 100644 reactos/lib/odbc32/odbc32.rc create mode 100644 reactos/lib/odbc32/odbc32.spec create mode 100644 reactos/lib/odbc32/proxyodbc.c create mode 100644 reactos/lib/odbc32/proxyodbc.h diff --git a/reactos/lib/odbc32/.cvsignore b/reactos/lib/odbc32/.cvsignore new file mode 100644 index 00000000000..d5bf780c608 --- /dev/null +++ b/reactos/lib/odbc32/.cvsignore @@ -0,0 +1,9 @@ +odbc32.dll.dbg.c +odbc32.spec.c +odbc32.spec.def +*.dll +*.o +*.sym +*.map +*.d +*.coff \ No newline at end of file diff --git a/reactos/lib/odbc32/Makefile.in b/reactos/lib/odbc32/Makefile.in new file mode 100644 index 00000000000..e912920e673 --- /dev/null +++ b/reactos/lib/odbc32/Makefile.in @@ -0,0 +1,13 @@ +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = odbc32.dll +IMPORTS = kernel32 + +C_SRCS = \ + proxyodbc.c + +@MAKE_DLL_RULES@ + +### Dependencies: diff --git a/reactos/lib/odbc32/Makefile.ros b/reactos/lib/odbc32/Makefile.ros new file mode 100644 index 00000000000..ba9d8d30902 --- /dev/null +++ b/reactos/lib/odbc32/Makefile.ros @@ -0,0 +1,21 @@ +# $Id: Makefile.ros,v 1.1 2004/02/25 20:09:39 sedwards Exp $ + +TARGET_NAME = odbc32 + +TARGET_OBJECTS = proxyodbc.o + +TARGET_CFLAGS = -D__REACTOS__ -D__WINESRC__ + +TARGET_SDKLIBS = kernel32.a libwine.a ntdll.a + +TARGET_BASE = 0x76660000 + +TARGET_RC_SRCS = +TARGET_RC_BINSRC = +TARGET_RC_BINARIES = + +default: all + +DEP_OBJECTS = $(TARGET_OBJECTS) + +include $(TOOLS_PATH)/depend.mk diff --git a/reactos/lib/odbc32/Makefile.ros-template b/reactos/lib/odbc32/Makefile.ros-template new file mode 100644 index 00000000000..3558498f02f --- /dev/null +++ b/reactos/lib/odbc32/Makefile.ros-template @@ -0,0 +1,21 @@ +# $Id: Makefile.ros-template,v 1.1 2004/02/25 20:09:39 sedwards Exp $ + +TARGET_NAME = odbc32 + +TARGET_OBJECTS = @C_SRCS@ + +TARGET_CFLAGS = @EXTRADEFS@ -D__REACTOS__ -D__WINESRC__ + +TARGET_SDKLIBS = @IMPORTS@ libwine.a ntdll.a + +TARGET_BASE = 0x76660000 + +TARGET_RC_SRCS = @RC_SRCS@ +TARGET_RC_BINSRC = @RC_BINSRC@ +TARGET_RC_BINARIES = @RC_BINARIES@ + +default: all + +DEP_OBJECTS = $(TARGET_OBJECTS) + +include $(TOOLS_PATH)/depend.mk diff --git a/reactos/lib/odbc32/README.txt b/reactos/lib/odbc32/README.txt new file mode 100644 index 00000000000..8c6b0790e20 --- /dev/null +++ b/reactos/lib/odbc32/README.txt @@ -0,0 +1,3 @@ +This stub odbc32.dll is based on the WINE odbc32 implementation except ours doesnt work. +Someone will need to import Unix-ODBC in to ReactOS CVS and merge it with this implemenation. +I only created this because MFC depends on odbc32.dll \ No newline at end of file diff --git a/reactos/lib/odbc32/makefile b/reactos/lib/odbc32/makefile new file mode 100644 index 00000000000..f88ea72f920 --- /dev/null +++ b/reactos/lib/odbc32/makefile @@ -0,0 +1,9 @@ +# $Id: makefile,v 1.1 2004/02/25 20:09:39 sedwards Exp $ + +PATH_TO_TOP = ../.. + +TARGET_TYPE = winedll + +include $(PATH_TO_TOP)/rules.mak + +include $(TOOLS_PATH)/helper.mk diff --git a/reactos/lib/odbc32/odbc32.rc b/reactos/lib/odbc32/odbc32.rc new file mode 100644 index 00000000000..e218c3c1910 --- /dev/null +++ b/reactos/lib/odbc32/odbc32.rc @@ -0,0 +1,38 @@ +#include +#include + +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +VS_VERSION_INFO VERSIONINFO + FILEVERSION RES_UINT_FV_MAJOR,RES_UINT_FV_MINOR,RES_UINT_FV_REVISION,RES_UINT_FV_BUILD + PRODUCTVERSION RES_UINT_PV_MAJOR,RES_UINT_PV_MINOR,RES_UINT_PV_REVISION,RES_UINT_PV_BUILD + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x40004L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", RES_STR_COMPANY_NAME + VALUE "FileDescription", "WINE IMM32 API Client DLL\0" + VALUE "FileVersion", RES_STR_FILE_VERSION + VALUE "InternalName", "imm32\0" + VALUE "LegalCopyright", RES_STR_LEGAL_COPYRIGHT + VALUE "OriginalFilename", "imm32.dll\0" + VALUE "ProductName", RES_STR_PRODUCT_NAME + VALUE "ProductVersion", RES_STR_PRODUCT_VERSION + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + diff --git a/reactos/lib/odbc32/odbc32.spec b/reactos/lib/odbc32/odbc32.spec new file mode 100644 index 00000000000..8c5ac336b56 --- /dev/null +++ b/reactos/lib/odbc32/odbc32.spec @@ -0,0 +1,176 @@ + 1 stdcall SQLAllocConnect(long ptr) + 2 stdcall SQLAllocEnv(ptr) + 3 stdcall SQLAllocStmt(long ptr) + 4 stdcall SQLBindCol(long long long ptr long ptr) + 5 stdcall SQLCancel(long) + 6 stdcall SQLColAttributes(long long long ptr long ptr ptr) + 7 stdcall SQLConnect(long str long str long str long) + 8 stdcall SQLDescribeCol(long long str long ptr ptr ptr ptr ptr) + 9 stdcall SQLDisconnect(long) + 10 stdcall SQLError(long long long str ptr str long ptr) + 11 stdcall SQLExecDirect(long str long) + 12 stdcall SQLExecute(long) + 13 stdcall SQLFetch(long) + 14 stdcall SQLFreeConnect(long) + 15 stdcall SQLFreeEnv(long) + 16 stdcall SQLFreeStmt(long long ) + 17 stdcall SQLGetCursorName(long str long ptr) + 18 stdcall SQLNumResultCols(long ptr) + 19 stdcall SQLPrepare(long str long) + 20 stdcall SQLRowCount(long ptr) + 21 stdcall SQLSetCursorName(long str long) + 22 stdcall SQLSetParam(long long long long long long ptr ptr) + 23 stdcall SQLTransact(long long long) + 24 stdcall SQLAllocHandle(long long ptr) + 25 stdcall SQLBindParam(long long long long long long ptr ptr) + 26 stdcall SQLCloseCursor(long) + 27 stdcall SQLColAttribute(long long long ptr long ptr ptr) + 28 stdcall SQLCopyDesc(long long) + 29 stdcall SQLEndTran(long long long) + 30 stdcall SQLFetchScroll(long long long) + 31 stdcall SQLFreeHandle(long long) + 32 stdcall SQLGetConnectAttr(long long ptr long ptr) + 33 stdcall SQLGetDescField(long long long ptr long ptr) + 34 stdcall SQLGetDescRec(long long str long ptr ptr ptr ptr ptr ptr ptr) + 35 stdcall SQLGetDiagField(long long long long ptr long ptr) + 36 stdcall SQLGetDiagRec(long long long str ptr str long ptr) + 37 stdcall SQLGetEnvAttr(long long ptr long ptr) + 38 stdcall SQLGetStmtAttr(long long ptr long ptr) + 39 stdcall SQLSetConnectAttr(long long ptr long) + 40 stdcall SQLColumns(long str long str long str long str long) + 41 stdcall SQLDriverConnect(long long str long str long str long) + 42 stdcall SQLGetConnectOption(long long ptr) + 43 stdcall SQLGetData(long long long ptr long ptr) + 44 stdcall SQLGetFunctions(long long ptr) + 45 stdcall SQLGetInfo(long long ptr long ptr) + 46 stdcall SQLGetStmtOption(long long ptr) + 47 stdcall SQLGetTypeInfo(long long) + 48 stdcall SQLParamData(long ptr) + 49 stdcall SQLPutData(long ptr long) + 50 stdcall SQLSetConnectOption(long long long) + 51 stdcall SQLSetStmtOption(long long long) + 52 stdcall SQLSpecialColumns(long long str long str long str long long long) + 53 stdcall SQLStatistics(long str long str long str long long long) + 54 stdcall SQLTables(long str long str long str long str long) + 55 stdcall SQLBrowseConnect(long str long str long ptr) + 56 stdcall SQLColumnPrivileges(long str long str long str long str long) + 57 stdcall SQLDataSources(long long str long ptr str long ptr) + 58 stdcall SQLDescribeParam(long long ptr ptr ptr ptr) + 59 stdcall SQLExtendedFetch(long long long ptr ptr) + 60 stdcall SQLForeignKeys(long str long str long str long str long str long str long) + 61 stdcall SQLMoreResults(long) + 62 stdcall SQLNativeSql(long str long str long ptr) + 63 stdcall SQLNumParams(long ptr) + 64 stdcall SQLParamOptions(long long ptr) + 65 stdcall SQLPrimaryKeys(long str long str long str long) + 66 stdcall SQLProcedureColumns(long str long str long str long str long) + 67 stdcall SQLProcedures(long str long str long str long) + 68 stdcall SQLSetPos(long long long long) + 69 stdcall SQLSetScrollOptions(long long long long) + 70 stdcall SQLTablePrivileges(long str long str long str long) + 71 stdcall SQLDrivers(long long str long ptr str long ptr) + 72 stdcall SQLBindParameter(long long long long long long long ptr long ptr) + 73 stdcall SQLSetDescField(long long long ptr long) + 74 stdcall SQLSetDescRec(long long long long long long long ptr ptr ptr) + 75 stdcall SQLSetEnvAttr(long long ptr long) + 76 stdcall SQLSetStmtAttr(long long ptr long) + 77 stdcall SQLAllocHandleStd(long long ptr) + 78 stdcall SQLBulkOperations(long long) + 79 stub CloseODBCPerfData + 80 stub CollectODBCPerfData + 81 stub CursorLibLockDbc + 82 stub CursorLibLockDesc + 83 stub CursorLibLockStmt + 84 stub ODBCGetTryWaitValue + 85 stub CursorLibTransact + 86 stub ODBSetTryWaitValue + 89 stub ODBCSharedPerfMon + 90 stub ODBCSharedVSFlag +106 stub SQLColAttributesW +107 stub SQLConnectW +108 stub SQLDescribeColW +110 stub SQLErrorW +111 stub SQLExecDirectW +117 stub SQLGetCursorNameW +119 stub SQLPrepareW +121 stub SQLSetCursorNameW +127 stub SQLColAttributeW +132 stub SQLGetConnectAttrW +133 stub SQLGetDescFieldW +134 stub SQLGetDescRecW +135 stub SQLGetDiagFieldW +136 stub SQLGetDiagRecW +138 stub SQLGetStmtAttrW +139 stub SQLSetConnectAttrW +140 stub SQLColumnsW +141 stub SQLDriverConnectW +142 stub SQLGetConnectOptionW +145 stub SQLGetInfoW +147 stub SQLGetTypeInfoW +150 stub SQLSetConnectOptionW +152 stub SQLSpecialColumnsW +153 stub SQLStatisticsW +154 stub SQLTablesW +155 stub SQLBrowseConnectW +156 stub SQLColumnPrivilegesW +157 stub SQLDataSourcesW +160 stub SQLForeignKeysW +162 stub SQLNativeSqlW +165 stub SQLPrimaryKeysW +166 stub SQLProcedureColumnsW +167 stub SQLProceduresW +170 stub SQLTablePrivilegesW +171 stub SQLDriversW +173 stub SQLSetDescFieldW +176 stub SQLSetStmtAttrW +206 stub SQLColAttributesA +207 stub SQLConnectA +208 stub SQLDescribeColA +210 stub SQLErrorA +211 stub SQLExecDirectA +217 stub SQLGetCursorNameA +219 stub SQLPrepareA +221 stub SQLSetCursorNameA +227 stub SQLColAttributeA +232 stub SQLGetConnectAttrA +233 stub SQLGetDescFieldA +234 stub SQLGetDescRecA +235 stub SQLGetDiagFieldA +236 stub SQLGetDiagRecA +238 stub SQLGetStmtAttrA +239 stub SQLSetConnectAttrA +240 stub SQLColumnsA +241 stub SQLDriverConnectA +242 stub SQLGetConnectOptionA +245 stub SQLGetInfoA +247 stub SQLGetTypeInfoA +250 stub SQLSetConnectOptionA +252 stub SQLSpecialColumnsA +253 stub SQLStatisticsA +254 stub SQLTablesA +255 stub SQLBrowseConnectA +256 stub SQLColumnPrivilegesA +257 stub SQLDataSourcesA +260 stub SQLForeignKeysA +262 stub SQLNativeSqlA +265 stub SQLPrimaryKeysA +266 stub SQLProcedureColumnsA +267 stub SQLProceduresA +270 stub SQLTablePrivilegesA +271 stub SQLDriversA +273 stub SQLSetDescFieldA +276 stub SQLSetStmtAttrA +300 stub ODBCSharedTraceFlag +301 stub ODBCQualifyFileDSNW + + + @ stub LockHandle + @ stub ODBCInternalConnectW + @ stub OpenODBCPerfData + @ stub PostComponentError + @ stub PostODBCComponentError + @ stub PostODBCError + @ stub SearchStatusCode + @ stub VFreeErrors + @ stub VRetrieveDriverErrorsRowCol + @ stub ValidateErrorQueue diff --git a/reactos/lib/odbc32/proxyodbc.c b/reactos/lib/odbc32/proxyodbc.c new file mode 100644 index 00000000000..a5f44f75dd7 --- /dev/null +++ b/reactos/lib/odbc32/proxyodbc.c @@ -0,0 +1,1803 @@ +/* + * Win32 ODBC functions + * + * Copyright 1999 Xiang Li, Corel Corporation + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NOTES: + * Proxy ODBC driver manager. This manager delegates all ODBC + * calls to a real ODBC driver manager named by the environment + * variable LIB_ODBC_DRIVER_MANAGER, or to libodbc.so if the + * variable is not set. + * + */ + +#include "config.h" +#include "wine/port.h" + +#include +#include +#include +#include +#include + +#include "windef.h" +#include "winbase.h" +#include "wine/debug.h" +//#include "wine/library.h" + +#include "sql.h" +#include "sqltypes.h" +#include "sqlext.h" + +#include "proxyodbc.h" + +static BOOL ODBC_LoadDriverManager(void); +static BOOL ODBC_LoadDMFunctions(void); + +WINE_DEFAULT_DEBUG_CHANNEL(odbc); + +static const DM_FUNC template_func[] = +{ + /* 00 */ { SQL_API_SQLALLOCCONNECT, "SQLAllocConnect", SQLAllocConnect, NULL }, + /* 01 */ { SQL_API_SQLALLOCENV, "SQLAllocEnv", SQLAllocEnv, NULL }, + /* 02 */ { SQL_API_SQLALLOCHANDLE, "SQLAllocHandle", SQLAllocHandle, NULL }, + /* 03 */ { SQL_API_SQLALLOCSTMT, "SQLAllocStmt", SQLAllocStmt, NULL }, + /* 04 */ { SQL_API_SQLALLOCHANDLESTD, "SQLAllocHandleStd", SQLAllocHandleStd, NULL }, + /* 05 */ { SQL_API_SQLBINDCOL, "SQLBindCol", SQLBindCol, NULL }, + /* 06 */ { SQL_API_SQLBINDPARAM, "SQLBindParam", SQLBindParam, NULL }, + /* 07 */ { SQL_API_SQLBINDPARAMETER, "SQLBindParameter", SQLBindParameter, NULL }, + /* 08 */ { SQL_API_SQLBROWSECONNECT, "SQLBrowseConnect", SQLBrowseConnect, NULL }, + /* 09 */ { SQL_API_SQLBULKOPERATIONS, "SQLBulkOperations", SQLBulkOperations, NULL }, + /* 10 */ { SQL_API_SQLCANCEL, "SQLCancel", SQLCancel, NULL }, + /* 11 */ { SQL_API_SQLCLOSECURSOR, "SQLCloseCursor", SQLCloseCursor, NULL }, + /* 12 */ { SQL_API_SQLCOLATTRIBUTE, "SQLColAttribute", SQLColAttribute, NULL }, + /* 13 */ { SQL_API_SQLCOLATTRIBUTES, "SQLColAttributes", SQLColAttributes, NULL }, + /* 14 */ { SQL_API_SQLCOLUMNPRIVILEGES, "SQLColumnPrivileges", SQLColumnPrivileges, NULL }, + /* 15 */ { SQL_API_SQLCOLUMNS, "SQLColumns", SQLColumns, NULL }, + /* 16 */ { SQL_API_SQLCONNECT, "SQLConnect", SQLConnect, NULL }, + /* 17 */ { SQL_API_SQLCOPYDESC, "SQLCopyDesc", SQLCopyDesc, NULL }, + /* 18 */ { SQL_API_SQLDATASOURCES, "SQLDataSources", SQLDataSources, NULL }, + /* 19 */ { SQL_API_SQLDESCRIBECOL, "SQLDescribeCol", SQLDescribeCol, NULL }, + /* 20 */ { SQL_API_SQLDESCRIBEPARAM, "SQLDescribeParam", SQLDescribeParam, NULL }, + /* 21 */ { SQL_API_SQLDISCONNECT, "SQLDisconnect", SQLDisconnect, NULL }, + /* 22 */ { SQL_API_SQLDRIVERCONNECT, "SQLDriverConnect", SQLDriverConnect, NULL }, + /* 23 */ { SQL_API_SQLDRIVERS, "SQLDrivers", SQLDrivers, NULL }, + /* 24 */ { SQL_API_SQLENDTRAN, "SQLEndTran", SQLEndTran, NULL }, + /* 25 */ { SQL_API_SQLERROR, "SQLError", SQLError, NULL }, + /* 26 */ { SQL_API_SQLEXECDIRECT, "SQLExecDirect", SQLExecDirect, NULL }, + /* 27 */ { SQL_API_SQLEXECUTE, "SQLExecute", SQLExecute, NULL }, + /* 28 */ { SQL_API_SQLEXTENDEDFETCH, "SQLExtendedFetch", SQLExtendedFetch, NULL }, + /* 29 */ { SQL_API_SQLFETCH, "SQLFetch", SQLFetch, NULL }, + /* 30 */ { SQL_API_SQLFETCHSCROLL, "SQLFetchScroll", SQLFetchScroll, NULL }, + /* 31 */ { SQL_API_SQLFOREIGNKEYS, "SQLForeignKeys", SQLForeignKeys, NULL }, + /* 32 */ { SQL_API_SQLFREEENV, "SQLFreeEnv", SQLFreeEnv, NULL }, + /* 33 */ { SQL_API_SQLFREEHANDLE, "SQLFreeHandle", SQLFreeHandle, NULL }, + /* 34 */ { SQL_API_SQLFREESTMT, "SQLFreeStmt", SQLFreeStmt, NULL }, + /* 35 */ { SQL_API_SQLFREECONNECT, "SQLFreeConnect", SQLFreeConnect, NULL }, + /* 36 */ { SQL_API_SQLGETCONNECTATTR, "SQLGetConnectAttr", SQLGetConnectAttr, NULL }, + /* 37 */ { SQL_API_SQLGETCONNECTOPTION, "SQLGetConnectOption", SQLGetConnectOption, NULL }, + /* 38 */ { SQL_API_SQLGETCURSORNAME, "SQLGetCursorName", SQLGetCursorName, NULL }, + /* 39 */ { SQL_API_SQLGETDATA, "SQLGetData", SQLGetData, NULL }, + /* 40 */ { SQL_API_SQLGETDESCFIELD, "SQLGetDescField", SQLGetDescField, NULL }, + /* 41 */ { SQL_API_SQLGETDESCREC, "SQLGetDescRec", SQLGetDescRec, NULL }, + /* 42 */ { SQL_API_SQLGETDIAGFIELD, "SQLGetDiagField", SQLGetDiagField, NULL }, + /* 43 */ { SQL_API_SQLGETENVATTR, "SQLGetEnvAttr", SQLGetEnvAttr, NULL }, + /* 44 */ { SQL_API_SQLGETFUNCTIONS, "SQLGetFunctions", SQLGetFunctions, NULL }, + /* 45 */ { SQL_API_SQLGETINFO, "SQLGetInfo", SQLGetInfo, NULL }, + /* 46 */ { SQL_API_SQLGETSTMTATTR, "SQLGetStmtAttr", SQLGetStmtAttr, NULL }, + /* 47 */ { SQL_API_SQLGETSTMTOPTION, "SQLGetStmtOption", SQLGetStmtOption, NULL }, + /* 48 */ { SQL_API_SQLGETTYPEINFO, "SQLGetTypeInfo", SQLGetTypeInfo, NULL }, + /* 49 */ { SQL_API_SQLMORERESULTS, "SQLMoreResults", SQLMoreResults, NULL }, + /* 50 */ { SQL_API_SQLNATIVESQL, "SQLNativeSql", SQLNativeSql, NULL }, + /* 51 */ { SQL_API_SQLNUMPARAMS, "SQLNumParams", SQLNumParams, NULL }, + /* 52 */ { SQL_API_SQLNUMRESULTCOLS, "SQLNumResultCols", SQLNumResultCols, NULL }, + /* 53 */ { SQL_API_SQLPARAMDATA, "SQLParamData", SQLParamData, NULL }, + /* 54 */ { SQL_API_SQLPARAMOPTIONS, "SQLParamOptions", SQLParamOptions, NULL }, + /* 55 */ { SQL_API_SQLPREPARE, "SQLPrepare", SQLPrepare, NULL }, + /* 56 */ { SQL_API_SQLPRIMARYKEYS, "SQLPrimaryKeys", SQLPrimaryKeys, NULL }, + /* 57 */ { SQL_API_SQLPROCEDURECOLUMNS, "SQLProcedureColumns", SQLProcedureColumns, NULL }, + /* 58 */ { SQL_API_SQLPROCEDURES, "SQLProcedures", SQLProcedures, NULL }, + /* 59 */ { SQL_API_SQLPUTDATA, "SQLPutData", SQLPutData, NULL }, + /* 60 */ { SQL_API_SQLROWCOUNT, "SQLRowCount", SQLRowCount, NULL }, + /* 61 */ { SQL_API_SQLSETCONNECTATTR, "SQLSetConnectAttr", SQLSetConnectAttr, NULL }, + /* 62 */ { SQL_API_SQLSETCONNECTOPTION, "SQLSetConnectOption", SQLSetConnectOption, NULL }, + /* 63 */ { SQL_API_SQLSETCURSORNAME, "SQLSetCursorName", SQLSetCursorName, NULL }, + /* 64 */ { SQL_API_SQLSETDESCFIELD, "SQLSetDescField", SQLSetDescField, NULL }, + /* 65 */ { SQL_API_SQLSETDESCREC, "SQLSetDescRec", SQLSetDescRec, NULL }, + /* 66 */ { SQL_API_SQLSETENVATTR, "SQLSetEnvAttr", SQLSetEnvAttr, NULL }, + /* 67 */ { SQL_API_SQLSETPARAM, "SQLSetParam", SQLSetParam, NULL }, + /* 68 */ { SQL_API_SQLSETPOS, "SQLSetPos", SQLSetPos, NULL }, + /* 69 */ { SQL_API_SQLSETSCROLLOPTIONS, "SQLSetScrollOptions", SQLSetScrollOptions, NULL }, + /* 70 */ { SQL_API_SQLSETSTMTATTR, "SQLSetStmtAttr", SQLSetStmtAttr, NULL }, + /* 71 */ { SQL_API_SQLSETSTMTOPTION, "SQLSetStmtOption", SQLSetStmtOption, NULL }, + /* 72 */ { SQL_API_SQLSPECIALCOLUMNS, "SQLSpecialColumns", SQLSpecialColumns, NULL }, + /* 73 */ { SQL_API_SQLSTATISTICS, "SQLStatistics", SQLStatistics, NULL }, + /* 74 */ { SQL_API_SQLTABLEPRIVILEGES, "SQLTablePrivileges", SQLTablePrivileges, NULL }, + /* 75 */ { SQL_API_SQLTABLES, "SQLTables", SQLTables, NULL }, + /* 76 */ { SQL_API_SQLTRANSACT, "SQLTransact", SQLTransact, NULL }, + /* 77 */ { SQL_API_SQLGETDIAGREC, "SQLGetDiagRec", SQLGetDiagRec, NULL }, +}; + +static PROXYHANDLE gProxyHandle; + +/* What is the difference between these two (dmHandle cf READY_AND_dmHandle)? When does one use one and when the other? */ + +#define CHECK_dmHandle() \ +{ \ + if (gProxyHandle.dmHandle == NULL) \ + { \ + TRACE ("Not ready\n"); \ + return SQL_ERROR; \ + } \ +} + +#define CHECK_READY_AND_dmHandle() \ +{ \ + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) \ + { \ + TRACE ("Not ready\n"); \ + return SQL_ERROR; \ + } \ +} + +SQLRETURN SQLDummyFunc() +{ + TRACE("SQLDummyFunc: \n"); + return SQL_SUCCESS; +} + +/*********************************************************************** + * DllMain [Internal] Initializes the internal 'ODBC32.DLL'. + * + * PARAMS + * hinstDLL [I] handle to the DLL's instance + * fdwReason [I] + * lpvReserved [I] reserved, must be NULL + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ + +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) +{ + int i; + TRACE("Initializing or Finalizing proxy ODBC: %p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved); + + if (fdwReason == DLL_PROCESS_ATTACH) + { + TRACE("Loading ODBC...\n"); + DisableThreadLibraryCalls(hinstDLL); + if (ODBC_LoadDriverManager()) + ODBC_LoadDMFunctions(); + } + else if (fdwReason == DLL_PROCESS_DETACH) + { + TRACE("Unloading ODBC...\n"); + if (gProxyHandle.bFunctionReady) + { + for ( i = 0; i < NUM_SQLFUNC; i ++ ) + { + gProxyHandle.functions[i].func = SQLDummyFunc; + } + } +#ifndef __REACTOS__ + if (gProxyHandle.dmHandle) + { + wine_dlclose(gProxyHandle.dmHandle,NULL,0); + gProxyHandle.dmHandle = NULL; + } +#endif + } + + return TRUE; +} + + +/*********************************************************************** + * ODBC_LoadDriverManager [Internal] Load ODBC library. + * + * PARAMS + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ + +static BOOL ODBC_LoadDriverManager(void) +{ + const char *s = getenv("LIB_ODBC_DRIVER_MANAGER"); + char error[256]; + + TRACE("\n"); + + gProxyHandle.bFunctionReady = FALSE; + gProxyHandle.nErrorType = ERROR_LIBRARY_NOT_FOUND; + + if (s!= NULL && strlen (s) >= sizeof(gProxyHandle.dmLibName)) + { + ERR("Driver name too long (%s)\n",s); + return FALSE; + } + if (s == NULL || strlen(s) == 0) + s = "libodbc.so"; + strcpy(gProxyHandle.dmLibName, s); +#ifndef __REACTOS__ + gProxyHandle.dmHandle = wine_dlopen(gProxyHandle.dmLibName, RTLD_LAZY, error, sizeof(error)); + + if (gProxyHandle.dmHandle == NULL) /* fail to load unixODBC driver manager */ + { + WARN("failed to open library %s: %s\n", gProxyHandle.dmLibName, error); + gProxyHandle.dmLibName[0] = '\0'; + gProxyHandle.nErrorType = ERROR_LIBRARY_NOT_FOUND; + return FALSE; + } + else + { + gProxyHandle.nErrorType = ERROR_FREE; + return TRUE; + } +#else + return FALSE; +#endif +} + + +/*********************************************************************** + * ODBC_LoadDMFunctions [Internal] Populate function table. + * + * PARAMS + * + * RETURNS + * Success: TRUE + * Failure: FALSE + */ + +static BOOL ODBC_LoadDMFunctions(void) +{ + int i; + char error[256]; + + if (gProxyHandle.dmHandle == NULL) + return FALSE; +#ifndef __REACTOS__ + for ( i = 0; i < NUM_SQLFUNC; i ++ ) + { + gProxyHandle.functions[i] = template_func[i]; + gProxyHandle.functions[i].func = wine_dlsym(gProxyHandle.dmHandle, + gProxyHandle.functions[i].name, error, sizeof(error)); + + if (error[0]) + { + ERR("Failed to load function %s\n",gProxyHandle.functions[i].name); + gProxyHandle.functions[i].func = SQLDummyFunc; + } + } + + gProxyHandle.bFunctionReady = TRUE; +#endif + return TRUE; +} + + +/************************************************************************* + * SQLAllocConnect [ODBC32.001] + */ +SQLRETURN WINAPI SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle) +{ + SQLRETURN ret; + TRACE("Env=%lx\n",EnvironmentHandle); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + *ConnectionHandle = SQL_NULL_HDBC; + TRACE("Not ready\n"); + return SQL_ERROR; + } + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func) + (EnvironmentHandle, ConnectionHandle); + TRACE("Returns ret=%d, Handle %lx\n",ret, *ConnectionHandle); + return ret; +} + + +/************************************************************************* + * SQLAllocEnv [ODBC32.002] + */ +SQLRETURN WINAPI SQLAllocEnv(SQLHENV *EnvironmentHandle) +{ + SQLRETURN ret; + TRACE("\n"); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + *EnvironmentHandle = SQL_NULL_HENV; + TRACE("Not ready\n"); + return SQL_ERROR; + } + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func) (EnvironmentHandle); + TRACE("Returns ret=%d, Env=%lx\n",ret, *EnvironmentHandle); + return ret; +} + + +/************************************************************************* + * SQLAllocHandle [ODBC32.024] + */ +SQLRETURN WINAPI SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle) +{ + SQLRETURN ret; + TRACE("(Type=%d, Handle=%lx)\n",HandleType,InputHandle); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND) + WARN("ProxyODBC: Can not load ODBC driver manager library.\n"); + + if (HandleType == SQL_HANDLE_ENV) + *OutputHandle = SQL_NULL_HENV; + else if (HandleType == SQL_HANDLE_DBC) + *OutputHandle = SQL_NULL_HDBC; + else if (HandleType == SQL_HANDLE_STMT) + *OutputHandle = SQL_NULL_HSTMT; + else if (HandleType == SQL_HANDLE_DESC) + *OutputHandle = SQL_NULL_HDESC; + + TRACE ("Not ready\n"); + return SQL_ERROR; + } + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func) + (HandleType, InputHandle, OutputHandle); + TRACE("Returns ret=%d, Handle=%lx\n",ret, *OutputHandle); + return ret; +} + + +/************************************************************************* + * SQLAllocStmt [ODBC32.003] + */ +SQLRETURN WINAPI SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle) +{ + SQLRETURN ret; + + TRACE("(Connection=%lx)\n",ConnectionHandle); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + *StatementHandle = SQL_NULL_HSTMT; + TRACE ("Not ready\n"); + return SQL_ERROR; + } + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func) + (ConnectionHandle, StatementHandle); + TRACE ("Returns ret=%d, Handle=%lx\n", ret, *StatementHandle); + return ret; +} + + +/************************************************************************* + * SQLAllocHandleStd [ODBC32.077] + */ +SQLRETURN WINAPI SQLAllocHandleStd( SQLSMALLINT HandleType, + SQLHANDLE InputHandle, SQLHANDLE *OutputHandle) +{ + TRACE("ProxyODBC: SQLAllocHandelStd.\n"); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND) + WARN("ProxyODBC: Can not load ODBC driver manager library.\n"); + + if (HandleType == SQL_HANDLE_ENV) + *OutputHandle = SQL_NULL_HENV; + else if (HandleType == SQL_HANDLE_DBC) + *OutputHandle = SQL_NULL_HDBC; + else if (HandleType == SQL_HANDLE_STMT) + *OutputHandle = SQL_NULL_HSTMT; + else if (HandleType == SQL_HANDLE_DESC) + *OutputHandle = SQL_NULL_HDESC; + + return SQL_ERROR; + } + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func) + (HandleType, InputHandle, OutputHandle); +} + + +/************************************************************************* + * SQLBindCol [ODBC32.004] + */ +SQLRETURN WINAPI SQLBindCol(SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType, + SQLPOINTER TargetValue, SQLINTEGER BufferLength, + SQLINTEGER *StrLen_or_Ind) +{ + TRACE("\n"); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + TRACE ("Not ready\n"); + return SQL_ERROR; + } + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func) + (StatementHandle, ColumnNumber, TargetType, + TargetValue, BufferLength, StrLen_or_Ind); +} + + +/************************************************************************* + * SQLBindParam [ODBC32.025] + */ +SQLRETURN WINAPI SQLBindParam(SQLHSTMT StatementHandle, + SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType, + SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision, + SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue, + SQLINTEGER *StrLen_or_Ind) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func) + (StatementHandle, ParameterNumber, ValueType, + ParameterScale, ParameterValue, StrLen_or_Ind); +} + + +/************************************************************************* + * SQLCancel [ODBC32.005] + */ +SQLRETURN WINAPI SQLCancel(SQLHSTMT StatementHandle) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func) (StatementHandle); +} + + +/************************************************************************* + * SQLCloseCursor [ODBC32.026] + */ +SQLRETURN WINAPI SQLCloseCursor(SQLHSTMT StatementHandle) +{ + SQLRETURN ret; + TRACE("(Handle=%lx)\n",StatementHandle); + + CHECK_READY_AND_dmHandle(); + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func) (StatementHandle); + TRACE("returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLColAttribute [ODBC32.027] + */ +SQLRETURN WINAPI SQLColAttribute (SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier, + SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength, + SQLSMALLINT *StringLength, SQLPOINTER NumericAttribute) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func) + (StatementHandle, ColumnNumber, FieldIdentifier, + CharacterAttribute, BufferLength, StringLength, NumericAttribute); +} + + +/************************************************************************* + * SQLColumns [ODBC32.040] + */ +SQLRETURN WINAPI SQLColumns(SQLHSTMT StatementHandle, + SQLCHAR *CatalogName, SQLSMALLINT NameLength1, + SQLCHAR *SchemaName, SQLSMALLINT NameLength2, + SQLCHAR *TableName, SQLSMALLINT NameLength3, + SQLCHAR *ColumnName, SQLSMALLINT NameLength4) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func) + (StatementHandle, CatalogName, NameLength1, + SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4); +} + + +/************************************************************************* + * SQLConnect [ODBC32.007] + */ +SQLRETURN WINAPI SQLConnect(SQLHDBC ConnectionHandle, + SQLCHAR *ServerName, SQLSMALLINT NameLength1, + SQLCHAR *UserName, SQLSMALLINT NameLength2, + SQLCHAR *Authentication, SQLSMALLINT NameLength3) +{ + SQLRETURN ret; + TRACE("(Server=%.*s)\n",NameLength1, ServerName); + + CHECK_READY_AND_dmHandle(); + + strcpy(gProxyHandle.ServerName, ServerName); + strcpy(gProxyHandle.UserName, UserName); + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func) + (ConnectionHandle, ServerName, NameLength1, + UserName, NameLength2, Authentication, NameLength3); + + TRACE("returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLCopyDesc [ODBC32.028] + */ +SQLRETURN WINAPI SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func) + (SourceDescHandle, TargetDescHandle); +} + + +/************************************************************************* + * SQLDataSources [ODBC32.057] + */ +SQLRETURN WINAPI SQLDataSources(SQLHENV EnvironmentHandle, + SQLUSMALLINT Direction, SQLCHAR *ServerName, + SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1, + SQLCHAR *Description, SQLSMALLINT BufferLength2, + SQLSMALLINT *NameLength2) +{ + SQLRETURN ret; + + TRACE("EnvironmentHandle = %p\n", (LPVOID)EnvironmentHandle); + + if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) + { + ERR("Error: empty dm handle (gProxyHandle.dmHandle == NULL)\n"); + return SQL_ERROR; + } + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func); + ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func) + (EnvironmentHandle, Direction, ServerName, + BufferLength1, NameLength1, Description, BufferLength2, NameLength2); + +#ifndef __REACTOS__ + if (TRACE_ON(odbc)) +#endif + { + TRACE("returns: %d \t", ret); + if (*NameLength1 > 0) + TRACE("DataSource = %s,", ServerName); + if (*NameLength2 > 0) + TRACE(" Description = %s", Description); + TRACE("\n"); + } + + return ret; +} + + +/************************************************************************* + * SQLDescribeCol [ODBC32.008] + */ +SQLRETURN WINAPI SQLDescribeCol(SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName, + SQLSMALLINT BufferLength, SQLSMALLINT *NameLength, + SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize, + SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func) + (StatementHandle, ColumnNumber, ColumnName, + BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable); +} + + +/************************************************************************* + * SQLDisconnect [ODBC32.009] + */ +SQLRETURN WINAPI SQLDisconnect(SQLHDBC ConnectionHandle) +{ + SQLRETURN ret; + TRACE("(Handle=%lx)\n", ConnectionHandle); + + CHECK_READY_AND_dmHandle(); + + gProxyHandle.ServerName[0] = '\0'; + gProxyHandle.UserName[0] = '\0'; + + assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func); + ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func) (ConnectionHandle); + TRACE("returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLEndTran [ODBC32.029] + */ +SQLRETURN WINAPI SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func) (HandleType, Handle, CompletionType); +} + + +/************************************************************************* + * SQLError [ODBC32.010] + */ +SQLRETURN WINAPI SQLError(SQLHENV EnvironmentHandle, + SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle, + SQLCHAR *Sqlstate, SQLINTEGER *NativeError, + SQLCHAR *MessageText, SQLSMALLINT BufferLength, + SQLSMALLINT *TextLength) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func) + (EnvironmentHandle, ConnectionHandle, StatementHandle, + Sqlstate, NativeError, MessageText, BufferLength, TextLength); +} + + +/************************************************************************* + * SQLExecDirect [ODBC32.011] + */ +SQLRETURN WINAPI SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func) + (StatementHandle, StatementText, TextLength); +} + + +/************************************************************************* + * SQLExecute [ODBC32.012] + */ +SQLRETURN WINAPI SQLExecute(SQLHSTMT StatementHandle) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func) (StatementHandle); +} + + +/************************************************************************* + * SQLFetch [ODBC32.013] + */ +SQLRETURN WINAPI SQLFetch(SQLHSTMT StatementHandle) +{ + TRACE("\n"); + + CHECK_READY_AND_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func) (StatementHandle); +} + + +/************************************************************************* + * SQLFetchScroll [ODBC32.030] + */ +SQLRETURN WINAPI SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func) + (StatementHandle, FetchOrientation, FetchOffset); +} + + +/************************************************************************* + * SQLFreeConnect [ODBC32.014] + */ +SQLRETURN WINAPI SQLFreeConnect(SQLHDBC ConnectionHandle) +{ + SQLRETURN ret; + TRACE("(Handle=%lx)\n",ConnectionHandle); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func) (ConnectionHandle); + TRACE("Returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLFreeEnv [ODBC32.015] + */ +SQLRETURN WINAPI SQLFreeEnv(SQLHENV EnvironmentHandle) +{ + SQLRETURN ret; + TRACE("(Env=%lx)\n",EnvironmentHandle); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func); + ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func) (EnvironmentHandle); + TRACE("Returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLFreeHandle [ODBC32.031] + */ +SQLRETURN WINAPI SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle) +{ + SQLRETURN ret; + TRACE("(Type=%d, Handle=%lx)\n",HandleType,Handle); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func); + ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func) + (HandleType, Handle); + TRACE ("Returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLFreeStmt [ODBC32.016] + */ +SQLRETURN WINAPI SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option) +{ + SQLRETURN ret; + TRACE("(Handle %lx, Option=%d)\n",StatementHandle, Option); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func); + ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func) + (StatementHandle, Option); + TRACE("Returns %d\n",ret); + return ret; +} + + +/************************************************************************* + * SQLGetConnectAttr [ODBC32.032] + */ +SQLRETURN WINAPI SQLGetConnectAttr(SQLHDBC ConnectionHandle, + SQLINTEGER Attribute, SQLPOINTER Value, + SQLINTEGER BufferLength, SQLINTEGER *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func) + (ConnectionHandle, Attribute, Value, + BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetConnectOption [ODBC32.042] + */ +SQLRETURN WINAPI SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func) + (ConnectionHandle, Option, Value); +} + + +/************************************************************************* + * SQLGetCursorName [ODBC32.017] + */ +SQLRETURN WINAPI SQLGetCursorName(SQLHSTMT StatementHandle, + SQLCHAR *CursorName, SQLSMALLINT BufferLength, + SQLSMALLINT *NameLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func) + (StatementHandle, CursorName, BufferLength, NameLength); +} + + +/************************************************************************* + * SQLGetData [ODBC32.043] + */ +SQLRETURN WINAPI SQLGetData(SQLHSTMT StatementHandle, + SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType, + SQLPOINTER TargetValue, SQLINTEGER BufferLength, + SQLINTEGER *StrLen_or_Ind) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func) + (StatementHandle, ColumnNumber, TargetType, + TargetValue, BufferLength, StrLen_or_Ind); +} + + +/************************************************************************* + * SQLGetDescField [ODBC32.033] + */ +SQLRETURN WINAPI SQLGetDescField(SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, + SQLPOINTER Value, SQLINTEGER BufferLength, + SQLINTEGER *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func) + (DescriptorHandle, RecNumber, FieldIdentifier, + Value, BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetDescRec [ODBC32.034] + */ +SQLRETURN WINAPI SQLGetDescRec(SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, SQLCHAR *Name, + SQLSMALLINT BufferLength, SQLSMALLINT *StringLength, + SQLSMALLINT *Type, SQLSMALLINT *SubType, + SQLINTEGER *Length, SQLSMALLINT *Precision, + SQLSMALLINT *Scale, SQLSMALLINT *Nullable) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func) + (DescriptorHandle, RecNumber, Name, BufferLength, + StringLength, Type, SubType, Length, Precision, Scale, Nullable); +} + + +/************************************************************************* + * SQLGetDiagField [ODBC32.035] + */ +SQLRETURN WINAPI SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle, + SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier, + SQLPOINTER DiagInfo, SQLSMALLINT BufferLength, + SQLSMALLINT *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func) + (HandleType, Handle, RecNumber, DiagIdentifier, + DiagInfo, BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetDiagRec [ODBC32.036] + */ +SQLRETURN WINAPI SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle, + SQLSMALLINT RecNumber, SQLCHAR *Sqlstate, + SQLINTEGER *NativeError, SQLCHAR *MessageText, + SQLSMALLINT BufferLength, SQLSMALLINT *TextLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func) + (HandleType, Handle, RecNumber, Sqlstate, NativeError, + MessageText, BufferLength, TextLength); +} + + +/************************************************************************* + * SQLGetEnvAttr [ODBC32.037] + */ +SQLRETURN WINAPI SQLGetEnvAttr(SQLHENV EnvironmentHandle, + SQLINTEGER Attribute, SQLPOINTER Value, + SQLINTEGER BufferLength, SQLINTEGER *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func) + (EnvironmentHandle, Attribute, Value, BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetFunctions [ODBC32.044] + */ +SQLRETURN WINAPI SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func) + (ConnectionHandle, FunctionId, Supported); +} + + +/************************************************************************* + * SQLGetInfo [ODBC32.045] + */ +SQLRETURN WINAPI SQLGetInfo(SQLHDBC ConnectionHandle, + SQLUSMALLINT InfoType, SQLPOINTER InfoValue, + SQLSMALLINT BufferLength, SQLSMALLINT *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func) + (ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetStmtAttr [ODBC32.038] + */ +SQLRETURN WINAPI SQLGetStmtAttr(SQLHSTMT StatementHandle, + SQLINTEGER Attribute, SQLPOINTER Value, + SQLINTEGER BufferLength, SQLINTEGER *StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func) + (StatementHandle, Attribute, Value, BufferLength, StringLength); +} + + +/************************************************************************* + * SQLGetStmtOption [ODBC32.046] + */ +SQLRETURN WINAPI SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func) + (StatementHandle, Option, Value); +} + + +/************************************************************************* + * SQLGetTypeInfo [ODBC32.047] + */ +SQLRETURN WINAPI SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func) + (StatementHandle, DataType); +} + + +/************************************************************************* + * SQLNumResultCols [ODBC32.018] + */ +SQLRETURN WINAPI SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func) + (StatementHandle, ColumnCount); +} + + +/************************************************************************* + * SQLParamData [ODBC32.048] + */ +SQLRETURN WINAPI SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func) + (StatementHandle, Value); +} + + +/************************************************************************* + * SQLPrepare [ODBC32.019] + */ +SQLRETURN WINAPI SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func) + (StatementHandle, StatementText, TextLength); +} + + +/************************************************************************* + * SQLPutData [ODBC32.049] + */ +SQLRETURN WINAPI SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLINTEGER StrLen_or_Ind) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func) + (StatementHandle, Data, StrLen_or_Ind); +} + + +/************************************************************************* + * SQLRowCount [ODBC32.020] + */ +SQLRETURN WINAPI SQLRowCount(SQLHSTMT StatementHandle, SQLINTEGER *RowCount) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func) + (StatementHandle, RowCount); +} + + +/************************************************************************* + * SQLSetConnectAttr [ODBC32.039] + */ +SQLRETURN WINAPI SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, + SQLPOINTER Value, SQLINTEGER StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func) + (ConnectionHandle, Attribute, Value, StringLength); +} + + +/************************************************************************* + * SQLSetConnectOption [ODBC32.050] + */ +SQLRETURN WINAPI SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLUINTEGER Value) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func) + (ConnectionHandle, Option, Value); +} + + +/************************************************************************* + * SQLSetCursorName [ODBC32.021] + */ +SQLRETURN WINAPI SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func) + (StatementHandle, CursorName, NameLength); +} + + +/************************************************************************* + * SQLSetDescField [ODBC32.073] + */ +SQLRETURN WINAPI SQLSetDescField(SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, + SQLPOINTER Value, SQLINTEGER BufferLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func) + (DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength); +} + + +/************************************************************************* + * SQLSetDescRec [ODBC32.074] + */ +SQLRETURN WINAPI SQLSetDescRec(SQLHDESC DescriptorHandle, + SQLSMALLINT RecNumber, SQLSMALLINT Type, + SQLSMALLINT SubType, SQLINTEGER Length, + SQLSMALLINT Precision, SQLSMALLINT Scale, + SQLPOINTER Data, SQLINTEGER *StringLength, + SQLINTEGER *Indicator) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func) + (DescriptorHandle, RecNumber, Type, SubType, Length, + Precision, Scale, Data, StringLength, Indicator); +} + + +/************************************************************************* + * SQLSetEnvAttr [ODBC32.075] + */ +SQLRETURN WINAPI SQLSetEnvAttr(SQLHENV EnvironmentHandle, + SQLINTEGER Attribute, SQLPOINTER Value, + SQLINTEGER StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func) + (EnvironmentHandle, Attribute, Value, StringLength); +} + + +/************************************************************************* + * SQLSetParam [ODBC32.022] + */ +SQLRETURN WINAPI SQLSetParam(SQLHSTMT StatementHandle, + SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType, + SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision, + SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue, + SQLINTEGER *StrLen_or_Ind) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func) + (StatementHandle, ParameterNumber, ValueType, ParameterType, LengthPrecision, + ParameterScale, ParameterValue, StrLen_or_Ind); +} + + +/************************************************************************* + * SQLSetStmtAttr [ODBC32.076] + */ +SQLRETURN WINAPI SQLSetStmtAttr(SQLHSTMT StatementHandle, + SQLINTEGER Attribute, SQLPOINTER Value, + SQLINTEGER StringLength) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func) + (StatementHandle, Attribute, Value, StringLength); +} + + +/************************************************************************* + * SQLSetStmtOption [ODBC32.051] + */ +SQLRETURN WINAPI SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLUINTEGER Value) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func) + (StatementHandle, Option, Value); +} + + +/************************************************************************* + * SQLSpecialColumns [ODBC32.052] + */ +SQLRETURN WINAPI SQLSpecialColumns(SQLHSTMT StatementHandle, + SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName, + SQLSMALLINT NameLength1, SQLCHAR *SchemaName, + SQLSMALLINT NameLength2, SQLCHAR *TableName, + SQLSMALLINT NameLength3, SQLUSMALLINT Scope, + SQLUSMALLINT Nullable) +{ + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func) + (StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName, + NameLength2, TableName, NameLength3, Scope, Nullable); +} + + +/************************************************************************* + * SQLStatistics [ODBC32.053] + */ +SQLRETURN WINAPI SQLStatistics(SQLHSTMT StatementHandle, + SQLCHAR *CatalogName, SQLSMALLINT NameLength1, + SQLCHAR *SchemaName, SQLSMALLINT NameLength2, + SQLCHAR *TableName, SQLSMALLINT NameLength3, + SQLUSMALLINT Unique, SQLUSMALLINT Reserved) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func) + (StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2, + TableName, NameLength3, Unique, Reserved); +} + + +/************************************************************************* + * SQLTables [ODBC32.054] + */ +SQLRETURN WINAPI SQLTables(SQLHSTMT StatementHandle, + SQLCHAR *CatalogName, SQLSMALLINT NameLength1, + SQLCHAR *SchemaName, SQLSMALLINT NameLength2, + SQLCHAR *TableName, SQLSMALLINT NameLength3, + SQLCHAR *TableType, SQLSMALLINT NameLength4) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func) + (StatementHandle, CatalogName, NameLength1, + SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4); +} + + +/************************************************************************* + * SQLTransact [ODBC32.023] + */ +SQLRETURN WINAPI SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle, + SQLUSMALLINT CompletionType) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func) + (EnvironmentHandle, ConnectionHandle, CompletionType); +} + + +/************************************************************************* + * SQLBrowseConnect [ODBC32.055] + */ +SQLRETURN WINAPI SQLBrowseConnect( + SQLHDBC hdbc, + SQLCHAR *szConnStrIn, + SQLSMALLINT cbConnStrIn, + SQLCHAR *szConnStrOut, + SQLSMALLINT cbConnStrOutMax, + SQLSMALLINT *pcbConnStrOut) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func) + (hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut); +} + + +/************************************************************************* + * SQLBulkOperations [ODBC32.078] + */ +SQLRETURN WINAPI SQLBulkOperations( + SQLHSTMT StatementHandle, + SQLSMALLINT Operation) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func) + (StatementHandle, Operation); +} + + +/************************************************************************* + * SQLColAttributes [ODBC32.006] + */ +SQLRETURN WINAPI SQLColAttributes( + SQLHSTMT hstmt, + SQLUSMALLINT icol, + SQLUSMALLINT fDescType, + SQLPOINTER rgbDesc, + SQLSMALLINT cbDescMax, + SQLSMALLINT *pcbDesc, + SQLINTEGER *pfDesc) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func) + (hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc); +} + + +/************************************************************************* + * SQLColumnPrivileges [ODBC32.056] + */ +SQLRETURN WINAPI SQLColumnPrivileges( + SQLHSTMT hstmt, + SQLCHAR *szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR *szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR *szTableName, + SQLSMALLINT cbTableName, + SQLCHAR *szColumnName, + SQLSMALLINT cbColumnName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func) + (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, + szTableName, cbTableName, szColumnName, cbColumnName); +} + + +/************************************************************************* + * SQLDescribeParam [ODBC32.058] + */ +SQLRETURN WINAPI SQLDescribeParam( + SQLHSTMT hstmt, + SQLUSMALLINT ipar, + SQLSMALLINT *pfSqlType, + SQLUINTEGER *pcbParamDef, + SQLSMALLINT *pibScale, + SQLSMALLINT *pfNullable) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func) + (hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable); +} + + +/************************************************************************* + * SQLExtendedFetch [ODBC32.059] + */ +SQLRETURN WINAPI SQLExtendedFetch( + SQLHSTMT hstmt, + SQLUSMALLINT fFetchType, + SQLINTEGER irow, + SQLUINTEGER *pcrow, + SQLUSMALLINT *rgfRowStatus) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func) + (hstmt, fFetchType, irow, pcrow, rgfRowStatus); +} + + +/************************************************************************* + * SQLForeignKeys [ODBC32.060] + */ +SQLRETURN WINAPI SQLForeignKeys( + SQLHSTMT hstmt, + SQLCHAR *szPkCatalogName, + SQLSMALLINT cbPkCatalogName, + SQLCHAR *szPkSchemaName, + SQLSMALLINT cbPkSchemaName, + SQLCHAR *szPkTableName, + SQLSMALLINT cbPkTableName, + SQLCHAR *szFkCatalogName, + SQLSMALLINT cbFkCatalogName, + SQLCHAR *szFkSchemaName, + SQLSMALLINT cbFkSchemaName, + SQLCHAR *szFkTableName, + SQLSMALLINT cbFkTableName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func) + (hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName, + szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName, szFkSchemaName, + cbFkSchemaName, szFkTableName, cbFkTableName); +} + + +/************************************************************************* + * SQLMoreResults [ODBC32.061] + */ +SQLRETURN WINAPI SQLMoreResults(SQLHSTMT hstmt) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func) (hstmt); +} + + +/************************************************************************* + * SQLNativeSql [ODBC32.062] + */ +SQLRETURN WINAPI SQLNativeSql( + SQLHDBC hdbc, + SQLCHAR *szSqlStrIn, + SQLINTEGER cbSqlStrIn, + SQLCHAR *szSqlStr, + SQLINTEGER cbSqlStrMax, + SQLINTEGER *pcbSqlStr) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func) + (hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr); +} + + +/************************************************************************* + * SQLNumParams [ODBC32.063] + */ +SQLRETURN WINAPI SQLNumParams( + SQLHSTMT hstmt, + SQLSMALLINT *pcpar) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func) (hstmt, pcpar); +} + + +/************************************************************************* + * SQLParamOptions [ODBC32.064] + */ +SQLRETURN WINAPI SQLParamOptions( + SQLHSTMT hstmt, + SQLUINTEGER crow, + SQLUINTEGER *pirow) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func) (hstmt, crow, pirow); +} + + +/************************************************************************* + * SQLPrimaryKeys [ODBC32.065] + */ +SQLRETURN WINAPI SQLPrimaryKeys( + SQLHSTMT hstmt, + SQLCHAR *szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR *szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR *szTableName, + SQLSMALLINT cbTableName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func) + (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, + szTableName, cbTableName); +} + + +/************************************************************************* + * SQLProcedureColumns [ODBC32.066] + */ +SQLRETURN WINAPI SQLProcedureColumns( + SQLHSTMT hstmt, + SQLCHAR *szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR *szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR *szProcName, + SQLSMALLINT cbProcName, + SQLCHAR *szColumnName, + SQLSMALLINT cbColumnName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func) + (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, + szProcName, cbProcName, szColumnName, cbColumnName); +} + + +/************************************************************************* + * SQLProcedures [ODBC32.067] + */ +SQLRETURN WINAPI SQLProcedures( + SQLHSTMT hstmt, + SQLCHAR *szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR *szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR *szProcName, + SQLSMALLINT cbProcName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func) + (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, + szProcName, cbProcName); +} + + +/************************************************************************* + * SQLSetPos [ODBC32.068] + */ +SQLRETURN WINAPI SQLSetPos( + SQLHSTMT hstmt, + SQLUSMALLINT irow, + SQLUSMALLINT fOption, + SQLUSMALLINT fLock) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func) + (hstmt, irow, fOption, fLock); +} + + +/************************************************************************* + * SQLTablePrivileges [ODBC32.070] + */ +SQLRETURN WINAPI SQLTablePrivileges( + SQLHSTMT hstmt, + SQLCHAR *szCatalogName, + SQLSMALLINT cbCatalogName, + SQLCHAR *szSchemaName, + SQLSMALLINT cbSchemaName, + SQLCHAR *szTableName, + SQLSMALLINT cbTableName) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func) + (hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, + szTableName, cbTableName); +} + + +/************************************************************************* + * SQLDrivers [ODBC32.071] + */ +SQLRETURN WINAPI SQLDrivers( + SQLHENV henv, + SQLUSMALLINT fDirection, + SQLCHAR *szDriverDesc, + SQLSMALLINT cbDriverDescMax, + SQLSMALLINT *pcbDriverDesc, + SQLCHAR *szDriverAttributes, + SQLSMALLINT cbDriverAttrMax, + SQLSMALLINT *pcbDriverAttr) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func) + (henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc, + szDriverAttributes, cbDriverAttrMax, pcbDriverAttr); +} + + +/************************************************************************* + * SQLBindParameter [ODBC32.072] + */ +SQLRETURN WINAPI SQLBindParameter( + SQLHSTMT hstmt, + SQLUSMALLINT ipar, + SQLSMALLINT fParamType, + SQLSMALLINT fCType, + SQLSMALLINT fSqlType, + SQLUINTEGER cbColDef, + SQLSMALLINT ibScale, + SQLPOINTER rgbValue, + SQLINTEGER cbValueMax, + SQLINTEGER *pcbValue) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func) + (hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, + rgbValue, cbValueMax, pcbValue); +} + + +/************************************************************************* + * SQLDriverConnect [ODBC32.041] + */ +SQLRETURN WINAPI SQLDriverConnect( + SQLHDBC hdbc, + SQLHWND hwnd, + SQLCHAR *conn_str_in, + SQLSMALLINT len_conn_str_in, + SQLCHAR *conn_str_out, + SQLSMALLINT conn_str_out_max, + SQLSMALLINT *ptr_conn_str_out, + SQLUSMALLINT driver_completion ) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func) + (hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out, + conn_str_out_max, ptr_conn_str_out, driver_completion); +} + + +/************************************************************************* + * SQLSetScrollOptions [ODBC32.069] + */ +SQLRETURN WINAPI SQLSetScrollOptions( + SQLHSTMT statement_handle, + SQLUSMALLINT f_concurrency, + SQLINTEGER crow_keyset, + SQLUSMALLINT crow_rowset ) +{ + TRACE("\n"); + + CHECK_dmHandle(); + + assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func); + return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func) + (statement_handle, f_concurrency, crow_keyset, crow_rowset); +} + +/* End of file */ diff --git a/reactos/lib/odbc32/proxyodbc.h b/reactos/lib/odbc32/proxyodbc.h new file mode 100644 index 00000000000..e327e1b3ae5 --- /dev/null +++ b/reactos/lib/odbc32/proxyodbc.h @@ -0,0 +1,131 @@ +/* + * Copyright 1999 Xiang Li, Corel Corporation + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _PROXYMANAGER_H +#define _PROXYMANAGER_H + +#define NUM_SQLFUNC 78 +#define ERROR_FREE 0 +#define ERROR_SQLERROR 1 +#define ERROR_LIBRARY_NOT_FOUND 2 +#define ERROR_FUNCTIONS_NOT_LOADED 3 + +#define ODBCVER 0x0351 + +typedef struct dm_func /* driver manager functions */ +{ + int ordinal; + const char *name; + void *d_func; + SQLRETURN (*func)(); +} DM_FUNC; + +typedef struct proxyhandle +{ + void *dmHandle; /* driver manager handle */ + BOOL isWindowsDriver; /* is driver a Windows version*/ + BOOL bCallbackReady; /* procs taken from Windows driver placed in driver manager as callbacks */ + BOOL bFunctionReady; + int nErrorType; + DM_FUNC functions[NUM_SQLFUNC]; /* entry point for driver manager functions */ + char driverLibName[200]; /* ODBC driver SO name */ + char dmLibName[200]; /* driver manager library name */ + char ServerName[200]; /* keep server name */ + char UserName[50]; /* keep username */ +} PROXYHANDLE; + +#define /* 00 */ SQLAPI_INDEX_SQLALLOCCONNECT 0 +#define /* 01 */ SQLAPI_INDEX_SQLALLOCENV 1 +#define /* 02 */ SQLAPI_INDEX_SQLALLOCHANDLE 2 +#define /* 03 */ SQLAPI_INDEX_SQLALLOCSTMT 3 +#define /* 04 */ SQLAPI_INDEX_SQLALLOCHANDLESTD 4 +#define /* 05 */ SQLAPI_INDEX_SQLBINDCOL 5 +#define /* 06 */ SQLAPI_INDEX_SQLBINDPARAM 6 +#define /* 07 */ SQLAPI_INDEX_SQLBINDPARAMETER 7 +#define /* 08 */ SQLAPI_INDEX_SQLBROWSECONNECT 8 +#define /* 09 */ SQLAPI_INDEX_SQLBULKOPERATIONS 9 +#define /* 10 */ SQLAPI_INDEX_SQLCANCEL 10 +#define /* 11 */ SQLAPI_INDEX_SQLCLOSECURSOR 11 +#define /* 12 */ SQLAPI_INDEX_SQLCOLATTRIBUTE 12 +#define /* 13 */ SQLAPI_INDEX_SQLCOLATTRIBUTES 13 +#define /* 14 */ SQLAPI_INDEX_SQLCOLUMNPRIVILEGES 14 +#define /* 15 */ SQLAPI_INDEX_SQLCOLUMNS 15 +#define /* 16 */ SQLAPI_INDEX_SQLCONNECT 16 +#define /* 17 */ SQLAPI_INDEX_SQLCOPYDESC 17 +#define /* 18 */ SQLAPI_INDEX_SQLDATASOURCES 18 +#define /* 19 */ SQLAPI_INDEX_SQLDESCRIBECOL 19 +#define /* 20 */ SQLAPI_INDEX_SQLDESCRIBEPARAM 20 +#define /* 21 */ SQLAPI_INDEX_SQLDISCONNECT 21 +#define /* 22 */ SQLAPI_INDEX_SQLDRIVERCONNECT 22 +#define /* 23 */ SQLAPI_INDEX_SQLDRIVERS 23 +#define /* 24 */ SQLAPI_INDEX_SQLENDTRAN 24 +#define /* 25 */ SQLAPI_INDEX_SQLERROR 25 +#define /* 26 */ SQLAPI_INDEX_SQLEXECDIRECT 26 +#define /* 27 */ SQLAPI_INDEX_SQLEXECUTE 27 +#define /* 28 */ SQLAPI_INDEX_SQLEXTENDEDFETCH 28 +#define /* 29 */ SQLAPI_INDEX_SQLFETCH 29 +#define /* 30 */ SQLAPI_INDEX_SQLFETCHSCROLL 30 +#define /* 31 */ SQLAPI_INDEX_SQLFOREIGNKEYS 31 +#define /* 32 */ SQLAPI_INDEX_SQLFREEENV 32 +#define /* 33 */ SQLAPI_INDEX_SQLFREEHANDLE 33 +#define /* 34 */ SQLAPI_INDEX_SQLFREESTMT 34 +#define /* 35 */ SQLAPI_INDEX_SQLFREECONNECT 35 +#define /* 36 */ SQLAPI_INDEX_SQLGETCONNECTATTR 36 +#define /* 37 */ SQLAPI_INDEX_SQLGETCONNECTOPTION 37 +#define /* 38 */ SQLAPI_INDEX_SQLGETCURSORNAME 38 +#define /* 39 */ SQLAPI_INDEX_SQLGETDATA 39 +#define /* 40 */ SQLAPI_INDEX_SQLGETDESCFIELD 40 +#define /* 41 */ SQLAPI_INDEX_SQLGETDESCREC 41 +#define /* 42 */ SQLAPI_INDEX_SQLGETDIAGFIELD 42 +#define /* 43 */ SQLAPI_INDEX_SQLGETENVATTR 43 +#define /* 44 */ SQLAPI_INDEX_SQLGETFUNCTIONS 44 +#define /* 45 */ SQLAPI_INDEX_SQLGETINFO 45 +#define /* 46 */ SQLAPI_INDEX_SQLGETSTMTATTR 46 +#define /* 47 */ SQLAPI_INDEX_SQLGETSTMTOPTION 47 +#define /* 48 */ SQLAPI_INDEX_SQLGETTYPEINFO 48 +#define /* 49 */ SQLAPI_INDEX_SQLMORERESULTS 49 +#define /* 50 */ SQLAPI_INDEX_SQLNATIVESQL 50 +#define /* 51 */ SQLAPI_INDEX_SQLNUMPARAMS 51 +#define /* 52 */ SQLAPI_INDEX_SQLNUMRESULTCOLS 52 +#define /* 53 */ SQLAPI_INDEX_SQLPARAMDATA 53 +#define /* 54 */ SQLAPI_INDEX_SQLPARAMOPTIONS 54 +#define /* 55 */ SQLAPI_INDEX_SQLPREPARE 55 +#define /* 56 */ SQLAPI_INDEX_SQLPRIMARYKEYS 56 +#define /* 57 */ SQLAPI_INDEX_SQLPROCEDURECOLUMNS 57 +#define /* 58 */ SQLAPI_INDEX_SQLPROCEDURES 58 +#define /* 59 */ SQLAPI_INDEX_SQLPUTDATA 59 +#define /* 60 */ SQLAPI_INDEX_SQLROWCOUNT 60 +#define /* 61 */ SQLAPI_INDEX_SQLSETCONNECTATTR 61 +#define /* 62 */ SQLAPI_INDEX_SQLSETCONNECTOPTION 62 +#define /* 63 */ SQLAPI_INDEX_SQLSETCURSORNAME 63 +#define /* 64 */ SQLAPI_INDEX_SQLSETDESCFIELD 64 +#define /* 65 */ SQLAPI_INDEX_SQLSETDESCREC 65 +#define /* 66 */ SQLAPI_INDEX_SQLSETENVATTR 66 +#define /* 67 */ SQLAPI_INDEX_SQLSETPARAM 67 +#define /* 68 */ SQLAPI_INDEX_SQLSETPOS 68 +#define /* 69 */ SQLAPI_INDEX_SQLSETSCROLLOPTIONS 69 +#define /* 70 */ SQLAPI_INDEX_SQLSETSTMTATTR 70 +#define /* 71 */ SQLAPI_INDEX_SQLSETSTMTOPTION 71 +#define /* 72 */ SQLAPI_INDEX_SQLSPECIALCOLUMNS 72 +#define /* 73 */ SQLAPI_INDEX_SQLSTATISTICS 73 +#define /* 74 */ SQLAPI_INDEX_SQLTABLEPRIVILEGES 74 +#define /* 75 */ SQLAPI_INDEX_SQLTABLES 75 +#define /* 76 */ SQLAPI_INDEX_SQLTRANSACT 76 +#define /* 77 */ SQLAPI_INDEX_SQLGETDIAGREC 77 + +#endif